自学教程：C++ Curl_write函数代码示例

CURLcode Curl_pp_flushsend(struct pingpong *pp){  /* we have a piece of a command still left to send */  struct connectdata *conn = pp->conn;  ssize_t written;  CURLcode result = CURLE_OK;  curl_socket_t sock = conn->sock[FIRSTSOCKET];  result = Curl_write(conn, sock, pp->sendthis + pp->sendsize -                      pp->sendleft, pp->sendleft, &written);  if(result)    return result;  if(written != (ssize_t)pp->sendleft) {    /* only a fraction was sent */    pp->sendleft -= written;  }  else {    free(pp->sendthis);    pp->sendthis=NULL;    pp->sendleft = pp->sendsize = 0;    pp->response = Curl_tvnow();  }  return CURLE_OK;}

/* * Sends data over the connected socket. Use after successful * curl_easy_perform() with CURLOPT_CONNECT_ONLY option. */CURLcode curl_easy_send(CURL *curl, const void *buffer, size_t buflen,                        size_t *n){  curl_socket_t sfd;  CURLcode ret;  ssize_t n1;  struct connectdata *c = NULL;  struct SessionHandle *data = (struct SessionHandle *)curl;  ret = easy_connection(data, &sfd, &c);  if(ret)    return ret;  *n = 0;  ret = Curl_write(c, sfd, buffer, buflen, &n1);  if(n1 == -1)    return CURLE_SEND_ERROR;  /* detect EAGAIN */  if((CURLE_OK == ret) && (0 == n1))    return CURLE_AGAIN;  *n = (size_t)n1;  return ret;}

/* * Sends data over the connected socket. Use after successful * curl_easy_perform() with CURLOPT_CONNECT_ONLY option. */CURLcode curl_easy_send(struct Curl_easy *data, const void *buffer,                        size_t buflen, size_t *n){  curl_socket_t sfd;  CURLcode result;  ssize_t n1;  struct connectdata *c = NULL;  result = easy_connection(data, &sfd, &c);  if(result)    return result;  *n = 0;  result = Curl_write(c, sfd, buffer, buflen, &n1);  if(n1 == -1)    return CURLE_SEND_ERROR;  /* detect EAGAIN */  if(!result && !n1)    return CURLE_AGAIN;  *n = (size_t)n1;  return result;}

/* Escape and send a telnet data block */static CURLcode send_telnet_data(struct connectdata *conn,                                 char *buffer, ssize_t nread){  ssize_t escapes, i, j, outlen;  unsigned char *outbuf = NULL;  CURLcode result = CURLE_OK;  ssize_t bytes_written, total_written;  /* Determine size of new buffer after escaping */  escapes = 0;  for(i = 0; i < nread; i++)    if((unsigned char)buffer[i] == CURL_IAC)      escapes++;  outlen = nread + escapes;  if(outlen == nread)    outbuf = (unsigned char *)buffer;  else {    outbuf = malloc(nread + escapes + 1);    if(!outbuf)      return CURLE_OUT_OF_MEMORY;    j = 0;    for(i = 0; i < nread; i++) {      outbuf[j++] = buffer[i];      if((unsigned char)buffer[i] == CURL_IAC)        outbuf[j++] = CURL_IAC;    }    outbuf[j] = '/0';  }  total_written = 0;  while(!result && total_written < outlen) {    /* Make sure socket is writable to avoid EWOULDBLOCK condition */    struct pollfd pfd[1];    pfd[0].fd = conn->sock[FIRSTSOCKET];    pfd[0].events = POLLOUT;    switch(Curl_poll(pfd, 1, -1)) {      case -1:                    /* error, abort writing */      case 0:                     /* timeout (will never happen) */        result = CURLE_SEND_ERROR;        break;      default:                    /* write! */        bytes_written = 0;        result = Curl_write(conn, conn->sock[FIRSTSOCKET],                            outbuf + total_written,                            outlen - total_written,                            &bytes_written);        total_written += bytes_written;        break;    }  }  /* Free malloc copy if escaped */  if(outbuf != (unsigned char *)buffer)    free(outbuf);  return result;}

