Commit 0eb3d15c authored by Daniel Stenberg's avatar Daniel Stenberg
Browse files

code cleanup: we prefer 'CURLcode result' 

... for the local variable name in functions holding the return
code. Using the same name universally makes code easier to read and
follow.

Also, unify code for checking for CURLcode errors with:

 if(result) or if(!result)

instead of

 if(result == CURLE_OK), if(CURLE_OK == result) or if(result != CURLE_OK)
parent 1752e9c0

lib/conncache.c

+2 −2
Original line number Diff line number Diff line
@@ -131,7 +131,7 @@ CURLcode Curl_conncache_add_conn(struct conncache *connc, 
                                      conn->host.name);

  if(!bundle) {

    result = Curl_bundle_create(data, &new_bundle);

    if(result != CURLE_OK)

    if(result)

      return result;



    if(!conncache_add_bundle(data->state.conn_cache,
@@ -143,7 +143,7 @@ CURLcode Curl_conncache_add_conn(struct conncache *connc, 
  }



  result = Curl_bundle_add_conn(bundle, conn);

  if(result != CURLE_OK) {

  if(result) {

    if(new_bundle)

      conncache_remove_bundle(data->state.conn_cache, new_bundle);

    return result;

lib/connect.c

+20 −21
Original line number Diff line number Diff line
@@ -717,11 +717,11 @@ CURLcode Curl_is_connected(struct connectdata *conn, 
                           bool *connected)

{

  struct SessionHandle *data = conn->data;

  CURLcode code = CURLE_OK;

  CURLcode result = CURLE_OK;

  long allow;

  int error = 0;

  struct timeval now;

  int result;

  int rc;

  int i;



  DEBUGASSERT(sockindex >= FIRSTSOCKET && sockindex <= SECONDARYSOCKET);
@@ -757,9 +757,9 @@ CURLcode Curl_is_connected(struct connectdata *conn, 
#endif



    /* check socket for connect */

    result = Curl_socket_ready(CURL_SOCKET_BAD, conn->tempsock[i], 0);

    rc = Curl_socket_ready(CURL_SOCKET_BAD, conn->tempsock[i], 0);



    if(result == 0) { /* no connection yet */

    if(rc == 0) { /* no connection yet */

      if(curlx_tvdiff(now, conn->connecttime) >= conn->timeoutms_per_addr) {

        infof(data, "After %ldms connect time, move on!\n",

              conn->timeoutms_per_addr);
@@ -772,7 +772,7 @@ CURLcode Curl_is_connected(struct connectdata *conn, 
        trynextip(conn, sockindex, 1);

      }

    }

    else if(result == CURL_CSELECT_OUT) {

    else if(rc == CURL_CSELECT_OUT) {

      if(verifyconnect(conn->tempsock[i], &error)) {

        /* we are connected with TCP, awesome! */

        int other = i ^ 1;
@@ -789,9 +789,9 @@ CURLcode Curl_is_connected(struct connectdata *conn, 
        }



        /* see if we need to do any proxy magic first once we connected */

        code = Curl_connected_proxy(conn, sockindex);

        if(code)

          return code;

        result = Curl_connected_proxy(conn, sockindex);

        if(result)

          return result;



        conn->bits.tcpconnect[sockindex] = TRUE;
@@ -806,7 +806,7 @@ CURLcode Curl_is_connected(struct connectdata *conn, 
      else

        infof(data, "Connection failed\n");

    }

    else if(result & CURL_CSELECT_ERR)

    else if(rc & CURL_CSELECT_ERR)

      (void)verifyconnect(conn->tempsock[i], &error);



    /*
@@ -825,21 +825,20 @@ CURLcode Curl_is_connected(struct connectdata *conn, 
        conn->timeoutms_per_addr = conn->tempaddr[i]->ai_next == NULL ?

                                   allow : allow / 2;



        code = trynextip(conn, sockindex, i);

        result = trynextip(conn, sockindex, i);

      }

    }

  }



  if(code) {

  if(result) {

    /* no more addresses to try */



    /* if the first address family runs out of addresses to try before

       the happy eyeball timeout, go ahead and try the next family now */

    if(conn->tempaddr[1] == NULL) {

      int rc;

      rc = trynextip(conn, sockindex, 1);

      if(rc == CURLE_OK)

        return CURLE_OK;

      result = trynextip(conn, sockindex, 1);

      if(!result)

        return result;

    }



    failf(data, "Failed to connect to %s port %ld: %s",
@@ -847,7 +846,7 @@ CURLcode Curl_is_connected(struct connectdata *conn, 
          conn->port, Curl_strerror(conn, error));

  }



  return code;

  return result;

}



static void tcpnodelay(struct connectdata *conn,
@@ -1117,7 +1116,7 @@ CURLcode Curl_connecthost(struct connectdata *conn, /* context */ 
{

  struct SessionHandle *data = conn->data;

  struct timeval before = Curl_tvnow();

  CURLcode res = CURLE_COULDNT_CONNECT;

  CURLcode result = CURLE_COULDNT_CONNECT;



  long timeout_ms = Curl_timeleft(data, &before, TRUE);
@@ -1140,14 +1139,14 @@ CURLcode Curl_connecthost(struct connectdata *conn, /* context */ 


  /* start connecting to first IP */

  while(conn->tempaddr[0]) {

    res = singleipconnect(conn, conn->tempaddr[0], &(conn->tempsock[0]));

    if(res == CURLE_OK)

    result = singleipconnect(conn, conn->tempaddr[0], &(conn->tempsock[0]));

    if(!result)

      break;

    conn->tempaddr[0] = conn->tempaddr[0]->ai_next;

  }



  if(conn->tempsock[0] == CURL_SOCKET_BAD)

    return res;

    return result;



  data->info.numconnects++; /* to track the number of connections made */

lib/curl_addrinfo.c

+2 −2
Original line number Diff line number Diff line
@@ -5,7 +5,7 @@ 
 *                            | (__| |_| |  _ <| |___

 *                             \___|\___/|_| \_\_____|

 *

 * Copyright (C) 1998 - 2012, Daniel Stenberg, <daniel@haxx.se>, et al.

 * Copyright (C) 1998 - 2014, Daniel Stenberg, <daniel@haxx.se>, et al.

 *

 * This software is licensed as described in the file COPYING, which

 * you should have received as part of this distribution. The terms
@@ -354,7 +354,7 @@ Curl_he2ai(const struct hostent *he, int port) 
    prevai = ai;

  }



  if(result != CURLE_OK) {

  if(result) {

    Curl_freeaddrinfo(firstai);

    firstai = NULL;

  }

lib/easy.c

+47 −47
Original line number Diff line number Diff line
@@ -136,9 +136,9 @@ static CURLcode win32_init(void) 


#ifdef USE_WINDOWS_SSPI

  {

    CURLcode err = Curl_sspi_global_init();

    if(err != CURLE_OK)

      return err;

    CURLcode result = Curl_sspi_global_init();

    if(result)

      return result;

  }

#endif
@@ -243,7 +243,7 @@ CURLcode curl_global_init(long flags) 
    }



  if(flags & CURL_GLOBAL_WIN32)

    if(win32_init() != CURLE_OK) {

    if(win32_init()) {

      DEBUGF(fprintf(stderr, "Error: win32_init failed\n"));

      return CURLE_FAILED_INIT;

    }
@@ -265,7 +265,7 @@ CURLcode curl_global_init(long flags) 
  idna_init();

#endif



  if(Curl_resolver_global_init() != CURLE_OK) {

  if(Curl_resolver_global_init()) {

    DEBUGF(fprintf(stderr, "Error: resolver_global_init failed\n"));

    return CURLE_FAILED_INIT;

  }
@@ -293,7 +293,7 @@ CURLcode curl_global_init_mem(long flags, curl_malloc_callback m, 
                              curl_free_callback f, curl_realloc_callback r,

                              curl_strdup_callback s, curl_calloc_callback c)

{

  CURLcode code = CURLE_OK;

  CURLcode result = CURLE_OK;



  /* Invalid input, return immediately */

  if(!m || !f || !r || !s || !c)
@@ -308,8 +308,8 @@ CURLcode curl_global_init_mem(long flags, curl_malloc_callback m, 
  }



  /* Call the actual init function first */

  code = curl_global_init(flags);

  if(code == CURLE_OK) {

  result = curl_global_init(flags);

  if(!result) {

    Curl_cmalloc = m;

    Curl_cfree = f;

    Curl_cstrdup = s;
@@ -317,7 +317,7 @@ CURLcode curl_global_init_mem(long flags, curl_malloc_callback m, 
    Curl_ccalloc = c;

  }



  return code;

  return result;

}



/**
@@ -357,13 +357,13 @@ void curl_global_cleanup(void) 
 */

CURL *curl_easy_init(void)

{

  CURLcode res;

  CURLcode result;

  struct SessionHandle *data;



  /* Make sure we inited the global SSL stuff */

  if(!initialized) {

    res = curl_global_init(CURL_GLOBAL_DEFAULT);

    if(res) {

    result = curl_global_init(CURL_GLOBAL_DEFAULT);

    if(result) {

      /* something in the global init failed, return nothing */

      DEBUGF(fprintf(stderr, "Error: curl_global_init failed\n"));

      return NULL;
@@ -371,8 +371,8 @@ CURL *curl_easy_init(void) 
  }



  /* We use curl_open() with undefined URL so far */

  res = Curl_open(&data);

  if(res != CURLE_OK) {

  result = Curl_open(&data);

  if(result) {

    DEBUGF(fprintf(stderr, "Error: Curl_open failed\n"));

    return NULL;

  }
@@ -390,17 +390,17 @@ CURLcode curl_easy_setopt(CURL *curl, CURLoption tag, ...) 
{

  va_list arg;

  struct SessionHandle *data = curl;

  CURLcode ret;

  CURLcode result;



  if(!curl)

    return CURLE_BAD_FUNCTION_ARGUMENT;



  va_start(arg, tag);



  ret = Curl_setopt(data, tag, arg);

  result = Curl_setopt(data, tag, arg);



  va_end(arg);

  return ret;

  return result;

}



#ifdef CURLDEBUG
@@ -570,7 +570,7 @@ static CURLcode wait_or_timeout(struct Curl_multi *multi, struct events *ev) 
{

  bool done = FALSE;

  CURLMcode mcode;

  CURLcode rc = CURLE_OK;

  CURLcode result = CURLE_OK;



  while(!done) {

    CURLMsg *msg;
@@ -640,12 +640,12 @@ static CURLcode wait_or_timeout(struct Curl_multi *multi, struct events *ev) 
       second argument */

    msg = curl_multi_info_read(multi, &pollrc);

    if(msg) {

      rc = msg->data.result;

      result = msg->data.result;

      done = TRUE;

    }

  }



  return rc;

  return result;

}
@@ -671,7 +671,7 @@ static CURLcode easy_transfer(CURLM *multi) 
{

  bool done = FALSE;

  CURLMcode mcode = CURLM_OK;

  CURLcode code = CURLE_OK;

  CURLcode result = CURLE_OK;

  struct timeval before;

  int without_fds = 0;  /* count number of consecutive returns from

                           curl_multi_wait() without any filedescriptors */
@@ -686,7 +686,7 @@ static CURLcode easy_transfer(CURLM *multi) 
    if(mcode == CURLM_OK) {

      if(ret == -1) {

        /* poll() failed not on EINTR, indicate a network problem */

        code = CURLE_RECV_ERROR;

        result = CURLE_RECV_ERROR;

        break;

      }

      else if(ret == 0) {
@@ -717,7 +717,7 @@ static CURLcode easy_transfer(CURLM *multi) 
      int rc;

      CURLMsg *msg = curl_multi_info_read(multi, &rc);

      if(msg) {

        code = msg->data.result;

        result = msg->data.result;

        done = TRUE;

      }

    }
@@ -731,7 +731,7 @@ static CURLcode easy_transfer(CURLM *multi) 
            CURLE_BAD_FUNCTION_ARGUMENT;

  }



  return code;

  return result;

}
@@ -756,7 +756,7 @@ static CURLcode easy_perform(struct SessionHandle *data, bool events) 
{

  CURLM *multi;

  CURLMcode mcode;

  CURLcode code = CURLE_OK;

  CURLcode result = CURLE_OK;

  SIGPIPE_VARIABLE(pipe_st);



  if(!data)
@@ -797,7 +797,7 @@ static CURLcode easy_perform(struct SessionHandle *data, bool events) 
  data->multi = multi;



  /* run the transfer */

  code = events ? easy_events(multi) : easy_transfer(multi);

  result = events ? easy_events(multi) : easy_transfer(multi);



  /* ignoring the return code isn't nice, but atm we can't really handle

     a failure here, room for future improvement! */
@@ -806,7 +806,7 @@ static CURLcode easy_perform(struct SessionHandle *data, bool events) 
  sigpipe_restore(&pipe_st);



  /* The multi handle is kept alive, owned by the easy handle */

  return code;

  return result;

}
@@ -857,16 +857,16 @@ CURLcode curl_easy_getinfo(CURL *curl, CURLINFO info, ...) 
{

  va_list arg;

  void *paramp;

  CURLcode ret;

  CURLcode result;

  struct SessionHandle *data = (struct SessionHandle *)curl;



  va_start(arg, info);

  paramp = va_arg(arg, void *);



  ret = Curl_getinfo(data, info, paramp);

  result = Curl_getinfo(data, info, paramp);



  va_end(arg);

  return ret;

  return result;

}



/*
@@ -893,7 +893,7 @@ CURL *curl_easy_duphandle(CURL *incurl) 
  outcurl->state.headersize = HEADERSIZE;



  /* copy all userdefined values */

  if(Curl_dupset(outcurl, data) != CURLE_OK)

  if(Curl_dupset(outcurl, data))

    goto fail;



  /* the connection cache is setup on demand */
@@ -939,7 +939,7 @@ CURL *curl_easy_duphandle(CURL *incurl) 


  /* Clone the resolver handle, if present, for the new handle */

  if(Curl_resolver_duphandle(&outcurl->state.resolver,

                             data->state.resolver) != CURLE_OK)

                             data->state.resolver))

    goto fail;



  Curl_convert_setup(outcurl);
@@ -1085,7 +1085,7 @@ CURLcode curl_easy_pause(CURL *curl, int action) 
        tempwrite += chunklen; /* advance the pointer */

      }



    } while((result == CURLE_OK) && tempsize);

    } while(!result && tempsize);



    free(freewrite); /* this is unconditionally no longer used */

  }
@@ -1132,20 +1132,20 @@ static CURLcode easy_connection(struct SessionHandle *data, 
CURLcode curl_easy_recv(CURL *curl, void *buffer, size_t buflen, size_t *n)

{

  curl_socket_t sfd;

  CURLcode ret;

  CURLcode result;

  ssize_t n1;

  struct connectdata *c;

  struct SessionHandle *data = (struct SessionHandle *)curl;



  ret = easy_connection(data, &sfd, &c);

  if(ret)

    return ret;

  result = easy_connection(data, &sfd, &c);

  if(result)

    return result;



  *n = 0;

  ret = Curl_read(c, sfd, buffer, buflen, &n1);

  result = Curl_read(c, sfd, buffer, buflen, &n1);



  if(ret != CURLE_OK)

    return ret;

  if(result)

    return result;



  *n = (size_t)n1;
@@ -1160,26 +1160,26 @@ CURLcode curl_easy_send(CURL *curl, const void *buffer, size_t buflen, 
                        size_t *n)

{

  curl_socket_t sfd;

  CURLcode ret;

  CURLcode result;

  ssize_t n1;

  struct connectdata *c = NULL;

  struct SessionHandle *data = (struct SessionHandle *)curl;



  ret = easy_connection(data, &sfd, &c);

  if(ret)

    return ret;

  result = easy_connection(data, &sfd, &c);

  if(result)

    return result;



  *n = 0;

  ret = Curl_write(c, sfd, buffer, buflen, &n1);

  result = Curl_write(c, sfd, buffer, buflen, &n1);



  if(n1 == -1)

    return CURLE_SEND_ERROR;



  /* detect EAGAIN */

  if((CURLE_OK == ret) && (0 == n1))

  if(!result && !n1)

    return CURLE_AGAIN;



  *n = (size_t)n1;



  return ret;

  return result;

}

lib/file.c

+19 −20
Original line number Diff line number Diff line
@@ -303,7 +303,7 @@ static CURLcode file_upload(struct connectdata *conn) 
  const char *dir = strchr(file->path, DIRSEP);

  int fd;

  int mode;

  CURLcode res=CURLE_OK;

  CURLcode result = CURLE_OK;

  struct SessionHandle *data = conn->data;

  char *buf = data->state.buffer;

  size_t nread;
@@ -359,10 +359,10 @@ static CURLcode file_upload(struct connectdata *conn) 
      data->state.resume_from = (curl_off_t)file_stat.st_size;

  }



  while(res == CURLE_OK) {

  while(!result) {

    int readcount;

    res = Curl_fillreadbuffer(conn, BUFSIZE, &readcount);

    if(res)

    result = Curl_fillreadbuffer(conn, BUFSIZE, &readcount);

    if(result)

      break;



    if(readcount <= 0)  /* fix questionable compare error. curlvms */
@@ -389,7 +389,7 @@ static CURLcode file_upload(struct connectdata *conn) 
    /* write the data to the target */

    nwrite = write(fd, buf2, nread);

    if(nwrite != nread) {

      res = CURLE_SEND_ERROR;

      result = CURLE_SEND_ERROR;

      break;

    }
@@ -398,16 +398,16 @@ static CURLcode file_upload(struct connectdata *conn) 
    Curl_pgrsSetUploadCounter(data, bytecount);



    if(Curl_pgrsUpdate(conn))

      res = CURLE_ABORTED_BY_CALLBACK;

      result = CURLE_ABORTED_BY_CALLBACK;

    else

      res = Curl_speedcheck(data, now);

      result = Curl_speedcheck(data, now);

  }

  if(!res && Curl_pgrsUpdate(conn))

    res = CURLE_ABORTED_BY_CALLBACK;

  if(!result && Curl_pgrsUpdate(conn))

    result = CURLE_ABORTED_BY_CALLBACK;



  close(fd);



  return res;

  return result;

}



/*
@@ -425,7 +425,7 @@ static CURLcode file_do(struct connectdata *conn, bool *done) 
     are supported. This means that files on remotely mounted directories

     (via NFS, Samba, NT sharing) can be accessed through a file:// URL

  */

  CURLcode res = CURLE_OK;

  CURLcode result = CURLE_OK;

  struct_stat statbuf; /* struct_stat instead of struct stat just to allow the

                          Windows version to have a different struct without

                          having to redefine the simple word 'stat' */
@@ -472,7 +472,6 @@ static CURLcode file_do(struct connectdata *conn, bool *done) 
     information. Which for FILE can't be much more than the file size and

     date. */

  if(data->set.opt_no_body && data->set.include_header && fstated) {

    CURLcode result;

    snprintf(buf, sizeof(data->state.buffer),

             "Content-Length: %" CURL_FORMAT_CURL_OFF_T "\r\n", expected_size);

    result = Curl_client_write(conn, CLIENTWRITE_BOTH, buf, 0);
@@ -554,7 +553,7 @@ static CURLcode file_do(struct connectdata *conn, bool *done) 


  Curl_pgrsTime(data, TIMER_STARTTRANSFER);



  while(res == CURLE_OK) {

  while(!result) {

    /* Don't fill a whole buffer if we want less than all data */

    size_t bytestoread =

      (expected_size < CURL_OFF_T_C(BUFSIZE) - CURL_OFF_T_C(1)) ?
@@ -571,21 +570,21 @@ static CURLcode file_do(struct connectdata *conn, bool *done) 
    bytecount += nread;

    expected_size -= nread;



    res = Curl_client_write(conn, CLIENTWRITE_BODY, buf, nread);

    if(res)

      return res;

    result = Curl_client_write(conn, CLIENTWRITE_BODY, buf, nread);

    if(result)

      return result;



    Curl_pgrsSetDownloadCounter(data, bytecount);



    if(Curl_pgrsUpdate(conn))

      res = CURLE_ABORTED_BY_CALLBACK;

      result = CURLE_ABORTED_BY_CALLBACK;

    else

      res = Curl_speedcheck(data, now);

      result = Curl_speedcheck(data, now);

  }

  if(Curl_pgrsUpdate(conn))

    res = CURLE_ABORTED_BY_CALLBACK;

    result = CURLE_ABORTED_BY_CALLBACK;



  return res;

  return result;

}



#endif