pinger.c File Reference

ICMP ping sender. More...

#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <ipxe/refcnt.h>
#include <ipxe/interface.h>
#include <ipxe/job.h>
#include <ipxe/xfer.h>
#include <ipxe/iobuf.h>
#include <ipxe/open.h>
#include <ipxe/socket.h>
#include <ipxe/retry.h>
#include <ipxe/pinger.h>

Go to the source code of this file.

Data Structures
struct	pinger
	A pinger. More...

Macros
#define	EPROTO_LEN   __einfo_error ( EINFO_EPROTO_LEN )
#define	EINFO_EPROTO_LEN
#define	EPROTO_DATA   __einfo_error ( EINFO_EPROTO_DATA )
#define	EINFO_EPROTO_DATA
#define	EPROTO_SEQ   __einfo_error ( EINFO_EPROTO_SEQ )
#define	EINFO_EPROTO_SEQ

Functions
	FILE_LICENCE (GPL2_OR_LATER_OR_UBDL)
static void	pinger_generate (struct pinger *pinger, void *data)
	Generate payload. More...
static int	pinger_verify (struct pinger *pinger, const void *data)
	Verify payload. More...
static void	pinger_close (struct pinger *pinger, int rc)
	Close pinger. More...
static void	pinger_window_changed (struct pinger *pinger)
	Handle data transfer window change. More...
static void	pinger_expired (struct retry_timer *timer, int over __unused)
	Handle timer expiry. More...
static int	pinger_deliver (struct pinger *pinger, struct io_buffer *iobuf, struct xfer_metadata *meta)
	Handle received data. More...
int	create_pinger (struct interface *job, const char *hostname, unsigned long timeout, size_t len, unsigned int count, void(*callback)(struct sockaddr *src, unsigned int sequence, size_t len, int rc))
	Create pinger. More...

Variables
static struct interface_operation	pinger_xfer_op []
	Pinger data transfer interface operations. More...
static struct interface_descriptor	pinger_xfer_desc
	Pinger data transfer interface descriptor. More...
static struct interface_operation	pinger_job_op []
	Pinger job control interface operations. More...
static struct interface_descriptor	pinger_job_desc
	Pinger job control interface descriptor. More...

Detailed Description

ICMP ping sender.

Definition in file pinger.c.

Macro Definition Documentation

EPROTO_LEN

#define EPROTO_LEN   __einfo_error ( EINFO_EPROTO_LEN )

Definition at line 46 of file pinger.c.

EINFO_EPROTO_LEN

#define EINFO_EPROTO_LEN

Value:

__einfo_uniqify ( EINFO_EPROTO, 0x01, \
                                           "Incorrect reply length" )

Definition at line 47 of file pinger.c.

EPROTO_DATA

#define EPROTO_DATA   __einfo_error ( EINFO_EPROTO_DATA )

Definition at line 49 of file pinger.c.

EINFO_EPROTO_DATA

#define EINFO_EPROTO_DATA

Value:

__einfo_uniqify ( EINFO_EPROTO, 0x02, \
                                            "Incorrect reply data" )

Definition at line 50 of file pinger.c.

EPROTO_SEQ

#define EPROTO_SEQ   __einfo_error ( EINFO_EPROTO_SEQ )

Definition at line 52 of file pinger.c.

EINFO_EPROTO_SEQ

#define EINFO_EPROTO_SEQ

Value:

__einfo_uniqify ( EINFO_EPROTO, 0x03, \
                                           "Delayed or out-of-sequence reply" )

Definition at line 53 of file pinger.c.

Function Documentation

FILE_LICENCE()

FILE_LICENCE

(

GPL2_OR_LATER_OR_UBDL

)

pinger_generate()

static void pinger_generate ( struct pinger *  pinger, void *  data  )

static

Generate payload.

Parameters

pinger	Pinger
data	Data buffer

Definition at line 99 of file pinger.c.

                                                                  {
        uint8_t *bytes = data;
        unsigned int i;

        /* Generate byte sequence */
        for ( i = 0 ; i < pinger->len ; i++ )
                bytes[i] = ( i & 0xff );
}

References bytes, data, and pinger::len.

Referenced by pinger_expired().

pinger_verify()

static int pinger_verify ( struct pinger *  pinger, const void *  data  )

static

Verify payload.

Parameters

pinger	Pinger
data	Data buffer

Return values

rc	Return status code

Definition at line 115 of file pinger.c.

                                                                     {
        const uint8_t *bytes = data;
        unsigned int i;

        /* Check byte sequence */
        for ( i = 0 ; i < pinger->len ; i++ ) {
                if ( bytes[i] != ( i & 0xff ) )
                        return -EPROTO_DATA;
        }

        return 0;
}

References bytes, data, EPROTO_DATA, and pinger::len.

Referenced by pinger_deliver().

pinger_close()

static void pinger_close ( struct pinger *  pinger, int  rc  )

static

Close pinger.

Parameters