/*********************************************************************** * * smtp_done() * * The DONE function. This does what needs to be done after a single DO has * performed. * * Input argument is already checked for validity. */static CURLcode smtp_done(struct connectdata *conn, CURLcode status,                          bool premature){  struct SessionHandle *data = conn->data;  struct FTP *smtp = data->state.proto.smtp;  CURLcode result = CURLE_OK;  ssize_t bytes_written;  (void)premature;  if(!smtp)    /* When the easy handle is removed from the multi while libcurl is still     * trying to resolve the host name, it seems that the smtp struct is not     * yet initialized, but the removal action calls Curl_done() which calls     * this function. So we simply return success if no smtp pointer is set.     */    return CURLE_OK;  if(status) {    conn->bits.close = TRUE; /* marked for closure */    result = status;      /* use the already set error code */  }  else    /* TODO: make this work even when the socket is EWOULDBLOCK in this       call! */    /* write to socket (send away data) */    result = Curl_write(conn,                        conn->writesockfd,  /* socket to send to */                        SMTP_EOB,           /* buffer pointer */                        SMTP_EOB_LEN,       /* buffer size */                        &bytes_written);    /* actually sent away */  if(status == CURLE_OK) {    struct smtp_conn *smtpc = &conn->proto.smtpc;    struct pingpong *pp = &smtpc->pp;    pp->response = Curl_tvnow(); /* timeout relative now */    state(conn, SMTP_POSTDATA);    /* run the state-machine       TODO: when the multi interface is used, this _really_ should be using       the smtp_multi_statemach function but we have no general support for       non-blocking DONE operations, not in the multi state machine and with       Curl_done() invokes on several places in the code!    */    result = smtp_easy_statemach(conn);  }  /* clear these for next connection */  smtp->transfer = FTPTRANSFER_BODY;  return result;}

/* Curl_sendf() sends formated data to the server */CURLcode Curl_sendf(curl_socket_t sockfd, struct connectdata *conn,                    const char *fmt, ...){    struct SessionHandle *data = conn->data;    ssize_t bytes_written;    size_t write_len;    CURLcode res;    char *s;    char *sptr;    va_list ap;    va_start(ap, fmt);    s = vaprintf(fmt, ap); /* returns an allocated string */    va_end(ap);    if(!s)        return CURLE_OUT_OF_MEMORY; /* failure */    bytes_written=0;    write_len = strlen(s);    sptr = s;    while (1)    {        /* Write the buffer to the socket */        res = Curl_write(conn, sockfd, sptr, write_len, &bytes_written);        if(CURLE_OK != res)            break;        if(data->set.verbose)            Curl_debug(data, CURLINFO_DATA_OUT, sptr, bytes_written);        if((size_t)bytes_written != write_len)        {            /* if not all was written at once, we must advance the pointer, decrease               the size left and try again! */            write_len -= bytes_written;            sptr += bytes_written;        }        else            break;    }    free(s); /* free the output string */    return res;}

/* * add_buffer_send() sends a buffer and frees all associated memory. */staticCURLcode add_buffer_send(int sockfd, struct connectdata *conn, send_buffer *in,                         long *bytes_written){  ssize_t amount;  CURLcode res;  char *ptr;  int size;  if(conn->data->set.verbose) {    fputs("> ", conn->data->set.err);    /* this data _may_ contain binary stuff */    fwrite(in->buffer, in->size_used, 1, conn->data->set.err);  }  /* The looping below is required since we use non-blocking sockets, but due     to the circumstances we will just loop and try again and again etc */  ptr = in->buffer;  size = in->size_used;  do {    res = Curl_write(conn, sockfd, ptr, size, &amount);    if(CURLE_OK != res)      break;    if(amount != size) {      size -= amount;      ptr += amount;    }    else      break;  } while(1);  if(in->buffer)    free(in->buffer);  free(in);  *bytes_written = amount;  return res;}

