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

/*********************************************************************** * * pop3_regular_transfer() * * The input argument is already checked for validity. * * Performs all commands done before a regular transfer between a local and a * remote host. * */staticCURLcode pop3_regular_transfer(struct connectdata *conn,                              bool *dophase_done){  CURLcode result=CURLE_OK;  bool connected=FALSE;  struct SessionHandle *data = conn->data;  data->req.size = -1; /* make sure this is unknown at this point */  Curl_pgrsSetUploadCounter(data, 0);  Curl_pgrsSetDownloadCounter(data, 0);  Curl_pgrsSetUploadSize(data, 0);  Curl_pgrsSetDownloadSize(data, 0);  result = pop3_perform(conn,                        &connected, /* have we connected after PASV/PORT */                        dophase_done); /* all commands in the DO-phase done? */  if(CURLE_OK == result) {    if(!*dophase_done)      /* the DO phase has not completed yet */      return CURLE_OK;    result = pop3_dophase_done(conn, connected);    if(result)      return result;  }  return result;}

/*********************************************************************** * * smtp_regular_transfer() * * The input argument is already checked for validity. * * Performs all commands done before a regular transfer between a local and a * remote host. */static CURLcode smtp_regular_transfer(struct connectdata *conn,                                      bool *dophase_done){  CURLcode result = CURLE_OK;  bool connected = FALSE;  struct SessionHandle *data = conn->data;  /* Make sure size is unknown at this point */  data->req.size = -1;  Curl_pgrsSetUploadCounter(data, 0);  Curl_pgrsSetDownloadCounter(data, 0);  Curl_pgrsSetUploadSize(data, 0);  Curl_pgrsSetDownloadSize(data, 0);  result = smtp_perform(conn, &connected, dophase_done);  if(CURLE_OK == result) {    if(!*dophase_done)      /* The DO phase has not completed yet */      return CURLE_OK;    result = smtp_dophase_done(conn, connected);    if(result)      return result;  }  return result;}

/*********************************************************************** * * smtp_regular_transfer() * * The input argument is already checked for validity. * * Performs all commands done before a regular transfer between a local and a * remote host. */static CURLcode smtp_regular_transfer(struct connectdata *conn,                                      bool *dophase_done){  CURLcode result = CURLE_OK;  bool connected = FALSE;  struct Curl_easy *data = conn->data;  /* Make sure size is unknown at this point */  data->req.size = -1;  /* Set the progress data */  Curl_pgrsSetUploadCounter(data, 0);  Curl_pgrsSetDownloadCounter(data, 0);  Curl_pgrsSetUploadSize(data, -1);  Curl_pgrsSetDownloadSize(data, -1);  /* Carry out the perform */  result = smtp_perform(conn, &connected, dophase_done);  /* Perform post DO phase operations if necessary */  if(!result && *dophase_done)    result = smtp_dophase_done(conn, connected);  return result;}