pinger	Pinger
rc	Reason for close

Definition at line 134 of file pinger.c.

                                                           {

        /* Stop timer */
        stop_timer ( &pinger->timer );

        /* Shut down interfaces */
        intf_shutdown ( &pinger->xfer, rc );
        intf_shutdown ( &pinger->job, rc );
}

References intf_shutdown(), pinger::job, rc, stop_timer(), pinger::timer, and pinger::xfer.

Referenced by create_pinger(), pinger_deliver(), and pinger_expired().

pinger_window_changed()

static void pinger_window_changed ( struct pinger *  pinger )

static

Handle data transfer window change.

Parameters

pinger

Pinger

Definition at line 149 of file pinger.c.

                                                            {

        /* Do nothing if timer is already running */
        if ( timer_running ( &pinger->timer ) )
                return;

        /* Start timer when window opens for the first time */
        if ( xfer_window ( &pinger->xfer ) )
                start_timer_nodelay ( &pinger->timer );
}

References start_timer_nodelay(), pinger::timer, pinger::xfer, and xfer_window().

pinger_expired()

static void pinger_expired ( struct retry_timer *  timer, int over  __unused  )

static

Handle timer expiry.

Parameters

timer	Timer
over	Failure indicator

Definition at line 166 of file pinger.c.

                                                                            {
        struct pinger *pinger = container_of ( timer, struct pinger, timer );
        struct xfer_metadata meta;
        struct io_buffer *iobuf;
        int rc;

        /* If no response has been received, notify the callback function */
        if ( pinger->pending && pinger->callback )
                pinger->callback ( NULL, pinger->sequence, 0, -ETIMEDOUT );

        /* Check for termination */
        if ( pinger->remaining && ( --pinger->remaining == 0 ) ) {
                pinger_close ( pinger, pinger->rc );
                return;
        }

        /* Increase sequence number */
        pinger->sequence++;

        /* Restart timer.  Do this before attempting to transmit, in
         * case the transmission attempt fails.
         */
        start_timer_fixed ( &pinger->timer, pinger->timeout );
        pinger->pending = 1;

        /* Allocate I/O buffer */
        iobuf = xfer_alloc_iob ( &pinger->xfer, pinger->len );
        if ( ! iobuf ) {
                DBGC ( pinger, "PINGER %p could not allocate I/O buffer\n",
                       pinger );
                return;
        }

        /* Generate payload */
        pinger_generate ( pinger, iob_put ( iobuf, pinger->len ) );

        /* Generate metadata */
        memset ( &meta, 0, sizeof ( meta ) );
        meta.flags = XFER_FL_ABS_OFFSET;
        meta.offset = pinger->sequence;

        /* Transmit packet */
        if ( ( rc = xfer_deliver ( &pinger->xfer, iobuf, &meta ) ) != 0 ) {
                DBGC ( pinger, "PINGER %p could not transmit: %s\n",
                       pinger, strerror ( rc ) );
                return;
        }
}

References pinger::callback, container_of, DBGC, ETIMEDOUT, iob_put, pinger::len, memset(), meta(), NULL, pinger::pending, pinger_close(), pinger_generate(), pinger::rc, rc, pinger::remaining, pinger::sequence, start_timer_fixed(), strerror(), pinger::timeout, pinger::timer, pinger::xfer, xfer_alloc_iob(), xfer_deliver(), and XFER_FL_ABS_OFFSET.

Referenced by create_pinger().

pinger_deliver()

static int pinger_deliver ( struct pinger *  pinger, struct io_buffer *  iobuf, struct xfer_metadata *  meta  )

static

Handle received data.

Parameters

pinger	Pinger
iobuf	I/O buffer
meta	Data transfer metadata

Return values

rc	Return status code

Definition at line 223 of file pinger.c.

                                                         {
        size_t len = iob_len ( iobuf );
        uint16_t sequence = meta->offset;
        int terminate = 0;
        int rc;

        /* Clear response pending flag, if applicable */
        if ( sequence == pinger->sequence )
                pinger->pending = 0;

        /* Check for errors */
        if ( len != pinger->len ) {
                /* Incorrect length: terminate immediately if we are
                 * not pinging indefinitely.
                 */
                DBGC ( pinger, "PINGER %p received incorrect length %zd "
                       "(expected %zd)\n", pinger, len, pinger->len );
                rc = -EPROTO_LEN;
                terminate = ( pinger->remaining != 0 );
        } else if ( ( rc = pinger_verify ( pinger, iobuf->data ) ) != 0 ) {
                /* Incorrect data: terminate immediately if we are not
                 * pinging indefinitely.
                 */
                DBGC ( pinger, "PINGER %p received incorrect data:\n", pinger );
                DBGC_HDA ( pinger, 0, iobuf->data, iob_len ( iobuf ) );
                terminate = ( pinger->remaining != 0 );
        } else if ( sequence != pinger->sequence ) {
                /* Incorrect sequence number (probably a delayed response):
                 * report via callback but otherwise ignore.
                 */
                DBGC ( pinger, "PINGER %p received sequence %d (expected %d)\n",
                       pinger, sequence, pinger->sequence );
                rc = -EPROTO_SEQ;
                terminate = 0;
        } else {
                /* Success: record that a packet was successfully received,
                 * and terminate if we expect to send no further packets.
                 */
                rc = 0;
                pinger->rc = 0;
                terminate = ( pinger->remaining == 1 );
        }

        /* Discard I/O buffer */
        free_iob ( iobuf );

        /* Notify callback function, if applicable */
        if ( pinger->callback )
                pinger->callback ( meta->src, sequence, len, rc );

        /* Terminate if applicable */
        if ( terminate )
                pinger_close ( pinger, rc );

        return rc;
}