/* * The implementation of nghttp2_send_callback type. Here we write |data| with * size |length| to the network and return the number of bytes actually * written. See the documentation of nghttp2_send_callback for the details. */static ssize_t send_callback(nghttp2_session *h2,                             const uint8_t *data, size_t length, int flags,                             void *userp){  struct connectdata *conn = (struct connectdata *)userp;  ssize_t written;  CURLcode rc =    Curl_write(conn, conn->sock[FIRSTSOCKET], data, length, &written);  (void)h2;  (void)flags;  if(rc) {    failf(conn->data, "Failed sending HTTP2 data");    return NGHTTP2_ERR_CALLBACK_FAILURE;  }  else if(!written)    return NGHTTP2_ERR_WOULDBLOCK;  return written;}

/* TODO: write large chunks of data instead of one byte at a time */static CURLcode send_telnet_data(struct connectdata *conn,                                 char *buffer, ssize_t nread){  unsigned char outbuf[2];  ssize_t bytes_written, total_written;  int out_count;  CURLcode result = CURLE_OK;  while(!result && nread--) {    outbuf[0] = *buffer++;    out_count = 1;    if(outbuf[0] == CURL_IAC)      outbuf[out_count++] = CURL_IAC;    total_written = 0;    do {      /* Make sure socket is writable to avoid EWOULDBLOCK condition */      struct pollfd pfd[1];      pfd[0].fd = conn->sock[FIRSTSOCKET];      pfd[0].events = POLLOUT;      switch (Curl_poll(pfd, 1, -1)) {        case -1:                    /* error, abort writing */        case 0:                     /* timeout (will never happen) */          result = CURLE_SEND_ERROR;          break;        default:                    /* write! */          bytes_written = 0;          result = Curl_write(conn, conn->sock[FIRSTSOCKET],                              outbuf+total_written, out_count-total_written,                              &bytes_written);          total_written += bytes_written;          break;      }      /* handle partial write */    } while(!result && total_written < out_count);  }  return result;}

/*********************************************************************** * * smtp_done() * * The DONE function. This does what needs to be done after a single DO has * performed. * * Input argument is already checked for validity. */static CURLcode smtp_done(struct connectdata *conn, CURLcode status,                          bool premature){  struct SessionHandle *data = conn->data;  struct FTP *smtp = data->state.proto.smtp;  CURLcode result=CURLE_OK;  ssize_t bytes_written;  (void)premature;  if(!smtp)    /* When the easy handle is removed from the multi while libcurl is still     * trying to resolve the host name, it seems that the smtp struct is not     * yet initialized, but the removal action calls Curl_done() which calls     * this function. So we simply return success if no smtp pointer is set.     */    return CURLE_OK;  if(status) {    conn->bits.close = TRUE; /* marked for closure */    result = status;      /* use the already set error code */  }  else    /* TODO: make this work even when the socket is EWOULDBLOCK in this call! */    /* write to socket (send away data) */    result = Curl_write(conn,                        conn->writesockfd,  /* socket to send to */                        SMTP_EOB,           /* buffer pointer */                        SMTP_EOB_LEN,       /* buffer size */                        &bytes_written);    /* actually sent away */  /* clear these for next connection */  smtp->transfer = FTPTRANSFER_BODY;  return result;}