//.........这里部分代码省略.........      const struct tm *tm;      time_t filetime = (time_t)statbuf.st_mtime;#ifdef HAVE_GMTIME_R      struct tm buffer;      tm = (const struct tm *)gmtime_r(&filetime, &buffer);#else      tm = gmtime(&filetime);#endif      /* format: "Tue, 15 Nov 1994 12:45:26 GMT" */      snprintf(buf, BUFSIZE-1,               "Last-Modified: %s, %02d %s %4d %02d:%02d:%02d GMT/r/n",               Curl_wkday[tm->tm_wday?tm->tm_wday-1:6],               tm->tm_mday,               Curl_month[tm->tm_mon],               tm->tm_year + 1900,               tm->tm_hour,               tm->tm_min,               tm->tm_sec);      result = Curl_client_write(conn, CLIENTWRITE_BOTH, buf, 0);    }    /* if we fstat()ed the file, set the file size to make it available post-       transfer */    if(fstated)      Curl_pgrsSetDownloadSize(data, expected_size);    return result;  }  /* Check whether file range has been specified */  file_range(conn);  /* Adjust the start offset in case we want to get the N last bytes   * of the stream iff the filesize could be determined */  if(data->state.resume_from < 0) {    if(!fstated) {      failf(data, "Can't get the size of file.");      return CURLE_READ_ERROR;    }    else      data->state.resume_from += (curl_off_t)statbuf.st_size;  }  if(data->state.resume_from <= expected_size)    expected_size -= data->state.resume_from;  else {    failf(data, "failed to resume file:// transfer");    return CURLE_BAD_DOWNLOAD_RESUME;  }  /* A high water mark has been specified so we obey... */  if (data->req.maxdownload > 0)    expected_size = data->req.maxdownload;  if(fstated && (expected_size == 0))    return CURLE_OK;  /* The following is a shortcut implementation of file reading     this is both more efficient than the former call to download() and     it avoids problems with select() and recv() on file descriptors     in Winsock */  if(fstated)    Curl_pgrsSetDownloadSize(data, expected_size);  if(data->state.resume_from) {    if(data->state.resume_from !=       lseek(fd, data->state.resume_from, SEEK_SET))      return CURLE_BAD_DOWNLOAD_RESUME;  }  Curl_pgrsTime(data, TIMER_STARTTRANSFER);  while(res == CURLE_OK) {    /* Don't fill a whole buffer if we want less than all data */    bytestoread = (expected_size < BUFSIZE-1)?(size_t)expected_size:BUFSIZE-1;    nread = read(fd, buf, bytestoread);    if( nread > 0)      buf[nread] = 0;    if (nread <= 0 || expected_size == 0)      break;    bytecount += nread;    expected_size -= nread;    res = Curl_client_write(conn, CLIENTWRITE_BODY, buf, nread);    if(res)      return res;    Curl_pgrsSetDownloadCounter(data, bytecount);    if(Curl_pgrsUpdate(conn))      res = CURLE_ABORTED_BY_CALLBACK;    else      res = Curl_speedcheck(data, now);  }  if(Curl_pgrsUpdate(conn))    res = CURLE_ABORTED_BY_CALLBACK;  return res;}

//.........这里部分代码省略.........    for(attribute = ldap_first_attribute(server, entryIterator, &ber);        attribute;        attribute = ldap_next_attribute(server, entryIterator, ber)) {      BerValue **vals = ldap_get_values_len(server, entryIterator, attribute);      if(vals != NULL) {        for(i = 0; (vals[i] != NULL); i++) {          result = Curl_client_write(conn, CLIENTWRITE_BODY, (char *)"/t", 1);          if(result)            goto quit;          result = Curl_client_write(conn, CLIENTWRITE_BODY,                                     (char *)attribute, 0);          if(result)            goto quit;          result = Curl_client_write(conn, CLIENTWRITE_BODY, (char *)": ", 2);          if(result)            goto quit;          dlsize += strlen(attribute)+3;          if((strlen(attribute) > 7) &&              (strcmp(";binary",                      (char *)attribute +                      (strlen((char *)attribute) - 7)) == 0)) {            /* Binary attribute, encode to base64. */            CURLcode error = Curl_base64_encode(data,                                                vals[i]->bv_val,                                                vals[i]->bv_len,                                                &val_b64,                                                &val_b64_sz);            if(error) {              ldap_value_free_len(vals);              ldap_memfree(attribute);              ldap_memfree(dn);              if(ber)                ber_free(ber, 0);              result = error;              goto quit;            }            if(val_b64_sz > 0) {              result = Curl_client_write(conn, CLIENTWRITE_BODY, val_b64,                                         val_b64_sz);              free(val_b64);              if(result)                goto quit;              dlsize += val_b64_sz;            }          }          else {            result = Curl_client_write(conn, CLIENTWRITE_BODY, vals[i]->bv_val,                                       vals[i]->bv_len);            if(result)              goto quit;            dlsize += vals[i]->bv_len;          }          result = Curl_client_write(conn, CLIENTWRITE_BODY, (char *)"/n", 0);          if(result)            goto quit;          dlsize++;        }        /* Free memory used to store values */        ldap_value_free_len(vals);      }      result = Curl_client_write(conn, CLIENTWRITE_BODY, (char *)"/n", 1);      if(result)        goto quit;      dlsize++;      Curl_pgrsSetDownloadCounter(data, dlsize);      ldap_memfree(attribute);    }    ldap_memfree(dn);    if(ber)       ber_free(ber, 0);  }quit:  if(ldapmsg) {    ldap_msgfree(ldapmsg);    LDAP_TRACE (("Received %d entries/n", num));  }  if(rc == LDAP_SIZELIMIT_EXCEEDED)    infof(data, "There are more than %d entries/n", num);  if(ludp)    ldap_free_urldesc(ludp);  if(server)    ldap_unbind_s(server);#if defined(HAVE_LDAP_SSL) && defined(CURL_HAS_NOVELL_LDAPSDK)  if(ldap_ssl)    ldapssl_client_deinit();#endif /* HAVE_LDAP_SSL && CURL_HAS_NOVELL_LDAPSDK */  /* no data to transfer */  Curl_setup_transfer(conn, -1, -1, FALSE, NULL, -1, NULL);  connclose(conn, "LDAP connection always disable re-use");  return result;}