References pinger::callback, io_buffer::data, DBGC, DBGC_HDA, EPROTO_LEN, EPROTO_SEQ, free_iob(), iob_len(), len, pinger::len, meta(), pinger::pending, pinger_close(), pinger_verify(), pinger::rc, rc, pinger::remaining, and pinger::sequence.

create_pinger()

int create_pinger	(	struct interface *	job,
		const char *	hostname,
		unsigned long	timeout,
		size_t	len,
		unsigned int	count,
		void(*)(struct sockaddr *src, unsigned int sequence, size_t len, int rc)	callback
	)

Create pinger.

Parameters

job	Job control interface
hostname	Hostname to ping
timeout	Timeout (in ticks)
len	Payload length
count	Number of packets to send (or zero for no limit)
callback	Callback function (or NULL)

Return values

rc	Return status code

Definition at line 312 of file pinger.c.

                                                     {
        struct pinger *pinger;
        int rc;

        /* Sanity check */
        if ( ! timeout )
                return -EINVAL;

        /* Allocate and initialise structure */
        pinger = zalloc ( sizeof ( *pinger ) );
        if ( ! pinger )
                return -ENOMEM;
        ref_init ( &pinger->refcnt, NULL );
        intf_init ( &pinger->job, &pinger_job_desc, &pinger->refcnt );
        intf_init ( &pinger->xfer, &pinger_xfer_desc, &pinger->refcnt );
        timer_init ( &pinger->timer, pinger_expired, &pinger->refcnt );
        pinger->timeout = timeout;
        pinger->len = len;
        pinger->remaining = ( count ? ( count + 1 /* Initial packet */ ) : 0 );
        pinger->callback = callback;
        pinger->rc = -ETIMEDOUT;

        /* Open socket */
        if ( ( rc = xfer_open_named_socket ( &pinger->xfer, SOCK_ECHO, NULL,
                                             hostname, NULL ) ) != 0 ) {
                DBGC ( pinger, "PINGER %p could not open socket: %s\n",
                       pinger, strerror ( rc ) );
                goto err;
        }

        /* Attach parent interface, mortalise self, and return */
        intf_plug_plug ( &pinger->job, job );
        ref_put ( &pinger->refcnt );
        return 0;

 err:
        pinger_close ( pinger, rc );
        ref_put ( &pinger->refcnt );
        return rc;
}

References pinger::callback, count, DBGC, EINVAL, ENOMEM, ETIMEDOUT, intf_init(), intf_plug_plug(), pinger::job, len, pinger::len, NULL, pinger_close(), pinger_expired(), pinger_job_desc, pinger_xfer_desc, pinger::rc, rc, ref_init, ref_put, pinger::refcnt, pinger::remaining, SOCK_ECHO, strerror(), pinger::timeout, timeout(), pinger::timer, pinger::xfer, xfer_open_named_socket(), and zalloc().

Referenced by ping().

Variable Documentation

pinger_xfer_op

struct interface_operation pinger_xfer_op[]

static

Initial value:

= {
        INTF_OP ( xfer_deliver, struct pinger *, pinger_deliver ),
        INTF_OP ( xfer_window_changed, struct pinger *, pinger_window_changed ),
        INTF_OP ( intf_close, struct pinger *, pinger_close ),
}

Pinger data transfer interface operations.

Definition at line 282 of file pinger.c.

pinger_xfer_desc

struct interface_descriptor pinger_xfer_desc

static

Initial value:

=
        INTF_DESC ( struct pinger, xfer, pinger_xfer_op )

Pinger data transfer interface descriptor.

Definition at line 289 of file pinger.c.

Referenced by create_pinger().

pinger_job_op

struct interface_operation pinger_job_op[]

static

Initial value:

= {
        INTF_OP ( intf_close, struct pinger *, pinger_close ),
}

Pinger job control interface operations.

Definition at line 293 of file pinger.c.

pinger_job_desc

struct interface_descriptor pinger_job_desc

static

Initial value:

=
        INTF_DESC ( struct pinger, job, pinger_job_op )

Pinger job control interface descriptor.

Definition at line 298 of file pinger.c.

Referenced by create_pinger().