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

/*********************************************************************** * * 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;}

//.........这里部分代码省略.........  conn->fread_func = data->set.fread_func;  conn->fread_in = data->set.in;  conn->data->req.upload_fromhere = buf;  if(!dir)    return CURLE_FILE_COULDNT_READ_FILE; /* fix: better error code */  if(!dir[1])     return CURLE_FILE_COULDNT_READ_FILE; /* fix: better error code */  if(data->state.resume_from)    fp = fopen( file->path, "ab" );  else {    int fd;#ifdef DOS_FILESYSTEM    fd = open(file->path, O_WRONLY|O_CREAT|O_TRUNC|O_BINARY,              conn->data->set.new_file_perms);#else    fd = open(file->path, O_WRONLY|O_CREAT|O_TRUNC,              conn->data->set.new_file_perms);#endif    if(fd < 0) {      failf(data, "Can't open %s for writing", file->path);      return CURLE_WRITE_ERROR;    }    close(fd);    fp = fopen(file->path, "wb");  }  if(!fp) {    failf(data, "Can't open %s for writing", file->path);    return CURLE_WRITE_ERROR;  }  if(-1 != data->set.infilesize)    /* known size of data to "upload" */    Curl_pgrsSetUploadSize(data, data->set.infilesize);  /* treat the negative resume offset value as the case of "-" */  if(data->state.resume_from < 0) {    if(fstat(fileno(fp), &file_stat)) {      fclose(fp);      failf(data, "Can't get the size of %s", file->path);      return CURLE_WRITE_ERROR;    }    else      data->state.resume_from = (curl_off_t)file_stat.st_size;  }  while(res == CURLE_OK) {    int readcount;    res = Curl_fillreadbuffer(conn, BUFSIZE, &readcount);    if(res)      break;    if(readcount <= 0)  /* fix questionable compare error. curlvms */      break;    nread = (size_t)readcount;    /*skip bytes before resume point*/    if(data->state.resume_from) {      if( (curl_off_t)nread <= data->state.resume_from ) {        data->state.resume_from -= nread;        nread = 0;        buf2 = buf;      }      else {        buf2 = buf + data->state.resume_from;        nread -= (size_t)data->state.resume_from;        data->state.resume_from = 0;      }    }    else      buf2 = buf;    /* write the data to the target */    nwrite = fwrite(buf2, 1, nread, fp);    if(nwrite != nread) {      res = CURLE_SEND_ERROR;      break;    }    bytecount += nread;    Curl_pgrsSetUploadCounter(data, bytecount);    if(Curl_pgrsUpdate(conn))      res = CURLE_ABORTED_BY_CALLBACK;    else      res = Curl_speedcheck(data, now);  }  if(!res && Curl_pgrsUpdate(conn))    res = CURLE_ABORTED_BY_CALLBACK;  fclose(fp);  return res;}

//.........这里部分代码省略.........  }  result = Curl_add_custom_headers(conn, FALSE, req_buffer);  if(result)    return result;  if(rtspreq == RTSPREQ_ANNOUNCE ||     rtspreq == RTSPREQ_SET_PARAMETER ||     rtspreq == RTSPREQ_GET_PARAMETER) {    if(data->set.upload) {      putsize = data->state.infilesize;      data->set.httpreq = HTTPREQ_PUT;    }    else {      postsize = (data->state.infilesize != -1)?        data->state.infilesize:        (data->set.postfields? (curl_off_t)strlen(data->set.postfields):0);      data->set.httpreq = HTTPREQ_POST;    }    if(putsize > 0 || postsize > 0) {      /* As stated in the http comments, it is probably not wise to       * actually set a custom Content-Length in the headers */      if(!Curl_checkheaders(conn, "Content-Length:")) {        result = Curl_add_bufferf(req_buffer,            "Content-Length: %" CURL_FORMAT_CURL_OFF_T"/r/n",            (data->set.upload ? putsize : postsize));        if(result)          return result;      }      if(rtspreq == RTSPREQ_SET_PARAMETER ||         rtspreq == RTSPREQ_GET_PARAMETER) {        if(!Curl_checkheaders(conn, "Content-Type:")) {          result = Curl_add_bufferf(req_buffer,              "Content-Type: text/parameters/r/n");          if(result)            return result;        }      }      if(rtspreq == RTSPREQ_ANNOUNCE) {        if(!Curl_checkheaders(conn, "Content-Type:")) {          result = Curl_add_bufferf(req_buffer,              "Content-Type: application/sdp/r/n");          if(result)            return result;        }      }      data->state.expect100header = FALSE; /* RTSP posts are simple/small */    }    else if(rtspreq == RTSPREQ_GET_PARAMETER) {      /* Check for an empty GET_PARAMETER (heartbeat) request */      data->set.httpreq = HTTPREQ_HEAD;      data->set.opt_no_body = TRUE;    }  }  /* RTSP never allows chunked transfer */  data->req.forbidchunk = TRUE;  /* Finish the request buffer */  result = Curl_add_buffer(req_buffer, "/r/n", 2);  if(result)    return result;  if(postsize > 0) {    result = Curl_add_buffer(req_buffer, data->set.postfields,                             (size_t)postsize);    if(result)      return result;  }  /* issue the request */  result = Curl_add_buffer_send(req_buffer, conn,                                &data->info.request_size, 0, FIRSTSOCKET);  if(result) {    failf(data, "Failed sending RTSP request");    return result;  }  Curl_setup_transfer(conn, FIRSTSOCKET, -1, TRUE, &http->readbytecount,                      putsize?FIRSTSOCKET:-1,                      putsize?&http->writebytecount:NULL);  /* Increment the CSeq on success */  data->state.rtsp_next_client_CSeq++;  if(http->writebytecount) {    /* if a request-body has been sent off, we make sure this progress is       noted properly */    Curl_pgrsSetUploadCounter(data, http->writebytecount);    if(Curl_pgrsUpdate(conn))      result = CURLE_ABORTED_BY_CALLBACK;  }  return result;}

static CURLcode file_upload(struct connectdata *conn){  struct FILEPROTO *file = conn->data->req.protop;  const char *dir = strchr(file->path, DIRSEP);  int fd;  int mode;  CURLcode result = CURLE_OK;  struct Curl_easy *data = conn->data;  char *buf = data->state.buffer;  size_t nread;  size_t nwrite;  curl_off_t bytecount = 0;  struct timeval now = Curl_tvnow();  struct_stat file_stat;  const char* buf2;  /*   * Since FILE: doesn't do the full init, we need to provide some extra   * assignments here.   */  conn->data->req.upload_fromhere = buf;  if(!dir)    return CURLE_FILE_COULDNT_READ_FILE; /* fix: better error code */  if(!dir[1])    return CURLE_FILE_COULDNT_READ_FILE; /* fix: better error code */#ifdef O_BINARY#define MODE_DEFAULT O_WRONLY|O_CREAT|O_BINARY#else#define MODE_DEFAULT O_WRONLY|O_CREAT#endif  if(data->state.resume_from)    mode = MODE_DEFAULT|O_APPEND;  else    mode = MODE_DEFAULT|O_TRUNC;  fd = open(file->path, mode, conn->data->set.new_file_perms);  if(fd < 0) {    failf(data, "Can't open %s for writing", file->path);    return CURLE_WRITE_ERROR;  }  if(-1 != data->state.infilesize)    /* known size of data to "upload" */    Curl_pgrsSetUploadSize(data, data->state.infilesize);  /* treat the negative resume offset value as the case of "-" */  if(data->state.resume_from < 0) {    if(fstat(fd, &file_stat)) {      close(fd);      failf(data, "Can't get the size of %s", file->path);      return CURLE_WRITE_ERROR;    }    else      data->state.resume_from = (curl_off_t)file_stat.st_size;  }  while(!result) {    int readcount;    result = Curl_fillreadbuffer(conn, BUFSIZE, &readcount);    if(result)      break;    if(readcount <= 0)  /* fix questionable compare error. curlvms */      break;    nread = (size_t)readcount;    /*skip bytes before resume point*/    if(data->state.resume_from) {      if((curl_off_t)nread <= data->state.resume_from) {        data->state.resume_from -= nread;        nread = 0;        buf2 = buf;      }      else {        buf2 = buf + data->state.resume_from;        nread -= (size_t)data->state.resume_from;        data->state.resume_from = 0;      }    }    else      buf2 = buf;    /* write the data to the target */    nwrite = write(fd, buf2, nread);    if(nwrite != nread) {      result = CURLE_SEND_ERROR;      break;    }    bytecount += nread;    Curl_pgrsSetUploadCounter(data, bytecount);    if(Curl_pgrsUpdate(conn))      result = CURLE_ABORTED_BY_CALLBACK;//.........这里部分代码省略.........

//.........这里部分代码省略.........  }  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;      }      if(nread > 0) {        result = send_telnet_data(conn, buf, nread);        if(result) {          keepon = FALSE;          break;        }        total_ul += nread;        Curl_pgrsSetUploadCounter(data, total_ul);      }      else if(nread < 0)        keepon = FALSE;      break;    } /* poll switch statement */    if(data->set.timeout) {      now = Curl_tvnow();      if(Curl_tvdiff(now, conn->created) >= data->set.timeout) {        failf(data, "Time-out");        result = CURLE_OPERATION_TIMEDOUT;        keepon = FALSE;      }    }    if(Curl_pgrsUpdate(conn)) {      result = CURLE_ABORTED_BY_CALLBACK;      break;    }  }#endif  /* mark this as "no further transfer wanted" */  Curl_setup_transfer(conn, -1, -1, FALSE, NULL, -1, NULL);  return result;}

static CURLcode file_upload(struct connectdata *conn){  struct FILEPROTO *file = conn->proto.file;  char *dir = strchr(file->path, DIRSEP);  FILE *fp;  CURLcode res=CURLE_OK;  struct SessionHandle *data = conn->data;  char *buf = data->state.buffer;  size_t nread;  size_t nwrite;  curl_off_t bytecount = 0;  struct timeval now = Curl_tvnow();  /*   * Since FILE: doesn't do the full init, we need to provide some extra   * assignments here.   */  conn->fread = data->set.fread;  conn->fread_in = data->set.in;  conn->upload_fromhere = buf;  if(!dir)    return CURLE_FILE_COULDNT_READ_FILE; /* fix: better error code */  if(!dir[1])     return CURLE_FILE_COULDNT_READ_FILE; /* fix: better error code */  fp = fopen(file->path, "wb");  if(!fp) {    failf(data, "Can't open %s for writing", file->path);    return CURLE_WRITE_ERROR;  }  if(-1 != data->set.infilesize)    /* known size of data to "upload" */    Curl_pgrsSetUploadSize(data, data->set.infilesize);  while (res == CURLE_OK) {    int readcount;    res = Curl_fillreadbuffer(conn, BUFSIZE, &readcount);    if(res)      break;    nread = (size_t)readcount;    if (nread <= 0)      break;    /* write the data to the target */    nwrite = fwrite(buf, 1, nread, fp);    if(nwrite != nread) {      res = CURLE_SEND_ERROR;      break;    }    bytecount += nread;    Curl_pgrsSetUploadCounter(data, bytecount);    if(Curl_pgrsUpdate(conn))      res = CURLE_ABORTED_BY_CALLBACK;    else      res = Curl_speedcheck(data, now);  }  if(!res && Curl_pgrsUpdate(conn))    res = CURLE_ABORTED_BY_CALLBACK;  fclose(fp);  return res;}