luna - curl/lib/tftp.c

   1/***************************************************************************
   2 *                                  _   _ ____  _
   3 *  Project                     ___| | | |  _ \| |
   4 *                             / __| | | | |_) | |
   5 *                            | (__| |_| |  _ <| |___
   6 *                             \___|\___/|_| \_\_____|
   7 *
   8 * Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al.
   9 *
  10 * This software is licensed as described in the file COPYING, which
  11 * you should have received as part of this distribution. The terms
  12 * are also available at https://curl.se/docs/copyright.html.
  13 *
  14 * You may opt to use, copy, modify, merge, publish, distribute and/or sell
  15 * copies of the Software, and permit persons to whom the Software is
  16 * furnished to do so, under the terms of the COPYING file.
  17 *
  18 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  19 * KIND, either express or implied.
  20 *
  21 * SPDX-License-Identifier: curl
  22 *
  23 ***************************************************************************/
  24#include "curl_setup.h"
  25#include "urldata.h"
  26#include "tftp.h"
  27
  28#ifndef CURL_DISABLE_TFTP
  29
  30#ifdef HAVE_NETINET_IN_H
  31#include <netinet/in.h>
  32#endif
  33#ifdef HAVE_NETDB_H
  34#include <netdb.h>
  35#endif
  36#ifdef HAVE_ARPA_INET_H
  37#include <arpa/inet.h>
  38#endif
  39#ifdef HAVE_NET_IF_H
  40#include <net/if.h>
  41#endif
  42#ifdef HAVE_SYS_IOCTL_H
  43#include <sys/ioctl.h>
  44#endif
  45
  46#ifdef HAVE_SYS_PARAM_H
  47#include <sys/param.h>
  48#endif
  49
  50#include "cfilters.h"
  51#include "cf-socket.h"
  52#include "transfer.h"
  53#include "sendf.h"
  54#include "curl_trc.h"
  55#include "progress.h"
  56#include "connect.h"
  57#include "sockaddr.h" /* required for Curl_sockaddr_storage */
  58#include "url.h"
  59#include "strcase.h"
  60#include "select.h"
  61#include "escape.h"
  62#include "curlx/strerr.h"
  63#include "curlx/strparse.h"
  64#include "curlx/strcopy.h"
  65
  66/* RFC2348 allows the block size to be negotiated */
  67#define TFTP_BLKSIZE_DEFAULT 512
  68#define TFTP_OPTION_BLKSIZE  "blksize"
  69
  70/* from RFC2349: */
  71#define TFTP_OPTION_TSIZE    "tsize"
  72#define TFTP_OPTION_INTERVAL "timeout"
  73
  74typedef enum {
  75  TFTP_MODE_NETASCII = 0,
  76  TFTP_MODE_OCTET
  77} tftp_mode_t;
  78
  79typedef enum {
  80  TFTP_STATE_START = 0,
  81  TFTP_STATE_RX,
  82  TFTP_STATE_TX,
  83  TFTP_STATE_FIN
  84} tftp_state_t;
  85
  86typedef enum {
  87  TFTP_EVENT_NONE = -1,
  88  TFTP_EVENT_INIT = 0,
  89  TFTP_EVENT_RRQ = 1,
  90  TFTP_EVENT_WRQ = 2,
  91  TFTP_EVENT_DATA = 3,
  92  TFTP_EVENT_ACK = 4,
  93  TFTP_EVENT_ERROR = 5,
  94  TFTP_EVENT_OACK = 6,
  95  TFTP_EVENT_TIMEOUT
  96} tftp_event_t;
  97
  98typedef enum {
  99  TFTP_ERR_UNDEF = 0,
 100  TFTP_ERR_NOTFOUND,
 101  TFTP_ERR_PERM,
 102  TFTP_ERR_DISKFULL,
 103  TFTP_ERR_ILLEGAL,
 104  TFTP_ERR_UNKNOWNID,
 105  TFTP_ERR_EXISTS,
 106  TFTP_ERR_NOSUCHUSER,  /* This will never be triggered by this code */
 107
 108  /* The remaining error codes are internal to curl */
 109  TFTP_ERR_NONE = -100,
 110  TFTP_ERR_TIMEOUT,
 111  TFTP_ERR_NORESPONSE
 112} tftp_error_t;
 113
 114struct tftp_packet {
 115  unsigned char *data;
 116};
 117
 118/* meta key for storing protocol meta at connection */
 119#define CURL_META_TFTP_CONN   "meta:proto:tftp:conn"
 120
 121struct tftp_conn {
 122  struct Curl_sockaddr_storage local_addr;
 123  struct Curl_sockaddr_storage remote_addr;
 124  struct tftp_packet rpacket;
 125  struct tftp_packet spacket;
 126  tftp_state_t    state;
 127  tftp_mode_t     mode;
 128  tftp_error_t    error;
 129  tftp_event_t    event;
 130  struct Curl_easy *data;
 131  curl_socket_t   sockfd;
 132  int             retries;
 133  int             retry_time;
 134  int             retry_max;
 135  time_t          rx_time;
 136  curl_socklen_t  remote_addrlen;
 137  int             rbytes;
 138  size_t          sbytes;
 139  unsigned int    blksize;
 140  unsigned int    requested_blksize;
 141  unsigned short  block;
 142  BIT(remote_pinned);
 143};
 144
 145/**********************************************************
 146 *
 147 * tftp_set_timeouts -
 148 *
 149 * Set timeouts based on state machine state.
 150 * Use user provided connect timeouts until DATA or ACK
 151 * packet is received, then use user-provided transfer timeouts
 152 *
 153 *
 154 **********************************************************/
 155static CURLcode tftp_set_timeouts(struct tftp_conn *state)
 156{
 157  time_t timeout;
 158  timediff_t timeout_ms;
 159
 160  /* Compute drop-dead time */
 161  timeout_ms = Curl_timeleft_ms(state->data);
 162
 163  if(timeout_ms < 0) {
 164    /* time-out, bail out, go home */
 165    failf(state->data, "Connection time-out");
 166    return CURLE_OPERATION_TIMEDOUT;
 167  }
 168
 169  /* Set per-block timeout to total */
 170  if(timeout_ms > 0)
 171    timeout = (time_t)(timeout_ms + 500) / 1000;
 172  else
 173    timeout = 15;
 174
 175  /* Average reposting an ACK after 5 seconds */
 176  state->retry_max = (int)timeout / 5;
 177
 178  /* Bound the total number */
 179  if(state->retry_max < 3)
 180    state->retry_max = 3;
 181
 182  if(state->retry_max > 50)
 183    state->retry_max = 50;
 184
 185  /* Compute the re-ACK interval to suit the timeout */
 186  state->retry_time = (int)(timeout / state->retry_max);
 187  if(state->retry_time < 1)
 188    state->retry_time = 1;
 189
 190  infof(state->data,
 191        "set timeouts for state %d; Total %" FMT_OFF_T ", retry %d maxtry %d",
 192        (int)state->state, timeout_ms, state->retry_time, state->retry_max);
 193
 194  /* init RX time */
 195  state->rx_time = time(NULL);
 196
 197  return CURLE_OK;
 198}
 199
 200/**********************************************************
 201 *
 202 * tftp_set_send_first
 203 *
 204 * Event handler for the START state
 205 *
 206 **********************************************************/
 207
 208static void setpacketevent(struct tftp_packet *packet, unsigned short num)
 209{
 210  packet->data[0] = (unsigned char)(num >> 8);
 211  packet->data[1] = (unsigned char)(num & 0xff);
 212}
 213
 214static void setpacketblock(struct tftp_packet *packet, unsigned short num)
 215{
 216  packet->data[2] = (unsigned char)(num >> 8);
 217  packet->data[3] = (unsigned char)(num & 0xff);
 218}
 219
 220static unsigned short getrpacketevent(const struct tftp_packet *packet)
 221{
 222  return (unsigned short)((packet->data[0] << 8) | packet->data[1]);
 223}
 224
 225static unsigned short getrpacketblock(const struct tftp_packet *packet)
 226{
 227  return (unsigned short)((packet->data[2] << 8) | packet->data[3]);
 228}
 229
 230static size_t tftp_strnlen(const char *string, size_t maxlen)
 231{
 232  const char *end = memchr(string, '\0', maxlen);
 233  return end ? (size_t)(end - string) : maxlen;
 234}
 235
 236static const char *tftp_option_get(const char *buf, size_t len,
 237                                   const char **option, const char **value)
 238{
 239  size_t loc;
 240
 241  loc = tftp_strnlen(buf, len);
 242  loc++; /* NULL term */
 243
 244  if(loc >= len)
 245    return NULL;
 246  *option = buf;
 247
 248  loc += tftp_strnlen(buf + loc, len - loc);
 249  loc++; /* NULL term */
 250
 251  if(loc > len)
 252    return NULL;
 253  *value = &buf[strlen(*option) + 1];
 254
 255  return &buf[loc];
 256}
 257
 258static CURLcode tftp_parse_option_ack(struct tftp_conn *state,
 259                                      const char *ptr, int len)
 260{
 261  const char *tmp = ptr;
 262  struct Curl_easy *data = state->data;
 263
 264  /* if OACK does not contain blksize option, the default (512) must be used */
 265  state->blksize = TFTP_BLKSIZE_DEFAULT;
 266
 267  while(tmp < ptr + len) {
 268    const char *option, *value;
 269    size_t olen;
 270
 271    tmp = tftp_option_get(tmp, ptr + len - tmp, &option, &value);
 272    if(!tmp) {
 273      failf(data, "Malformed ACK packet, rejecting");
 274      return CURLE_TFTP_ILLEGAL;
 275    }
 276    olen = strlen(option);
 277
 278    infof(data, "got option=(%s) value=(%s)", option, value);
 279
 280    if((strlen(TFTP_OPTION_BLKSIZE) == olen) &&
 281       checkprefix(TFTP_OPTION_BLKSIZE, option)) {
 282      curl_off_t blksize;
 283      if(curlx_str_number(&value, &blksize, TFTP_BLKSIZE_MAX)) {
 284        failf(data, "%s (%d)", "blksize is larger than max supported",
 285              TFTP_BLKSIZE_MAX);
 286        return CURLE_TFTP_ILLEGAL;
 287      }
 288      if(!blksize) {
 289        failf(data, "invalid blocksize value in OACK packet");
 290        return CURLE_TFTP_ILLEGAL;
 291      }
 292      else if(blksize < TFTP_BLKSIZE_MIN) {
 293        failf(data, "%s (%d)", "blksize is smaller than min supported",
 294              TFTP_BLKSIZE_MIN);
 295        return CURLE_TFTP_ILLEGAL;
 296      }
 297      else if(blksize > state->requested_blksize) {
 298        /* could realloc pkt buffers here, but the spec does not call out
 299         * support for the server requesting a bigger blksize than the client
 300         * requests */
 301        failf(data, "server requested blksize larger than allocated (%"
 302              CURL_FORMAT_CURL_OFF_T ")", blksize);
 303        return CURLE_TFTP_ILLEGAL;
 304      }
 305
 306      state->blksize = (unsigned int)blksize;
 307      infof(data, "blksize parsed from OACK (%u) requested (%u)",
 308            state->blksize, state->requested_blksize);
 309    }
 310    else if((strlen(TFTP_OPTION_TSIZE) == olen) &&
 311            checkprefix(TFTP_OPTION_TSIZE, option)) {
 312      curl_off_t tsize = 0;
 313      /* tsize should be ignored on upload: Who cares about the size of the
 314         remote file? */
 315      if(!data->state.upload &&
 316         !curlx_str_number(&value, &tsize, CURL_OFF_T_MAX)) {
 317        if(!tsize) {
 318          failf(data, "invalid tsize -:%s:- value in OACK packet", value);
 319          return CURLE_TFTP_ILLEGAL;
 320        }
 321        infof(data, "tsize parsed from OACK (%" CURL_FORMAT_CURL_OFF_T ")",
 322              tsize);
 323        Curl_pgrsSetDownloadSize(data, tsize);
 324      }
 325    }
 326  }
 327
 328  return CURLE_OK;
 329}
 330
 331static CURLcode tftp_option_add(struct tftp_conn *state, size_t *csize,
 332                                size_t index, const char *option)
 333{
 334  char *buf = (char *)&state->spacket.data[index];
 335  size_t oplen = strlen(option);
 336  size_t blen;
 337  if((state->blksize <= index) ||
 338     (oplen + 1) > (size_t)(state->blksize - index))
 339    return CURLE_TFTP_ILLEGAL;
 340  blen = state->blksize - index;
 341  curlx_strcopy(buf, blen, option, oplen);
 342  *csize += oplen + 1;
 343  return CURLE_OK;
 344}
 345
 346/* the next blocknum is x + 1 but it needs to wrap at an unsigned 16-bit
 347   boundary */
 348#define NEXT_BLOCKNUM(x) (((x) + 1) & 0xffff)
 349
 350/**********************************************************
 351 *
 352 * tftp_tx
 353 *
 354 * Event handler for the TX state
 355 *
 356 **********************************************************/
 357static CURLcode tftp_tx(struct tftp_conn *state, tftp_event_t event)
 358{
 359  struct Curl_easy *data = state->data;
 360  ssize_t sbytes;
 361  CURLcode result = CURLE_OK;
 362  struct SingleRequest *k = &data->req;
 363  size_t cb; /* Bytes currently read */
 364  char buffer[STRERROR_LEN];
 365  char *bufptr;
 366  bool eos;
 367
 368  switch(event) {
 369
 370  case TFTP_EVENT_ACK:
 371  case TFTP_EVENT_OACK:
 372    if(event == TFTP_EVENT_ACK) {
 373      /* Ack the packet */
 374      int rblock = getrpacketblock(&state->rpacket);
 375
 376      if(rblock != state->block &&
 377         /* There is a bug in tftpd-hpa that causes it to send us an ACK for
 378          * 65535 when the block number wraps to 0. To handle it, when we are
 379          * expecting 0, also accept 65535. See
 380          * https://www.syslinux.org/archives/2010-September/015612.html
 381          * */
 382         !(state->block == 0 && rblock == 65535)) {
 383        /* This is not the expected block. Log it and up the retry counter */
 384        infof(data, "Received ACK for block %d, expecting %d",
 385              rblock, state->block);
 386        state->retries++;
 387        /* Bail out if over the maximum */
 388        if(state->retries > state->retry_max) {
 389          failf(data, "tftp_tx: giving up waiting for block %d ack",
 390                state->block);
 391          result = CURLE_SEND_ERROR;
 392        }
 393        else {
 394          /* Re-send the data packet */
 395          sbytes = sendto(state->sockfd, (void *)state->spacket.data,
 396                          4 + (SEND_TYPE_ARG3)state->sbytes, SEND_4TH_ARG,
 397                          (struct sockaddr *)&state->remote_addr,
 398                          state->remote_addrlen);
 399          /* Check all sbytes were sent */
 400          if(sbytes < 0) {
 401            failf(data, "%s",
 402                  curlx_strerror(SOCKERRNO, buffer, sizeof(buffer)));
 403            result = CURLE_SEND_ERROR;
 404          }
 405        }
 406
 407        return result;
 408      }
 409      /* This is the expected packet. Reset the counters and send the next
 410         block */
 411      state->rx_time = time(NULL);
 412      state->block++;
 413    }
 414    else
 415      state->block = 1; /* first data block is 1 when using OACK */
 416
 417    state->retries = 0;
 418    setpacketevent(&state->spacket, TFTP_EVENT_DATA);
 419    setpacketblock(&state->spacket, state->block);
 420    if(state->block > 1 && state->sbytes < state->blksize) {
 421      state->state = TFTP_STATE_FIN;
 422      return CURLE_OK;
 423    }
 424
 425    /* TFTP considers data block size < 512 bytes as an end of session, so
 426     * in some cases we must wait for additional data to build full (512 bytes)
 427     * data block.
 428     * */
 429    state->sbytes = 0;
 430    bufptr = (char *)state->spacket.data + 4;
 431    do {
 432      result = Curl_client_read(data, bufptr, state->blksize - state->sbytes,
 433                                &cb, &eos);
 434      if(result)
 435        return result;
 436      state->sbytes += cb;
 437      bufptr += cb;
 438    } while(state->sbytes < state->blksize && cb);
 439
 440    sbytes = sendto(state->sockfd, (void *)state->spacket.data,
 441                    4 + (SEND_TYPE_ARG3)state->sbytes, SEND_4TH_ARG,
 442                    (struct sockaddr *)&state->remote_addr,
 443                    state->remote_addrlen);
 444    /* Check all sbytes were sent */
 445    if(sbytes < 0) {
 446      failf(data, "%s", curlx_strerror(SOCKERRNO, buffer, sizeof(buffer)));
 447      return CURLE_SEND_ERROR;
 448    }
 449    /* Update the progress meter */
 450    k->writebytecount += state->sbytes;
 451    Curl_pgrs_upload_inc(data, state->sbytes);
 452    break;
 453
 454  case TFTP_EVENT_TIMEOUT:
 455    /* Increment the retry counter and log the timeout */
 456    state->retries++;
 457    infof(data, "Timeout waiting for block %d ACK. "
 458          "Retries = %d", NEXT_BLOCKNUM(state->block), state->retries);
 459    /* Decide if we have had enough */
 460    if(state->retries > state->retry_max) {
 461      state->error = TFTP_ERR_TIMEOUT;
 462      state->state = TFTP_STATE_FIN;
 463    }
 464    else {
 465      /* Re-send the data packet */
 466      sbytes = sendto(state->sockfd, (void *)state->spacket.data,
 467                      4 + (SEND_TYPE_ARG3)state->sbytes, SEND_4TH_ARG,
 468                      (struct sockaddr *)&state->remote_addr,
 469                      state->remote_addrlen);
 470      /* Check all sbytes were sent */
 471      if(sbytes < 0) {
 472        failf(data, "%s", curlx_strerror(SOCKERRNO, buffer, sizeof(buffer)));
 473        return CURLE_SEND_ERROR;
 474      }
 475      /* since this was a re-send, we remain at the still byte position */
 476      Curl_pgrsSetUploadCounter(data, k->writebytecount);
 477    }
 478    break;
 479
 480  case TFTP_EVENT_ERROR:
 481    state->state = TFTP_STATE_FIN;
 482    setpacketevent(&state->spacket, TFTP_EVENT_ERROR);
 483    setpacketblock(&state->spacket, state->block);
 484    (void)sendto(state->sockfd, (void *)state->spacket.data, 4, SEND_4TH_ARG,
 485                 (struct sockaddr *)&state->remote_addr,
 486                 state->remote_addrlen);
 487    /* do not bother with the return code, but if the socket is still up we
 488     * should be a good TFTP client and let the server know we are done */
 489    state->state = TFTP_STATE_FIN;
 490    break;
 491
 492  default:
 493    failf(data, "tftp_tx: internal error, event: %i", (int)event);
 494    break;
 495  }
 496
 497  return result;
 498}
 499
 500static CURLcode tftp_connect_for_tx(struct tftp_conn *state,
 501                                    tftp_event_t event)
 502{
 503  CURLcode result;
 504
 505  infof(state->data, "%s", "Connected for transmit");
 506
 507  state->state = TFTP_STATE_TX;
 508  result = tftp_set_timeouts(state);
 509  if(result)
 510    return result;
 511  return tftp_tx(state, event);
 512}
 513
 514/**********************************************************
 515 *
 516 * tftp_rx
 517 *
 518 * Event handler for the RX state
 519 *
 520 **********************************************************/
 521static CURLcode tftp_rx(struct tftp_conn *state, tftp_event_t event)
 522{
 523  ssize_t sbytes;
 524  int rblock;
 525  struct Curl_easy *data = state->data;
 526  char buffer[STRERROR_LEN];
 527
 528  switch(event) {
 529
 530  case TFTP_EVENT_DATA:
 531    /* Is this the block we expect? */
 532    rblock = getrpacketblock(&state->rpacket);
 533    if(NEXT_BLOCKNUM(state->block) == rblock) {
 534      /* This is the expected block. Reset counters and ACK it. */
 535      state->retries = 0;
 536    }
 537    else if(state->block == rblock) {
 538      /* This is the last recently received block again. Log it and ACK it
 539         again. */
 540      infof(data, "Received last DATA packet block %d again.", rblock);
 541    }
 542    else {
 543      /* totally unexpected, log it */
 544      infof(data,
 545            "Received unexpected DATA packet block %d, expecting block %d",
 546            rblock, NEXT_BLOCKNUM(state->block));
 547      break;
 548    }
 549
 550    /* ACK this block. */
 551    state->block = (unsigned short)rblock;
 552    setpacketevent(&state->spacket, TFTP_EVENT_ACK);
 553    setpacketblock(&state->spacket, state->block);
 554    sbytes = sendto(state->sockfd, (void *)state->spacket.data,
 555                    4, SEND_4TH_ARG,
 556                    (struct sockaddr *)&state->remote_addr,
 557                    state->remote_addrlen);
 558    if(sbytes < 0) {
 559      failf(data, "%s", curlx_strerror(SOCKERRNO, buffer, sizeof(buffer)));
 560      return CURLE_SEND_ERROR;
 561    }
 562
 563    /* Check if completed (That is, a less than full packet is received) */
 564    if(state->rbytes < (ssize_t)state->blksize + 4) {
 565      state->state = TFTP_STATE_FIN;
 566    }
 567    else {
 568      state->state = TFTP_STATE_RX;
 569    }
 570    state->rx_time = time(NULL);
 571    break;
 572
 573  case TFTP_EVENT_OACK:
 574    /* ACK option acknowledgement so we can move on to data */
 575    state->block = 0;
 576    state->retries = 0;
 577    setpacketevent(&state->spacket, TFTP_EVENT_ACK);
 578    setpacketblock(&state->spacket, state->block);
 579    sbytes = sendto(state->sockfd, (void *)state->spacket.data,
 580                    4, SEND_4TH_ARG,
 581                    (struct sockaddr *)&state->remote_addr,
 582                    state->remote_addrlen);
 583    if(sbytes < 0) {
 584      failf(data, "%s", curlx_strerror(SOCKERRNO, buffer, sizeof(buffer)));
 585      return CURLE_SEND_ERROR;
 586    }
 587
 588    /* we are ready to RX data */
 589    state->state = TFTP_STATE_RX;
 590    state->rx_time = time(NULL);
 591    break;
 592
 593  case TFTP_EVENT_TIMEOUT:
 594    /* Increment the retry count and fail if over the limit */
 595    state->retries++;
 596    infof(data,
 597          "Timeout waiting for block %d ACK. Retries = %d",
 598          NEXT_BLOCKNUM(state->block), state->retries);
 599    if(state->retries > state->retry_max) {
 600      state->error = TFTP_ERR_TIMEOUT;
 601      state->state = TFTP_STATE_FIN;
 602    }
 603    else {
 604      /* Resend the previous ACK */
 605      sbytes = sendto(state->sockfd, (void *)state->spacket.data,
 606                      4, SEND_4TH_ARG,
 607                      (struct sockaddr *)&state->remote_addr,
 608                      state->remote_addrlen);
 609      if(sbytes < 0) {
 610        failf(data, "%s", curlx_strerror(SOCKERRNO, buffer, sizeof(buffer)));
 611        return CURLE_SEND_ERROR;
 612      }
 613    }
 614    break;
 615
 616  case TFTP_EVENT_ERROR:
 617    setpacketevent(&state->spacket, TFTP_EVENT_ERROR);
 618    setpacketblock(&state->spacket, state->block);
 619    (void)sendto(state->sockfd, (void *)state->spacket.data,
 620                 4, SEND_4TH_ARG,
 621                 (struct sockaddr *)&state->remote_addr,
 622                 state->remote_addrlen);
 623    /* do not bother with the return code, but if the socket is still up we
 624     * should be a good TFTP client and let the server know we are done */
 625    state->state = TFTP_STATE_FIN;
 626    break;
 627
 628  default:
 629    failf(data, "%s", "tftp_rx: internal error");
 630    return CURLE_TFTP_ILLEGAL; /* not really the perfect return code for
 631                                  this */
 632  }
 633  return CURLE_OK;
 634}
 635
 636static CURLcode tftp_connect_for_rx(struct tftp_conn *state,
 637                                    tftp_event_t event)
 638{
 639  CURLcode result;
 640
 641  infof(state->data, "%s", "Connected for receive");
 642
 643  state->state = TFTP_STATE_RX;
 644  result = tftp_set_timeouts(state);
 645  if(result)
 646    return result;
 647  return tftp_rx(state, event);
 648}
 649
 650static CURLcode tftp_send_first(struct tftp_conn *state,
 651                                tftp_event_t event)
 652{
 653  size_t sbytes;
 654  ssize_t senddata;
 655  const char *mode = "octet";
 656  char *filename;
 657  struct Curl_easy *data = state->data;
 658  const struct Curl_sockaddr_ex *remote_addr = NULL;
 659  CURLcode result = CURLE_OK;
 660
 661  /* Set ASCII mode if -B flag was used */
 662  if(data->state.prefer_ascii)
 663    mode = "netascii";
 664
 665  switch(event) {
 666
 667  case TFTP_EVENT_INIT:    /* Send the first packet out */
 668  case TFTP_EVENT_TIMEOUT: /* Resend the first packet out */
 669    /* Increment the retry counter, quit if over the limit */
 670    state->retries++;
 671    if(state->retries > state->retry_max) {
 672      state->error = TFTP_ERR_NORESPONSE;
 673      state->state = TFTP_STATE_FIN;
 674      return result;
 675    }
 676
 677    if(data->state.upload) {
 678      /* If we are uploading, send a WRQ */
 679      setpacketevent(&state->spacket, TFTP_EVENT_WRQ);
 680      if(data->state.infilesize != -1)
 681        Curl_pgrsSetUploadSize(data, data->state.infilesize);
 682    }
 683    else {
 684      /* If we are downloading, send an RRQ */
 685      setpacketevent(&state->spacket, TFTP_EVENT_RRQ);
 686    }
 687    /* As RFC3617 describes the separator slash is not actually part of the
 688       filename so we skip the always-present first letter of the path
 689       string. */
 690    if(!state->data->state.up.path[1]) {
 691      failf(data, "Missing filename");
 692      return CURLE_TFTP_ILLEGAL;
 693    }
 694    result = Curl_urldecode(&state->data->state.up.path[1], 0,
 695                            &filename, NULL, REJECT_ZERO);
 696    if(result)
 697      return result;
 698
 699    if(strlen(filename) + strlen(mode) + 4 > state->blksize) {
 700      failf(data, "TFTP filename too long");
 701      curlx_free(filename);
 702      return CURLE_TFTP_ILLEGAL; /* too long filename field */
 703    }
 704
 705    sbytes = 2 +
 706      curl_msnprintf((char *)state->spacket.data + 2,
 707                     state->blksize,
 708                     "%s%c%s%c", filename, '\0', mode, '\0');
 709    curlx_free(filename);
 710
 711    /* optional addition of TFTP options */
 712    if(!data->set.tftp_no_options) {
 713      char buf[64];
 714      /* add tsize option */
 715      curl_msnprintf(buf, sizeof(buf), "%" FMT_OFF_T,
 716                     data->state.upload && (data->state.infilesize != -1) ?
 717                     data->state.infilesize : 0);
 718
 719      result = tftp_option_add(state, &sbytes, sbytes, TFTP_OPTION_TSIZE);
 720      if(result == CURLE_OK)
 721        result = tftp_option_add(state, &sbytes, sbytes, buf);
 722
 723      /* add blksize option */
 724      curl_msnprintf(buf, sizeof(buf), "%u", state->requested_blksize);
 725      if(result == CURLE_OK)
 726        result = tftp_option_add(state, &sbytes, sbytes, TFTP_OPTION_BLKSIZE);
 727      if(result == CURLE_OK)
 728        result = tftp_option_add(state, &sbytes, sbytes, buf);
 729
 730      /* add timeout option */
 731      curl_msnprintf(buf, sizeof(buf), "%d", state->retry_time);
 732      if(result == CURLE_OK)
 733        result = tftp_option_add(state, &sbytes, sbytes, TFTP_OPTION_INTERVAL);
 734      if(result == CURLE_OK)
 735        result = tftp_option_add(state, &sbytes, sbytes, buf);
 736
 737      if(result != CURLE_OK) {
 738        failf(data, "TFTP buffer too small for options");
 739        return CURLE_TFTP_ILLEGAL;
 740      }
 741    }
 742
 743    /* the typecast for the 3rd argument is mostly for systems that do
 744       not have a size_t argument, like older unixes that want an 'int' */
 745#ifdef __AMIGA__
 746#define CURL_SENDTO_ARG5(x) CURL_UNCONST(x)
 747#else
 748#define CURL_SENDTO_ARG5(x) (x)
 749#endif
 750    remote_addr = Curl_conn_get_remote_addr(data, FIRSTSOCKET);
 751    if(!remote_addr)
 752      return CURLE_FAILED_INIT;
 753
 754    senddata = sendto(state->sockfd, (void *)state->spacket.data,
 755                      (SEND_TYPE_ARG3)sbytes, 0,
 756                      CURL_SENDTO_ARG5(&remote_addr->curl_sa_addr),
 757                      (curl_socklen_t)remote_addr->addrlen);
 758    if(senddata != (ssize_t)sbytes) {
 759      char buffer[STRERROR_LEN];
 760      failf(data, "%s", curlx_strerror(SOCKERRNO, buffer, sizeof(buffer)));
 761      return CURLE_SEND_ERROR;
 762    }
 763    break;
 764
 765  case TFTP_EVENT_OACK:
 766    if(data->state.upload) {
 767      result = tftp_connect_for_tx(state, event);
 768    }
 769    else {
 770      result = tftp_connect_for_rx(state, event);
 771    }
 772    break;
 773
 774  case TFTP_EVENT_ACK: /* Connected for transmit */
 775    result = tftp_connect_for_tx(state, event);
 776    break;
 777
 778  case TFTP_EVENT_DATA: /* Connected for receive */
 779    result = tftp_connect_for_rx(state, event);
 780    break;
 781
 782  case TFTP_EVENT_ERROR:
 783    state->state = TFTP_STATE_FIN;
 784    break;
 785
 786  default:
 787    failf(state->data, "tftp_send_first: internal error");
 788    return CURLE_TFTP_ILLEGAL;
 789  }
 790
 791  return result;
 792}
 793
 794/**********************************************************
 795 *
 796 * tftp_translate_code
 797 *
 798 * Translate internal error codes to CURL error codes
 799 *
 800 **********************************************************/
 801static CURLcode tftp_translate_code(tftp_error_t error)
 802{
 803  CURLcode result = CURLE_OK;
 804
 805  if(error != TFTP_ERR_NONE) {
 806    switch(error) {
 807    case TFTP_ERR_NOTFOUND:
 808      result = CURLE_TFTP_NOTFOUND;
 809      break;
 810    case TFTP_ERR_PERM:
 811      result = CURLE_TFTP_PERM;
 812      break;
 813    case TFTP_ERR_DISKFULL:
 814      result = CURLE_REMOTE_DISK_FULL;
 815      break;
 816    case TFTP_ERR_UNDEF:
 817    case TFTP_ERR_ILLEGAL:
 818      result = CURLE_TFTP_ILLEGAL;
 819      break;
 820    case TFTP_ERR_UNKNOWNID:
 821      result = CURLE_TFTP_UNKNOWNID;
 822      break;
 823    case TFTP_ERR_EXISTS:
 824      result = CURLE_REMOTE_FILE_EXISTS;
 825      break;
 826    case TFTP_ERR_NOSUCHUSER:
 827      result = CURLE_TFTP_NOSUCHUSER;
 828      break;
 829    case TFTP_ERR_TIMEOUT:
 830      result = CURLE_OPERATION_TIMEDOUT;
 831      break;
 832    case TFTP_ERR_NORESPONSE:
 833      result = CURLE_COULDNT_CONNECT;
 834      break;
 835    default:
 836      result = CURLE_ABORTED_BY_CALLBACK;
 837      break;
 838    }
 839  }
 840  else
 841    result = CURLE_OK;
 842
 843  return result;
 844}
 845
 846/**********************************************************
 847 *
 848 * tftp_state_machine
 849 *
 850 * The tftp state machine event dispatcher
 851 *
 852 **********************************************************/
 853static CURLcode tftp_state_machine(struct tftp_conn *state,
 854                                   tftp_event_t event)
 855{
 856  CURLcode result = CURLE_OK;
 857  struct Curl_easy *data = state->data;
 858
 859  switch(state->state) {
 860  case TFTP_STATE_START:
 861    DEBUGF(infof(data, "TFTP_STATE_START"));
 862    result = tftp_send_first(state, event);
 863    break;
 864  case TFTP_STATE_RX:
 865    DEBUGF(infof(data, "TFTP_STATE_RX"));
 866    result = tftp_rx(state, event);
 867    break;
 868  case TFTP_STATE_TX:
 869    DEBUGF(infof(data, "TFTP_STATE_TX"));
 870    result = tftp_tx(state, event);
 871    break;
 872  case TFTP_STATE_FIN:
 873    infof(data, "%s", "TFTP finished");
 874    break;
 875  default:
 876    DEBUGF(infof(data, "STATE: %d", state->state));
 877    failf(data, "%s", "Internal state machine error");
 878    result = CURLE_TFTP_ILLEGAL;
 879    break;
 880  }
 881
 882  return result;
 883}
 884
 885static void tftp_conn_dtor(void *key, size_t klen, void *entry)
 886{
 887  struct tftp_conn *state = entry;
 888  (void)key;
 889  (void)klen;
 890  curlx_safefree(state->rpacket.data);
 891  curlx_safefree(state->spacket.data);
 892  curlx_free(state);
 893}
 894
 895/**********************************************************
 896 *
 897 * tftp_connect
 898 *
 899 * The connect callback
 900 *
 901 **********************************************************/
 902static CURLcode tftp_connect(struct Curl_easy *data, bool *done)
 903{
 904  struct tftp_conn *state;
 905  int blksize;
 906  int need_blksize;
 907  struct connectdata *conn = data->conn;
 908  const struct Curl_sockaddr_ex *remote_addr = NULL;
 909  CURLcode result;
 910
 911  blksize = TFTP_BLKSIZE_DEFAULT;
 912
 913  state = curlx_calloc(1, sizeof(*state));
 914  if(!state ||
 915     Curl_conn_meta_set(conn, CURL_META_TFTP_CONN, state, tftp_conn_dtor))
 916    return CURLE_OUT_OF_MEMORY;
 917
 918  /* alloc pkt buffers based on specified blksize */
 919  if(data->set.tftp_blksize)
 920    /* range checked when set */
 921    blksize = (int)data->set.tftp_blksize;
 922
 923  need_blksize = blksize;
 924  /* default size is the fallback when no OACK is received */
 925  if(need_blksize < TFTP_BLKSIZE_DEFAULT)
 926    need_blksize = TFTP_BLKSIZE_DEFAULT;
 927
 928  if(!state->rpacket.data) {
 929    state->rpacket.data = curlx_calloc(1, need_blksize + 2 + 2);
 930
 931    if(!state->rpacket.data)
 932      return CURLE_OUT_OF_MEMORY;
 933  }
 934
 935  if(!state->spacket.data) {
 936    state->spacket.data = curlx_calloc(1, need_blksize + 2 + 2);
 937
 938    if(!state->spacket.data)
 939      return CURLE_OUT_OF_MEMORY;
 940  }
 941
 942  /* we do not keep TFTP connections up because there is none or little gain
 943   * for UDP */
 944  connclose(conn, "TFTP");
 945
 946  state->data = data;
 947  state->sockfd = conn->sock[FIRSTSOCKET];
 948  state->state = TFTP_STATE_START;
 949  state->error = TFTP_ERR_NONE;
 950  state->blksize = TFTP_BLKSIZE_DEFAULT; /* Unless updated by OACK response */
 951  state->requested_blksize = blksize;
 952
 953  remote_addr = Curl_conn_get_remote_addr(data, FIRSTSOCKET);
 954  DEBUGASSERT(remote_addr);
 955  if(!remote_addr)
 956    return CURLE_FAILED_INIT;
 957
 958  ((struct sockaddr *)&state->local_addr)->sa_family =
 959    (CURL_SA_FAMILY_T)(remote_addr->family);
 960
 961  result = tftp_set_timeouts(state);
 962  if(result)
 963    return result;
 964
 965  if(!conn->bits.bound) {
 966    /* If not already bound, bind to any interface, random UDP port. If it is
 967     * reused or a custom local port was desired, this has already been done!
 968     *
 969     * We once used the size of the local_addr struct as the third argument
 970     * for bind() to better work with IPv6 or whatever size the struct could
 971     * have, but we learned that at least Tru64, AIX and IRIX *requires* the
 972     * size of that argument to match the exact size of a 'sockaddr_in' struct
 973     * when running IPv4-only.
 974     *
 975     * Therefore we use the size from the address we connected to, which we
 976     * assume uses the same IP version and thus hopefully this works for both
 977     * IPv4 and IPv6...
 978     */
 979    int rc = bind(state->sockfd, (struct sockaddr *)&state->local_addr,
 980                  (curl_socklen_t)remote_addr->addrlen);
 981    if(rc) {
 982      char buffer[STRERROR_LEN];
 983      failf(data, "bind() failed; %s",
 984            curlx_strerror(SOCKERRNO, buffer, sizeof(buffer)));
 985      return CURLE_COULDNT_CONNECT;
 986    }
 987    conn->bits.bound = TRUE;
 988  }
 989
 990  Curl_pgrsStartNow(data);
 991
 992  *done = TRUE;
 993
 994  return CURLE_OK;
 995}
 996
 997/**********************************************************
 998 *
 999 * tftp_done
1000 *
1001 * The done callback
1002 *
1003 **********************************************************/
1004static CURLcode tftp_done(struct Curl_easy *data, CURLcode status,
1005                          bool premature)
1006{
1007  CURLcode result = CURLE_OK;
1008  struct connectdata *conn = data->conn;
1009  struct tftp_conn *state = Curl_conn_meta_get(conn, CURL_META_TFTP_CONN);
1010
1011  (void)status;
1012  (void)premature;
1013
1014  if(Curl_pgrsDone(data))
1015    return CURLE_ABORTED_BY_CALLBACK;
1016
1017  /* If we have encountered an error */
1018  if(state)
1019    result = tftp_translate_code(state->error);
1020
1021  return result;
1022}
1023
1024static CURLcode tftp_pollset(struct Curl_easy *data,
1025                             struct easy_pollset *ps)
1026{
1027  return Curl_pollset_add_in(data, ps, data->conn->sock[FIRSTSOCKET]);
1028}
1029
1030/**********************************************************
1031 *
1032 * tftp_receive_packet
1033 *
1034 * Called once select fires and data is ready on the socket
1035 *
1036 **********************************************************/
1037static CURLcode tftp_receive_packet(struct Curl_easy *data,
1038                                    struct tftp_conn *state)
1039{
1040  CURLcode result = CURLE_OK;
1041  struct Curl_sockaddr_storage remote_addr;
1042  curl_socklen_t fromlen = sizeof(remote_addr);
1043
1044  /* Receive the packet */
1045  state->rbytes = (int)recvfrom(state->sockfd,
1046                                (void *)state->rpacket.data,
1047                                (RECV_TYPE_ARG3)state->blksize + 4,
1048                                0,
1049                                (struct sockaddr *)&remote_addr,
1050                                &fromlen);
1051  if((state->rbytes >= 0) && fromlen) {
1052    if(state->remote_pinned) {
1053      /* pinned, verify that it comes from the same address */
1054      if((state->remote_addrlen != fromlen) ||
1055         memcmp(&remote_addr, &state->remote_addr, fromlen)) {
1056        failf(data, "Data received from another address");
1057        return CURLE_RECV_ERROR;
1058      }
1059    }
1060    else {
1061      /* pin address on first use */
1062      state->remote_pinned = TRUE;
1063      state->remote_addrlen = fromlen;
1064      memcpy(&state->remote_addr, &remote_addr, fromlen);
1065    }
1066  }
1067
1068  /* Sanity check packet length */
1069  if(state->rbytes < 4) {
1070    failf(data, "Received too short packet");
1071    /* Not a timeout, but how best to handle it? */
1072    state->event = TFTP_EVENT_TIMEOUT;
1073  }
1074  else {
1075    /* The event is given by the TFTP packet time */
1076    unsigned short event = getrpacketevent(&state->rpacket);
1077    state->event = (tftp_event_t)event;
1078
1079    switch(state->event) {
1080    case TFTP_EVENT_DATA:
1081      /* Do not pass to the client empty or retransmitted packets */
1082      if(state->rbytes > 4 &&
1083         (NEXT_BLOCKNUM(state->block) == getrpacketblock(&state->rpacket))) {
1084        result = Curl_client_write(data, CLIENTWRITE_BODY,
1085                                   (const char *)state->rpacket.data + 4,
1086                                   state->rbytes - 4);
1087        if(result) {
1088          tftp_state_machine(state, TFTP_EVENT_ERROR);
1089          return result;
1090        }
1091      }
1092      break;
1093    case TFTP_EVENT_ERROR: {
1094      unsigned short error = getrpacketblock(&state->rpacket);
1095      const char *str = (const char *)state->rpacket.data + 4;
1096      size_t strn = state->rbytes - 4;
1097      state->error = (tftp_error_t)error;
1098      if(tftp_strnlen(str, strn) < strn)
1099        infof(data, "TFTP error: %s", str);
1100      break;
1101    }
1102    case TFTP_EVENT_ACK:
1103      break;
1104    case TFTP_EVENT_OACK:
1105      result = tftp_parse_option_ack(state,
1106                                     (const char *)state->rpacket.data + 2,
1107                                     state->rbytes-2);
1108      if(result)
1109        return result;
1110      break;
1111    case TFTP_EVENT_RRQ:
1112    case TFTP_EVENT_WRQ:
1113    default:
1114      failf(data, "%s", "Internal error: Unexpected packet");
1115      break;
1116    }
1117
1118    /* Update the progress meter */
1119    result = Curl_pgrsUpdate(data);
1120    if(result) {
1121      tftp_state_machine(state, TFTP_EVENT_ERROR);
1122      return result;
1123    }
1124  }
1125  return result;
1126}
1127
1128/**********************************************************
1129 *
1130 * tftp_state_timeout
1131 *
1132 * Check if timeouts have been reached
1133 *
1134 **********************************************************/
1135static timediff_t tftp_state_timeout(struct tftp_conn *state,
1136                                     tftp_event_t *event)
1137{
1138  time_t current;
1139  timediff_t timeout_ms;
1140
1141  if(event)
1142    *event = TFTP_EVENT_NONE;
1143
1144  timeout_ms = Curl_timeleft_ms(state->data);
1145  if(timeout_ms < 0) {
1146    state->error = TFTP_ERR_TIMEOUT;
1147    state->state = TFTP_STATE_FIN;
1148    return timeout_ms;
1149  }
1150  current = time(NULL);
1151  if(current > state->rx_time + state->retry_time) {
1152    if(event)
1153      *event = TFTP_EVENT_TIMEOUT;
1154    state->rx_time = time(NULL); /* update even though we received nothing */
1155  }
1156
1157  return timeout_ms;
1158}
1159
1160/**********************************************************
1161 *
1162 * tftp_multi_statemach
1163 *
1164 * Handle single RX socket event and return
1165 *
1166 **********************************************************/
1167static CURLcode tftp_multi_statemach(struct Curl_easy *data, bool *done)
1168{
1169  tftp_event_t event;
1170  CURLcode result = CURLE_OK;
1171  struct connectdata *conn = data->conn;
1172  struct tftp_conn *state = Curl_conn_meta_get(conn, CURL_META_TFTP_CONN);
1173  timediff_t timeout_ms;
1174
1175  *done = FALSE;
1176  if(!state)
1177    return CURLE_FAILED_INIT;
1178
1179  timeout_ms = tftp_state_timeout(state, &event);
1180  if(timeout_ms < 0) {
1181    failf(data, "TFTP response timeout");
1182    return CURLE_OPERATION_TIMEDOUT;
1183  }
1184  if(event != TFTP_EVENT_NONE) {
1185    result = tftp_state_machine(state, event);
1186    if(result)
1187      return result;
1188    *done = (state->state == TFTP_STATE_FIN);
1189    if(*done)
1190      /* Tell curl we are done */
1191      Curl_xfer_setup_nop(data);
1192  }
1193  else {
1194    /* no timeouts to handle, check our socket */
1195    int rc = SOCKET_READABLE(state->sockfd, 0);
1196
1197    if(rc == -1) {
1198      /* bail out */
1199      int error = SOCKERRNO;
1200      char buffer[STRERROR_LEN];
1201      failf(data, "%s", curlx_strerror(error, buffer, sizeof(buffer)));
1202      state->event = TFTP_EVENT_ERROR;
1203    }
1204    else if(rc) {
1205      result = tftp_receive_packet(data, state);
1206      if(result)
1207        return result;
1208      result = tftp_state_machine(state, state->event);
1209      if(result)
1210        return result;
1211      *done = (state->state == TFTP_STATE_FIN);
1212      if(*done)
1213        /* Tell curl we are done */
1214        Curl_xfer_setup_nop(data);
1215    }
1216    /* if rc == 0, then select() timed out */
1217  }
1218
1219  return result;
1220}
1221
1222/**********************************************************
1223 *
1224 * tftp_doing
1225 *
1226 * Called from multi.c while DOing
1227 *
1228 **********************************************************/
1229static CURLcode tftp_doing(struct Curl_easy *data, bool *dophase_done)
1230{
1231  CURLcode result;
1232  result = tftp_multi_statemach(data, dophase_done);
1233
1234  if(*dophase_done) {
1235    DEBUGF(infof(data, "DO phase is complete"));
1236  }
1237  else if(!result) {
1238    /* The multi code does not have this logic for the DOING state so we
1239       provide it for TFTP since it may do the entire transfer in this
1240       state. */
1241    result = Curl_pgrsCheck(data);
1242  }
1243  return result;
1244}
1245
1246/**********************************************************
1247 *
1248 * tftp_perform
1249 *
1250 * Entry point for transfer from tftp_do, starts state mach
1251 *
1252 **********************************************************/
1253static CURLcode tftp_perform(struct Curl_easy *data, bool *dophase_done)
1254{
1255  CURLcode result = CURLE_OK;
1256  struct connectdata *conn = data->conn;
1257  struct tftp_conn *state = Curl_conn_meta_get(conn, CURL_META_TFTP_CONN);
1258
1259  *dophase_done = FALSE;
1260  if(!state)
1261    return CURLE_FAILED_INIT;
1262
1263  result = tftp_state_machine(state, TFTP_EVENT_INIT);
1264
1265  if((state->state == TFTP_STATE_FIN) || result)
1266    return result;
1267
1268  result = tftp_multi_statemach(data, dophase_done);
1269
1270  if(*dophase_done)
1271    DEBUGF(infof(data, "DO phase is complete"));
1272
1273  return result;
1274}
1275
1276/**********************************************************
1277 *
1278 * tftp_do
1279 *
1280 * The do callback
1281 *
1282 * This callback initiates the TFTP transfer
1283 *
1284 **********************************************************/
1285
1286static CURLcode tftp_do(struct Curl_easy *data, bool *done)
1287{
1288  struct connectdata *conn = data->conn;
1289  struct tftp_conn *state = Curl_conn_meta_get(conn, CURL_META_TFTP_CONN);
1290  CURLcode result;
1291
1292  *done = FALSE;
1293
1294  if(!state) {
1295    result = tftp_connect(data, done);
1296    if(result)
1297      return result;
1298
1299    state = Curl_conn_meta_get(conn, CURL_META_TFTP_CONN);
1300    if(!state)
1301      return CURLE_TFTP_ILLEGAL;
1302  }
1303
1304  result = tftp_perform(data, done);
1305
1306  /* If tftp_perform() returned an error, use that for return code. If it
1307     was OK, see if tftp_translate_code() has an error. */
1308  if(!result)
1309    /* If we have encountered an internal tftp error, translate it. */
1310    result = tftp_translate_code(state->error);
1311
1312  return result;
1313}
1314
1315static CURLcode tftp_setup_connection(struct Curl_easy *data,
1316                                      struct connectdata *conn)
1317{
1318  char *path = data->state.up.path;
1319  size_t len = strlen(path);
1320
1321  conn->transport_wanted = TRNSPRT_UDP;
1322
1323  /* TFTP URLs support a trailing ";mode=netascii" or ";mode=octet" */
1324  if((len >= 14) && !memcmp(&path[len - 14], ";mode=netascii", 14)) {
1325    data->state.prefer_ascii = TRUE;
1326    path[len - 14] = 0; /* cut it there */
1327  }
1328  else if((len >= 11) && !memcmp(&path[len - 11], ";mode=octet", 11)) {
1329    data->state.prefer_ascii = FALSE;
1330    path[len - 11] = 0; /* cut it there */
1331  }
1332
1333  return CURLE_OK;
1334}
1335
1336/*
1337 * TFTP protocol handler.
1338 */
1339const struct Curl_protocol Curl_protocol_tftp = {
1340  tftp_setup_connection,                /* setup_connection */
1341  tftp_do,                              /* do_it */
1342  tftp_done,                            /* done */
1343  ZERO_NULL,                            /* do_more */
1344  tftp_connect,                         /* connect_it */
1345  tftp_multi_statemach,                 /* connecting */
1346  tftp_doing,                           /* doing */
1347  tftp_pollset,                         /* proto_pollset */
1348  tftp_pollset,                         /* doing_pollset */
1349  ZERO_NULL,                            /* domore_pollset */
1350  ZERO_NULL,                            /* perform_pollset */
1351  ZERO_NULL,                            /* disconnect */
1352  ZERO_NULL,                            /* write_resp */
1353  ZERO_NULL,                            /* write_resp_hd */
1354  ZERO_NULL,                            /* connection_is_dead */
1355  ZERO_NULL,                            /* attach connection */
1356  ZERO_NULL,                            /* follow */
1357};
1358
1359#endif