qemu/roms/ipxe/src/core/pinger.c

   1 /*
   2  * Copyright (C) 2013 Michael Brown <mbrown@fensystems.co.uk>.
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License as
   6  * published by the Free Software Foundation; either version 2 of the
   7  * License, or any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful, but
  10  * WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  17  * 02110-1301, USA.
  18  */
  19
  20 FILE_LICENCE ( GPL2_OR_LATER );
  21
  22 #include <stdlib.h>
  23 #include <string.h>
  24 #include <errno.h>
  25 #include <ipxe/refcnt.h>
  26 #include <ipxe/interface.h>
  27 #include <ipxe/job.h>
  28 #include <ipxe/xfer.h>
  29 #include <ipxe/iobuf.h>
  30 #include <ipxe/open.h>
  31 #include <ipxe/socket.h>
  32 #include <ipxe/retry.h>
  33 #include <ipxe/pinger.h>
  34
  35 /** @file
  36  *
  37  * ICMP ping sender
  38  *
  39  */
  40
  41 /* Disambiguate the various error causes */
  42 #define EPROTO_LEN __einfo_error ( EINFO_EPROTO_LEN )
  43 #define EINFO_EPROTO_LEN __einfo_uniqify ( EINFO_EPROTO, 0x01, \
  44                                            "Incorrect reply length" )
  45 #define EPROTO_DATA __einfo_error ( EINFO_EPROTO_DATA )
  46 #define EINFO_EPROTO_DATA __einfo_uniqify ( EINFO_EPROTO, 0x02, \
  47                                             "Incorrect reply data" )
  48 #define EPROTO_SEQ __einfo_error ( EINFO_EPROTO_SEQ )
  49 #define EINFO_EPROTO_SEQ __einfo_uniqify ( EINFO_EPROTO, 0x03, \
  50                                            "Delayed or out-of-sequence reply" )
  51
  52 /** A pinger */
  53 struct pinger {
  54         /** Reference count */
  55         struct refcnt refcnt;
  56
  57         /** Job control interface */
  58         struct interface job;
  59         /** Data transfer interface */
  60         struct interface xfer;
  61
  62         /** Timer */
  63         struct retry_timer timer;
  64         /** Timeout */
  65         unsigned long timeout;
  66
  67         /** Payload length */
  68         size_t len;
  69         /** Current sequence number */
  70         uint16_t sequence;
  71         /** Response for current sequence number is still pending */
  72         int pending;
  73         /** Number of remaining expiry events (zero to continue indefinitely) */
  74         unsigned int remaining;
  75         /** Return status */
  76         int rc;
  77
  78         /** Callback function
  79          *
  80          * @v src               Source socket address, or NULL
  81          * @v sequence          Sequence number
  82          * @v len               Payload length
  83          * @v rc                Status code
  84          */
  85         void ( * callback ) ( struct sockaddr *src, unsigned int sequence,
  86                               size_t len, int rc );
  87 };
  88
  89 /**
  90  * Generate payload
  91  *
  92  * @v pinger            Pinger
  93  * @v data              Data buffer
  94  */
  95 static void pinger_generate ( struct pinger *pinger, void *data ) {
  96         uint8_t *bytes = data;
  97         unsigned int i;
  98
  99         /* Generate byte sequence */
 100         for ( i = 0 ; i < pinger->len ; i++ )
 101                 bytes[i] = ( i & 0xff );
 102 }
 103
 104 /**
 105  * Verify payload
 106  *
 107  * @v pinger            Pinger
 108  * @v data              Data buffer
 109  * @ret rc              Return status code
 110  */
 111 static int pinger_verify ( struct pinger *pinger, const void *data ) {
 112         const uint8_t *bytes = data;
 113         unsigned int i;
 114
 115         /* Check byte sequence */
 116         for ( i = 0 ; i < pinger->len ; i++ ) {
 117                 if ( bytes[i] != ( i & 0xff ) )
 118                         return -EPROTO_DATA;
 119         }
 120
 121         return 0;
 122 }
 123
 124 /**
 125  * Close pinger
 126  *
 127  * @v pinger            Pinger
 128  * @v rc                Reason for close
 129  */
 130 static void pinger_close ( struct pinger *pinger, int rc ) {
 131
 132         /* Stop timer */
 133         stop_timer ( &pinger->timer );
 134
 135         /* Shut down interfaces */
 136         intf_shutdown ( &pinger->xfer, rc );
 137         intf_shutdown ( &pinger->job, rc );
 138 }
 139
 140 /**
 141  * Handle data transfer window change
 142  *
 143  * @v pinger            Pinger
 144  */
 145 static void pinger_window_changed ( struct pinger *pinger ) {
 146
 147         /* Do nothing if timer is already running */
 148         if ( timer_running ( &pinger->timer ) )
 149                 return;
 150
 151         /* Start timer when window opens for the first time */
 152         if ( xfer_window ( &pinger->xfer ) )
 153                 start_timer_nodelay ( &pinger->timer );
 154 }
 155
 156 /**
 157  * Handle timer expiry
 158  *
 159  * @v timer             Timer
 160  * @v over              Failure indicator
 161  */
 162 static void pinger_expired ( struct retry_timer *timer, int over __unused ) {
 163         struct pinger *pinger = container_of ( timer, struct pinger, timer );
 164         struct xfer_metadata meta;
 165         struct io_buffer *iobuf;
 166         int rc;
 167
 168         /* If no response has been received, notify the callback function */
 169         if ( pinger->pending && pinger->callback )
 170                 pinger->callback ( NULL, pinger->sequence, 0, -ETIMEDOUT );
 171
 172         /* Check for termination */
 173         if ( pinger->remaining && ( --pinger->remaining == 0 ) ) {
 174                 pinger_close ( pinger, pinger->rc );
 175                 return;
 176         }
 177
 178         /* Increase sequence number */
 179         pinger->sequence++;
 180
 181         /* Restart timer.  Do this before attempting to transmit, in
 182          * case the transmission attempt fails.
 183          */
 184         start_timer_fixed ( &pinger->timer, pinger->timeout );
 185         pinger->pending = 1;
 186
 187         /* Allocate I/O buffer */
 188         iobuf = xfer_alloc_iob ( &pinger->xfer, pinger->len );
 189         if ( ! iobuf ) {
 190                 DBGC ( pinger, "PINGER %p could not allocate I/O buffer\n",
 191                        pinger );
 192                 return;
 193         }
 194
 195         /* Generate payload */
 196         pinger_generate ( pinger, iob_put ( iobuf, pinger->len ) );
 197
 198         /* Generate metadata */
 199         memset ( &meta, 0, sizeof ( meta ) );
 200         meta.flags = XFER_FL_ABS_OFFSET;
 201         meta.offset = pinger->sequence;
 202
 203         /* Transmit packet */
 204         if ( ( rc = xfer_deliver ( &pinger->xfer, iobuf, &meta ) ) != 0 ) {
 205                 DBGC ( pinger, "PINGER %p could not transmit: %s\n",
 206                        pinger, strerror ( rc ) );
 207                 return;
 208         }
 209 }
 210
 211 /**
 212  * Handle received data
 213  *
 214  * @v pinger            Pinger
 215  * @v iobuf             I/O buffer
 216  * @v meta              Data transfer metadata
 217  * @ret rc              Return status code
 218  */
 219 static int pinger_deliver ( struct pinger *pinger, struct io_buffer *iobuf,
 220                             struct xfer_metadata *meta ) {
 221         size_t len = iob_len ( iobuf );
 222         uint16_t sequence = meta->offset;
 223         int terminate = 0;
 224         int rc;
 225
 226         /* Clear response pending flag, if applicable */
 227         if ( sequence == pinger->sequence )
 228                 pinger->pending = 0;
 229
 230         /* Check for errors */
 231         if ( len != pinger->len ) {
 232                 /* Incorrect length: terminate immediately if we are
 233                  * not pinging indefinitely.
 234                  */
 235                 DBGC ( pinger, "PINGER %p received incorrect length %zd "
 236                        "(expected %zd)\n", pinger, len, pinger->len );
 237                 rc = -EPROTO_LEN;
 238                 terminate = ( pinger->remaining != 0 );
 239         } else if ( ( rc = pinger_verify ( pinger, iobuf->data ) ) != 0 ) {
 240                 /* Incorrect data: terminate immediately if we are not
 241                  * pinging indefinitely.
 242                  */
 243                 DBGC ( pinger, "PINGER %p received incorrect data:\n", pinger );
 244                 DBGC_HDA ( pinger, 0, iobuf->data, iob_len ( iobuf ) );
 245                 terminate = ( pinger->remaining != 0 );
 246         } else if ( sequence != pinger->sequence ) {
 247                 /* Incorrect sequence number (probably a delayed response):
 248                  * report via callback but otherwise ignore.
 249                  */
 250                 DBGC ( pinger, "PINGER %p received sequence %d (expected %d)\n",
 251                        pinger, sequence, pinger->sequence );
 252                 rc = -EPROTO_SEQ;
 253                 terminate = 0;
 254         } else {
 255                 /* Success: record that a packet was successfully received,
 256                  * and terminate if we expect to send no further packets.
 257                  */
 258                 rc = 0;
 259                 pinger->rc = 0;
 260                 terminate = ( pinger->remaining == 1 );
 261         }
 262
 263         /* Discard I/O buffer */
 264         free_iob ( iobuf );
 265
 266         /* Notify callback function, if applicable */
 267         if ( pinger->callback )
 268                 pinger->callback ( meta->src, sequence, len, rc );
 269
 270         /* Terminate if applicable */
 271         if ( terminate )
 272                 pinger_close ( pinger, rc );
 273
 274         return rc;
 275 }
 276
 277 /** Pinger data transfer interface operations */
 278 static struct interface_operation pinger_xfer_op[] = {
 279         INTF_OP ( xfer_deliver, struct pinger *, pinger_deliver ),
 280         INTF_OP ( xfer_window_changed, struct pinger *, pinger_window_changed ),
 281         INTF_OP ( intf_close, struct pinger *, pinger_close ),
 282 };
 283
 284 /** Pinger data transfer interface descriptor */
 285 static struct interface_descriptor pinger_xfer_desc =
 286         INTF_DESC ( struct pinger, xfer, pinger_xfer_op );
 287
 288 /** Pinger job control interface operations */
 289 static struct interface_operation pinger_job_op[] = {
 290         INTF_OP ( intf_close, struct pinger *, pinger_close ),
 291 };
 292
 293 /** Pinger job control interface descriptor */
 294 static struct interface_descriptor pinger_job_desc =
 295         INTF_DESC ( struct pinger, job, pinger_job_op );
 296
 297 /**
 298  * Create pinger
 299  *
 300  * @v job               Job control interface
 301  * @v hostname          Hostname to ping
 302  * @v timeout           Timeout (in ticks)
 303  * @v len               Payload length
 304  * @v count             Number of packets to send (or zero for no limit)
 305  * @v callback          Callback function (or NULL)
 306  * @ret rc              Return status code
 307  */
 308 int create_pinger ( struct interface *job, const char *hostname,
 309                     unsigned long timeout, size_t len, unsigned int count,
 310                     void ( * callback ) ( struct sockaddr *src,
 311                                           unsigned int sequence, size_t len,
 312                                           int rc ) ) {
 313         struct pinger *pinger;
 314         int rc;
 315
 316         /* Sanity check */
 317         if ( ! timeout )
 318                 return -EINVAL;
 319
 320         /* Allocate and initialise structure */
 321         pinger = zalloc ( sizeof ( *pinger ) );
 322         if ( ! pinger )
 323                 return -ENOMEM;
 324         ref_init ( &pinger->refcnt, NULL );
 325         intf_init ( &pinger->job, &pinger_job_desc, &pinger->refcnt );
 326         intf_init ( &pinger->xfer, &pinger_xfer_desc, &pinger->refcnt );
 327         timer_init ( &pinger->timer, pinger_expired, &pinger->refcnt );
 328         pinger->timeout = timeout;
 329         pinger->len = len;
 330         pinger->remaining = ( count ? ( count + 1 /* Initial packet */ ) : 0 );
 331         pinger->callback = callback;
 332         pinger->rc = -ETIMEDOUT;
 333
 334         /* Open socket */
 335         if ( ( rc = xfer_open_named_socket ( &pinger->xfer, SOCK_ECHO, NULL,
 336                                              hostname, NULL ) ) != 0 ) {
 337                 DBGC ( pinger, "PINGER %p could not open socket: %s\n",
 338                        pinger, strerror ( rc ) );
 339                 goto err;
 340         }
 341
 342         /* Attach parent interface, mortalise self, and return */
 343         intf_plug_plug ( &pinger->job, job );
 344         ref_put ( &pinger->refcnt );
 345         return 0;
 346
 347  err:
 348         pinger_close ( pinger, rc );
 349         ref_put ( &pinger->refcnt );
 350         return rc;
 351 }