---

net.c File Reference

#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>
#include "pi-debug.h"
#include "pi-source.h"
#include "pi-net.h"
#include "pi-error.h"

Include dependency graph for net.c:

Go to the source code of this file.

Defines
#define	PI_NET_TIMEOUT   30*1000
Functions
static int	net_flush (pi_socket_t *ps, int flags)
static int	net_getsockopt (pi_socket_t *ps, int level, int option_name, void *option_value, size_t *option_len)
static int	net_setsockopt (pi_socket_t *ps, int level, int option_name, const void *option_value, size_t *option_len)
static pi_protocol_t *	net_protocol_dup (pi_protocol_t *prot)
static void	net_protocol_free (pi_protocol_t *prot)
pi_protocol_t *	net_protocol (void)
int	net_rx_handshake (pi_socket_t *ps)
int	net_tx_handshake (pi_socket_t *ps)
ssize_t	net_tx (pi_socket_t *ps, const unsigned char *msg, size_t len, int flags)
ssize_t	net_rx (pi_socket_t *ps, pi_buffer_t *msg, size_t len, int flags)
void	net_dump_header (unsigned char *data, int rxtx, int sd)
void	net_dump (unsigned char *header, unsigned char *data)

---

Define Documentation

#define PI_NET_TIMEOUT   30*1000

Definition at line 40 of file net.c.

Referenced by net_rx().

---

Function Documentation

void net_dump	(	unsigned char *	header,
		unsigned char *	data
	)

Definition at line 702 of file net.c.

References get_long, pi_dumpdata(), PI_NET_OFFSET_SIZE, and size.

Referenced by net_rx().

{
        size_t  size;

        size = get_long(&header[PI_NET_OFFSET_SIZE]);
        pi_dumpdata((char *)data, size);
}

Here is the call graph for this function:

void net_dump_header	(	unsigned char *	data,
		int	rxtx,
		int	sd
	)

Definition at line 678 of file net.c.

References get_byte, get_long, LOG, PI_DBG_LVL_NONE, PI_DBG_NET, PI_NET_OFFSET_SIZE, PI_NET_OFFSET_TXID, and PI_NET_OFFSET_TYPE.

Referenced by net_rx(), and net_tx().

{
        LOG((PI_DBG_NET, PI_DBG_LVL_NONE,
            "NET %s sd=%i type=%d txid=0x%.2x len=0x%.4x\n",
            rxtx ? "TX" : "RX",
            sd,
            get_byte(&data[PI_NET_OFFSET_TYPE]),
            get_byte(&data[PI_NET_OFFSET_TXID]),
            get_long(&data[PI_NET_OFFSET_SIZE])));
}

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

Definition at line 277 of file net.c.

References pi_protocol::flush, PI_ERR_SOCK_INVALID, PI_LEVEL_NET, pi_protocol(), pi_protocol_next(), pi_set_error(), and pi_socket::sd.

Referenced by net_protocol().

{
        pi_protocol_t   *prot,
                        *next;

        prot = pi_protocol(ps->sd, PI_LEVEL_NET);
        if (prot == NULL)
                return pi_set_error(ps->sd, PI_ERR_SOCK_INVALID);

        next = pi_protocol_next(ps->sd, PI_LEVEL_NET);
        if (next == NULL)
                return pi_set_error(ps->sd, PI_ERR_SOCK_INVALID);

        return next->flush(ps, flags);
}

Here is the call graph for this function:

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

Definition at line 573 of file net.c.

References pi_protocol::data, PI_ERR_GENERIC_ARGUMENT, PI_ERR_SOCK_INVALID, PI_LEVEL_NET, PI_NET_TYPE, pi_protocol(), pi_set_error(), pi_socket::sd, and pi_net_data::type.

Referenced by net_protocol().

{
        pi_protocol_t *prot;
        pi_net_data_t *data;

        prot = pi_protocol(ps->sd, PI_LEVEL_NET);
        if (prot == NULL)
                return pi_set_error(ps->sd, PI_ERR_SOCK_INVALID);

        data = (pi_net_data_t *)prot->data;

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

        return 0;
}

Here is the call graph for this function:

pi_protocol_t* net_protocol