/*********************************************************************** * * smtp_done() * * The DONE function. This does what needs to be done after a single DO has * performed. * * Input argument is already checked for validity. */static CURLcode smtp_done(struct connectdata *conn, CURLcode status,                          bool premature){  CURLcode result = CURLE_OK;  struct Curl_easy *data = conn->data;  struct SMTP *smtp = data->req.protop;  struct pingpong *pp = &conn->proto.smtpc.pp;  char *eob;  ssize_t len;  ssize_t bytes_written;  (void)premature;  if(!smtp || !pp->conn)    return CURLE_OK;  /* Cleanup our per-request based variables */  Curl_safefree(smtp->custom);  if(status) {    connclose(conn, "SMTP done with bad status"); /* marked for closure */    result = status;         /* use the already set error code */  }  else if(!data->set.connect_only && data->set.mail_rcpt &&          (data->set.upload || data->set.mimepost.kind)) {    /* Calculate the EOB taking into account any terminating CRLF from the       previous line of the email or the CRLF of the DATA command when there       is "no mail data". RFC-5321, sect. 4.1.1.4.       Note: As some SSL backends, such as OpenSSL, will cause Curl_write() to       fail when using a different pointer following a previous write, that       returned CURLE_AGAIN, we duplicate the EOB now rather than when the       bytes written doesn't equal len. */    if(smtp->trailing_crlf || !conn->data->state.infilesize) {      eob = strdup(SMTP_EOB + 2);      len = SMTP_EOB_LEN - 2;    }    else {      eob = strdup(SMTP_EOB);      len = SMTP_EOB_LEN;    }    if(!eob)      return CURLE_OUT_OF_MEMORY;    /* Send the end of block data */    result = Curl_write(conn, conn->writesockfd, eob, len, &bytes_written);    if(result) {      free(eob);      return result;    }    if(bytes_written != len) {      /* The whole chunk was not sent so keep it around and adjust the         pingpong structure accordingly */      pp->sendthis = eob;      pp->sendsize = len;      pp->sendleft = len - bytes_written;    }    else {      /* Successfully sent so adjust the response timeout relative to now */      pp->response = Curl_now();      free(eob);    }    state(conn, SMTP_POSTDATA);    /* Run the state-machine       TODO: when the multi interface is used, this _really_ should be using       the smtp_multi_statemach function but we have no general support for       non-blocking DONE operations!    */    result = smtp_block_statemach(conn);  }  /* Clear the transfer mode for the next request */  smtp->transfer = FTPTRANSFER_BODY;  return result;}

//.........这里部分代码省略.........        socksreq[6] = (unsigned char)ip[2];        socksreq[7] = (unsigned char)ip[3];      }      else        hp = NULL; /* fail! */      Curl_resolv_unlock(data, dns); /* not used anymore from now on */    }    if(!hp) {      failf(data, "Failed to resolve /"%s/" for SOCKS4 connect.",            conn->host.name);      return CURLE_COULDNT_RESOLVE_HOST;    }  }  /*   * This is currently not supporting "Identification Protocol (RFC1413)".   */  socksreq[8] = 0; /* ensure empty userid is NUL-terminated */  if (proxy_name)    strlcat((char*)socksreq + 8, proxy_name, sizeof(socksreq) - 8);  /*   * Make connection   */  {    ssize_t actualread;    ssize_t written;    int packetsize = 9 +      (int)strlen((char*)socksreq + 8); /* size including NUL */    /* Send request */    code = Curl_write(conn, sock, (char *)socksreq, packetsize, &written);    if ((code != CURLE_OK) || (written != packetsize)) {      failf(data, "Failed to send SOCKS4 connect request.");      return CURLE_COULDNT_CONNECT;    }    packetsize = 8; /* receive data size */    /* Receive response */    result = blockread_all(conn, sock, (char *)socksreq, packetsize,                           &actualread, timeout);    if ((result != CURLE_OK) || (actualread != packetsize)) {      failf(data, "Failed to receive SOCKS4 connect request ack.");      return CURLE_COULDNT_CONNECT;    }    /*     * Response format     *     *     +----+----+----+----+----+----+----+----+     *     | VN | CD | DSTPORT |      DSTIP        |     *     +----+----+----+----+----+----+----+----+     * # of bytes:  1    1      2              4     *     * VN is the version of the reply code and should be 0. CD is the result     * code with one of the following values:     *     * 90: request granted     * 91: request rejected or failed     * 92: request rejected because SOCKS server cannot connect to     *     identd on the client     * 93: request rejected because the client program and identd     *     report different user-ids

