pinger.c

Go to the documentation of this file.

/*
 * Copyright (C) 2013 Michael Brown <mbrown@fensystems.co.uk>.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 * 02110-1301, USA.
 *
 * You can also choose to distribute this program under the terms of
 * the Unmodified Binary Distribution Licence (as given in the file
 * COPYING.UBDL), provided that you have satisfied its requirements.
 */

FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );

#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>

/** @file
 *
 * ICMP ping sender
 *
 */

/* Disambiguate the various error causes */
#define EPROTO_LEN __einfo_error ( EINFO_EPROTO_LEN )
#define EINFO_EPROTO_LEN __einfo_uniqify ( EINFO_EPROTO, 0x01, \
                                           "Incorrect reply length" )
#define EPROTO_DATA __einfo_error ( EINFO_EPROTO_DATA )
#define EINFO_EPROTO_DATA __einfo_uniqify ( EINFO_EPROTO, 0x02, \
                                            "Incorrect reply data" )
#define EPROTO_SEQ __einfo_error ( EINFO_EPROTO_SEQ )
#define EINFO_EPROTO_SEQ __einfo_uniqify ( EINFO_EPROTO, 0x03, \
                                           "Delayed or out-of-sequence reply" )

/** A pinger */
struct pinger {
        /** Reference count */
        struct refcnt refcnt;

        /** Job control interface */
        struct interface job;
        /** Data transfer interface */
        struct interface xfer;

        /** Timer */
        struct retry_timer timer;
        /** Timeout */
        unsigned long timeout;

        /** Payload length */
        size_t len;
        /** Current sequence number */
        uint16_t sequence;
        /** Response for current sequence number is still pending */
        int pending;
        /** Number of remaining expiry events (zero to continue indefinitely) */
        unsigned int remaining;
        /** Return status */
        int rc;

        /** Callback function
         *
         * @v src               Source socket address, or NULL
         * @v sequence          Sequence number
         * @v len               Payload length
         * @v rc                Status code
         */
        void ( * callback ) ( struct sockaddr *src, unsigned int sequence,
                              size_t len, int rc );
};

/**
 * Generate payload
 *
 * @v pinger            Pinger
 * @v data              Data buffer
 */
static void pinger_generate ( struct pinger *pinger, void *data ) {
        uint8_t *bytes = data;
        unsigned int i;

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

/**
 * Verify payload
 *
 * @v pinger            Pinger
 * @v data              Data buffer
 * @ret rc              Return status code
 */
static int pinger_verify ( struct pinger *pinger, const void *data ) {
        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;
}

/**
 * Close pinger
 *
 * @v pinger            Pinger
 * @v rc                Reason for close
 */
static void pinger_close ( struct pinger *pinger, int rc ) {

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

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

/**
 * Handle data transfer window change
 *
 * @v pinger            Pinger
 */
static void pinger_window_changed ( struct pinger *pinger ) {

        /* 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 );
}

/**
 * Handle timer expiry
 *
 * @v timer             Timer
 * @v over              Failure indicator
 */
static void pinger_expired ( struct retry_timer *timer, int over __unused ) {
        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;
        }
}

/**
 * Handle received data
 *
 * @v pinger            Pinger
 * @v iobuf             I/O buffer
 * @v meta              Data transfer metadata
 * @ret rc              Return status code
 */
static int pinger_deliver ( struct pinger *pinger, struct io_buffer *iobuf,
                            struct xfer_metadata *meta ) {
        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;
}

/** Pinger data transfer interface operations */
static struct interface_operation pinger_xfer_op[] = {
        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 descriptor */
static struct interface_descriptor pinger_xfer_desc =
        INTF_DESC ( struct pinger, xfer, pinger_xfer_op );

/** Pinger job control interface operations */
static struct interface_operation pinger_job_op[] = {
        INTF_OP ( intf_close, struct pinger *, pinger_close ),
};

/** Pinger job control interface descriptor */
static struct interface_descriptor pinger_job_desc =
        INTF_DESC ( struct pinger, job, pinger_job_op );

/**
 * Create pinger
 *
 * @v job               Job control interface
 * @v hostname          Hostname to ping
 * @v timeout           Timeout (in ticks)
 * @v len               Payload length
 * @v count             Number of packets to send (or zero for no limit)
 * @v callback          Callback function (or NULL)
 * @ret rc              Return status code
 */
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 ) ) {
        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;
}