(

void

)

Definition at line 135 of file net.c.

References pi_protocol::data, pi_protocol::dup, pi_protocol::flush, pi_protocol::free, pi_protocol::getsockopt, pi_protocol::level, net_flush(), net_getsockopt(), net_protocol_dup(), net_protocol_free(), net_rx(), net_setsockopt(), net_tx(), PI_LEVEL_NET, PI_NET_TYPE_DATA, pi_protocol::read, pi_protocol::setsockopt, pi_net_data::split_writes, pi_net_data::txid, pi_net_data::type, pi_protocol::write, and pi_net_data::write_chunksize.

{
        pi_protocol_t *prot = NULL;
        pi_net_data_t *data = NULL;

        prot = (pi_protocol_t *)malloc (sizeof (pi_protocol_t));        
        if (prot != NULL) {
                data = (pi_net_data_t *)malloc (sizeof (pi_net_data_t));
                if (data == NULL) {
                        free(prot);
                        prot = NULL;
                }
        }

        if (prot != NULL && data != NULL) {
                prot->level             = PI_LEVEL_NET;
                prot->dup               = net_protocol_dup;
                prot->free              = net_protocol_free;
                prot->read              = net_rx;
                prot->write             = net_tx;
                prot->flush             = net_flush;
                prot->getsockopt        = net_getsockopt;
                prot->setsockopt        = net_setsockopt;

                data->type              = PI_NET_TYPE_DATA;
                data->split_writes      = 1;        /* write packet header and data separately */
                data->write_chunksize   = 4096;     /* and push data in 4k chunks. Required for some USB devices */
                data->txid              = 0x00;
                prot->data              = data;
        }

        return prot;
}

Here is the call graph for this function:

static pi_protocol_t* net_protocol_dup

(

pi_protocol_t *

prot

)

[static]

Definition at line 60 of file net.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, pi_net_data::split_writes, pi_net_data::txid, pi_net_data::type, pi_protocol::write, and pi_net_data::write_chunksize.

Referenced by net_protocol().

{
        pi_protocol_t *new_prot = NULL;
        pi_net_data_t   *data = NULL,
                        *new_data = NULL;

        ASSERT(prot != NULL);
        
        new_prot = (pi_protocol_t *)malloc (sizeof (pi_protocol_t));
        if (new_prot != NULL) {
                new_data = (pi_net_data_t *)malloc (sizeof (pi_net_data_t));
                if (new_data == NULL) {
                        free(new_prot);
                        new_prot = NULL;
                }
        }

        if (new_prot != NULL && new_data != 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;

                data                    = (pi_net_data_t *)prot->data;
                new_data->type          = data->type;
                new_data->split_writes  = data->split_writes;
                new_data->write_chunksize       = data->write_chunksize;
                new_data->txid          = data->txid;
                new_prot->data          = new_data;
        }

        return new_prot;
}

static void net_protocol_free

(

pi_protocol_t *

prot

)

[static]

Definition at line 111 of file net.c.

References ASSERT, and pi_protocol::data.

Referenced by net_protocol().