//.........这里部分代码省略.........    poll_cnt = 2;    interval_ms = 1 * 1000;  }  while(keepon) {    switch (Curl_poll(pfd, poll_cnt, interval_ms)) {    case -1:                    /* error, stop reading */      keepon = FALSE;      continue;    case 0:                     /* timeout */      pfd[0].revents = 0;      pfd[1].revents = 0;      /* fall through */    default:                    /* read! */      if(pfd[0].revents & POLLIN) {        /* read data from network */        result = Curl_read(conn, sockfd, buf, BUFSIZE - 1, &nread);        /* read would've blocked. Loop again */        if(result == CURLE_AGAIN)          break;        /* returned not-zero, this an error */        else if(result) {          keepon = FALSE;          break;        }        /* returned zero but actually received 0 or less here,           the server closed the connection and we bail out */        else if(nread <= 0) {          keepon = FALSE;          break;        }        total_dl += nread;        Curl_pgrsSetDownloadCounter(data, total_dl);        result = telrcv(conn, (unsigned char *)buf, nread);        if(result) {          keepon = FALSE;          break;        }        /* 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;        }      }      nread = 0;      if(poll_cnt == 2) {        if(pfd[1].revents & POLLIN) { /* read from in file */          nread = read(pfd[1].fd, buf, BUFSIZE - 1);        }      }      else {        /* read from user-supplied method */        nread = (int)data->state.fread_func(buf, 1, BUFSIZE - 1,                                            data->state.in);        if(nread == CURL_READFUNC_ABORT) {          keepon = FALSE;          break;        }        if(nread == CURL_READFUNC_PAUSE)          break;      }

//.........这里部分代码省略.........              tm->tm_year + 1900,              tm->tm_hour,              tm->tm_min,              tm->tm_sec,              data->set.opt_no_body ? "": "/r/n");    result = Curl_client_write(conn, CLIENTWRITE_HEADER, header, 0);    if(result)      return result;    /* set the file size to make it available post transfer */    Curl_pgrsSetDownloadSize(data, expected_size);    if(data->set.opt_no_body)      return result;  }  /* Check whether file range has been specified */  result = Curl_range(conn);  if(result)    return result;  /* Adjust the start offset in case we want to get the N last bytes   * of the stream if the filesize could be determined */  if(data->state.resume_from < 0) {    if(!fstated) {      failf(data, "Can't get the size of file.");      return CURLE_READ_ERROR;    }    data->state.resume_from += (curl_off_t)statbuf.st_size;  }  if(data->state.resume_from <= expected_size)    expected_size -= data->state.resume_from;  else {    failf(data, "failed to resume file:// transfer");    return CURLE_BAD_DOWNLOAD_RESUME;  }  /* A high water mark has been specified so we obey... */  if(data->req.maxdownload > 0)    expected_size = data->req.maxdownload;  if(!fstated || (expected_size == 0))    size_known = FALSE;  else    size_known = TRUE;  /* The following is a shortcut implementation of file reading     this is both more efficient than the former call to download() and     it avoids problems with select() and recv() on file descriptors     in Winsock */  if(fstated)    Curl_pgrsSetDownloadSize(data, expected_size);  if(data->state.resume_from) {    if(data->state.resume_from !=       lseek(fd, data->state.resume_from, SEEK_SET))      return CURLE_BAD_DOWNLOAD_RESUME;  }  Curl_pgrsTime(data, TIMER_STARTTRANSFER);  while(!result) {    ssize_t nread;    /* Don't fill a whole buffer if we want less than all data */    size_t bytestoread;    if(size_known) {      bytestoread = (expected_size < data->set.buffer_size) ?        curlx_sotouz(expected_size) : (size_t)data->set.buffer_size;    }    else      bytestoread = data->set.buffer_size-1;    nread = read(fd, buf, bytestoread);    if(nread > 0)      buf[nread] = 0;    if(nread <= 0 || (size_known && (expected_size == 0)))      break;    bytecount += nread;    if(size_known)      expected_size -= nread;    result = Curl_client_write(conn, CLIENTWRITE_BODY, buf, nread);    if(result)      return result;    Curl_pgrsSetDownloadCounter(data, bytecount);    if(Curl_pgrsUpdate(conn))      result = CURLE_ABORTED_BY_CALLBACK;    else      result = Curl_speedcheck(data, Curl_now());  }  if(Curl_pgrsUpdate(conn))    result = CURLE_ABORTED_BY_CALLBACK;  return result;}

