You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

pinger.c 7.7KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303
  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. FILE_LICENCE ( GPL2_OR_LATER );
  20. #include <stdlib.h>
  21. #include <string.h>
  22. #include <errno.h>
  23. #include <ipxe/refcnt.h>
  24. #include <ipxe/interface.h>
  25. #include <ipxe/job.h>
  26. #include <ipxe/xfer.h>
  27. #include <ipxe/iobuf.h>
  28. #include <ipxe/open.h>
  29. #include <ipxe/socket.h>
  30. #include <ipxe/retry.h>
  31. #include <ipxe/pinger.h>
  32. /** @file
  33. *
  34. * ICMP ping sender
  35. *
  36. */
  37. /* Disambiguate the various error causes */
  38. #define EPROTO_LEN __einfo_error ( EINFO_EPROTO_LEN )
  39. #define EINFO_EPROTO_LEN __einfo_uniqify ( EINFO_EPROTO, 0x01, \
  40. "Incorrect reply length" )
  41. #define EPROTO_DATA __einfo_error ( EINFO_EPROTO_DATA )
  42. #define EINFO_EPROTO_DATA __einfo_uniqify ( EINFO_EPROTO, 0x02, \
  43. "Incorrect reply data" )
  44. #define EPROTO_SEQ __einfo_error ( EINFO_EPROTO_SEQ )
  45. #define EINFO_EPROTO_SEQ __einfo_uniqify ( EINFO_EPROTO, 0x03, \
  46. "Delayed or out-of-sequence reply" )
  47. /** A pinger */
  48. struct pinger {
  49. /** Reference count */
  50. struct refcnt refcnt;
  51. /** Job control interface */
  52. struct interface job;
  53. /** Data transfer interface */
  54. struct interface xfer;
  55. /** Timer */
  56. struct retry_timer timer;
  57. /** Timeout */
  58. unsigned long timeout;
  59. /** Payload length */
  60. size_t len;
  61. /** Current sequence number */
  62. uint16_t sequence;
  63. /** Callback function
  64. *
  65. * @v src Source socket address
  66. * @v sequence Sequence number
  67. * @v len Payload length
  68. * @v rc Status code
  69. */
  70. void ( * callback ) ( struct sockaddr *src, unsigned int sequence,
  71. size_t len, int rc );
  72. };
  73. /**
  74. * Generate payload
  75. *
  76. * @v pinger Pinger
  77. * @v data Data buffer
  78. */
  79. static void pinger_generate ( struct pinger *pinger, void *data ) {
  80. uint8_t *bytes = data;
  81. unsigned int i;
  82. /* Generate byte sequence */
  83. for ( i = 0 ; i < pinger->len ; i++ )
  84. bytes[i] = ( i & 0xff );
  85. }
  86. /**
  87. * Verify payload
  88. *
  89. * @v pinger Pinger
  90. * @v data Data buffer
  91. * @ret rc Return status code
  92. */
  93. static int pinger_verify ( struct pinger *pinger, const void *data ) {
  94. const uint8_t *bytes = data;
  95. unsigned int i;
  96. /* Check byte sequence */
  97. for ( i = 0 ; i < pinger->len ; i++ ) {
  98. if ( bytes[i] != ( i & 0xff ) )
  99. return -EPROTO_DATA;
  100. }
  101. return 0;
  102. }
  103. /**
  104. * Close pinger
  105. *
  106. * @v pinger Pinger
  107. * @v rc Reason for close
  108. */
  109. static void pinger_close ( struct pinger *pinger, int rc ) {
  110. /* Stop timer */
  111. stop_timer ( &pinger->timer );
  112. /* Shut down interfaces */
  113. intf_shutdown ( &pinger->xfer, rc );
  114. intf_shutdown ( &pinger->job, rc );
  115. }
  116. /**
  117. * Handle data transfer window change
  118. *
  119. * @v pinger Pinger
  120. */
  121. static void pinger_window_changed ( struct pinger *pinger ) {
  122. /* Do nothing if timer is already running */
  123. if ( timer_running ( &pinger->timer ) )
  124. return;
  125. /* Start timer when window opens for the first time */
  126. if ( xfer_window ( &pinger->xfer ) )
  127. start_timer_nodelay ( &pinger->timer );
  128. }
  129. /**
  130. * Handle timer expiry
  131. *
  132. * @v timer Timer
  133. * @v over Failure indicator
  134. */
  135. static void pinger_expired ( struct retry_timer *timer, int over __unused ) {
  136. struct pinger *pinger = container_of ( timer, struct pinger, timer );
  137. struct xfer_metadata meta;
  138. struct io_buffer *iobuf;
  139. int rc;
  140. /* Increase sequence number */
  141. pinger->sequence++;
  142. /* Restart timer. Do this before attempting to transmit, in
  143. * case the transmission attempt fails.
  144. */
  145. start_timer_fixed ( &pinger->timer, pinger->timeout );
  146. /* Allocate I/O buffer */
  147. iobuf = xfer_alloc_iob ( &pinger->xfer, pinger->len );
  148. if ( ! iobuf ) {
  149. DBGC ( pinger, "PINGER %p could not allocate I/O buffer\n",
  150. pinger );
  151. return;
  152. }
  153. /* Generate payload */
  154. pinger_generate ( pinger, iob_put ( iobuf, pinger->len ) );
  155. /* Generate metadata */
  156. memset ( &meta, 0, sizeof ( meta ) );
  157. meta.flags = XFER_FL_ABS_OFFSET;
  158. meta.offset = pinger->sequence;
  159. /* Transmit packet */
  160. if ( ( rc = xfer_deliver ( &pinger->xfer, iobuf, &meta ) ) != 0 ) {
  161. DBGC ( pinger, "PINGER %p could not transmit: %s\n",
  162. pinger, strerror ( rc ) );
  163. return;
  164. }
  165. }
  166. /**
  167. * Handle received data
  168. *
  169. * @v pinger Pinger
  170. * @v iobuf I/O buffer
  171. * @v meta Data transfer metadata
  172. * @ret rc Return status code
  173. */
  174. static int pinger_deliver ( struct pinger *pinger, struct io_buffer *iobuf,
  175. struct xfer_metadata *meta ) {
  176. size_t len = iob_len ( iobuf );
  177. uint16_t sequence = meta->offset;
  178. int rc;
  179. /* Check for errors */
  180. if ( len != pinger->len ) {
  181. DBGC ( pinger, "PINGER %p received incorrect length %zd "
  182. "(expected %zd)\n", pinger, len, pinger->len );
  183. rc = -EPROTO_LEN;
  184. } else if ( ( rc = pinger_verify ( pinger, iobuf->data ) ) != 0 ) {
  185. DBGC ( pinger, "PINGER %p received incorrect data:\n", pinger );
  186. DBGC_HDA ( pinger, 0, iobuf->data, iob_len ( iobuf ) );
  187. } else if ( sequence != pinger->sequence ) {
  188. DBGC ( pinger, "PINGER %p received sequence %d (expected %d)\n",
  189. pinger, sequence, pinger->sequence );
  190. rc = -EPROTO_SEQ;
  191. } else {
  192. rc = 0;
  193. }
  194. /* Discard I/O buffer */
  195. free_iob ( iobuf );
  196. /* Notify callback function */
  197. pinger->callback ( meta->src, sequence, len, rc );
  198. return rc;
  199. }
  200. /** Pinger data transfer interface operations */
  201. static struct interface_operation pinger_xfer_op[] = {
  202. INTF_OP ( xfer_deliver, struct pinger *, pinger_deliver ),
  203. INTF_OP ( xfer_window_changed, struct pinger *, pinger_window_changed ),
  204. INTF_OP ( intf_close, struct pinger *, pinger_close ),
  205. };
  206. /** Pinger data transfer interface descriptor */
  207. static struct interface_descriptor pinger_xfer_desc =
  208. INTF_DESC ( struct pinger, xfer, pinger_xfer_op );
  209. /** Pinger job control interface operations */
  210. static struct interface_operation pinger_job_op[] = {
  211. INTF_OP ( intf_close, struct pinger *, pinger_close ),
  212. };
  213. /** Pinger job control interface descriptor */
  214. static struct interface_descriptor pinger_job_desc =
  215. INTF_DESC ( struct pinger, job, pinger_job_op );
  216. /**
  217. * Create pinger
  218. *
  219. * @v job Job control interface
  220. * @v hostname Hostname to ping
  221. * @v timeout Timeout (in ticks)
  222. * @v len Payload length
  223. * @ret rc Return status code
  224. */
  225. int create_pinger ( struct interface *job, const char *hostname,
  226. unsigned long timeout, size_t len,
  227. void ( * callback ) ( struct sockaddr *src,
  228. unsigned int sequence, size_t len,
  229. int rc ) ) {
  230. struct pinger *pinger;
  231. int rc;
  232. /* Sanity check */
  233. if ( ! timeout )
  234. return -EINVAL;
  235. /* Allocate and initialise structure */
  236. pinger = zalloc ( sizeof ( *pinger ) );
  237. if ( ! pinger )
  238. return -ENOMEM;
  239. ref_init ( &pinger->refcnt, NULL );
  240. intf_init ( &pinger->job, &pinger_job_desc, &pinger->refcnt );
  241. intf_init ( &pinger->xfer, &pinger_xfer_desc, &pinger->refcnt );
  242. timer_init ( &pinger->timer, pinger_expired, &pinger->refcnt );
  243. pinger->timeout = timeout;
  244. pinger->len = len;
  245. pinger->callback = callback;
  246. /* Open socket */
  247. if ( ( rc = xfer_open_named_socket ( &pinger->xfer, SOCK_ECHO, NULL,
  248. hostname, NULL ) ) != 0 ) {
  249. DBGC ( pinger, "PINGER %p could not open socket: %s\n",
  250. pinger, strerror ( rc ) );
  251. goto err;
  252. }
  253. /* Attach parent interface, mortalise self, and return */
  254. intf_plug_plug ( &pinger->job, job );
  255. ref_put ( &pinger->refcnt );
  256. return 0;
  257. err:
  258. pinger_close ( pinger, rc );
  259. ref_put ( &pinger->refcnt );
  260. return rc;
  261. }