{
        ASSERT (prot != NULL);

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

ssize_t net_rx	(	pi_socket_t *	ps,
		pi_buffer_t *	msg,
		size_t	len,
		int	flags
	)

Definition at line 407 of file net.c.

References CHECK, pi_socket::command, pi_buffer_t::data, pi_protocol::data, pi_protocol::flush, get_long, LOG, net_dump(), net_dump_header(), pi_buffer_free(), pi_buffer_new(), PI_DBG_LVL_DEBUG, PI_DBG_LVL_ERR, PI_DBG_LVL_INFO, PI_DBG_NET, PI_DEV_TIMEOUT, pi_dumpdata(), PI_ERR_GENERIC_MEMORY, PI_ERR_PROT_BADPACKET, PI_ERR_SOCK_INVALID, PI_FLUSH_INPUT, pi_getsockopt(), PI_LEVEL_DEV, PI_LEVEL_NET, PI_LEVEL_SOCK, PI_NET_HEADER_LEN, PI_NET_OFFSET_SIZE, PI_NET_OFFSET_TXID, PI_NET_OFFSET_TYPE, PI_NET_TIMEOUT, PI_NET_TYPE_DATA, PI_NET_TYPE_TCKL, pi_protocol(), pi_protocol_next(), pi_set_error(), pi_setsockopt(), PI_SOCK_CONN_INIT, PI_SOCK_HONOR_RX_TIMEOUT, pi_protocol::read, pi_socket::sd, set_long, size, pi_socket::state, pi_net_data::txid, pi_net_data::type, and pi_buffer_t::used.

Referenced by net_protocol(), net_rx_handshake(), and net_tx_handshake().

{
        int     bytes, 
                total_bytes, 
                packet_len,
                timeout,
                honor_rx_timeout;
        size_t  size;
        pi_protocol_t   *prot,
                        *next;
        pi_buffer_t *header;
        pi_net_data_t *data;

        prot = pi_protocol(ps->sd, PI_LEVEL_NET);
        if (prot == NULL)
                return pi_set_error(ps->sd, PI_ERR_SOCK_INVALID);
        
        data = (pi_net_data_t *)prot->data;
        next = pi_protocol_next(ps->sd, PI_LEVEL_NET);
        if (next == NULL)
                return pi_set_error(ps->sd, PI_ERR_SOCK_INVALID);

        size = sizeof(honor_rx_timeout);
        pi_getsockopt(ps->sd, PI_LEVEL_SOCK, PI_SOCK_HONOR_RX_TIMEOUT,
                &honor_rx_timeout, &size);

        timeout = honor_rx_timeout ? PI_NET_TIMEOUT : 0;
        size = sizeof(timeout);
        pi_setsockopt(ps->sd, PI_LEVEL_DEV, PI_DEV_TIMEOUT, 
                      &timeout, &size);

        header = pi_buffer_new (PI_NET_HEADER_LEN);
        if (header == NULL) {
                errno = ENOMEM;
                return pi_set_error(ps->sd, PI_ERR_GENERIC_MEMORY);
        }

        /* loop until we find a non-tickle packet (if the other end
           sends us a tickle, we would receive it prior to getting
           the expected reply to one of our commands, so we need
           to make sure tickle packets don't get in the way) */
        total_bytes = 0;
        while (!total_bytes) {
                if (data->txid == 0) {  
                        /* Peek to see if it is a headerless packet */
                        bytes = next->read(ps, header, 1, flags);
                        if (bytes <= 0) {
                                pi_buffer_free (header);
                                return bytes;
                        }
                        
                        LOG ((PI_DBG_NET, PI_DBG_LVL_INFO,
                                  "NET RX (%i): Checking for headerless packet %d\n",
                                  ps->sd, header->data[0]));
                        
                        if (header->data[0] == 0x90) {
                                /* Cause the header bytes to be skipped */
                                LOG ((PI_DBG_NET, PI_DBG_LVL_INFO,
                                          "NET RX (%i): Headerless packet\n",
                                          ps->sd));
                                total_bytes = PI_NET_HEADER_LEN;
                                header->data[PI_NET_OFFSET_TYPE] = PI_NET_TYPE_DATA;
                                header->data[PI_NET_OFFSET_TXID] = 0x01;
                                set_long (&header->data[PI_NET_OFFSET_SIZE], 21);
                                break;
                        } else {
                                total_bytes += bytes;
                        }
                }
                
                /* bytes in what's left of the header */
                while (total_bytes < PI_NET_HEADER_LEN) {
                        bytes = next->read(ps, header,
                                        (size_t)(PI_NET_HEADER_LEN - total_bytes), flags);
                        if (bytes <= 0) {
                                pi_buffer_free (header);
                                return bytes;
                        }
                        total_bytes += bytes;
                }
                
                packet_len = get_long(&header->data[PI_NET_OFFSET_SIZE]);
                data->type = header->data[PI_NET_OFFSET_TYPE];

                switch (data->type) {
                        case PI_NET_TYPE_TCKL:
                                if (packet_len != 0) {
                                        LOG ((PI_DBG_NET, PI_DBG_LVL_ERR,
                                                "NET RX (%i): tickle packet with non-zero length\n",
                                                ps->sd));
                                        pi_buffer_free(header);
                                        return pi_set_error(ps->sd, PI_ERR_PROT_BADPACKET);
                                }
                                /* valid tickle packet; continue reading. */
                                LOG((PI_DBG_NET, PI_DBG_LVL_DEBUG,
                                        "NET RX (%i): received tickle packet\n",
                                        ps->sd));
                                total_bytes = 0;
                                header->used = 0;
                                break;
                        
                        case PI_NET_TYPE_DATA:
                                /* move on to reading the rest of the packet */
                                break;

                        default:
                                LOG ((PI_DBG_NET, PI_DBG_LVL_ERR,
                                        "NET RX (%i): Unknown packet type\n",
                                        ps->sd));
                                CHECK(PI_DBG_NET, PI_DBG_LVL_INFO, pi_dumpdata((char *)header->data, PI_NET_HEADER_LEN));
                                pi_buffer_free(header);
                                return pi_set_error(ps->sd, PI_ERR_PROT_BADPACKET);
                }
        }

        total_bytes = 0;
        packet_len = get_long(&header->data[PI_NET_OFFSET_SIZE]);

        /* shield against absurd packet lengths */
        if (packet_len < 0 || packet_len > 0x100000L) {
                /* we see an invalid packet */
                next->flush(ps, PI_FLUSH_INPUT);
                LOG ((PI_DBG_NET, PI_DBG_LVL_ERR, "NET RX (%i): Invalid packet length (%ld)\n", ps->sd, packet_len));
                pi_buffer_free(header);
                return pi_set_error(ps->sd, PI_ERR_PROT_BADPACKET);
        }

        /* read the actual packet data */
        while (total_bytes < packet_len) {
                bytes = next->read(ps, msg,
                        (size_t)(packet_len - total_bytes), flags);
                if (bytes < 0) {
                        pi_buffer_free (header);
                        return bytes;
                }
                total_bytes += bytes;
        }

        CHECK(PI_DBG_NET, PI_DBG_LVL_INFO, net_dump_header(header->data, 0, ps->sd));
        CHECK(PI_DBG_NET, PI_DBG_LVL_DEBUG, net_dump(header->data, msg->data));

        /* Update the transaction id */
        if (ps->state == PI_SOCK_CONN_INIT || ps->command == 1)
                data->txid = header->data[PI_NET_OFFSET_TXID];
        else {
                data->txid++;
                if (data->txid == 0xff)
                        data->txid = 1;
        }

        pi_buffer_free (header);
        return packet_len;
}

Here is the call graph for this function:

int net_rx_handshake

(

pi_socket_t *

ps

)

Definition at line 182 of file net.c.

References buffer, net_rx(), net_tx(), pi_buffer_free(), pi_buffer_new(), PI_ERR_GENERIC_MEMORY, pi_set_error(), and pi_socket::sd.

Referenced by pi_bluetooth_accept(), pi_inet_accept(), pi_serial_accept(), and pi_usb_accept().

{
        static const unsigned char msg1[] =     /* 50 bytes */
                "\x12\x01\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00"
                "\x24\xff\xff\xff\xff\x3c\x00\x3c\x00\x00\x00\x00\x00"
                "\x00\x00\x00\x00\xc0\xa8\xa5\x1f\x04\x27\x00\x00\x00"
                "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00";
        static const unsigned char msg2[] =     /* 46 bytes */
                "\x13\x01\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00"
                "\x20\xff\xff\xff\xff\x00\x3c\x00\x3c\x00\x00\x00\x00"
                "\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00"
                "\x00\x00\x00\x00\x00\x00\x00";
        pi_buffer_t *buffer;
        int err;

        buffer = pi_buffer_new (256);
        if (buffer == NULL) {
                errno = ENOMEM;
                return pi_set_error(ps->sd, PI_ERR_GENERIC_MEMORY);
        }

        if ((err = net_rx(ps, buffer, 256, 0)) >= 0  &&
                (err = net_tx(ps, msg1, 50, 0)) >= 0    &&
                (err = net_rx(ps, buffer, 50, 0)) >= 0  &&
                (err = net_tx(ps, msg2, 46, 0)) >= 0    &&
                (err = net_rx(ps, buffer, 8, 0)) >= 0)
        {
                pi_buffer_free (buffer);
                return 0;
        }

        pi_buffer_free (buffer);
        return err;
}

Here is the call graph for this function:

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

Definition at line 613 of file net.c.

References pi_protocol::data, PI_ERR_GENERIC_ARGUMENT, PI_ERR_SOCK_INVALID, PI_LEVEL_NET, PI_NET_SPLIT_WRITES, PI_NET_TYPE, PI_NET_WRITE_CHUNKSIZE, pi_protocol(), pi_set_error(), pi_socket::sd, pi_net_data::split_writes, pi_net_data::type, and pi_net_data::write_chunksize.

Referenced by net_protocol().

{
        pi_protocol_t *prot;
        pi_net_data_t *data;

        prot = pi_protocol(ps->sd, PI_LEVEL_NET);
        if (prot == NULL)
                return pi_set_error(ps->sd, PI_ERR_SOCK_INVALID);

        data = (pi_net_data_t *)prot->data;

        switch (option_name) {
                case PI_NET_TYPE:
                        if (*option_len != sizeof (data->type)) {
                                errno = EINVAL;
                                return pi_set_error(ps->sd, PI_ERR_GENERIC_ARGUMENT);
                        }
                        memcpy (&data->type, option_value,
                                sizeof (data->type));
                        break;
                
                /* this option, when set to != 0, instructs NET to separately
                 * write the NET header and the data block. Data can be further
                 * sent in chunks by also setting PI_NET_WRITE_CHUNKSIZE below.
                 */
                case PI_NET_SPLIT_WRITES:
                        if (*option_len != sizeof (data->split_writes)) {
                                errno = EINVAL;
                                return pi_set_error(ps->sd, PI_ERR_GENERIC_ARGUMENT);
                        }
                        memcpy (&data->split_writes, option_value,
                                sizeof(data->split_writes));
                        break;

                /* this option, when set to != 0, instructs NET to write the
                 * packet data in chunks of the given maximum size. If
                 * PI_NET_SPLIT_WRITES is not set, and this option is set, we
                 * chunk the whole write (including the NET header)
                 */
                case PI_NET_WRITE_CHUNKSIZE:
                        if (*option_len != sizeof (data->write_chunksize)) {
                                errno = EINVAL;
                                return pi_set_error(ps->sd, PI_ERR_GENERIC_ARGUMENT);
                        }
                        memcpy (&data->write_chunksize, option_value,
                                sizeof(data->write_chunksize));
                        break;
        }

        return 0;
}

Here is the call graph for this function:

ssize_t net_tx	(	pi_socket_t *	ps,
		const unsigned char *	msg,
		size_t	len,
		int	flags
	)

Definition at line 305 of file net.c.

References buf, CHECK, pi_protocol::data, net_dump_header(), PI_DBG_LVL_DEBUG, PI_DBG_LVL_INFO, PI_DBG_NET, pi_dumpdata(), PI_ERR_GENERIC_MEMORY, PI_ERR_SOCK_INVALID, PI_LEVEL_NET, PI_NET_HEADER_LEN, PI_NET_OFFSET_SIZE, PI_NET_OFFSET_TXID, PI_NET_OFFSET_TYPE, PI_NET_TYPE_TCKL, pi_protocol(), pi_protocol_next(), pi_set_error(), pi_socket::sd, set_long, pi_net_data::split_writes, pi_net_data::txid, pi_net_data::type, pi_protocol::write, and pi_net_data::write_chunksize.

{
        int     bytes,
                        offset,
                        remain,
                        tosend;
        pi_protocol_t   *prot,
                        *next;
        pi_net_data_t *data;
        unsigned char *buf;

        prot = pi_protocol(ps->sd, PI_LEVEL_NET);
        if (prot == NULL)
                return pi_set_error(ps->sd, PI_ERR_SOCK_INVALID);
        data = (pi_net_data_t *)prot->data;

        next = pi_protocol_next(ps->sd, PI_LEVEL_NET);
        if (next == NULL)
                return pi_set_error(ps->sd, PI_ERR_SOCK_INVALID);

        /* Create the header */
        buf = (unsigned char *) malloc(PI_NET_HEADER_LEN + len);
        if (buf == NULL)
                return pi_set_error(ps->sd, PI_ERR_GENERIC_MEMORY);
        buf[PI_NET_OFFSET_TYPE] = data->type;
        if (data->type == PI_NET_TYPE_TCKL)
                buf[PI_NET_OFFSET_TXID] = 0xff;
        else
                buf[PI_NET_OFFSET_TXID] = data->txid;
        set_long(&buf[PI_NET_OFFSET_SIZE], len);
        memcpy(&buf[PI_NET_HEADER_LEN], msg, len);

        /* Write the header and body, possibly in one write, or in two,
         * or in more, depending on the current options. Crucial options
         * here are `split_writes' and `write_chunksize' in this protocol's
         * data (use net_setsockopt() to set them).
         */
        if (data->split_writes)
        {
                /* Bugfix for USB send problems. If connected over
                 * USB, do the following:
                 * - send the 6 bytes of header first
                 * - split the rest of data into chunks if the write_chunksize opt is set
                 * This is what Palm Desktop does on Windows for the Zire 72
                 * (uses split writes and 4k chunks)
                 * -- FP
                 */
                bytes = next->write(ps, buf, PI_NET_HEADER_LEN, flags);
                if (bytes < PI_NET_HEADER_LEN)
                {
                        free(buf);
                        return bytes;
                }
                offset = PI_NET_HEADER_LEN;
                remain = len;
        }
        else
        {
                offset = 0;
                remain = PI_NET_HEADER_LEN + len;
        }

        while (remain > 0)
        {
                if (data->write_chunksize)
                        tosend = (remain > data->write_chunksize) ? data->write_chunksize : remain;
                else
                        tosend = remain;

                bytes = next->write(ps, &buf[offset], tosend, flags);
                if (bytes < tosend)
                {
                        free(buf);
                        return bytes;
                }
                remain -= bytes;
                offset += bytes;
        }

        CHECK(PI_DBG_NET, PI_DBG_LVL_INFO, net_dump_header(buf, 1, ps->sd));
        CHECK(PI_DBG_NET, PI_DBG_LVL_DEBUG, pi_dumpdata((char *)msg, len));
        
        free(buf);
        return len;
}

Here is the call graph for this function:

int net_tx_handshake

(

pi_socket_t *

ps

)

Definition at line 230 of file net.c.

References buffer, net_rx(), net_tx(), pi_buffer_free(), pi_buffer_new(), PI_ERR_GENERIC_MEMORY, pi_set_error(), and pi_socket::sd.

Referenced by pi_inet_connect(), and pi_usb_connect().

{
        static const unsigned char msg1[] =     /* 22 bytes */
                "\x90\x01\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00"
                "\x08\x01\x00\x00\x00\x00\x00\x00\x00";
        static const unsigned char msg2[] =     /* 50 bytes */
                "\x92\x01\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00"
                "\x24\xff\xff\xff\xff\x00\x3c\x00\x3c\x40\x00\x00\x00"
                "\x01\x00\x00\x00\xc0\xa8\xa5\x1e\x04\x01\x00\x00\x00"
                "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00";
        static const unsigned char msg3[] =     /* 8 bytes */
                "\x93\x00\x00\x00\x00\x00\x00\x00";
        pi_buffer_t *buffer;
        int err;

        buffer = pi_buffer_new (256);
        if (buffer == NULL) {
                errno = ENOMEM;
                return pi_set_error(ps->sd, PI_ERR_GENERIC_MEMORY);
        }
        
        if ((err = net_tx(ps, msg1, 22, 0)) >= 0        &&
                (err = net_rx(ps, buffer, 256, 0)) >= 0  &&
                (err = net_tx(ps, msg2, 50, 0)) >= 0    &&
                (err = net_rx(ps, buffer, 256, 0)) >= 0  &&
                (err = net_tx(ps, msg3, 8, 0)) >= 0)
        {
                pi_buffer_free (buffer);
                return 0;
        }

        pi_buffer_free (buffer);
        return err;
}

Here is the call graph for this function:

---

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