//.........这里部分代码省略.........            char linkPath[PATH_MAX + 1];            snprintf(linkPath, PATH_MAX, "%s%s", sftp->path, filename);            len = libssh2_sftp_readlink(sftp->sftp_session, linkPath, filename,                                        PATH_MAX);            line = realloc(line, totalLen + 4 + len);            if (!line)              return CURLE_OUT_OF_MEMORY;            currLen += snprintf(line+currLen, totalLen-currLen, " -> %s",                                filename);          }          currLen += snprintf(line+currLen, totalLen-currLen, "/n");          res = Curl_client_write(conn, CLIENTWRITE_BODY, line, 0);          free(line);        }      }      libssh2_sftp_closedir(sftp->sftp_handle);      sftp->sftp_handle = NULL;      /* no data to transfer */      res = Curl_setup_transfer(conn, -1, -1, FALSE, NULL, -1, NULL);    }    else {      /*       * Work on getting the specified file       */      sftp->sftp_handle =        libssh2_sftp_open(sftp->sftp_session, sftp->path, LIBSSH2_FXF_READ,                          LIBSSH2_SFTP_S_IRUSR|LIBSSH2_SFTP_S_IWUSR|                          LIBSSH2_SFTP_S_IRGRP|LIBSSH2_SFTP_S_IROTH);      if (!sftp->sftp_handle)        return CURLE_SSH;      if (libssh2_sftp_stat(sftp->sftp_session, sftp->path, &attrs)) {        /*         * libssh2_sftp_open() didn't return an error, so maybe the server         * just doesn't support stat()         */        data->reqdata.size = -1;        data->reqdata.maxdownload = -1;      }      else {        data->reqdata.size = attrs.filesize;        data->reqdata.maxdownload = attrs.filesize;        Curl_pgrsSetDownloadSize(data, attrs.filesize);      }      Curl_pgrsTime(data, TIMER_STARTTRANSFER);      /* Now download data. The libssh2 0.14 doesn't offer any way to do this         without using this BLOCKING approach, so here's room for improvement         once libssh2 can return EWOULDBLOCK to us. */#if 0      /* code left here just because this is what this function will use the         day libssh2 is improved */      res = Curl_setup_transfer(conn, FIRSTSOCKET,                                bytecount, FALSE, NULL, -1, NULL);#endif      while (res == CURLE_OK) {        size_t nread;        /* NOTE: most *read() functions return ssize_t but this returns size_t           which normally is unsigned! */        nread = libssh2_sftp_read(data->reqdata.proto.ssh->sftp_handle,                                  buf, BUFSIZE-1);        if (nread > 0)          buf[nread] = 0;        /* this check can be changed to a <= 0 when nread is changed to a           signed variable type */        if ((nread == 0) || (nread == (size_t)~0))          break;        bytecount += nread;        res = Curl_client_write(conn, CLIENTWRITE_BODY, buf, nread);        if(res)          return res;        Curl_pgrsSetDownloadCounter(data, bytecount);        if(Curl_pgrsUpdate(conn))          res = CURLE_ABORTED_BY_CALLBACK;        else {          struct timeval now = Curl_tvnow();          res = Curl_speedcheck(data, now);        }      }      if(Curl_pgrsUpdate(conn))        res = CURLE_ABORTED_BY_CALLBACK;      /* no (more) data to transfer */      res = Curl_setup_transfer(conn, -1, -1, FALSE, NULL, -1, NULL);    }  }  return res;}