---

inet.c File Reference

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <netinet/tcp.h>
#include "pi-debug.h"
#include "pi-source.h"
#include "pi-inet.h"
#include "pi-cmp.h"
#include "pi-net.h"

Include dependency graph for inet.c:

Go to the source code of this file.

Functions
static void	pi_inet_device_free (pi_device_t *dev)
static pi_protocol_t *	pi_inet_protocol (pi_device_t *dev)
static pi_protocol_t *	pi_inet_protocol_dup (pi_protocol_t *prot)
static void	pi_inet_protocol_free (pi_protocol_t *prot)
static int	pi_inet_close (pi_socket_t *ps)
static int	pi_inet_connect (pi_socket_t *ps, struct sockaddr *addr, size_t addrlen)
static int	pi_inet_bind (pi_socket_t *ps, struct sockaddr *addr, size_t addrlen)
static int	pi_inet_listen (pi_socket_t *ps, int backlog)
static int	pi_inet_accept (pi_socket_t *ps, struct sockaddr *addr, size_t *addrlen)
static ssize_t	pi_inet_read (pi_socket_t *ps, pi_buffer_t *msg, size_t len, int flags)
static ssize_t	pi_inet_write (pi_socket_t *ps, const unsigned char *msg, size_t len, int flags)
static int	pi_inet_getsockopt (pi_socket_t *ps, int level, int option_name, void *option_value, size_t *option_len)
static int	pi_inet_setsockopt (pi_socket_t *ps, int level, int option_name, const void *option_value, size_t *option_len)
static int	pi_inet_flush (pi_socket_t *ps, int flags)
int	pi_socket_init (pi_socket_t *ps)
pi_device_t *	pi_inet_device (int type)

---

Function Documentation

static int pi_inet_accept	(	pi_socket_t *	ps,
		struct sockaddr *	addr,
		size_t *	addrlen
	)			[static]

Definition at line 329 of file inet.c.

References pi_socket::cmd, CMP_FL_LONG_PACKET_SUPPORT, cmp_rx_handshake(), pi_socket::command, pi_socket::dlprecord, fail(), LOG, net_rx_handshake(), PI_CMD_CMP, PI_CMD_NET, PI_CMP_FLAGS, PI_DBG_DEV, PI_DBG_LVL_INFO, PI_ERR_GENERIC_SYSTEM, pi_getsockopt(), PI_LEVEL_CMP, PI_LEVEL_NET, PI_LEVEL_PADP, PI_NET_SPLIT_WRITES, PI_NET_WRITE_CHUNKSIZE, PI_PADP_USE_LONG_FORMAT, pi_set_error(), pi_setsockopt(), PI_SOCK_CONN_ACCEPT, pi_socket_init(), pi_socket_setsd(), pi_socket::sd, sd, size, and pi_socket::state.

Referenced by pi_inet_device().

{
        int     sd,
                err,
                split = 0,
                chunksize = 0;
        size_t  len,
                size;
        pl_socklen_t l = 0;
        unsigned char cmp_flags;
        
        if (addrlen)
                l = *addrlen;
        sd = accept(ps->sd, addr, &l);
        if (addrlen)
                *addrlen = l;
        if (sd < 0) {
                pi_set_error(ps->sd, sd);
                err = PI_ERR_GENERIC_SYSTEM;
                goto fail;
        }

        pi_socket_setsd(ps, sd);
        pi_socket_init(ps);

        switch (ps->cmd) {
                case PI_CMD_CMP:
                        if ((err = cmp_rx_handshake(ps, 57600, 0)) < 0)
                                goto fail;

                        /* propagate the long packet format flag to both command and non-command stacks */
                        size = sizeof(cmp_flags);
                        pi_getsockopt(ps->sd, PI_LEVEL_CMP, PI_CMP_FLAGS, &cmp_flags, &size);   
                        if (cmp_flags & CMP_FL_LONG_PACKET_SUPPORT) {
                                int use_long_format = 1;
                                size = sizeof(int);
                                pi_setsockopt(ps->sd, PI_LEVEL_PADP, PI_PADP_USE_LONG_FORMAT,
                                              &use_long_format, &size);
                                ps->command ^= 1;
                                pi_setsockopt(ps->sd, PI_LEVEL_PADP, PI_PADP_USE_LONG_FORMAT,
                                              &use_long_format, &size);
                                ps->command ^= 1;
                        }

                        break;
                case PI_CMD_NET:
                        /* network: make sure we don't split writes. set socket option
                         * on both the command and non-command instances of the protocol
                         */
                        len = sizeof (split);
                        pi_setsockopt(ps->sd, PI_LEVEL_NET, PI_NET_SPLIT_WRITES,
                                &split, &len);
                        len = sizeof (chunksize);
                        pi_setsockopt(ps->sd, PI_LEVEL_NET, PI_NET_WRITE_CHUNKSIZE,
                                &chunksize, &len);

                        ps->command ^= 1;
                        len = sizeof (split);
                        pi_setsockopt(ps->sd, PI_LEVEL_NET, PI_NET_SPLIT_WRITES,
                                &split, &len);
                        len = sizeof (chunksize);
                        pi_setsockopt(ps->sd, PI_LEVEL_NET, PI_NET_WRITE_CHUNKSIZE,
                                &chunksize, &len);
                        ps->command ^= 1;

                        if ((err = net_rx_handshake(ps)) < 0)
                                goto fail;
                        break;
        }

        ps->state       = PI_SOCK_CONN_ACCEPT;
        ps->command     = 0;
        ps->dlprecord = 0;

        LOG((PI_DBG_DEV, PI_DBG_LVL_INFO, "DEV INET ACCEPT accepted\n"));

        return ps->sd;

 fail:
        return err;
}

