luna - curl/lib/telnet.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 "telnet.h"
  27
  28#ifndef CURL_DISABLE_TELNET
  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 "url.h"
  51#include "transfer.h"
  52#include "sendf.h"
  53#include "curl_trc.h"
  54#include "progress.h"
  55#include "arpa_telnet.h"
  56#include "select.h"
  57#include "curlx/strparse.h"
  58
  59#define SUBBUFSIZE 512
  60
  61#define CURL_SB_CLEAR(x) x->subpointer = (x)->subbuffer
  62#define CURL_SB_TERM(x)            \
  63  do {                             \
  64    (x)->subend = (x)->subpointer; \
  65    CURL_SB_CLEAR(x);              \
  66  } while(0)
  67#define CURL_SB_ACCUM(x, c)                                         \
  68  do {                                                              \
  69    if((x)->subpointer < ((x)->subbuffer + sizeof((x)->subbuffer))) \
  70      *(x)->subpointer++ = (c);                                     \
  71  } while(0)
  72
  73#define CURL_SB_GET(x) ((*(x)->subpointer++) & 0xff)
  74#define CURL_SB_LEN(x) ((x)->subend - (x)->subpointer)
  75
  76/* For posterity:
  77#define  CURL_SB_PEEK(x) ((*x->subpointer)&0xff)
  78#define  CURL_SB_EOF(x) (x->subpointer >= x->subend) */
  79
  80/* For negotiation compliant to RFC 1143 */
  81#define CURL_NO          0
  82#define CURL_YES         1
  83#define CURL_WANTYES     2
  84#define CURL_WANTNO      3
  85
  86#define CURL_EMPTY       0
  87#define CURL_OPPOSITE    1
  88
  89/* meta key for storing protocol meta at easy handle */
  90#define CURL_META_TELNET_EASY   "meta:proto:telnet:easy"
  91
  92/*
  93 * Telnet receiver states for fsm
  94 */
  95typedef enum {
  96  CURL_TS_DATA = 0,
  97  CURL_TS_IAC,
  98  CURL_TS_WILL,
  99  CURL_TS_WONT,
 100  CURL_TS_DO,
 101  CURL_TS_DONT,
 102  CURL_TS_CR,
 103  CURL_TS_SB,   /* sub-option collection */
 104  CURL_TS_SE    /* looking for sub-option end */
 105} TelnetReceive;
 106
 107struct TELNET {
 108  int please_negotiate;
 109  int already_negotiated;
 110  int us[256];
 111  int usq[256];
 112  int us_preferred[256];
 113  int him[256];
 114  int himq[256];
 115  int him_preferred[256];
 116  int subnegotiation[256];
 117  const char *subopt_ttype;          /* Set with suboption TTYPE */
 118  const char *subopt_xdisploc;       /* Set with suboption XDISPLOC */
 119  unsigned short subopt_wsx;         /* Set with suboption NAWS */
 120  unsigned short subopt_wsy;         /* Set with suboption NAWS */
 121  TelnetReceive telrcv_state;
 122  struct curl_slist *telnet_vars;    /* Environment variables */
 123  struct dynbuf out;                 /* output buffer */
 124
 125  /* suboptions */
 126  unsigned char subbuffer[SUBBUFSIZE];
 127  unsigned char *subpointer, *subend;      /* buffer for sub-options */
 128};
 129
 130#ifndef CURLVERBOSE
 131#define printoption(a, b, c, d) Curl_nop_stmt
 132#else
 133static void printoption(struct Curl_easy *data,
 134                        const char *direction, int cmd, int option)
 135{
 136  if(data->set.verbose) {
 137    if(cmd == CURL_IAC) {
 138      if(CURL_TELCMD_OK(option))
 139        infof(data, "%s IAC %s", direction, CURL_TELCMD(option));
 140      else
 141        infof(data, "%s IAC %d", direction, option);
 142    }
 143    else {
 144      const char *fmt = (cmd == CURL_WILL) ? "WILL" :
 145                        (cmd == CURL_WONT) ? "WONT" :
 146                        (cmd == CURL_DO) ? "DO" :
 147                        (cmd == CURL_DONT) ? "DONT" : 0;
 148      if(fmt) {
 149        const char *opt;
 150        if(CURL_TELOPT_OK(option))
 151          opt = CURL_TELOPT(option);
 152        else if(option == CURL_TELOPT_EXOPL)
 153          opt = "EXOPL";
 154        else
 155          opt = NULL;
 156
 157        if(opt)
 158          infof(data, "%s %s %s", direction, fmt, opt);
 159        else
 160          infof(data, "%s %s %d", direction, fmt, option);
 161      }
 162      else
 163        infof(data, "%s %d %d", direction, cmd, option);
 164    }
 165  }
 166}
 167#endif /* !CURLVERBOSE */
 168
 169static void telnet_easy_dtor(void *key, size_t klen, void *entry)
 170{
 171  struct TELNET *tn = entry;
 172  (void)key;
 173  (void)klen;
 174  curl_slist_free_all(tn->telnet_vars);
 175  curlx_dyn_free(&tn->out);
 176  curlx_free(tn);
 177}
 178
 179static CURLcode init_telnet(struct Curl_easy *data)
 180{
 181  struct TELNET *tn;
 182
 183  tn = curlx_calloc(1, sizeof(struct TELNET));
 184  if(!tn)
 185    return CURLE_OUT_OF_MEMORY;
 186
 187  curlx_dyn_init(&tn->out, 0xffff);
 188
 189  tn->telrcv_state = CURL_TS_DATA;
 190
 191  /* Init suboptions */
 192  CURL_SB_CLEAR(tn);
 193
 194  /* Set the options we want by default */
 195  tn->us_preferred[CURL_TELOPT_SGA] = CURL_YES;
 196  tn->him_preferred[CURL_TELOPT_SGA] = CURL_YES;
 197
 198  /* To be compliant with previous releases of libcurl
 199     we enable this option by default. This behavior
 200         can be changed thanks to the "BINARY" option in
 201         CURLOPT_TELNETOPTIONS
 202  */
 203  tn->us_preferred[CURL_TELOPT_BINARY] = CURL_YES;
 204  tn->him_preferred[CURL_TELOPT_BINARY] = CURL_YES;
 205
 206  /* We must allow the server to echo what we sent
 207         but it is not necessary to request the server
 208         to do so (it might forces the server to close
 209         the connection). Hence, we ignore ECHO in the
 210         negotiate function
 211  */
 212  tn->him_preferred[CURL_TELOPT_ECHO] = CURL_YES;
 213
 214  /* Set the subnegotiation fields to send information after negotiation
 215     passed (do/will)
 216
 217     Default values are (0,0) initialized by calloc.
 218     According to the RFC1013 it is valid:
 219     A value equal to zero is acceptable for the width (or height),
 220         and means that no character width (or height) is being sent.
 221         In this case, the width (or height) that will be assumed by the
 222         Telnet server is operating system specific (it will probably be
 223         based upon the terminal type information that may have been sent
 224         using the TERMINAL TYPE Telnet option). */
 225  tn->subnegotiation[CURL_TELOPT_NAWS] = CURL_YES;
 226
 227  return Curl_meta_set(data, CURL_META_TELNET_EASY, tn, telnet_easy_dtor);
 228}
 229
 230static void send_negotiation(struct Curl_easy *data, int cmd, int option)
 231{
 232  unsigned char buf[3];
 233  ssize_t bytes_written;
 234  struct connectdata *conn = data->conn;
 235
 236  buf[0] = CURL_IAC;
 237  buf[1] = (unsigned char)cmd;
 238  buf[2] = (unsigned char)option;
 239
 240  bytes_written = swrite(conn->sock[FIRSTSOCKET], buf, 3);
 241  if(bytes_written < 0) {
 242    int err = SOCKERRNO;
 243    failf(data, "Sending data failed (%d)", err);
 244  }
 245
 246  printoption(data, "SENT", cmd, option);
 247}
 248
 249static void set_remote_option(struct Curl_easy *data, struct TELNET *tn,
 250                              int option, int newstate)
 251{
 252  if(newstate == CURL_YES) {
 253    switch(tn->him[option]) {
 254    case CURL_NO:
 255      tn->him[option] = CURL_WANTYES;
 256      send_negotiation(data, CURL_DO, option);
 257      break;
 258
 259    case CURL_YES:
 260      /* Already enabled */
 261      break;
 262
 263    case CURL_WANTNO:
 264      switch(tn->himq[option]) {
 265      case CURL_EMPTY:
 266        /* Already negotiating for CURL_YES, queue the request */
 267        tn->himq[option] = CURL_OPPOSITE;
 268        break;
 269      case CURL_OPPOSITE:
 270        /* Error: already queued an enable request */
 271        break;
 272      }
 273      break;
 274
 275    case CURL_WANTYES:
 276      switch(tn->himq[option]) {
 277      case CURL_EMPTY:
 278        /* Error: already negotiating for enable */
 279        break;
 280      case CURL_OPPOSITE:
 281        tn->himq[option] = CURL_EMPTY;
 282        break;
 283      }
 284      break;
 285    }
 286  }
 287  else { /* NO */
 288    switch(tn->him[option]) {
 289    case CURL_NO:
 290      /* Already disabled */
 291      break;
 292
 293    case CURL_YES:
 294      tn->him[option] = CURL_WANTNO;
 295      send_negotiation(data, CURL_DONT, option);
 296      break;
 297
 298    case CURL_WANTNO:
 299      switch(tn->himq[option]) {
 300      case CURL_EMPTY:
 301        /* Already negotiating for NO */
 302        break;
 303      case CURL_OPPOSITE:
 304        tn->himq[option] = CURL_EMPTY;
 305        break;
 306      }
 307      break;
 308
 309    case CURL_WANTYES:
 310      switch(tn->himq[option]) {
 311      case CURL_EMPTY:
 312        tn->himq[option] = CURL_OPPOSITE;
 313        break;
 314      case CURL_OPPOSITE:
 315        break;
 316      }
 317      break;
 318    }
 319  }
 320}
 321
 322static void set_local_option(struct Curl_easy *data, struct TELNET *tn,
 323                             int option, int newstate)
 324{
 325  if(newstate == CURL_YES) {
 326    switch(tn->us[option]) {
 327    case CURL_NO:
 328      tn->us[option] = CURL_WANTYES;
 329      send_negotiation(data, CURL_WILL, option);
 330      break;
 331
 332    case CURL_YES:
 333      /* Already enabled */
 334      break;
 335
 336    case CURL_WANTNO:
 337      switch(tn->usq[option]) {
 338      case CURL_EMPTY:
 339        /* Already negotiating for CURL_YES, queue the request */
 340        tn->usq[option] = CURL_OPPOSITE;
 341        break;
 342      case CURL_OPPOSITE:
 343        /* Error: already queued an enable request */
 344        break;
 345      }
 346      break;
 347
 348    case CURL_WANTYES:
 349      switch(tn->usq[option]) {
 350      case CURL_EMPTY:
 351        /* Error: already negotiating for enable */
 352        break;
 353      case CURL_OPPOSITE:
 354        tn->usq[option] = CURL_EMPTY;
 355        break;
 356      }
 357      break;
 358    }
 359  }
 360  else { /* NO */
 361    switch(tn->us[option]) {
 362    case CURL_NO:
 363      /* Already disabled */
 364      break;
 365
 366    case CURL_YES:
 367      tn->us[option] = CURL_WANTNO;
 368      send_negotiation(data, CURL_WONT, option);
 369      break;
 370
 371    case CURL_WANTNO:
 372      switch(tn->usq[option]) {
 373      case CURL_EMPTY:
 374        /* Already negotiating for NO */
 375        break;
 376      case CURL_OPPOSITE:
 377        tn->usq[option] = CURL_EMPTY;
 378        break;
 379      }
 380      break;
 381
 382    case CURL_WANTYES:
 383      switch(tn->usq[option]) {
 384      case CURL_EMPTY:
 385        tn->usq[option] = CURL_OPPOSITE;
 386        break;
 387      case CURL_OPPOSITE:
 388        break;
 389      }
 390      break;
 391    }
 392  }
 393}
 394
 395static void telnet_negotiate(struct Curl_easy *data, struct TELNET *tn)
 396{
 397  int i;
 398
 399  for(i = 0; i < CURL_NTELOPTS; i++) {
 400    if(i == CURL_TELOPT_ECHO)
 401      continue;
 402
 403    if(tn->us_preferred[i] == CURL_YES)
 404      set_local_option(data, tn, i, CURL_YES);
 405
 406    if(tn->him_preferred[i] == CURL_YES)
 407      set_remote_option(data, tn, i, CURL_YES);
 408  }
 409}
 410
 411static void rec_will(struct Curl_easy *data, struct TELNET *tn, int option)
 412{
 413  switch(tn->him[option]) {
 414  case CURL_NO:
 415    if(tn->him_preferred[option] == CURL_YES) {
 416      tn->him[option] = CURL_YES;
 417      send_negotiation(data, CURL_DO, option);
 418    }
 419    else
 420      send_negotiation(data, CURL_DONT, option);
 421
 422    break;
 423
 424  case CURL_YES:
 425    /* Already enabled */
 426    break;
 427
 428  case CURL_WANTNO:
 429    switch(tn->himq[option]) {
 430    case CURL_EMPTY:
 431      /* Error: DONT answered by WILL */
 432      tn->him[option] = CURL_NO;
 433      break;
 434    case CURL_OPPOSITE:
 435      /* Error: DONT answered by WILL */
 436      tn->him[option] = CURL_YES;
 437      tn->himq[option] = CURL_EMPTY;
 438      break;
 439    }
 440    break;
 441
 442  case CURL_WANTYES:
 443    switch(tn->himq[option]) {
 444    case CURL_EMPTY:
 445      tn->him[option] = CURL_YES;
 446      break;
 447    case CURL_OPPOSITE:
 448      tn->him[option] = CURL_WANTNO;
 449      tn->himq[option] = CURL_EMPTY;
 450      send_negotiation(data, CURL_DONT, option);
 451      break;
 452    }
 453    break;
 454  }
 455}
 456
 457static void rec_wont(struct Curl_easy *data, struct TELNET *tn, int option)
 458{
 459  switch(tn->him[option]) {
 460  case CURL_NO:
 461    /* Already disabled */
 462    break;
 463
 464  case CURL_YES:
 465    tn->him[option] = CURL_NO;
 466    send_negotiation(data, CURL_DONT, option);
 467    break;
 468
 469  case CURL_WANTNO:
 470    switch(tn->himq[option]) {
 471    case CURL_EMPTY:
 472      tn->him[option] = CURL_NO;
 473      break;
 474
 475    case CURL_OPPOSITE:
 476      tn->him[option] = CURL_WANTYES;
 477      tn->himq[option] = CURL_EMPTY;
 478      send_negotiation(data, CURL_DO, option);
 479      break;
 480    }
 481    break;
 482
 483  case CURL_WANTYES:
 484    switch(tn->himq[option]) {
 485    case CURL_EMPTY:
 486      tn->him[option] = CURL_NO;
 487      break;
 488    case CURL_OPPOSITE:
 489      tn->him[option] = CURL_NO;
 490      tn->himq[option] = CURL_EMPTY;
 491      break;
 492    }
 493    break;
 494  }
 495}
 496
 497static void printsub(struct Curl_easy *data,
 498                     int direction,                /* '<' or '>' */
 499                     const unsigned char *pointer, /* ptr to suboption data */
 500                     size_t length)                /* suboption data length */
 501{
 502  if(data->set.verbose) {
 503    unsigned int i = 0;
 504    if(direction) {
 505      infof(data, "%s IAC SB ", (direction == '<') ? "RCVD" : "SENT");
 506      if(length >= 3) {
 507        int j;
 508
 509        i = pointer[length - 2];
 510        j = pointer[length - 1];
 511
 512        if(i != CURL_IAC || j != CURL_SE) {
 513          infof(data, "(terminated by ");
 514          if(CURL_TELOPT_OK(i))
 515            infof(data, "%s ", CURL_TELOPT(i));
 516          else if(CURL_TELCMD_OK(i))
 517            infof(data, "%s ", CURL_TELCMD(i));
 518          else
 519            infof(data, "%u ", i);
 520          if(CURL_TELOPT_OK(j))
 521            infof(data, "%s", CURL_TELOPT(j));
 522          else if(CURL_TELCMD_OK(j))
 523            infof(data, "%s", CURL_TELCMD(j));
 524          else
 525            infof(data, "%d", j);
 526          infof(data, ", not IAC SE) ");
 527        }
 528      }
 529      if(length >= 2)
 530        length -= 2;
 531      else /* bad input */
 532        return;
 533    }
 534    if(length <= 1) {
 535      infof(data, "(Empty suboption?)");
 536      return;
 537    }
 538
 539    if(CURL_TELOPT_OK(pointer[0])) {
 540      switch(pointer[0]) {
 541      case CURL_TELOPT_TTYPE:
 542      case CURL_TELOPT_XDISPLOC:
 543      case CURL_TELOPT_NEW_ENVIRON:
 544      case CURL_TELOPT_NAWS:
 545        infof(data, "%s", CURL_TELOPT(pointer[0]));
 546        break;
 547      default:
 548        infof(data, "%s (unsupported)", CURL_TELOPT(pointer[0]));
 549        break;
 550      }
 551    }
 552    else
 553      infof(data, "%d (unknown)", pointer[0]);
 554
 555    switch(pointer[0]) {
 556    case CURL_TELOPT_NAWS:
 557      if(length > 4)
 558        infof(data, "Width: %d ; Height: %d", (pointer[1] << 8) | pointer[2],
 559              (pointer[3] << 8) | pointer[4]);
 560      break;
 561    default:
 562      switch(pointer[1]) {
 563      case CURL_TELQUAL_IS:
 564        infof(data, " IS");
 565        break;
 566      case CURL_TELQUAL_SEND:
 567        infof(data, " SEND");
 568        break;
 569      case CURL_TELQUAL_INFO:
 570        infof(data, " INFO/REPLY");
 571        break;
 572      case CURL_TELQUAL_NAME:
 573        infof(data, " NAME");
 574        break;
 575      }
 576
 577      switch(pointer[0]) {
 578      case CURL_TELOPT_TTYPE:
 579      case CURL_TELOPT_XDISPLOC:
 580        infof(data, " \"%.*s\"",
 581              (int)((length > 2) ? (length - 2) : 0), &pointer[2]);
 582        break;
 583      case CURL_TELOPT_NEW_ENVIRON:
 584        if(pointer[1] == CURL_TELQUAL_IS) {
 585          infof(data, " ");
 586          for(i = 3; i < length; i++) {
 587            switch(pointer[i]) {
 588            case CURL_NEW_ENV_VAR:
 589              infof(data, ", ");
 590              break;
 591            case CURL_NEW_ENV_VALUE:
 592              infof(data, " = ");
 593              break;
 594            default:
 595              infof(data, "%c", pointer[i]);
 596              break;
 597            }
 598          }
 599        }
 600        break;
 601      default:
 602        for(i = 2; i < length; i++)
 603          infof(data, " %.2x", pointer[i]);
 604        break;
 605      }
 606    }
 607  }
 608}
 609
 610/* Escape and send a telnet data block */
 611static CURLcode send_telnet_data(struct Curl_easy *data,
 612                                 struct TELNET *tn,
 613                                 const char *buffer, ssize_t nread)
 614{
 615  size_t i, outlen;
 616  const unsigned char *outbuf;
 617  CURLcode result = CURLE_OK;
 618  size_t bytes_written;
 619  size_t total_written = 0;
 620  struct connectdata *conn = data->conn;
 621
 622  DEBUGASSERT(tn);
 623  DEBUGASSERT(nread > 0);
 624  if(nread < 0)
 625    return CURLE_TOO_LARGE;
 626
 627  if(memchr(buffer, CURL_IAC, nread)) {
 628    /* only use the escape buffer when necessary */
 629    curlx_dyn_reset(&tn->out);
 630
 631    for(i = 0; i < (size_t)nread && !result; i++) {
 632      result = curlx_dyn_addn(&tn->out, &buffer[i], 1);
 633      if(!result && ((unsigned char)buffer[i] == CURL_IAC))
 634        /* IAC is FF in hex */
 635        result = curlx_dyn_addn(&tn->out, "\xff", 1);
 636    }
 637
 638    outlen = curlx_dyn_len(&tn->out);
 639    outbuf = curlx_dyn_uptr(&tn->out);
 640  }
 641  else {
 642    outlen = (size_t)nread;
 643    outbuf = (const unsigned char *)buffer;
 644  }
 645  while(!result && total_written < outlen) {
 646    /* Make sure socket is writable to avoid EWOULDBLOCK condition */
 647    struct pollfd pfd[1];
 648    pfd[0].fd = conn->sock[FIRSTSOCKET];
 649    pfd[0].events = POLLOUT;
 650    switch(Curl_poll(pfd, 1, -1)) {
 651    case -1:                    /* error, abort writing */
 652    case 0:                     /* timeout (will never happen) */
 653      result = CURLE_SEND_ERROR;
 654      break;
 655    default:                    /* write! */
 656      bytes_written = 0;
 657      result = Curl_xfer_send(data, outbuf + total_written,
 658                              outlen - total_written, FALSE, &bytes_written);
 659      total_written += bytes_written;
 660      break;
 661    }
 662  }
 663
 664  return result;
 665}
 666
 667/*
 668 * sendsuboption()
 669 *
 670 * Send suboption information to the server side.
 671 */
 672static void sendsuboption(struct Curl_easy *data,
 673                          struct TELNET *tn, int option)
 674{
 675  ssize_t bytes_written;
 676  int err;
 677  unsigned short x, y;
 678  const unsigned char *uc1, *uc2;
 679  struct connectdata *conn = data->conn;
 680
 681  switch(option) {
 682  case CURL_TELOPT_NAWS:
 683    /* We prepare data to be sent */
 684    CURL_SB_CLEAR(tn);
 685    CURL_SB_ACCUM(tn, CURL_IAC);
 686    CURL_SB_ACCUM(tn, CURL_SB);
 687    CURL_SB_ACCUM(tn, CURL_TELOPT_NAWS);
 688    /* We must deal either with little or big endian processors */
 689    /* Window size must be sent according to the 'network order' */
 690    x = htons(tn->subopt_wsx);
 691    y = htons(tn->subopt_wsy);
 692    uc1 = (const unsigned char *)&x;
 693    uc2 = (const unsigned char *)&y;
 694    CURL_SB_ACCUM(tn, uc1[0]);
 695    CURL_SB_ACCUM(tn, uc1[1]);
 696    CURL_SB_ACCUM(tn, uc2[0]);
 697    CURL_SB_ACCUM(tn, uc2[1]);
 698
 699    CURL_SB_ACCUM(tn, CURL_IAC);
 700    CURL_SB_ACCUM(tn, CURL_SE);
 701    CURL_SB_TERM(tn);
 702    /* data suboption is now ready */
 703
 704    printsub(data, '>', (const unsigned char *)tn->subbuffer + 2,
 705             CURL_SB_LEN(tn) - 2);
 706
 707    /* we send the header of the suboption... */
 708    bytes_written = swrite(conn->sock[FIRSTSOCKET], tn->subbuffer, 3);
 709    if(bytes_written < 0) {
 710      err = SOCKERRNO;
 711      failf(data, "Sending data failed (%d)", err);
 712    }
 713    /* ... then the window size with the send_telnet_data() function
 714       to deal with 0xFF cases ... */
 715    send_telnet_data(data, tn, (const char *)tn->subbuffer + 3, 4);
 716    /* ... and the footer */
 717    bytes_written = swrite(conn->sock[FIRSTSOCKET], tn->subbuffer + 7, 2);
 718    if(bytes_written < 0) {
 719      err = SOCKERRNO;
 720      failf(data, "Sending data failed (%d)", err);
 721    }
 722    break;
 723  }
 724}
 725
 726static void rec_do(struct Curl_easy *data, struct TELNET *tn, int option)
 727{
 728  switch(tn->us[option]) {
 729  case CURL_NO:
 730    if(tn->us_preferred[option] == CURL_YES) {
 731      tn->us[option] = CURL_YES;
 732      send_negotiation(data, CURL_WILL, option);
 733      if(tn->subnegotiation[option] == CURL_YES)
 734        /* transmission of data option */
 735        sendsuboption(data, tn, option);
 736    }
 737    else if(tn->subnegotiation[option] == CURL_YES) {
 738      /* send information to achieve this option */
 739      tn->us[option] = CURL_YES;
 740      send_negotiation(data, CURL_WILL, option);
 741      sendsuboption(data, tn, option);
 742    }
 743    else
 744      send_negotiation(data, CURL_WONT, option);
 745    break;
 746
 747  case CURL_YES:
 748    /* Already enabled */
 749    break;
 750
 751  case CURL_WANTNO:
 752    switch(tn->usq[option]) {
 753    case CURL_EMPTY:
 754      /* Error: DONT answered by WILL */
 755      tn->us[option] = CURL_NO;
 756      break;
 757    case CURL_OPPOSITE:
 758      /* Error: DONT answered by WILL */
 759      tn->us[option] = CURL_YES;
 760      tn->usq[option] = CURL_EMPTY;
 761      break;
 762    }
 763    break;
 764
 765  case CURL_WANTYES:
 766    switch(tn->usq[option]) {
 767    case CURL_EMPTY:
 768      tn->us[option] = CURL_YES;
 769      if(tn->subnegotiation[option] == CURL_YES) {
 770        /* transmission of data option */
 771        sendsuboption(data, tn, option);
 772      }
 773      break;
 774    case CURL_OPPOSITE:
 775      tn->us[option] = CURL_WANTNO;
 776      tn->himq[option] = CURL_EMPTY;
 777      send_negotiation(data, CURL_WONT, option);
 778      break;
 779    }
 780    break;
 781  }
 782}
 783
 784static void rec_dont(struct Curl_easy *data, struct TELNET *tn, int option)
 785{
 786  switch(tn->us[option]) {
 787  case CURL_NO:
 788    /* Already disabled */
 789    break;
 790
 791  case CURL_YES:
 792    tn->us[option] = CURL_NO;
 793    send_negotiation(data, CURL_WONT, option);
 794    break;
 795
 796  case CURL_WANTNO:
 797    switch(tn->usq[option]) {
 798    case CURL_EMPTY:
 799      tn->us[option] = CURL_NO;
 800      break;
 801
 802    case CURL_OPPOSITE:
 803      tn->us[option] = CURL_WANTYES;
 804      tn->usq[option] = CURL_EMPTY;
 805      send_negotiation(data, CURL_WILL, option);
 806      break;
 807    }
 808    break;
 809
 810  case CURL_WANTYES:
 811    switch(tn->usq[option]) {
 812    case CURL_EMPTY:
 813      tn->us[option] = CURL_NO;
 814      break;
 815    case CURL_OPPOSITE:
 816      tn->us[option] = CURL_NO;
 817      tn->usq[option] = CURL_EMPTY;
 818      break;
 819    }
 820    break;
 821  }
 822}
 823
 824static bool str_is_nonascii(const char *str)
 825{
 826  char c;
 827  while((c = *str++) != 0)
 828    if(c & 0x80)
 829      return TRUE;
 830
 831  return FALSE;
 832}
 833
 834static CURLcode check_telnet_options(struct Curl_easy *data,
 835                                     struct TELNET *tn)
 836{
 837  struct curl_slist *head;
 838  struct curl_slist *beg;
 839  CURLcode result = CURLE_OK;
 840
 841  /* Add the username as an environment variable if it
 842     was given on the command line */
 843  if(data->state.creds) {
 844    char buffer[256];
 845    if(str_is_nonascii(Curl_creds_user(data->conn->creds))) {
 846      DEBUGF(infof(data, "set a non ASCII username in telnet"));
 847      return CURLE_BAD_FUNCTION_ARGUMENT;
 848    }
 849    curl_msnprintf(buffer, sizeof(buffer), "USER,%s",
 850                   Curl_creds_user(data->conn->creds));
 851    beg = curl_slist_append(tn->telnet_vars, buffer);
 852    if(!beg) {
 853      curl_slist_free_all(tn->telnet_vars);
 854      tn->telnet_vars = NULL;
 855      return CURLE_OUT_OF_MEMORY;
 856    }
 857    tn->telnet_vars = beg;
 858    tn->us_preferred[CURL_TELOPT_NEW_ENVIRON] = CURL_YES;
 859  }
 860
 861  for(head = data->set.telnet_options; head && !result; head = head->next) {
 862    size_t olen;
 863    const char *option = head->data;
 864    const char *arg;
 865    const char *sep = strchr(option, '=');
 866    if(sep) {
 867      olen = sep - option;
 868      arg = ++sep;
 869      if(str_is_nonascii(arg))
 870        continue;
 871      switch(olen) {
 872      case 5:
 873        /* Terminal type */
 874        if(curl_strnequal(option, "TTYPE", 5)) {
 875          tn->subopt_ttype = arg;
 876          tn->us_preferred[CURL_TELOPT_TTYPE] = CURL_YES;
 877          break;
 878        }
 879        result = CURLE_UNKNOWN_OPTION;
 880        break;
 881
 882      case 8:
 883        /* Display variable */
 884        if(curl_strnequal(option, "XDISPLOC", 8)) {
 885          tn->subopt_xdisploc = arg;
 886          tn->us_preferred[CURL_TELOPT_XDISPLOC] = CURL_YES;
 887          break;
 888        }
 889        result = CURLE_UNKNOWN_OPTION;
 890        break;
 891
 892      case 7:
 893        /* Environment variable */
 894        if(curl_strnequal(option, "NEW_ENV", 7)) {
 895          beg = curl_slist_append(tn->telnet_vars, arg);
 896          if(!beg) {
 897            result = CURLE_OUT_OF_MEMORY;
 898            break;
 899          }
 900          tn->telnet_vars = beg;
 901          tn->us_preferred[CURL_TELOPT_NEW_ENVIRON] = CURL_YES;
 902        }
 903        else
 904          result = CURLE_UNKNOWN_OPTION;
 905        break;
 906
 907      case 2:
 908        /* Window Size */
 909        if(curl_strnequal(option, "WS", 2)) {
 910          const char *p = arg;
 911          curl_off_t x = 0;
 912          curl_off_t y = 0;
 913          if(curlx_str_number(&p, &x, 0xffff) ||
 914             curlx_str_single(&p, 'x') ||
 915             curlx_str_number(&p, &y, 0xffff)) {
 916            failf(data, "Syntax error in telnet option: %s", head->data);
 917            result = CURLE_SETOPT_OPTION_SYNTAX;
 918          }
 919          else {
 920            tn->subopt_wsx = (unsigned short)x;
 921            tn->subopt_wsy = (unsigned short)y;
 922            tn->us_preferred[CURL_TELOPT_NAWS] = CURL_YES;
 923          }
 924        }
 925        else
 926          result = CURLE_UNKNOWN_OPTION;
 927        break;
 928
 929      case 6:
 930        /* To take care or not of the 8th bit in data exchange */
 931        if(curl_strnequal(option, "BINARY", 6)) {
 932          const char *p = arg;
 933          curl_off_t binary_option;
 934          if(!curlx_str_number(&p, &binary_option, 1) &&
 935             (binary_option != 1)) {
 936            tn->us_preferred[CURL_TELOPT_BINARY] = CURL_NO;
 937            tn->him_preferred[CURL_TELOPT_BINARY] = CURL_NO;
 938          }
 939        }
 940        else
 941          result = CURLE_UNKNOWN_OPTION;
 942        break;
 943      default:
 944        failf(data, "Unknown telnet option %s", head->data);
 945        result = CURLE_UNKNOWN_OPTION;
 946        break;
 947      }
 948    }
 949    else {
 950      failf(data, "Syntax error in telnet option: %s", head->data);
 951      result = CURLE_SETOPT_OPTION_SYNTAX;
 952    }
 953  }
 954
 955  if(result) {
 956    curl_slist_free_all(tn->telnet_vars);
 957    tn->telnet_vars = NULL;
 958  }
 959
 960  return result;
 961}
 962
 963/* if the option contains an IAC code, it should be escaped in the output, but
 964   as we cannot think of any legit way to send that as part of the content we
 965   rather ban its use instead */
 966static bool bad_option(const char *data)
 967{
 968  return !data || !!strchr(data, CURL_IAC);
 969}
 970
 971/*
 972 * suboption()
 973 *
 974 * Look at the sub-option buffer, and try to be helpful to the other
 975 * side.
 976 */
 977static CURLcode suboption(struct Curl_easy *data, struct TELNET *tn)
 978{
 979  struct curl_slist *v;
 980  unsigned char temp[2048];
 981  ssize_t bytes_written;
 982  size_t len;
 983  int err;
 984  struct connectdata *conn = data->conn;
 985
 986  if(!CURL_SB_LEN(tn)) /* ignore empty suboption */
 987    return CURLE_OK;
 988
 989  printsub(data, '<', (const unsigned char *)tn->subbuffer,
 990           CURL_SB_LEN(tn) + 2);
 991  switch(CURL_SB_GET(tn)) {
 992  case CURL_TELOPT_TTYPE:
 993    if(bad_option(tn->subopt_ttype))
 994      return CURLE_BAD_FUNCTION_ARGUMENT;
 995    if(strlen(tn->subopt_ttype) > 1000) {
 996      failf(data, "Tool long telnet TTYPE");
 997      return CURLE_SEND_ERROR;
 998    }
 999    len = curl_msnprintf((char *)temp, sizeof(temp), "%c%c%c%c%s%c%c",
1000                         CURL_IAC, CURL_SB, CURL_TELOPT_TTYPE,
1001                         CURL_TELQUAL_IS, tn->subopt_ttype, CURL_IAC,
1002                         CURL_SE);
1003    bytes_written = swrite(conn->sock[FIRSTSOCKET], temp, len);
1004
1005    if(bytes_written < 0) {
1006      err = SOCKERRNO;
1007      failf(data, "Sending data failed (%d)", err);
1008      return CURLE_SEND_ERROR;
1009    }
1010    printsub(data, '>', &temp[2], len-2);
1011    break;
1012  case CURL_TELOPT_XDISPLOC:
1013    if(bad_option(tn->subopt_xdisploc))
1014      return CURLE_BAD_FUNCTION_ARGUMENT;
1015    if(strlen(tn->subopt_xdisploc) > 1000) {
1016      failf(data, "Tool long telnet XDISPLOC");
1017      return CURLE_SEND_ERROR;
1018    }
1019    len = curl_msnprintf((char *)temp, sizeof(temp), "%c%c%c%c%s%c%c",
1020                         CURL_IAC, CURL_SB, CURL_TELOPT_XDISPLOC,
1021                         CURL_TELQUAL_IS, tn->subopt_xdisploc, CURL_IAC,
1022                         CURL_SE);
1023    bytes_written = swrite(conn->sock[FIRSTSOCKET], temp, len);
1024    if(bytes_written < 0) {
1025      err = SOCKERRNO;
1026      failf(data, "Sending data failed (%d)", err);
1027      return CURLE_SEND_ERROR;
1028    }
1029    printsub(data, '>', &temp[2], len - 2);
1030    break;
1031  case CURL_TELOPT_NEW_ENVIRON:
1032    len = curl_msnprintf((char *)temp, sizeof(temp), "%c%c%c%c",
1033                         CURL_IAC, CURL_SB, CURL_TELOPT_NEW_ENVIRON,
1034                         CURL_TELQUAL_IS);
1035    for(v = tn->telnet_vars; v; v = v->next) {
1036      size_t tmplen = (strlen(v->data) + 1);
1037      if(bad_option(v->data))
1038        return CURLE_BAD_FUNCTION_ARGUMENT;
1039      /* Add the variable if it fits */
1040      if(len + tmplen < (int)sizeof(temp) - 6) {
1041        const char *s = strchr(v->data, ',');
1042        if(!s)
1043          len += curl_msnprintf((char *)&temp[len], sizeof(temp) - len,
1044                                "%c%s", CURL_NEW_ENV_VAR, v->data);
1045        else {
1046          size_t vlen = s - v->data;
1047          len += curl_msnprintf((char *)&temp[len], sizeof(temp) - len,
1048                                "%c%.*s%c%s", CURL_NEW_ENV_VAR,
1049                                (int)vlen, v->data, CURL_NEW_ENV_VALUE, ++s);
1050        }
1051      }
1052    }
1053    curl_msnprintf((char *)&temp[len], sizeof(temp) - len,
1054                   "%c%c", CURL_IAC, CURL_SE);
1055    len += 2;
1056    bytes_written = swrite(conn->sock[FIRSTSOCKET], temp, len);
1057    if(bytes_written < 0) {
1058      err = SOCKERRNO;
1059      failf(data, "Sending data failed (%d)", err);
1060    }
1061    printsub(data, '>', &temp[2], len - 2);
1062    break;
1063  }
1064  return CURLE_OK;
1065}
1066
1067static CURLcode telrcv(struct Curl_easy *data,
1068                       struct TELNET *tn,
1069                       const unsigned char *inbuf, /* Data received from
1070                                                      socket */
1071                       ssize_t count)              /* Number of bytes
1072                                                      received */
1073{
1074  unsigned char c;
1075  CURLcode result;
1076  int in = 0;
1077  int startwrite = -1;
1078
1079#define startskipping()                                          \
1080  if(startwrite >= 0) {                                          \
1081    result = Curl_client_write(data,                             \
1082                               CLIENTWRITE_BODY,                 \
1083                               (const char *)&inbuf[startwrite], \
1084                               in-startwrite);                   \
1085    if(result)                                                   \
1086      return result;                                             \
1087  }                                                              \
1088  startwrite = -1
1089
1090#define writebyte()  \
1091  if(startwrite < 0) \
1092    startwrite = in
1093
1094#define bufferflush() startskipping()
1095
1096  while(count--) {
1097    c = inbuf[in];
1098
1099    switch(tn->telrcv_state) {
1100    case CURL_TS_CR:
1101      tn->telrcv_state = CURL_TS_DATA;
1102      if(c == '\0') {
1103        startskipping();
1104        break;   /* Ignore \0 after CR */
1105      }
1106      writebyte();
1107      break;
1108
1109    case CURL_TS_DATA:
1110      if(c == CURL_IAC) {
1111        tn->telrcv_state = CURL_TS_IAC;
1112        startskipping();
1113        break;
1114      }
1115      else if(c == '\r')
1116        tn->telrcv_state = CURL_TS_CR;
1117      writebyte();
1118      break;
1119
1120    case CURL_TS_IAC:
1121      DEBUGASSERT(startwrite < 0);
1122      switch(c) {
1123      case CURL_WILL:
1124        tn->telrcv_state = CURL_TS_WILL;
1125        break;
1126      case CURL_WONT:
1127        tn->telrcv_state = CURL_TS_WONT;
1128        break;
1129      case CURL_DO:
1130        tn->telrcv_state = CURL_TS_DO;
1131        break;
1132      case CURL_DONT:
1133        tn->telrcv_state = CURL_TS_DONT;
1134        break;
1135      case CURL_SB:
1136        CURL_SB_CLEAR(tn);
1137        tn->telrcv_state = CURL_TS_SB;
1138        break;
1139      case CURL_IAC:
1140        tn->telrcv_state = CURL_TS_DATA;
1141        writebyte();
1142        break;
1143      case CURL_DM:
1144      case CURL_NOP:
1145      case CURL_GA:
1146      default:
1147        tn->telrcv_state = CURL_TS_DATA;
1148        printoption(data, "RCVD", CURL_IAC, c);
1149        break;
1150      }
1151      break;
1152
1153    case CURL_TS_WILL:
1154      printoption(data, "RCVD", CURL_WILL, c);
1155      tn->please_negotiate = 1;
1156      rec_will(data, tn, c);
1157      tn->telrcv_state = CURL_TS_DATA;
1158      break;
1159
1160    case CURL_TS_WONT:
1161      printoption(data, "RCVD", CURL_WONT, c);
1162      tn->please_negotiate = 1;
1163      rec_wont(data, tn, c);
1164      tn->telrcv_state = CURL_TS_DATA;
1165      break;
1166
1167    case CURL_TS_DO:
1168      printoption(data, "RCVD", CURL_DO, c);
1169      tn->please_negotiate = 1;
1170      rec_do(data, tn, c);
1171      tn->telrcv_state = CURL_TS_DATA;
1172      break;
1173
1174    case CURL_TS_DONT:
1175      printoption(data, "RCVD", CURL_DONT, c);
1176      tn->please_negotiate = 1;
1177      rec_dont(data, tn, c);
1178      tn->telrcv_state = CURL_TS_DATA;
1179      break;
1180
1181    case CURL_TS_SB:
1182      if(c == CURL_IAC)
1183        tn->telrcv_state = CURL_TS_SE;
1184      else
1185        CURL_SB_ACCUM(tn, c);
1186      break;
1187
1188    case CURL_TS_SE:
1189      if(c != CURL_SE) {
1190        if(c != CURL_IAC) {
1191          /*
1192           * This is an error. We only expect to get "IAC IAC" or "IAC SE".
1193           * Several things may have happened. An IAC was not doubled, the IAC
1194           * SE was left off, or another option got inserted into the
1195           * suboption are all possibilities.
1196           */
1197          failf(data, "telnet: suboption error");
1198          return CURLE_RECV_ERROR;
1199        }
1200        CURL_SB_ACCUM(tn, c);
1201        tn->telrcv_state = CURL_TS_SB;
1202      }
1203      else {
1204        CURL_SB_ACCUM(tn, CURL_IAC);
1205        CURL_SB_ACCUM(tn, CURL_SE);
1206        tn->subpointer -= 2;
1207        CURL_SB_TERM(tn);
1208        result = suboption(data, tn);   /* handle sub-option */
1209        if(result)
1210          return result;
1211        tn->telrcv_state = CURL_TS_DATA;
1212      }
1213      break;
1214    }
1215    ++in;
1216  }
1217  bufferflush();
1218  return CURLE_OK;
1219}
1220
1221static CURLcode telnet_done(struct Curl_easy *data,
1222                            CURLcode status, bool premature)
1223{
1224  (void)status;
1225  (void)premature;
1226  Curl_meta_remove(data, CURL_META_TELNET_EASY);
1227  return CURLE_OK;
1228}
1229
1230static CURLcode telnet_do(struct Curl_easy *data, bool *done)
1231{
1232  CURLcode result;
1233  struct connectdata *conn = data->conn;
1234  curl_socket_t sockfd = conn->sock[FIRSTSOCKET];
1235#ifdef USE_WINSOCK
1236  WSAEVENT event_handle;
1237  WSANETWORKEVENTS events;
1238  HANDLE stdin_handle;
1239  HANDLE objs[2];
1240  DWORD obj_count;
1241  DWORD wait_timeout;
1242  DWORD readfile_read;
1243  int err;
1244#else
1245  timediff_t interval_ms;
1246  struct pollfd pfd[2];
1247  int poll_cnt;
1248  ssize_t snread;
1249#endif
1250  bool keepon = TRUE;
1251  char buffer[4 * 1024];
1252  struct TELNET *tn;
1253
1254  *done = TRUE; /* unconditionally */
1255
1256  result = init_telnet(data);
1257  if(result)
1258    return result;
1259
1260  tn = Curl_meta_get(data, CURL_META_TELNET_EASY);
1261  if(!tn)
1262    return CURLE_FAILED_INIT;
1263
1264  result = check_telnet_options(data, tn);
1265  if(result)
1266    return result;
1267
1268#ifdef USE_WINSOCK
1269  /* We want to wait for both stdin and the socket. Since
1270   * the select() function in Winsock only works on sockets
1271   * we have to use the WaitForMultipleObjects() call.
1272   */
1273
1274  /* First, create a sockets event object */
1275  event_handle = WSACreateEvent();
1276  if(event_handle == WSA_INVALID_EVENT) {
1277    failf(data, "WSACreateEvent failed (%d)", SOCKERRNO);
1278    return CURLE_FAILED_INIT;
1279  }
1280
1281  /* Tell Winsock what events we want to listen to */
1282  if(WSAEventSelect(sockfd, event_handle, FD_READ | FD_CLOSE) != 0) {
1283    WSACloseEvent(event_handle);
1284    return CURLE_RECV_ERROR;
1285  }
1286
1287  /* The get the Windows file handle for stdin */
1288  stdin_handle = GetStdHandle(STD_INPUT_HANDLE);
1289
1290  /* Create the list of objects to wait for */
1291  objs[0] = event_handle;
1292  objs[1] = stdin_handle;
1293
1294  /* If stdin_handle is a pipe, use PeekNamedPipe() method to check it,
1295     else use the old WaitForMultipleObjects() way */
1296  if(GetFileType(stdin_handle) == FILE_TYPE_PIPE || data->set.is_fread_set) {
1297    /* Do not wait for stdin_handle, wait for event_handle */
1298    obj_count = 1;
1299    /* Check stdin_handle per 100 milliseconds */
1300    wait_timeout = 100;
1301  }
1302  else {
1303    obj_count = 2;
1304    wait_timeout = 1000;
1305  }
1306
1307  /* Keep on listening and act on events */
1308  while(keepon) {
1309    const DWORD buf_size = (DWORD)sizeof(buffer);
1310    DWORD waitret = WaitForMultipleObjects(obj_count, objs,
1311                                           FALSE, wait_timeout);
1312    switch(waitret) {
1313
1314    case WAIT_TIMEOUT: {
1315      for(;;) {
1316        if(data->set.is_fread_set) {
1317          size_t n;
1318          /* read from user-supplied method */
1319          n = data->state.fread_func(buffer, 1, buf_size, data->state.in);
1320          if(n == CURL_READFUNC_ABORT) {
1321            keepon = FALSE;
1322            result = CURLE_READ_ERROR;
1323            break;
1324          }
1325
1326          if(n == CURL_READFUNC_PAUSE)
1327            break;
1328
1329          if(n == 0)                        /* no bytes */
1330            break;
1331
1332          /* fall through with number of bytes read */
1333          readfile_read = (DWORD)n;
1334        }
1335        else {
1336          /* read from stdin */
1337          if(!PeekNamedPipe(stdin_handle, NULL, 0, NULL,
1338                            &readfile_read, NULL)) {
1339            keepon = FALSE;
1340            result = CURLE_READ_ERROR;
1341            break;
1342          }
1343
1344          if(!readfile_read)
1345            break;
1346
1347          if(!ReadFile(stdin_handle, buffer, buf_size, &readfile_read, NULL)) {
1348            keepon = FALSE;
1349            result = CURLE_READ_ERROR;
1350            break;
1351          }
1352        }
1353
1354        result = send_telnet_data(data, tn, buffer, readfile_read);
1355        if(result) {
1356          keepon = FALSE;
1357          break;
1358        }
1359      }
1360    }
1361    break;
1362
1363    case WAIT_OBJECT_0 + 1: {
1364      if(!ReadFile(stdin_handle, buffer, buf_size, &readfile_read, NULL)) {
1365        keepon = FALSE;
1366        result = CURLE_READ_ERROR;
1367        break;
1368      }
1369
1370      result = send_telnet_data(data, tn, buffer, readfile_read);
1371      if(result) {
1372        keepon = FALSE;
1373        break;
1374      }
1375    }
1376    break;
1377
1378    case WAIT_OBJECT_0: {
1379      events.lNetworkEvents = 0;
1380      if(WSAEnumNetworkEvents(sockfd, event_handle, &events) != 0) {
1381        err = SOCKERRNO;
1382        if(err != SOCKEINPROGRESS) {
1383          infof(data, "WSAEnumNetworkEvents failed (%d)", err);
1384          keepon = FALSE;
1385          result = CURLE_READ_ERROR;
1386        }
1387        break;
1388      }
1389      if(events.lNetworkEvents & FD_READ) {
1390        /* read data from network */
1391        size_t nread;
1392        result = Curl_xfer_recv(data, buffer, sizeof(buffer), &nread);
1393        /* read would have blocked. Loop again */
1394        if(result == CURLE_AGAIN)
1395          break;
1396        /* returned not-zero, this an error */
1397        else if(result) {
1398          keepon = FALSE;
1399          break;
1400        }
1401        /* returned zero but actually received 0 or less here,
1402           the server closed the connection and we bail out */
1403        else if(!nread) {
1404          keepon = FALSE;
1405          break;
1406        }
1407
1408        result = telrcv(data, tn, (unsigned char *)buffer, nread);
1409        if(result) {
1410          keepon = FALSE;
1411          break;
1412        }
1413
1414        /* Negotiate if the peer has started negotiating,
1415           otherwise do not. We do not want to speak telnet with
1416           non-telnet servers, like POP or SMTP. */
1417        if(tn->please_negotiate && !tn->already_negotiated) {
1418          telnet_negotiate(data, tn);
1419          tn->already_negotiated = 1;
1420        }
1421      }
1422      if(events.lNetworkEvents & FD_CLOSE) {
1423        keepon = FALSE;
1424      }
1425      break;
1426    }
1427    } /* switch */
1428
1429    if(data->set.timeout) {
1430      if(curlx_ptimediff_ms(Curl_pgrs_now(data), &conn->created) >=
1431         data->set.timeout) {
1432        failf(data, "Time-out");
1433        result = CURLE_OPERATION_TIMEDOUT;
1434        keepon = FALSE;
1435      }
1436    }
1437  }
1438
1439  /* We called WSACreateEvent, so call WSACloseEvent */
1440  if(!WSACloseEvent(event_handle)) {
1441    infof(data, "WSACloseEvent failed (%d)", SOCKERRNO);
1442  }
1443#else
1444  pfd[0].fd = sockfd;
1445  pfd[0].events = POLLIN;
1446
1447  if(data->set.is_fread_set) {
1448    poll_cnt = 1;
1449    interval_ms = 100; /* poll user-supplied read function */
1450  }
1451  else {
1452    /* really using fread, so infile is a FILE* */
1453    pfd[1].fd = fileno((FILE *)data->state.in);
1454    pfd[1].events = POLLIN;
1455    poll_cnt = 2;
1456    interval_ms = 1 * 1000;
1457    if(pfd[1].fd < 0) {
1458      failf(data, "cannot read input");
1459      result = CURLE_RECV_ERROR;
1460      keepon = FALSE;
1461    }
1462  }
1463
1464  while(keepon) {
1465    DEBUGF(infof(data, "telnet_do, poll %d fds", poll_cnt));
1466    switch(Curl_poll(pfd, (unsigned int)poll_cnt, interval_ms)) {
1467    case -1:                    /* error, stop reading */
1468      keepon = FALSE;
1469      continue;
1470    case 0:                     /* timeout */
1471      pfd[0].revents = 0;
1472      pfd[1].revents = 0;
1473      FALLTHROUGH();
1474    default:                    /* read! */
1475      if(pfd[0].revents & POLLIN) {
1476        /* read data from network */
1477        size_t nread;
1478        result = Curl_xfer_recv(data, buffer, sizeof(buffer), &nread);
1479        /* read would have blocked. Loop again */
1480        if(result == CURLE_AGAIN)
1481          break;
1482        /* returned not-zero, this an error */
1483        if(result) {
1484          keepon = FALSE;
1485          /* In test 1452, macOS sees a ECONNRESET sometimes? Is this the
1486           * telnet test server not shutting down the socket in a clean way?
1487           * Seems to be timing related, happens more on slow debug build */
1488          if(data->state.os_errno == SOCKECONNRESET) {
1489            DEBUGF(infof(data, "telnet_do, unexpected ECONNRESET on recv"));
1490          }
1491          break;
1492        }
1493        /* returned zero but actually received 0 or less here,
1494           the server closed the connection and we bail out */
1495        else if(!nread) {
1496          keepon = FALSE;
1497          break;
1498        }
1499
1500        Curl_pgrs_download_inc(data, nread);
1501        result = telrcv(data, tn, (unsigned char *)buffer, nread);
1502        if(result) {
1503          keepon = FALSE;
1504          break;
1505        }
1506
1507        /* Negotiate if the peer has started negotiating,
1508           otherwise do not. We do not want to speak telnet with
1509           non-telnet servers, like POP or SMTP. */
1510        if(tn->please_negotiate && !tn->already_negotiated) {
1511          telnet_negotiate(data, tn);
1512          tn->already_negotiated = 1;
1513        }
1514      }
1515
1516      snread = 0;
1517      if(poll_cnt == 2) {
1518        if(pfd[1].revents & POLLIN) { /* read from in file */
1519          snread = read(pfd[1].fd, buffer, sizeof(buffer));
1520        }
1521      }
1522      else {
1523        /* read from user-supplied method */
1524        snread = (int)data->state.fread_func(buffer, 1, sizeof(buffer),
1525                                             data->state.in);
1526        if(snread == CURL_READFUNC_ABORT) {
1527          keepon = FALSE;
1528          break;
1529        }
1530        if(snread == CURL_READFUNC_PAUSE)
1531          break;
1532      }
1533
1534      if(snread > 0) {
1535        result = send_telnet_data(data, tn, buffer, snread);
1536        if(result) {
1537          keepon = FALSE;
1538          break;
1539        }
1540        Curl_pgrs_upload_inc(data, (size_t)snread);
1541      }
1542      else if(snread < 0)
1543        keepon = FALSE;
1544
1545      break;
1546    } /* poll switch statement */
1547
1548    if(data->set.timeout) {
1549      if(curlx_ptimediff_ms(Curl_pgrs_now(data), &conn->created) >=
1550         data->set.timeout) {
1551        failf(data, "Time-out");
1552        result = CURLE_OPERATION_TIMEDOUT;
1553        keepon = FALSE;
1554      }
1555    }
1556
1557    if(!result) {
1558      result = Curl_pgrsUpdate(data);
1559      if(result)
1560        keepon = FALSE;
1561    }
1562  }
1563#endif
1564  /* mark this as "no further transfer wanted" */
1565  Curl_xfer_setup_nop(data);
1566
1567  return result;
1568}
1569
1570/*
1571 * TELNET protocol handler.
1572 */
1573const struct Curl_protocol Curl_protocol_telnet = {
1574  ZERO_NULL,                            /* setup_connection */
1575  telnet_do,                            /* do_it */
1576  telnet_done,                          /* done */
1577  ZERO_NULL,                            /* do_more */
1578  ZERO_NULL,                            /* connect_it */
1579  ZERO_NULL,                            /* connecting */
1580  ZERO_NULL,                            /* doing */
1581  ZERO_NULL,                            /* proto_pollset */
1582  ZERO_NULL,                            /* doing_pollset */
1583  ZERO_NULL,                            /* domore_pollset */
1584  ZERO_NULL,                            /* perform_pollset */
1585  ZERO_NULL,                            /* disconnect */
1586  ZERO_NULL,                            /* write_resp */
1587  ZERO_NULL,                            /* write_resp_hd */
1588  ZERO_NULL,                            /* connection_is_dead */
1589  ZERO_NULL,                            /* attach connection */
1590  ZERO_NULL,                            /* follow */
1591};
1592
1593#endif /* !CURL_DISABLE_TELNET */