//.........这里部分代码省略.........  objs[1] = event_handle;  /* Tell winsock what events we want to listen to */  if(event_select_func(sockfd, event_handle, FD_READ|FD_CLOSE) == SOCKET_ERROR) {    close_event_func(event_handle);    FreeLibrary(wsock2);    return 0;  }  /* Keep on listening and act on events */  while(keepon) {    waitret = WaitForMultipleObjects(2, objs, FALSE, INFINITE);    switch(waitret - WAIT_OBJECT_0) {    case 0:    {      unsigned char outbuf[2];      int out_count = 0;      ssize_t bytes_written;      char *buffer = buf;                    if(!ReadFile(stdin_handle, buf, sizeof(data->state.buffer),                   &readfile_read, NULL)) {        keepon = FALSE;        break;      }      nread = readfile_read;              while(nread--) {        outbuf[0] = *buffer++;        out_count = 1;        if(outbuf[0] == CURL_IAC)          outbuf[out_count++] = CURL_IAC;                  Curl_write(conn, conn->sock[FIRSTSOCKET], outbuf,                   out_count, &bytes_written);      }    }    break;          case 1:      if(enum_netevents_func(sockfd, event_handle, &events)         != SOCKET_ERROR) {        if(events.lNetworkEvents & FD_READ) {          /* This reallu OUGHT to check its return code. */          (void)Curl_read(conn, sockfd, buf, BUFSIZE - 1, &nread);                      telrcv(conn, (unsigned char *)buf, nread);                    fflush(stdout);                      /* Negotiate if the peer has started negotiating,             otherwise don't. We don't want to speak telnet with             non-telnet servers, like POP or SMTP. */          if(tn->please_negotiate && !tn->already_negotiated) {            negotiate(conn);            tn->already_negotiated = 1;          }        }                  if(events.lNetworkEvents & FD_CLOSE) {          keepon = FALSE;        }      }      break;    }  }