Here is the call graph for this function:

static int pi_inet_bind	(	pi_socket_t *	ps,
		struct sockaddr *	addr,
		size_t	addrlen
	)			[static]

Definition at line 171 of file inet.c.

References LOG, PI_DBG_DEV, PI_DBG_LVL_ERR, PI_DBG_LVL_INFO, pi_sockaddr::pi_device, PI_ERR_GENERIC_SYSTEM, pi_set_error(), pi_socket_setsd(), port, pi_socket::sd, and sd.

Referenced by pi_inet_device().

{
        int     opt,
                sd,
                err;
        size_t  optlen;
        struct  pi_sockaddr *paddr = (struct pi_sockaddr *) addr;
        struct  sockaddr_in serv_addr;
        char    *device = paddr->pi_device, 
                *port   = NULL;

        /* Figure out the addresses to allow */
        memset(&serv_addr, 0, sizeof(serv_addr));
        serv_addr.sin_family = AF_INET;
        if (strlen(device) > 1 && strncmp(device, "any", 3)) {
                serv_addr.sin_addr.s_addr = inet_addr(device);
                if (serv_addr.sin_addr.s_addr == (in_addr_t)-1) {
                        struct hostent *hostent = gethostbyname(device);

                        if (!hostent)
                                return pi_set_error(ps->sd, PI_ERR_GENERIC_SYSTEM);

                        memcpy((char *) &serv_addr.sin_addr.s_addr,
                                   hostent->h_addr, (size_t)hostent->h_length);
                }
        } else {
                serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
        }
        if ((port = strchr(device, ':')) != NULL) {
                serv_addr.sin_port = htons(atoi(++port));
        } else {
                serv_addr.sin_port = htons(14238);
        }

        sd = socket(AF_INET, SOCK_STREAM, 0);
        if (sd < 0) {
                LOG((PI_DBG_DEV, PI_DBG_LVL_ERR, 
                        "DEV BIND Inet: Unable to create socket\n"));
                return pi_set_error(ps->sd, PI_ERR_GENERIC_SYSTEM);
        }       
        if ((err = pi_socket_setsd (ps, sd)) < 0)
                return err;

        opt = 1;
        optlen = sizeof(opt);

        if (setsockopt(ps->sd, SOL_SOCKET, SO_REUSEADDR, (void *) &opt,
                        (int)optlen) < 0) {
                return pi_set_error(ps->sd, PI_ERR_GENERIC_SYSTEM);
        }

        if (bind(ps->sd, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0)
                return pi_set_error(ps->sd, PI_ERR_GENERIC_SYSTEM);

        LOG((PI_DBG_DEV, PI_DBG_LVL_INFO,
                "DEV BIND Inet Bound to %s\n", device));

        ps->raddr       = malloc(addrlen);
        memcpy(ps->raddr, addr, addrlen);
        ps->raddrlen    = addrlen;
        ps->laddr       = malloc(addrlen);
        memcpy(ps->laddr, addr, addrlen);
        ps->laddrlen    = addrlen;

        return 0;
}

Here is the call graph for this function:

static int pi_inet_close

(

pi_socket_t *

ps

)

[static]

Definition at line 412 of file inet.c.

References pi_socket::laddr, pi_socket::raddr, and pi_socket::sd.

Referenced by pi_inet_device().

{
        if (ps->sd) {
                close(ps->sd);
                ps->sd = 0;
        }
        if (ps->laddr) {
                free(ps->laddr);
                ps->laddr = NULL;
        }
        if (ps->raddr) {
                free(ps->raddr);
                ps->raddr = NULL;
        }
        return 0;
}

static int pi_inet_connect	(	pi_socket_t *	ps,
		struct sockaddr *	addr,
		size_t	addrlen
	)			[static]

Definition at line 239 of file inet.c.

References cmp_tx_handshake(), fail(), LOG, net_tx_handshake(), PI_CMD_CMP, PI_CMD_NET, PI_DBG_DEV, PI_DBG_LVL_ERR, PI_DBG_LVL_INFO, pi_sockaddr::pi_device, PI_ERR_GENERIC_SYSTEM, pi_set_error(), PI_SOCK_CONN_INIT, pi_socket_setsd(), pi_socket::sd, and sd.

Referenced by pi_inet_device().

{
        int     sd,
                err;

        struct  pi_sockaddr *paddr = (struct pi_sockaddr *) addr;
        struct  sockaddr_in serv_addr;
        char    *device = paddr->pi_device;
        
        /* Figure out the addresses to allow */
        memset(&serv_addr, 0, sizeof(serv_addr));
        serv_addr.sin_family = AF_INET;
        if (strlen(device) > 1) {
                serv_addr.sin_addr.s_addr = inet_addr(device);
                if (serv_addr.sin_addr.s_addr == (in_addr_t)-1) {
                        struct hostent *hostent = gethostbyname(device);
                
                        if (!hostent) {
                                LOG((PI_DBG_DEV, PI_DBG_LVL_ERR, 
                                        "DEV CONNECT Inet: Unable"
                                        " to determine host\n"));
                                return pi_set_error(ps->sd, PI_ERR_GENERIC_SYSTEM);
                        }
                        
                        memcpy((char *) &serv_addr.sin_addr.s_addr,
                                   hostent->h_addr, (size_t)hostent->h_length);
                }
        } else {
                serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
        }
        serv_addr.sin_port = htons(14238);

        sd = socket(AF_INET, SOCK_STREAM, 0);

        if (sd < 0) {
                LOG((PI_DBG_DEV, PI_DBG_LVL_ERR, 
                        "DEV CONNECT Inet: Unable to create socket\n"));
                return pi_set_error(ps->sd, PI_ERR_GENERIC_SYSTEM);
        }

        if ((err = pi_socket_setsd (ps, sd)) < 0)
                return err;

        if (connect (ps->sd, (struct sockaddr *) &serv_addr,
                         sizeof(serv_addr)) < 0) {
                LOG((PI_DBG_DEV, PI_DBG_LVL_ERR, 
                        "DEV CONNECT Inet: Unable to connect\n"));
                return pi_set_error(ps->sd, PI_ERR_GENERIC_SYSTEM);
        }

        ps->raddr       = malloc(addrlen);
        memcpy(ps->raddr, addr, addrlen);
        ps->raddrlen    = addrlen;
        ps->laddr       = malloc(addrlen);
        memcpy(ps->laddr, addr, addrlen);
        ps->laddrlen    = addrlen;

        switch (ps->cmd) {
                case PI_CMD_CMP:
                        if ((err = cmp_tx_handshake(ps)) < 0)
                                goto fail;
                        break;
                case PI_CMD_NET:
                        if ((err = net_tx_handshake(ps)) < 0)
                                goto fail;
                        break;
        }
        ps->state = PI_SOCK_CONN_INIT;
        ps->command = 0;

        LOG((PI_DBG_DEV, PI_DBG_LVL_INFO, "DEV CONNECT Inet: Connected\n"));
        return 0;

fail:
        return err;
}

Here is the call graph for this function:

pi_device_t* pi_inet_device

(

int

type

)

Definition at line 66 of file inet.c.

References pi_device::accept, pi_device::bind, pi_device::close, pi_device::connect, pi_device::data, pi_device::free, pi_device::listen, pi_inet_accept(), pi_inet_bind(), pi_inet_close(), pi_inet_connect(), pi_inet_device_free(), pi_inet_listen(), pi_inet_protocol(), pi_device::protocol, pi_inet_data::rx_bytes, pi_inet_data::rx_errors, pi_inet_data::timeout, pi_inet_data::tx_bytes, and pi_inet_data::tx_errors.

Referenced by pi_devsocket().

{
        pi_device_t *dev = NULL;
        pi_inet_data_t *data = NULL;

        dev = (pi_device_t *)malloc (sizeof (pi_device_t));
        if (dev != NULL) {
                data = (pi_inet_data_t *)malloc (sizeof (pi_inet_data_t));
                if (data == NULL) {
                        free(dev);
                        dev = NULL;
                }
        }

        if (dev != NULL && data != NULL) {
                dev->free       = pi_inet_device_free;
                dev->protocol   = pi_inet_protocol;     
                dev->bind       = pi_inet_bind;
                dev->listen     = pi_inet_listen;
                dev->accept     = pi_inet_accept;
                dev->connect    = pi_inet_connect;
                dev->close      = pi_inet_close;

                data->timeout   = 0;
                data->rx_bytes  = 0;
                data->rx_errors = 0;
                data->tx_bytes  = 0;
                data->tx_errors = 0;
                dev->data       = data;
        }

        return dev;
}

Here is the call graph for this function:

static void pi_inet_device_free

(

pi_device_t *

dev

)

[static]

Definition at line 101 of file inet.c.

References ASSERT, and pi_device::data.

Referenced by pi_inet_device().

{
        ASSERT (dev != NULL);
        if (dev != NULL) {
                if (dev->data != NULL)
                        free(dev->data);
                free(dev);
        }
}

static int pi_inet_flush	(	pi_socket_t *	ps,
		int	flags
	)			[static]

Definition at line 430 of file inet.c.

References buf, O_NONBLOCK, PI_FLUSH_INPUT, and pi_socket::sd.

Referenced by pi_inet_protocol().

{
        char buf[256];
        int fl;

        if (flags & PI_FLUSH_INPUT) {
                if ((fl = fcntl(ps->sd, F_GETFL, 0)) != -1) {
                        fcntl(ps->sd, F_SETFL, fl | O_NONBLOCK);
                        while (recv(ps->sd, buf, sizeof(buf), 0) > 0)
                                ;
                        fcntl(ps->sd, F_SETFL, fl);
                }
        }
        return 0;
}

static int pi_inet_getsockopt	(	pi_socket_t *	ps,
		int	level,
		int	option_name,
		void *	option_value,
		size_t *	option_len
	)			[static]

Definition at line 550 of file inet.c.

References pi_device::data, pi_socket::device, PI_DEV_TIMEOUT, PI_ERR_GENERIC_ARGUMENT, pi_set_error(), pi_socket::sd, and pi_inet_data::timeout.

Referenced by pi_inet_protocol().

{
        pi_inet_data_t *data = (pi_inet_data_t *)ps->device->data;

        switch (option_name) {
                case PI_DEV_TIMEOUT:
                        if (*option_len != sizeof (data->timeout)) {
                                errno = EINVAL;
                                return pi_set_error(ps->sd, PI_ERR_GENERIC_ARGUMENT);
                        }
                        memcpy (option_value, &data->timeout,
                                sizeof (data->timeout));
                        *option_len = sizeof (data->timeout);
                        break;
        }

        return 0;
}

Here is the call graph for this function:

static int pi_inet_listen	(	pi_socket_t *	ps,
		int	backlog
	)			[static]

Definition at line 317 of file inet.c.

References PI_SOCK_LISTEN, pi_socket::sd, and pi_socket::state.

Referenced by pi_inet_device().

{
        int     result;
        
        result = listen(ps->sd, backlog);
        if (result == 0)
                ps->state = PI_SOCK_LISTEN;

        return result;
}

static pi_protocol_t * pi_inet_protocol

(

pi_device_t *

dev

)

[static]

Definition at line 112 of file inet.c.

References ASSERT, pi_protocol::data, pi_device::data, pi_protocol::dup, pi_protocol::flush, pi_protocol::free, pi_protocol::getsockopt, pi_protocol::level, pi_inet_flush(), pi_inet_getsockopt(), pi_inet_protocol_dup(), pi_inet_protocol_free(), pi_inet_read(), pi_inet_setsockopt(), pi_inet_write(), PI_LEVEL_DEV, pi_protocol::read, pi_protocol::setsockopt, and pi_protocol::write.

Referenced by pi_inet_device().

{       
        pi_protocol_t *prot;
        pi_inet_data_t *data;

        ASSERT (dev != NULL);
        
        data = dev->data;
        
        prot = (pi_protocol_t *)malloc (sizeof (pi_protocol_t));

        if (prot != NULL) {
                prot->level             = PI_LEVEL_DEV;
                prot->dup               = pi_inet_protocol_dup;
                prot->free              = pi_inet_protocol_free;
                prot->read              = pi_inet_read;
                prot->write             = pi_inet_write;
                prot->flush             = pi_inet_flush;
                prot->getsockopt        = pi_inet_getsockopt;
                prot->setsockopt        = pi_inet_setsockopt;
                prot->data = NULL;
        }
        
        return prot;
}

Here is the call graph for this function:

static pi_protocol_t * pi_inet_protocol_dup

(

pi_protocol_t *

prot

)

[static]

Definition at line 139 of file inet.c.

References ASSERT, pi_protocol::data, pi_protocol::dup, pi_protocol::flush, pi_protocol::free, pi_protocol::getsockopt, pi_protocol::level, pi_protocol::read, pi_protocol::setsockopt, and pi_protocol::write.

Referenced by pi_inet_protocol().

{
        pi_protocol_t *new_prot;

        ASSERT (prot != NULL);

        new_prot = (pi_protocol_t *)malloc (sizeof (pi_protocol_t));

        if (new_prot != NULL) {
                new_prot->level         = prot->level;
                new_prot->dup           = prot->dup;
                new_prot->free          = prot->free;
                new_prot->read          = prot->read;
                new_prot->write         = prot->write;
                new_prot->flush         = prot->flush;
                new_prot->getsockopt    = prot->getsockopt;
                new_prot->setsockopt    = prot->setsockopt;
                new_prot->data          = NULL;
        }

        return new_prot;
}

static void pi_inet_protocol_free

(

pi_protocol_t *

prot

)

[static]

Definition at line 163 of file inet.c.

References ASSERT.

Referenced by pi_inet_protocol().

{
        ASSERT (prot != NULL);
        if (prot != NULL)
                free(prot);
}

static ssize_t pi_inet_read	(	pi_socket_t *	ps,
		pi_buffer_t *	msg,
		size_t	len,
		int	flags
	)			[static]

Definition at line 495 of file inet.c.

References pi_device::data, pi_socket::device, LOG, pi_buffer_expect(), PI_DBG_DEV, PI_DBG_LVL_INFO, PI_DBG_LVL_WARN, PI_ERR_GENERIC_MEMORY, PI_ERR_SOCK_DISCONNECTED, PI_ERR_SOCK_IO, PI_ERR_SOCK_TIMEOUT, PI_MSG_PEEK, pi_set_error(), PI_SOCK_CONN_BREAK, pi_inet_data::rx_bytes, pi_inet_data::rx_errors, pi_socket::sd, pi_socket::state, and pi_inet_data::timeout.

Referenced by pi_inet_protocol().

{
        int     r, 
                fl      = 0;
        pi_inet_data_t *data = (pi_inet_data_t *)ps->device->data;
        fd_set  ready;
        struct  timeval t;

        if (pi_buffer_expect (msg, len) == NULL) {
                errno = ENOMEM;
                return pi_set_error(ps->sd, PI_ERR_GENERIC_MEMORY);
        }

        if (flags == PI_MSG_PEEK)
                fl = MSG_PEEK;
        
        FD_ZERO(&ready);
        FD_SET(ps->sd, &ready);

        /* If timeout == 0, wait forever for packet, otherwise wait till
           timeout milliseconds */
        if (data->timeout == 0)
                select(ps->sd + 1, &ready, 0, 0, 0);
        else {
                t.tv_sec        = data->timeout / 1000;
                t.tv_usec       = (data->timeout % 1000) * 1000;
                if (select(ps->sd + 1, &ready, 0, 0, &t) == 0)
                        return pi_set_error(ps->sd, PI_ERR_SOCK_TIMEOUT);
        }

        /* If data is available in time, read it */
        if (FD_ISSET(ps->sd, &ready)) {
                r = recv(ps->sd, msg->data + msg->used, len, fl);
                if (r < 0) {
                        if (errno == EPIPE || errno == EBADF) {
                                ps->state = PI_SOCK_CONN_BREAK;
                                return pi_set_error(ps->sd, PI_ERR_SOCK_DISCONNECTED);
                        }
                        return pi_set_error(ps->sd, PI_ERR_SOCK_IO);
                }

                data->rx_bytes += r;
                msg->used += r;

                LOG((PI_DBG_DEV, PI_DBG_LVL_INFO, "DEV RX Inet Bytes: %d\n", r));
                return r;
        }

        /* otherwise throw out any current packet and return */
        LOG((PI_DBG_DEV, PI_DBG_LVL_WARN, "DEV RX Inet timeout\n"));
        data->rx_errors++;
        return 0;
}

Here is the call graph for this function:

static int pi_inet_setsockopt	(	pi_socket_t *	ps,
		int	level,
		int	option_name,
		const void *	option_value,
		size_t *	option_len
	)			[static]

Definition at line 571 of file inet.c.

References pi_device::data, pi_socket::device, PI_DEV_TIMEOUT, PI_ERR_GENERIC_ARGUMENT, pi_set_error(), pi_socket::sd, and pi_inet_data::timeout.

Referenced by pi_inet_protocol().

{
        pi_inet_data_t *data = (pi_inet_data_t *)ps->device->data;

        switch (option_name) {
                case PI_DEV_TIMEOUT:
                        if (*option_len != sizeof (data->timeout)) {
                                errno = EINVAL;
                                return pi_set_error(ps->sd, PI_ERR_GENERIC_ARGUMENT);
                        }
                        memcpy (&data->timeout, option_value,
                                sizeof (data->timeout));
                        break;
        }

        return 0;
}

Here is the call graph for this function:

static ssize_t pi_inet_write	(	pi_socket_t *	ps,
		const unsigned char *	msg,
		size_t	len,
		int	flags
	)			[static]

Definition at line 447 of file inet.c.

References pi_device::data, pi_socket::device, LOG, PI_DBG_DEV, PI_DBG_LVL_INFO, PI_ERR_SOCK_DISCONNECTED, PI_ERR_SOCK_IO, PI_ERR_SOCK_TIMEOUT, pi_set_error(), PI_SOCK_CONN_BREAK, pi_socket::sd, pi_socket::state, pi_inet_data::timeout, and pi_inet_data::tx_bytes.

Referenced by pi_inet_protocol().

{
        int     total,
                nwrote;
        pi_inet_data_t *data = (pi_inet_data_t *)ps->device->data;
        struct  timeval t;
        fd_set  ready;

        FD_ZERO(&ready);
        FD_SET(ps->sd, &ready);

        total = len;
        while (total > 0) {
                if (data->timeout == 0) {
                        if (select(ps->sd + 1, 0, &ready, 0, 0) < 0
                                && errno == EINTR)
                                continue;
                } else {
                        t.tv_sec        = data->timeout / 1000;
                        t.tv_usec       = (data->timeout % 1000) * 1000;
                        if (select(ps->sd + 1, 0, &ready, 0, &t) == 0)
                                return pi_set_error(ps->sd, PI_ERR_SOCK_TIMEOUT);
                }
                if (!FD_ISSET(ps->sd, &ready)) {
                        ps->state = PI_SOCK_CONN_BREAK;
                        return pi_set_error(ps->sd, PI_ERR_SOCK_DISCONNECTED);
                }

                nwrote = write(ps->sd, msg, len);
                if (nwrote < 0) {
                        /* test errno to properly set the socket error */
                        if (errno == EPIPE || errno == EBADF) {
                                ps->state = PI_SOCK_CONN_BREAK;
                                return pi_set_error(ps->sd, PI_ERR_SOCK_DISCONNECTED);
                        }
                        return pi_set_error(ps->sd, PI_ERR_SOCK_IO);
                }

                total -= nwrote;
        }
        data->tx_bytes += len;

        LOG((PI_DBG_DEV, PI_DBG_LVL_INFO, "DEV TX Inet Bytes: %d\n", len));

        return len;
}

Here is the call graph for this function:

int pi_socket_init

(

pi_socket_t *

ps

)

---

© 1996-2007 by pilot-link.org. All rights reserved.