/* * This function logs in to a SOCKS5 proxy and sends the specifics to the final * destination server. */CURLcode Curl_SOCKS5(const char *proxy_name,                     const char *proxy_password,                     struct connectdata *conn){  /*    According to the RFC1928, section "6.  Replies". This is what a SOCK5    replies:        +----+-----+-------+------+----------+----------+        |VER | REP |  RSV  | ATYP | BND.ADDR | BND.PORT |        +----+-----+-------+------+----------+----------+        | 1  |  1  | X'00' |  1   | Variable |    2     |        +----+-----+-------+------+----------+----------+    Where:    o  VER    protocol version: X'05'    o  REP    Reply field:    o  X'00' succeeded  */  unsigned char socksreq[600]; /* room for large user/pw (255 max each) */  ssize_t actualread;  ssize_t written;  int result;  CURLcode code;  curl_socket_t sock = conn->sock[FIRSTSOCKET];  struct SessionHandle *data = conn->data;  long timeout;  /* get timeout */  if(data->set.timeout && data->set.connecttimeout) {    if (data->set.timeout < data->set.connecttimeout)      timeout = data->set.timeout*1000;    else      timeout = data->set.connecttimeout*1000;  }  else if(data->set.timeout)    timeout = data->set.timeout*1000;  else if(data->set.connecttimeout)    timeout = data->set.connecttimeout*1000;  else    timeout = DEFAULT_CONNECT_TIMEOUT;  Curl_nonblock(sock, TRUE);  /* wait until socket gets connected */  result = Curl_select(CURL_SOCKET_BAD, sock, (int)timeout);  if(-1 == result) {    failf(conn->data, "SOCKS5: no connection here");    return CURLE_COULDNT_CONNECT;  }  else if(0 == result) {    failf(conn->data, "SOCKS5: connection timeout");    return CURLE_OPERATION_TIMEDOUT;  }  if(result & CSELECT_ERR) {    failf(conn->data, "SOCKS5: error occured during connection");    return CURLE_COULDNT_CONNECT;  }  socksreq[0] = 5; /* version */  socksreq[1] = (char)(proxy_name ? 2 : 1); /* number of methods (below) */  socksreq[2] = 0; /* no authentication */  socksreq[3] = 2; /* username/password */  Curl_nonblock(sock, FALSE);  code = Curl_write(conn, sock, (char *)socksreq, (2 + (int)socksreq[1]),                      &written);  if ((code != CURLE_OK) || (written != (2 + (int)socksreq[1]))) {    failf(data, "Unable to send initial SOCKS5 request.");    return CURLE_COULDNT_CONNECT;  }  Curl_nonblock(sock, TRUE);  result = Curl_select(sock, CURL_SOCKET_BAD, (int)timeout);  if(-1 == result) {    failf(conn->data, "SOCKS5 nothing to read");    return CURLE_COULDNT_CONNECT;  }  else if(0 == result) {    failf(conn->data, "SOCKS5 read timeout");    return CURLE_OPERATION_TIMEDOUT;  }  if(result & CSELECT_ERR) {    failf(conn->data, "SOCKS5 read error occured");    return CURLE_RECV_ERROR;  }  Curl_nonblock(sock, FALSE);//.........这里部分代码省略.........

/*********************************************************************** * * Curl_pp_sendfv() * * Send the formated string as a command to a pingpong server. Note that * the string should not have any CRLF appended, as this function will * append the necessary things itself. * * NOTE: we build the command in a fixed-length buffer, which sets length * restrictions on the command! * * made to never block */CURLcode Curl_pp_vsendf(struct pingpong *pp,                        const char *fmt,                        va_list args){  ssize_t bytes_written;/* may still not be big enough for some krb5 tokens */#define SBUF_SIZE 1024  char s[SBUF_SIZE];  size_t write_len;  char *sptr=s;  CURLcode res = CURLE_OK;  struct connectdata *conn = pp->conn;  struct SessionHandle *data = conn->data;#if defined(HAVE_KRB4) || defined(HAVE_GSSAPI)  enum protection_level data_sec = conn->data_prot;#endif  vsnprintf(s, SBUF_SIZE-3, fmt, args);  strcat(s, "/r/n"); /* append a trailing CRLF */  bytes_written=0;  write_len = strlen(s);  Curl_pp_init(pp);#ifdef CURL_DOES_CONVERSIONS  res = Curl_convert_to_network(data, s, write_len);  /* Curl_convert_to_network calls failf if unsuccessful */  if(res != CURLE_OK) {    return res;  }#endif /* CURL_DOES_CONVERSIONS */#if defined(HAVE_KRB4) || defined(HAVE_GSSAPI)  conn->data_prot = prot_cmd;#endif  res = Curl_write(conn, conn->sock[FIRSTSOCKET], sptr, write_len,                   &bytes_written);#if defined(HAVE_KRB4) || defined(HAVE_GSSAPI)  conn->data_prot = data_sec;#endif  if(CURLE_OK != res)    return res;  if(conn->data->set.verbose)    Curl_debug(conn->data, CURLINFO_HEADER_OUT,               sptr, (size_t)bytes_written, conn);  if(bytes_written != (ssize_t)write_len) {    /* the whole chunk was not sent, store the rest of the data */    write_len -= bytes_written;    sptr += bytes_written;    pp->sendthis = malloc(write_len);    if(pp->sendthis) {      memcpy(pp->sendthis, sptr, write_len);      pp->sendsize = pp->sendleft = write_len;    }    else {      failf(data, "out of memory");      res = CURLE_OUT_OF_MEMORY;    }  }  else    pp->response = Curl_tvnow();  return res;}

/*********************************************************************** * * smtp_done() * * The DONE function. This does what needs to be done after a single DO has * performed. * * Input argument is already checked for validity. */static CURLcode smtp_done(struct connectdata *conn, CURLcode status,                          bool premature){  struct SessionHandle *data = conn->data;  struct FTP *smtp = data->state.proto.smtp;  CURLcode result = CURLE_OK;  ssize_t bytes_written;  (void)premature;  if(!smtp)    /* When the easy handle is removed from the multi while libcurl is still     * trying to resolve the host name, it seems that the smtp struct is not     * yet initialized, but the removal action calls Curl_done() which calls     * this function. So we simply return success if no smtp pointer is set.     */    return CURLE_OK;  if(status) {    conn->bits.close = TRUE; /* marked for closure */    result = status;         /* use the already set error code */  }  else if(!data->set.connect_only) {    struct smtp_conn *smtpc = &conn->proto.smtpc;    struct pingpong *pp = &smtpc->pp;    /* Send the end of block data */    result = Curl_write(conn,                        conn->writesockfd,  /* socket to send to */                        SMTP_EOB,           /* buffer pointer */                        SMTP_EOB_LEN,       /* buffer size */                        &bytes_written);    /* actually sent away */    if(result)      return result;    if(bytes_written != SMTP_EOB_LEN) {      /* The whole chunk was not sent so keep it around and adjust the         pingpong structure accordingly */      pp->sendthis = strdup(SMTP_EOB);      pp->sendsize = SMTP_EOB_LEN;      pp->sendleft = SMTP_EOB_LEN - bytes_written;    }    else      /* Successfully sent so adjust the response timeout relative to now */      pp->response = Curl_tvnow();    state(conn, SMTP_POSTDATA);    /* Run the state-machine       TODO: when the multi interface is used, this _really_ should be using       the smtp_multi_statemach function but we have no general support for       non-blocking DONE operations, not in the multi state machine and with       Curl_done() invokes on several places in the code!    */    result = smtp_easy_statemach(conn);  }  /* Clear the transfer mode for the next connection */  smtp->transfer = FTPTRANSFER_BODY;  return result;}

//.........这里部分代码省略.........  while(keepon) {    waitret = WaitForMultipleObjects(obj_count, objs, FALSE, wait_timeout);    switch(waitret) {    case WAIT_TIMEOUT:    {      unsigned char outbuf[2];      int out_count = 0;      ssize_t bytes_written;      char *buffer = buf;      while(1) {        if(!PeekNamedPipe(stdin_handle, NULL, 0, NULL, &readfile_read, NULL)) {          keepon = FALSE;          break;        }        nread = readfile_read;        if(!nread)          break;        if(!ReadFile(stdin_handle, buf, sizeof(data->state.buffer),                     &readfile_read, NULL)) {          keepon = FALSE;          break;        }        nread = readfile_read;        while(nread--) {          outbuf[0] = *buffer++;          out_count = 1;          if(outbuf[0] == CURL_IAC)            outbuf[out_count++] = CURL_IAC;          Curl_write(conn, conn->sock[FIRSTSOCKET], outbuf,                     out_count, &bytes_written);        }      }    }    break;    case WAIT_OBJECT_0 + 1:    {      unsigned char outbuf[2];      int out_count = 0;      ssize_t bytes_written;      char *buffer = buf;      if(!ReadFile(stdin_handle, buf, sizeof(data->state.buffer),                   &readfile_read, NULL)) {        keepon = FALSE;        break;      }      nread = readfile_read;      while(nread--) {        outbuf[0] = *buffer++;        out_count = 1;        if(outbuf[0] == CURL_IAC)          outbuf[out_count++] = CURL_IAC;        Curl_write(conn, conn->sock[FIRSTSOCKET], outbuf,                   out_count, &bytes_written);      }    }    break;

/*********************************************************************** * * Curl_pp_vsendf() * * Send the formatted string as a command to a pingpong server. Note that * the string should not have any CRLF appended, as this function will * append the necessary things itself. * * made to never block */CURLcode Curl_pp_vsendf(struct pingpong *pp,                        const char *fmt,                        va_list args){  ssize_t bytes_written;  size_t write_len;  char *fmt_crlf;  char *s;  CURLcode result;  struct connectdata *conn = pp->conn;  struct Curl_easy *data;#ifdef HAVE_GSSAPI  enum protection_level data_sec;#endif  DEBUGASSERT(pp->sendleft == 0);  DEBUGASSERT(pp->sendsize == 0);  DEBUGASSERT(pp->sendthis == NULL);  if(!conn)    /* can't send without a connection! */    return CURLE_SEND_ERROR;  data = conn->data;  fmt_crlf = aprintf("%s/r/n", fmt); /* append a trailing CRLF */  if(!fmt_crlf)    return CURLE_OUT_OF_MEMORY;  s = vaprintf(fmt_crlf, args); /* trailing CRLF appended */  free(fmt_crlf);  if(!s)    return CURLE_OUT_OF_MEMORY;  bytes_written = 0;  write_len = strlen(s);  Curl_pp_init(pp);  result = Curl_convert_to_network(data, s, write_len);  /* Curl_convert_to_network calls failf if unsuccessful */  if(result) {    free(s);    return result;  }#ifdef HAVE_GSSAPI  conn->data_prot = PROT_CMD;#endif  result = Curl_write(conn, conn->sock[FIRSTSOCKET], s, write_len,                     &bytes_written);#ifdef HAVE_GSSAPI  data_sec = conn->data_prot;  DEBUGASSERT(data_sec > PROT_NONE && data_sec < PROT_LAST);  conn->data_prot = data_sec;#endif  if(result) {    free(s);    return result;  }  if(conn->data->set.verbose)    Curl_debug(conn->data, CURLINFO_HEADER_OUT,               s, (size_t)bytes_written, conn);  if(bytes_written != (ssize_t)write_len) {    /* the whole chunk was not sent, keep it around and adjust sizes */    pp->sendthis = s;    pp->sendsize = write_len;    pp->sendleft = write_len - bytes_written;  }  else {    free(s);    pp->sendthis = NULL;    pp->sendleft = pp->sendsize = 0;    pp->response = Curl_now();  }  return CURLE_OK;}

static CURLcode gopher_do(struct connectdata *conn, bool *done){  CURLcode result=CURLE_OK;  struct SessionHandle *data=conn->data;  curl_socket_t sockfd = conn->sock[FIRSTSOCKET];  curl_off_t *bytecount = &data->req.bytecount;  char *path = data->state.path;  char *sel;  char *sel_org = NULL;  ssize_t amount, k;  int len;  *done = TRUE; /* unconditionally */  /* Create selector. Degenerate cases: / and /1 => convert to "" */  if(strlen(path) <= 2) {    sel = (char *)"";    len = (int)strlen(sel);  }  else {    char *newp;    size_t j, i;    /* Otherwise, drop / and the first character (i.e., item type) ... */    newp = path;    newp+=2;    /* ... then turn ? into TAB for search servers, Veronica, etc. ... */    j = strlen(newp);    for(i=0; i<j; i++)      if(newp[i] == '?')        newp[i] = '/x09';    /* ... and finally unescape */    sel = curl_easy_unescape(data, newp, 0, &len);    if(!sel)      return CURLE_OUT_OF_MEMORY;    sel_org = sel;  }  /* We use Curl_write instead of Curl_sendf to make sure the entire buffer is     sent, which could be sizeable with long selectors. */  k = curlx_uztosz(len);  for(;;) {    result = Curl_write(conn, sockfd, sel, k, &amount);    if(!result) { /* Which may not have written it all! */      result = Curl_client_write(conn, CLIENTWRITE_HEADER, sel, amount);      if(result) {        free(sel_org);        return result;      }      k -= amount;      sel += amount;      if(k < 1)        break; /* but it did write it all */    }    else {      failf(data, "Failed sending Gopher request");      free(sel_org);      return result;    }    /* Don't busyloop. The entire loop thing is a work-around as it causes a       BLOCKING behavior which is a NO-NO. This function should rather be       split up in a do and a doing piece where the pieces that aren't       possible to send now will be sent in the doing function repeatedly       until the entire request is sent.       Wait a while for the socket to be writable. Note that this doesn't       acknowledge the timeout.    */    Curl_socket_ready(CURL_SOCKET_BAD, sockfd, 100);  }  free(sel_org);  /* We can use Curl_sendf to send the terminal /r/n relatively safely and     save allocing another string/doing another _write loop. */  result = Curl_sendf(sockfd, conn, "/r/n");  if(result) {    failf(data, "Failed sending Gopher request");    return result;  }  result = Curl_client_write(conn, CLIENTWRITE_HEADER, (char *)"/r/n", 2);  if(result)    return result;  Curl_setup_transfer(conn, FIRSTSOCKET, -1, FALSE, bytecount,                      -1, NULL); /* no upload */  return CURLE_OK;}