moparisthebest
/
curl
mirror of https://github.com/moparisthebest/curl
1
0
Fork 0
Code Issues Releases Wiki Activity

All static functions that were previously name Curl_* something no longer 

use that prefix as we use that prefix only for library-wide internal global
symbols.
This commit is contained in:
Daniel Stenberg 2007-12-08 22:50:55 +00:00
parent f8172f85b1
commit 662bee7193
11 changed files with 185 additions and 185 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
lib/dict.c
View File

@ -87,7 +87,7 @@
* Forward declarations. * Forward declarations.
*/ */
static CURLcode Curl_dict(struct connectdata *conn, bool *done); static CURLcode dict_do(struct connectdata *conn, bool *done);
/* /*
* DICT protocol handler. * DICT protocol handler.
@ -96,7 +96,7 @@ static CURLcode Curl_dict(struct connectdata *conn, bool *done);
const struct Curl_handler Curl_handler_dict = { const struct Curl_handler Curl_handler_dict = {
"DICT", /* scheme */ "DICT", /* scheme */
ZERO_NULL, /* setup_connection */ ZERO_NULL, /* setup_connection */
Curl_dict, /* do_it */ dict_do, /* do_it */
ZERO_NULL, /* done */ ZERO_NULL, /* done */
ZERO_NULL, /* do_more */ ZERO_NULL, /* do_more */
ZERO_NULL, /* connect_it */ ZERO_NULL, /* connect_it */
@ -142,7 +142,7 @@ static char *unescape_word(struct SessionHandle *data, const char *inp)
return dictp; return dictp;
} }
static CURLcode Curl_dict(struct connectdata *conn, bool *done) static CURLcode dict_do(struct connectdata *conn, bool *done)
{ {
char *word; char *word;
char *eword; char *eword;

26
lib/file.c
View File

@ -94,10 +94,10 @@
* Forward declarations. * Forward declarations.
*/ */
static CURLcode Curl_file(struct connectdata *, bool *done); static CURLcode file_do(struct connectdata *, bool *done);
static CURLcode Curl_file_done(struct connectdata *conn, static CURLcode file_done(struct connectdata *conn,
CURLcode status, bool premature); CURLcode status, bool premature);
static CURLcode Curl_file_connect(struct connectdata *conn, bool *done); static CURLcode file_connect(struct connectdata *conn, bool *done);
/* /*
* FILE scheme handler. * FILE scheme handler.
@ -106,10 +106,10 @@ static CURLcode Curl_file_connect(struct connectdata *conn, bool *done);
const struct Curl_handler Curl_handler_file = { const struct Curl_handler Curl_handler_file = {
"FILE", /* scheme */ "FILE", /* scheme */
ZERO_NULL, /* setup_connection */ ZERO_NULL, /* setup_connection */
Curl_file, /* do_it */ file_do, /* do_it */
Curl_file_done, /* done */ file_done, /* done */
ZERO_NULL, /* do_more */ ZERO_NULL, /* do_more */
Curl_file_connect, /* connect_it */ file_connect, /* connect_it */
ZERO_NULL, /* connecting */ ZERO_NULL, /* connecting */
ZERO_NULL, /* doing */ ZERO_NULL, /* doing */
ZERO_NULL, /* proto_getsock */ ZERO_NULL, /* proto_getsock */
@ -120,11 +120,11 @@ const struct Curl_handler Curl_handler_file = {
}; };
/* /*
* Curl_file_connect() gets called from Curl_protocol_connect() to allow us to * file_connect() gets called from Curl_protocol_connect() to allow us to
* do protocol-specific actions at connect-time. We emulate a * do protocol-specific actions at connect-time. We emulate a
* connect-then-transfer protocol and "connect" to the file here * connect-then-transfer protocol and "connect" to the file here
*/ */
static CURLcode Curl_file_connect(struct connectdata *conn, bool *done) static CURLcode file_connect(struct connectdata *conn, bool *done)
{ {
struct SessionHandle *data = conn->data; struct SessionHandle *data = conn->data;
char *real_path = curl_easy_unescape(data, data->state.path, 0, NULL); char *real_path = curl_easy_unescape(data, data->state.path, 0, NULL);
@ -201,7 +201,7 @@ static CURLcode Curl_file_connect(struct connectdata *conn, bool *done)
file->fd = fd; file->fd = fd;
if(!data->set.upload && (fd == -1)) { if(!data->set.upload && (fd == -1)) {
failf(data, "Couldn't open file %s", data->state.path); failf(data, "Couldn't open file %s", data->state.path);
Curl_file_done(conn, CURLE_FILE_COULDNT_READ_FILE, FALSE); file_done(conn, CURLE_FILE_COULDNT_READ_FILE, FALSE);
return CURLE_FILE_COULDNT_READ_FILE; return CURLE_FILE_COULDNT_READ_FILE;
} }
*done = TRUE; *done = TRUE;
@ -209,7 +209,7 @@ static CURLcode Curl_file_connect(struct connectdata *conn, bool *done)
return CURLE_OK; return CURLE_OK;
} }
static CURLcode Curl_file_done(struct connectdata *conn, static CURLcode file_done(struct connectdata *conn,
CURLcode status, bool premature) CURLcode status, bool premature)
{ {
struct FILEPROTO *file = conn->data->state.proto.file; struct FILEPROTO *file = conn->data->state.proto.file;
@ -349,14 +349,14 @@ static CURLcode file_upload(struct connectdata *conn)
} }
/* /*
* Curl_file() is the protocol-specific function for the do-phase, separated * file_do() is the protocol-specific function for the do-phase, separated
* from the connect-phase above. Other protocols merely setup the transfer in * from the connect-phase above. Other protocols merely setup the transfer in
* the do-phase, to have it done in the main transfer loop but since some * the do-phase, to have it done in the main transfer loop but since some
* platforms we support don't allow select()ing etc on file handles (as * platforms we support don't allow select()ing etc on file handles (as
* opposed to sockets) we instead perform the whole do-operation in this * opposed to sockets) we instead perform the whole do-operation in this
* function. * function.
*/ */
static CURLcode Curl_file(struct connectdata *conn, bool *done) static CURLcode file_do(struct connectdata *conn, bool *done)
{ {
/* This implementation ignores the host name in conformance with /* This implementation ignores the host name in conformance with
RFC 1738. Only local files (reachable via the standard file system) RFC 1738. Only local files (reachable via the standard file system)

110
lib/ftp.c
View File

@ -134,21 +134,21 @@ static CURLcode ftp_nb_type(struct connectdata *conn,
bool ascii, ftpstate newstate); bool ascii, ftpstate newstate);
static int ftp_need_type(struct connectdata *conn, static int ftp_need_type(struct connectdata *conn,
bool ascii); bool ascii);
static CURLcode Curl_ftp(struct connectdata *conn, bool *done); static CURLcode ftp_do(struct connectdata *conn, bool *done);
static CURLcode Curl_ftp_done(struct connectdata *conn, static CURLcode ftp_done(struct connectdata *conn,
CURLcode, bool premature); CURLcode, bool premature);
static CURLcode Curl_ftp_connect(struct connectdata *conn, bool *done); static CURLcode ftp_connect(struct connectdata *conn, bool *done);
static CURLcode Curl_ftp_disconnect(struct connectdata *conn); static CURLcode ftp_disconnect(struct connectdata *conn);
static CURLcode Curl_ftp_nextconnect(struct connectdata *conn); static CURLcode ftp_nextconnect(struct connectdata *conn);
static CURLcode Curl_ftp_multi_statemach(struct connectdata *conn, bool *done); static CURLcode ftp_multi_statemach(struct connectdata *conn, bool *done);
static int Curl_ftp_getsock(struct connectdata *conn, static int ftp_getsock(struct connectdata *conn,
curl_socket_t *socks, curl_socket_t *socks,
int numsocks); int numsocks);
static CURLcode Curl_ftp_doing(struct connectdata *conn, static CURLcode ftp_doing(struct connectdata *conn,
bool *dophase_done); bool *dophase_done);
static CURLcode Curl_ftp_setup_connection(struct connectdata * conn); static CURLcode ftp_setup_connection(struct connectdata * conn);
#ifdef USE_SSL #ifdef USE_SSL
static CURLcode Curl_ftps_setup_connection(struct connectdata * conn); static CURLcode ftps_setup_connection(struct connectdata * conn);
#endif #endif
/* easy-to-use macro: */ /* easy-to-use macro: */
@ -164,16 +164,16 @@ static CURLcode Curl_ftps_setup_connection(struct connectdata * conn);
const struct Curl_handler Curl_handler_ftp = { const struct Curl_handler Curl_handler_ftp = {
"FTP", /* scheme */ "FTP", /* scheme */
Curl_ftp_setup_connection, /* setup_connection */ ftp_setup_connection, /* setup_connection */
Curl_ftp, /* do_it */ ftp_do, /* do_it */
Curl_ftp_done, /* done */ ftp_done, /* done */
Curl_ftp_nextconnect, /* do_more */ ftp_nextconnect, /* do_more */
Curl_ftp_connect, /* connect_it */ ftp_connect, /* connect_it */
Curl_ftp_multi_statemach, /* connecting */ ftp_multi_statemach, /* connecting */
Curl_ftp_doing, /* doing */ ftp_doing, /* doing */
Curl_ftp_getsock, /* proto_getsock */ ftp_getsock, /* proto_getsock */
Curl_ftp_getsock, /* doing_getsock */ ftp_getsock, /* doing_getsock */
Curl_ftp_disconnect, /* disconnect */ ftp_disconnect, /* disconnect */
PORT_FTP, /* defport */ PORT_FTP, /* defport */
PROT_FTP /* protocol */ PROT_FTP /* protocol */
}; };
@ -186,16 +186,16 @@ const struct Curl_handler Curl_handler_ftp = {
const struct Curl_handler Curl_handler_ftps = { const struct Curl_handler Curl_handler_ftps = {
"FTPS", /* scheme */ "FTPS", /* scheme */
Curl_ftps_setup_connection, /* setup_connection */ ftps_setup_connection, /* setup_connection */
Curl_ftp, /* do_it */ ftp_do, /* do_it */
Curl_ftp_done, /* done */ ftp_done, /* done */
Curl_ftp_nextconnect, /* do_more */ ftp_nextconnect, /* do_more */
Curl_ftp_connect, /* connect_it */ ftp_connect, /* connect_it */
Curl_ftp_multi_statemach, /* connecting */ ftp_multi_statemach, /* connecting */
Curl_ftp_doing, /* doing */ ftp_doing, /* doing */
Curl_ftp_getsock, /* proto_getsock */ ftp_getsock, /* proto_getsock */
Curl_ftp_getsock, /* doing_getsock */ ftp_getsock, /* doing_getsock */
Curl_ftp_disconnect, /* disconnect */ ftp_disconnect, /* disconnect */
PORT_FTPS, /* defport */ PORT_FTPS, /* defport */
PROT_FTP | PROT_FTPS | PROT_SSL /* protocol */ PROT_FTP | PROT_FTPS | PROT_SSL /* protocol */
}; };
@ -810,7 +810,7 @@ static CURLcode ftp_state_pwd(struct connectdata *conn)
} }
/* For the FTP "protocol connect" and "doing" phases only */ /* For the FTP "protocol connect" and "doing" phases only */
static int Curl_ftp_getsock(struct connectdata *conn, static int ftp_getsock(struct connectdata *conn,
curl_socket_t *socks, curl_socket_t *socks,
int numsocks) int numsocks)
{ {
@ -1589,7 +1589,7 @@ static CURLcode ftp_state_ul_setup(struct connectdata *conn,
result=Curl_setup_transfer(conn, -1, -1, FALSE, NULL, -1, NULL); result=Curl_setup_transfer(conn, -1, -1, FALSE, NULL, -1, NULL);
/* Set ->transfer so that we won't get any error in /* Set ->transfer so that we won't get any error in
* Curl_ftp_done() because we didn't transfer anything! */ * ftp_done() because we didn't transfer anything! */
ftp->transfer = FTPTRANSFER_NONE; ftp->transfer = FTPTRANSFER_NONE;
state(conn, FTP_STOP); state(conn, FTP_STOP);
@ -2148,7 +2148,7 @@ static CURLcode ftp_state_post_retr_size(struct connectdata *conn,
result = Curl_setup_transfer(conn, -1, -1, FALSE, NULL, -1, NULL); result = Curl_setup_transfer(conn, -1, -1, FALSE, NULL, -1, NULL);
infof(data, "File already completely downloaded\n"); infof(data, "File already completely downloaded\n");
/* Set ->transfer so that we won't get any error in Curl_ftp_done() /* Set ->transfer so that we won't get any error in ftp_done()
* because we didn't transfer the any file */ * because we didn't transfer the any file */
ftp->transfer = FTPTRANSFER_NONE; ftp->transfer = FTPTRANSFER_NONE;
state(conn, FTP_STOP); state(conn, FTP_STOP);
@ -2930,7 +2930,7 @@ static long ftp_state_timeout(struct connectdata *conn)
/* called repeatedly until done from multi.c */ /* called repeatedly until done from multi.c */
static CURLcode Curl_ftp_multi_statemach(struct connectdata *conn, static CURLcode ftp_multi_statemach(struct connectdata *conn,
bool *done) bool *done)
{ {
curl_socket_t sock = conn->sock[FIRSTSOCKET]; curl_socket_t sock = conn->sock[FIRSTSOCKET];
@ -3032,14 +3032,14 @@ static CURLcode ftp_init(struct connectdata *conn)
} }
/* /*
* Curl_ftp_connect() should do everything that is to be considered a part of * ftp_connect() should do everything that is to be considered a part of
* the connection phase. * the connection phase.
* *
* The variable 'done' points to will be TRUE if the protocol-layer connect * The variable 'done' points to will be TRUE if the protocol-layer connect
* phase is done when this function returns, or FALSE is not. When called as * phase is done when this function returns, or FALSE is not. When called as
* a part of the easy interface, it will always be TRUE. * a part of the easy interface, it will always be TRUE.
*/ */
static CURLcode Curl_ftp_connect(struct connectdata *conn, static CURLcode ftp_connect(struct connectdata *conn,
bool *done) /* see description above */ bool *done) /* see description above */
{ {
CURLcode result; CURLcode result;
@ -3107,7 +3107,7 @@ static CURLcode Curl_ftp_connect(struct connectdata *conn,
ftpc->response = Curl_tvnow(); /* start response time-out now! */ ftpc->response = Curl_tvnow(); /* start response time-out now! */
if(data->state.used_interface == Curl_if_multi) if(data->state.used_interface == Curl_if_multi)
result = Curl_ftp_multi_statemach(conn, done); result = ftp_multi_statemach(conn, done);
else { else {
result = ftp_easy_statemach(conn); result = ftp_easy_statemach(conn);
if(!result) if(!result)
@ -3119,14 +3119,14 @@ static CURLcode Curl_ftp_connect(struct connectdata *conn,
/*********************************************************************** /***********************************************************************
* *
* Curl_ftp_done() * ftp_done()
* *
* The DONE function. This does what needs to be done after a single DO has * The DONE function. This does what needs to be done after a single DO has
* performed. * performed.
* *
* Input argument is already checked for validity. * Input argument is already checked for validity.
*/ */
static CURLcode Curl_ftp_done(struct connectdata *conn, CURLcode status, static CURLcode ftp_done(struct connectdata *conn, CURLcode status,
bool premature) bool premature)
{ {
struct SessionHandle *data = conn->data; struct SessionHandle *data = conn->data;
@ -3472,19 +3472,19 @@ static CURLcode ftp_range(struct connectdata *conn)
/* /*
* Curl_ftp_nextconnect() * ftp_nextconnect()
* *
* This function shall be called when the second FTP (data) connection is * This function shall be called when the second FTP (data) connection is
* connected. * connected.
*/ */
static CURLcode Curl_ftp_nextconnect(struct connectdata *conn) static CURLcode ftp_nextconnect(struct connectdata *conn)
{ {
struct SessionHandle *data=conn->data; struct SessionHandle *data=conn->data;
struct ftp_conn *ftpc = &conn->proto.ftpc; struct ftp_conn *ftpc = &conn->proto.ftpc;
CURLcode result = CURLE_OK; CURLcode result = CURLE_OK;
/* the ftp struct is inited in Curl_ftp_connect() */ /* the ftp struct is inited in ftp_connect() */
struct FTP *ftp = data->state.proto.ftp; struct FTP *ftp = data->state.proto.ftp;
DEBUGF(infof(data, "DO-MORE phase starts\n")); DEBUGF(infof(data, "DO-MORE phase starts\n"));
@ -3574,7 +3574,7 @@ CURLcode ftp_perform(struct connectdata *conn,
/* run the state-machine */ /* run the state-machine */
if(conn->data->state.used_interface == Curl_if_multi) if(conn->data->state.used_interface == Curl_if_multi)
result = Curl_ftp_multi_statemach(conn, dophase_done); result = ftp_multi_statemach(conn, dophase_done);
else { else {
result = ftp_easy_statemach(conn); result = ftp_easy_statemach(conn);
*dophase_done = TRUE; /* with the easy interface we are done here */ *dophase_done = TRUE; /* with the easy interface we are done here */
@ -3589,14 +3589,14 @@ CURLcode ftp_perform(struct connectdata *conn,
/*********************************************************************** /***********************************************************************
* *
* Curl_ftp() * ftp_do()
* *
* This function is registered as 'curl_do' function. It decodes the path * This function is registered as 'curl_do' function. It decodes the path
* parts etc as a wrapper to the actual DO function (ftp_perform). * parts etc as a wrapper to the actual DO function (ftp_perform).
* *
* The input argument is already checked for validity. * The input argument is already checked for validity.
*/ */
static CURLcode Curl_ftp(struct connectdata *conn, bool *done) static CURLcode ftp_do(struct connectdata *conn, bool *done)
{ {
CURLcode retcode = CURLE_OK; CURLcode retcode = CURLE_OK;
@ -3606,7 +3606,7 @@ static CURLcode Curl_ftp(struct connectdata *conn, bool *done)
Since connections can be re-used between SessionHandles, this might be a Since connections can be re-used between SessionHandles, this might be a
connection already existing but on a fresh SessionHandle struct so we must connection already existing but on a fresh SessionHandle struct so we must
make sure we have a good 'struct FTP' to play with. For new connections, make sure we have a good 'struct FTP' to play with. For new connections,
the struct FTP is allocated and setup in the Curl_ftp_connect() function. the struct FTP is allocated and setup in the ftp_connect() function.
*/ */
Curl_reset_reqproto(conn); Curl_reset_reqproto(conn);
retcode = ftp_init(conn); retcode = ftp_init(conn);
@ -3789,12 +3789,12 @@ static CURLcode ftp_quit(struct connectdata *conn)
/*********************************************************************** /***********************************************************************
* *
* Curl_ftp_disconnect() * ftp_disconnect()
* *
* Disconnect from an FTP server. Cleanup protocol-specific per-connection * Disconnect from an FTP server. Cleanup protocol-specific per-connection
* resources. BLOCKING. * resources. BLOCKING.
*/ */
static CURLcode Curl_ftp_disconnect(struct connectdata *conn) static CURLcode ftp_disconnect(struct connectdata *conn)
{ {
struct ftp_conn *ftpc= &conn->proto.ftpc; struct ftp_conn *ftpc= &conn->proto.ftpc;
@ -4024,7 +4024,7 @@ static CURLcode ftp_dophase_done(struct connectdata *conn,
struct ftp_conn *ftpc = &conn->proto.ftpc; struct ftp_conn *ftpc = &conn->proto.ftpc;
if(connected) if(connected)
result = Curl_ftp_nextconnect(conn); result = ftp_nextconnect(conn);
if(result && (conn->sock[SECONDARYSOCKET] != CURL_SOCKET_BAD)) { if(result && (conn->sock[SECONDARYSOCKET] != CURL_SOCKET_BAD)) {
/* Failure detected, close the second socket if it was created already */ /* Failure detected, close the second socket if it was created already */
@ -4046,11 +4046,11 @@ static CURLcode ftp_dophase_done(struct connectdata *conn,
} }
/* called from multi.c while DOing */ /* called from multi.c while DOing */
static CURLcode Curl_ftp_doing(struct connectdata *conn, static CURLcode ftp_doing(struct connectdata *conn,
bool *dophase_done) bool *dophase_done)
{ {
CURLcode result; CURLcode result;
result = Curl_ftp_multi_statemach(conn, dophase_done); result = ftp_multi_statemach(conn, dophase_done);
if(*dophase_done) { if(*dophase_done) {
result = ftp_dophase_done(conn, FALSE /* not connected */); result = ftp_dophase_done(conn, FALSE /* not connected */);
@ -4070,7 +4070,7 @@ static CURLcode Curl_ftp_doing(struct connectdata *conn,
* remote host. * remote host.
* *
* ftp->ctl_valid starts out as FALSE, and gets set to TRUE if we reach the * ftp->ctl_valid starts out as FALSE, and gets set to TRUE if we reach the
* Curl_ftp_done() function without finding any major problem. * ftp_done() function without finding any major problem.
*/ */
static static
CURLcode ftp_regular_transfer(struct connectdata *conn, CURLcode ftp_regular_transfer(struct connectdata *conn,
@ -4109,7 +4109,7 @@ CURLcode ftp_regular_transfer(struct connectdata *conn,
return result; return result;
} }
static CURLcode Curl_ftp_setup_connection(struct connectdata * conn) static CURLcode ftp_setup_connection(struct connectdata * conn)
{ {
struct SessionHandle *data = conn->data; struct SessionHandle *data = conn->data;
char * type; char * type;
@ -4170,12 +4170,12 @@ static CURLcode Curl_ftp_setup_connection(struct connectdata * conn)
} }
#ifdef USE_SSL #ifdef USE_SSL
static CURLcode Curl_ftps_setup_connection(struct connectdata * conn) static CURLcode ftps_setup_connection(struct connectdata * conn)
{ {
struct SessionHandle *data = conn->data; struct SessionHandle *data = conn->data;
conn->ssl[SECONDARYSOCKET].use = data->set.ftp_ssl != CURLUSESSL_CONTROL; conn->ssl[SECONDARYSOCKET].use = data->set.ftp_ssl != CURLUSESSL_CONTROL;
return Curl_ftp_setup_connection(conn); return ftp_setup_connection(conn);
} }
#endif #endif

44
lib/http.c
View File

@ -109,9 +109,9 @@
* Forward declarations. * Forward declarations.
*/ */
static CURLcode Curl_https_connecting(struct connectdata *conn, bool *done); static CURLcode https_connecting(struct connectdata *conn, bool *done);
#ifdef USE_SSL #ifdef USE_SSL
static int Curl_https_getsock(struct connectdata *conn, static int https_getsock(struct connectdata *conn,
curl_socket_t *socks, curl_socket_t *socks,
int numsocks); int numsocks);
#endif #endif
@ -146,9 +146,9 @@ const struct Curl_handler Curl_handler_https = {
Curl_http_done, /* done */ Curl_http_done, /* done */
ZERO_NULL, /* do_more */ ZERO_NULL, /* do_more */
Curl_http_connect, /* connect_it */ Curl_http_connect, /* connect_it */
Curl_https_connecting, /* connecting */ https_connecting, /* connecting */
ZERO_NULL, /* doing */ ZERO_NULL, /* doing */
Curl_https_getsock, /* proto_getsock */ https_getsock, /* proto_getsock */
ZERO_NULL, /* doing_getsock */ ZERO_NULL, /* doing_getsock */
ZERO_NULL, /* disconnect */ ZERO_NULL, /* disconnect */
PORT_HTTPS, /* defport */ PORT_HTTPS, /* defport */
@ -176,12 +176,12 @@ static char *checkheaders(struct SessionHandle *data, const char *thisheader)
} }
/* /*
* Curl_output_basic() sets up an Authorization: header (or the proxy version) * http_output_basic() sets up an Authorization: header (or the proxy version)
* for HTTP Basic authentication. * for HTTP Basic authentication.
* *
* Returns CURLcode. * Returns CURLcode.
*/ */
static CURLcode Curl_output_basic(struct connectdata *conn, bool proxy) static CURLcode http_output_basic(struct connectdata *conn, bool proxy)
{ {
char *authorization; char *authorization;
struct SessionHandle *data=conn->data; struct SessionHandle *data=conn->data;
@ -435,11 +435,11 @@ CURLcode Curl_http_auth_act(struct connectdata *conn)
* @returns CURLcode * @returns CURLcode
*/ */
static CURLcode static CURLcode
Curl_http_output_auth(struct connectdata *conn, http_output_auth(struct connectdata *conn,
const char *request, const char *request,
const char *path, const char *path,
bool proxytunnel) /* TRUE if this is the request setting bool proxytunnel) /* TRUE if this is the request setting
up the proxy tunnel */ up the proxy tunnel */
{ {
CURLcode result = CURLE_OK; CURLcode result = CURLE_OK;
struct SessionHandle *data = conn->data; struct SessionHandle *data = conn->data;
@ -502,11 +502,11 @@ Curl_http_output_auth(struct connectdata *conn,
if(conn->bits.proxy_user_passwd && if(conn->bits.proxy_user_passwd &&
!checkheaders(data, "Proxy-authorization:")) { !checkheaders(data, "Proxy-authorization:")) {
auth="Basic"; auth="Basic";
result = Curl_output_basic(conn, TRUE); result = http_output_basic(conn, TRUE);
if(result) if(result)
return result; return result;
} }
/* NOTE: Curl_output_basic() should set 'done' TRUE, as the other auth /* NOTE: http_output_basic() should set 'done' TRUE, as the other auth
functions work that way */ functions work that way */
authproxy->done = TRUE; authproxy->done = TRUE;
} }
@ -582,7 +582,7 @@ Curl_http_output_auth(struct connectdata *conn,
if(conn->bits.user_passwd && if(conn->bits.user_passwd &&
!checkheaders(data, "Authorization:")) { !checkheaders(data, "Authorization:")) {
auth="Basic"; auth="Basic";
result = Curl_output_basic(conn, FALSE); result = http_output_basic(conn, FALSE);
if(result) if(result)
return result; return result;
} }
@ -1264,7 +1264,7 @@ CURLcode Curl_proxyCONNECT(struct connectdata *conn,
} }
/* Setup the proxy-authorization header, if any */ /* Setup the proxy-authorization header, if any */
result = Curl_http_output_auth(conn, (char *)"CONNECT", host_port, TRUE); result = http_output_auth(conn, (char *)"CONNECT", host_port, TRUE);
if(CURLE_OK == result) { if(CURLE_OK == result) {
char *host=(char *)""; char *host=(char *)"";
@ -1682,7 +1682,7 @@ CURLcode Curl_http_connect(struct connectdata *conn, bool *done)
if(conn->protocol & PROT_HTTPS) { if(conn->protocol & PROT_HTTPS) {
/* perform SSL initialization */ /* perform SSL initialization */
if(data->state.used_interface == Curl_if_multi) { if(data->state.used_interface == Curl_if_multi) {
result = Curl_https_connecting(conn, done); result = https_connecting(conn, done);
if(result) if(result)
return result; return result;
} }
@ -1701,7 +1701,7 @@ CURLcode Curl_http_connect(struct connectdata *conn, bool *done)
return CURLE_OK; return CURLE_OK;
} }
static CURLcode Curl_https_connecting(struct connectdata *conn, bool *done) static CURLcode https_connecting(struct connectdata *conn, bool *done)
{ {
CURLcode result; CURLcode result;
DEBUGASSERT((conn) && (conn->protocol & PROT_HTTPS)); DEBUGASSERT((conn) && (conn->protocol & PROT_HTTPS));
@ -1717,7 +1717,7 @@ static CURLcode Curl_https_connecting(struct connectdata *conn, bool *done)
#ifdef USE_SSLEAY #ifdef USE_SSLEAY
/* This function is OpenSSL-specific. It should be made to query the generic /* This function is OpenSSL-specific. It should be made to query the generic
SSL layer instead. */ SSL layer instead. */
static int Curl_https_getsock(struct connectdata *conn, static int https_getsock(struct connectdata *conn,
curl_socket_t *socks, curl_socket_t *socks,
int numsocks) int numsocks)
{ {
@ -1742,7 +1742,7 @@ static int Curl_https_getsock(struct connectdata *conn,
} }
#else #else
#ifdef USE_GNUTLS #ifdef USE_GNUTLS
int Curl_https_getsock(struct connectdata *conn, int https_getsock(struct connectdata *conn,
curl_socket_t *socks, curl_socket_t *socks,
int numsocks) int numsocks)
{ {
@ -1753,7 +1753,7 @@ int Curl_https_getsock(struct connectdata *conn,
} }
#else #else
#ifdef USE_NSS #ifdef USE_NSS
int Curl_https_getsock(struct connectdata *conn, int https_getsock(struct connectdata *conn,
curl_socket_t *socks, curl_socket_t *socks,
int numsocks) int numsocks)
{ {
@ -1764,7 +1764,7 @@ int Curl_https_getsock(struct connectdata *conn,
} }
#else #else
#ifdef USE_QSOSSL #ifdef USE_QSOSSL
int Curl_https_getsock(struct connectdata *conn, int https_getsock(struct connectdata *conn,
curl_socket_t *socks, curl_socket_t *socks,
int numsocks) int numsocks)
{ {
@ -1979,7 +1979,7 @@ CURLcode Curl_http(struct connectdata *conn, bool *done)
} }
/* setup the authentication headers */ /* setup the authentication headers */
result = Curl_http_output_auth(conn, request, ppath, FALSE); result = http_output_auth(conn, request, ppath, FALSE);
if(result) if(result)
return result; return result;

6
lib/parsedate.c
View File

@ -84,7 +84,7 @@
#include <curl/curl.h> #include <curl/curl.h>
static time_t Curl_parsedate(const char *date); static time_t parsedate(const char *date);
const char * const Curl_wkday[] = const char * const Curl_wkday[] =
{"Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"}; {"Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"};
@ -223,7 +223,7 @@ enum assume {
DATE_TIME DATE_TIME
}; };
static time_t Curl_parsedate(const char *date) static time_t parsedate(const char *date)
{ {
time_t t = 0; time_t t = 0;
int wdaynum=-1; /* day of the week number, 0-6 (mon-sun) */ int wdaynum=-1; /* day of the week number, 0-6 (mon-sun) */
@ -421,5 +421,5 @@ static time_t Curl_parsedate(const char *date)
time_t curl_getdate(const char *p, const time_t *now) time_t curl_getdate(const char *p, const time_t *now)
{ {
(void)now; (void)now;
return Curl_parsedate(p); return parsedate(p);
} }

10
lib/sendf.c
View File

@ -310,10 +310,10 @@ CURLcode Curl_sendf(curl_socket_t sockfd, struct connectdata *conn,
return res; return res;
} }
static ssize_t Curl_plain_send(struct connectdata *conn, static ssize_t send_plain(struct connectdata *conn,
int num, int num,
void *mem, void *mem,
size_t len) size_t len)
{ {
curl_socket_t sockfd = conn->sock[num]; curl_socket_t sockfd = conn->sock[num];
ssize_t bytes_written = swrite(sockfd, mem, len); ssize_t bytes_written = swrite(sockfd, mem, len);
@ -368,7 +368,7 @@ CURLcode Curl_write(struct connectdata *conn,
/* only TRUE if krb enabled */ /* only TRUE if krb enabled */
bytes_written = Curl_sec_send(conn, num, mem, len); bytes_written = Curl_sec_send(conn, num, mem, len);
else else
bytes_written = Curl_plain_send(conn, num, mem, len); bytes_written = send_plain(conn, num, mem, len);
*written = bytes_written; *written = bytes_written;
retcode = (-1 != bytes_written)?CURLE_OK:CURLE_SEND_ERROR; retcode = (-1 != bytes_written)?CURLE_OK:CURLE_SEND_ERROR;

40
lib/ssluse.c
View File

@ -850,9 +850,9 @@ int Curl_ossl_close_all(struct SessionHandle *data)
return 0; return 0;
} }
static int Curl_ASN1_UTCTIME_output(struct connectdata *conn, static int asn1_output(struct connectdata *conn,
const char *prefix, const char *prefix,
const ASN1_UTCTIME *tm) const ASN1_UTCTIME *tm)
{ {
const char *asn1_string; const char *asn1_string;
int gmt=FALSE; int gmt=FALSE;
@ -1256,8 +1256,8 @@ static void ssl_tls_trace(int direction, int ssl_ver, int content_type,
/* ====================================================== */ /* ====================================================== */
static CURLcode static CURLcode
Curl_ossl_connect_step1(struct connectdata *conn, ossl_connect_step1(struct connectdata *conn,
int sockindex) int sockindex)
{ {
CURLcode retcode = CURLE_OK; CURLcode retcode = CURLE_OK;
@ -1443,8 +1443,8 @@ Curl_ossl_connect_step1(struct connectdata *conn,
} }
static CURLcode static CURLcode
Curl_ossl_connect_step2(struct connectdata *conn, ossl_connect_step2(struct connectdata *conn,
int sockindex, long *timeout_ms) int sockindex, long *timeout_ms)
{ {
struct SessionHandle *data = conn->data; struct SessionHandle *data = conn->data;
int err; int err;
@ -1607,10 +1607,10 @@ static CURLcode servercert(struct connectdata *conn,
CRYPTO_free(str); CRYPTO_free(str);
certdate = X509_get_notBefore(connssl->server_cert); certdate = X509_get_notBefore(connssl->server_cert);
Curl_ASN1_UTCTIME_output(conn, "\t start date: ", certdate); asn1_output(conn, "\t start date: ", certdate);
certdate = X509_get_notAfter(connssl->server_cert); certdate = X509_get_notAfter(connssl->server_cert);
Curl_ASN1_UTCTIME_output(conn, "\t expire date: ", certdate); asn1_output(conn, "\t expire date: ", certdate);
if(data->set.ssl.verifyhost) { if(data->set.ssl.verifyhost) {
retcode = verifyhost(conn, connssl->server_cert); retcode = verifyhost(conn, connssl->server_cert);
@ -1664,8 +1664,8 @@ static CURLcode servercert(struct connectdata *conn,
static CURLcode static CURLcode
Curl_ossl_connect_step3(struct connectdata *conn, ossl_connect_step3(struct connectdata *conn,
int sockindex) int sockindex)
{ {
CURLcode retcode = CURLE_OK; CURLcode retcode = CURLE_OK;
void *ssl_sessionid=NULL; void *ssl_sessionid=NULL;
@ -1724,10 +1724,10 @@ Curl_ossl_connect_step3(struct connectdata *conn,
} }
static CURLcode static CURLcode
Curl_ossl_connect_common(struct connectdata *conn, ossl_connect_common(struct connectdata *conn,
int sockindex, int sockindex,
bool nonblocking, bool nonblocking,
bool *done) bool *done)
{ {
CURLcode retcode; CURLcode retcode;
struct SessionHandle *data = conn->data; struct SessionHandle *data = conn->data;
@ -1736,7 +1736,7 @@ Curl_ossl_connect_common(struct connectdata *conn,
long timeout_ms; long timeout_ms;
if(ssl_connect_1==connssl->connecting_state) { if(ssl_connect_1==connssl->connecting_state) {
retcode = Curl_ossl_connect_step1(conn, sockindex); retcode = ossl_connect_step1(conn, sockindex);
if(retcode) if(retcode)
return retcode; return retcode;
} }
@ -1780,7 +1780,7 @@ Curl_ossl_connect_common(struct connectdata *conn,
} }
/* get the timeout from step2 to avoid computing it twice. */ /* get the timeout from step2 to avoid computing it twice. */
retcode = Curl_ossl_connect_step2(conn, sockindex, &timeout_ms); retcode = ossl_connect_step2(conn, sockindex, &timeout_ms);
if(retcode) if(retcode)
return retcode; return retcode;
@ -1788,7 +1788,7 @@ Curl_ossl_connect_common(struct connectdata *conn,
if(ssl_connect_3==connssl->connecting_state) { if(ssl_connect_3==connssl->connecting_state) {
retcode = Curl_ossl_connect_step3(conn, sockindex); retcode = ossl_connect_step3(conn, sockindex);
if(retcode) if(retcode)
return retcode; return retcode;
} }
@ -1811,7 +1811,7 @@ Curl_ossl_connect_nonblocking(struct connectdata *conn,
int sockindex, int sockindex,
bool *done) bool *done)
{ {
return Curl_ossl_connect_common(conn, sockindex, TRUE, done); return ossl_connect_common(conn, sockindex, TRUE, done);
} }
CURLcode CURLcode
@ -1821,7 +1821,7 @@ Curl_ossl_connect(struct connectdata *conn,
CURLcode retcode; CURLcode retcode;
bool done = FALSE; bool done = FALSE;
retcode = Curl_ossl_connect_common(conn, sockindex, FALSE, &done); retcode = ossl_connect_common(conn, sockindex, FALSE, &done);
if(retcode) if(retcode)
return retcode; return retcode;

12
lib/telnet.c
View File

@ -125,8 +125,8 @@ static void printsub(struct SessionHandle *data,
size_t length); size_t length);
static void suboption(struct connectdata *); static void suboption(struct connectdata *);
static CURLcode Curl_telnet(struct connectdata *conn, bool *done); static CURLcode telnet_do(struct connectdata *conn, bool *done);
static CURLcode Curl_telnet_done(struct connectdata *conn, static CURLcode telnet_done(struct connectdata *conn,
CURLcode, bool premature); CURLcode, bool premature);
/* For negotiation compliant to RFC 1143 */ /* For negotiation compliant to RFC 1143 */
@ -182,8 +182,8 @@ struct TELNET {
const struct Curl_handler Curl_handler_telnet = { const struct Curl_handler Curl_handler_telnet = {
"TELNET", /* scheme */ "TELNET", /* scheme */
ZERO_NULL, /* setup_connection */ ZERO_NULL, /* setup_connection */
Curl_telnet, /* do_it */ telnet_do, /* do_it */
Curl_telnet_done, /* done */ telnet_done, /* done */
ZERO_NULL, /* do_more */ ZERO_NULL, /* do_more */
ZERO_NULL, /* connect_it */ ZERO_NULL, /* connect_it */
ZERO_NULL, /* connecting */ ZERO_NULL, /* connecting */
@ -1117,7 +1117,7 @@ void telrcv(struct connectdata *conn,
bufferflush(); bufferflush();
} }
static CURLcode Curl_telnet_done(struct connectdata *conn, static CURLcode telnet_done(struct connectdata *conn,
CURLcode status, bool premature) CURLcode status, bool premature)
{ {
struct TELNET *tn = (struct TELNET *)conn->data->state.proto.telnet; struct TELNET *tn = (struct TELNET *)conn->data->state.proto.telnet;
@ -1132,7 +1132,7 @@ static CURLcode Curl_telnet_done(struct connectdata *conn,
return CURLE_OK; return CURLE_OK;
} }
static CURLcode Curl_telnet(struct connectdata *conn, bool *done) static CURLcode telnet_do(struct connectdata *conn, bool *done)
{ {
CURLcode code; CURLcode code;
struct SessionHandle *data = conn->data; struct SessionHandle *data = conn->data;

34
lib/tftp.c
View File

@ -151,11 +151,11 @@ typedef struct tftp_state_data {
/* Forward declarations */ /* Forward declarations */
static CURLcode tftp_rx(tftp_state_data_t *state, tftp_event_t event) ; static CURLcode tftp_rx(tftp_state_data_t *state, tftp_event_t event) ;
static CURLcode tftp_tx(tftp_state_data_t *state, tftp_event_t event) ; static CURLcode tftp_tx(tftp_state_data_t *state, tftp_event_t event) ;
static CURLcode Curl_tftp_connect(struct connectdata *conn, bool *done); static CURLcode tftp_connect(struct connectdata *conn, bool *done);
static CURLcode Curl_tftp(struct connectdata *conn, bool *done); static CURLcode tftp_do(struct connectdata *conn, bool *done);
static CURLcode Curl_tftp_done(struct connectdata *conn, static CURLcode tftp_done(struct connectdata *conn,
CURLcode, bool premature); CURLcode, bool premature);
static CURLcode Curl_tftp_setup_connection(struct connectdata * conn); static CURLcode tftp_setup_connection(struct connectdata * conn);
/* /*
@ -164,11 +164,11 @@ static CURLcode Curl_tftp_setup_connection(struct connectdata * conn);
const struct Curl_handler Curl_handler_tftp = { const struct Curl_handler Curl_handler_tftp = {
"TFTP", /* scheme */ "TFTP", /* scheme */
Curl_tftp_setup_connection, /* setup_connection */ tftp_setup_connection, /* setup_connection */
Curl_tftp, /* do_it */ tftp_do, /* do_it */
Curl_tftp_done, /* done */ tftp_done, /* done */
ZERO_NULL, /* do_more */ ZERO_NULL, /* do_more */
Curl_tftp_connect, /* connect_it */ tftp_connect, /* connect_it */
ZERO_NULL, /* connecting */ ZERO_NULL, /* connecting */
ZERO_NULL, /* doing */ ZERO_NULL, /* doing */
ZERO_NULL, /* proto_getsock */ ZERO_NULL, /* proto_getsock */
@ -598,12 +598,12 @@ static CURLcode tftp_state_machine(tftp_state_data_t *state,
/********************************************************** /**********************************************************
* *
* Curl_tftp_connect * tftp_connect
* *
* The connect callback * The connect callback
* *
**********************************************************/ **********************************************************/
static CURLcode Curl_tftp_connect(struct connectdata *conn, bool *done) static CURLcode tftp_connect(struct connectdata *conn, bool *done)
{ {
CURLcode code; CURLcode code;
tftp_state_data_t *state; tftp_state_data_t *state;
@ -665,12 +665,12 @@ static CURLcode Curl_tftp_connect(struct connectdata *conn, bool *done)
/********************************************************** /**********************************************************
* *
* Curl_tftp_done * tftp_done
* *
* The done callback * The done callback
* *
**********************************************************/ **********************************************************/
static CURLcode Curl_tftp_done(struct connectdata *conn, CURLcode status, static CURLcode tftp_done(struct connectdata *conn, CURLcode status,
bool premature) bool premature)
{ {
(void)status; /* unused */ (void)status; /* unused */
@ -684,7 +684,7 @@ static CURLcode Curl_tftp_done(struct connectdata *conn, CURLcode status,
/********************************************************** /**********************************************************
* *
* Curl_tftp * tftp
* *
* The do callback * The do callback
* *
@ -692,7 +692,7 @@ static CURLcode Curl_tftp_done(struct connectdata *conn, CURLcode status,
* *
**********************************************************/ **********************************************************/
static CURLcode Curl_tftp(struct connectdata *conn, bool *done) static CURLcode tftp_do(struct connectdata *conn, bool *done)
{ {
struct SessionHandle *data = conn->data; struct SessionHandle *data = conn->data;
tftp_state_data_t *state; tftp_state_data_t *state;
@ -710,12 +710,12 @@ static CURLcode Curl_tftp(struct connectdata *conn, bool *done)
Since connections can be re-used between SessionHandles, this might be a Since connections can be re-used between SessionHandles, this might be a
connection already existing but on a fresh SessionHandle struct so we must connection already existing but on a fresh SessionHandle struct so we must
make sure we have a good 'struct TFTP' to play with. For new connections, make sure we have a good 'struct TFTP' to play with. For new connections,
the struct TFTP is allocated and setup in the Curl_tftp_connect() function. the struct TFTP is allocated and setup in the tftp_connect() function.
*/ */
Curl_reset_reqproto(conn); Curl_reset_reqproto(conn);
if(!data->state.proto.tftp) { if(!data->state.proto.tftp) {
code = Curl_tftp_connect(conn, done); code = tftp_connect(conn, done);
if(code) if(code)
return code; return code;
} }
@ -864,7 +864,7 @@ static CURLcode Curl_tftp(struct connectdata *conn, bool *done)
return code; return code;
} }
static CURLcode Curl_tftp_setup_connection(struct connectdata * conn) static CURLcode tftp_setup_connection(struct connectdata * conn)
{ {
struct SessionHandle *data = conn->data; struct SessionHandle *data = conn->data;
char * type; char * type;

6
lib/transfer.c
View File

@ -2219,8 +2219,8 @@ CURLcode Curl_follow(struct SessionHandle *data,
} }
static CURLcode static CURLcode
Curl_connect_host(struct SessionHandle *data, connect_host(struct SessionHandle *data,
struct connectdata **conn) struct connectdata **conn)
{ {
CURLcode res = CURLE_OK; CURLcode res = CURLE_OK;
int urlchanged = FALSE; int urlchanged = FALSE;
@ -2327,7 +2327,7 @@ CURLcode Curl_perform(struct SessionHandle *data)
*/ */
do { do {
res = Curl_connect_host(data, &conn); /* primary connection */ res = connect_host(data, &conn); /* primary connection */
if(res == CURLE_OK) { if(res == CURLE_OK) {
bool do_done; bool do_done;

76
lib/url.c
View File

@ -298,7 +298,7 @@ void Curl_freeset(struct SessionHandle * data)
Curl_safefree(data->set.str[i]); Curl_safefree(data->set.str[i]);
} }
static CURLcode Curl_setstropt(char **charp, char * s) static CURLcode setstropt(char **charp, char * s)
{ {
/* Release the previous storage at `charp' and replace by a dynamic storage /* Release the previous storage at `charp' and replace by a dynamic storage
copy of `s'. Return CURLE_OK or CURLE_OUT_OF_MEMORY. */ copy of `s'. Return CURLE_OK or CURLE_OUT_OF_MEMORY. */
@ -334,7 +334,7 @@ CURLcode Curl_dupset(struct SessionHandle * dst, struct SessionHandle * src)
/* duplicate all strings */ /* duplicate all strings */
for(i=(enum dupstring)0; i< STRING_LAST; i++) { for(i=(enum dupstring)0; i< STRING_LAST; i++) {
r = Curl_setstropt(&dst->set.str[i], src->set.str[i]); r = setstropt(&dst->set.str[i], src->set.str[i]);
if(r != CURLE_OK) if(r != CURLE_OK)
break; break;
} }
@ -743,7 +743,7 @@ CURLcode Curl_open(struct SessionHandle **curl)
data->set.ssl.sessionid = TRUE; /* session ID caching enabled by default */ data->set.ssl.sessionid = TRUE; /* session ID caching enabled by default */
#ifdef CURL_CA_BUNDLE #ifdef CURL_CA_BUNDLE
/* This is our preferred CA cert bundle since install time */ /* This is our preferred CA cert bundle since install time */
res = Curl_setstropt(&data->set.str[STRING_SSL_CAFILE], res = setstropt(&data->set.str[STRING_SSL_CAFILE],
(char *) CURL_CA_BUNDLE); (char *) CURL_CA_BUNDLE);
#endif #endif
} }
@ -786,7 +786,7 @@ CURLcode Curl_setopt(struct SessionHandle *data, CURLoption option,
break; break;
case CURLOPT_SSL_CIPHER_LIST: case CURLOPT_SSL_CIPHER_LIST:
/* set a list of cipher we want to use in the SSL connection */ /* set a list of cipher we want to use in the SSL connection */
result = Curl_setstropt(&data->set.str[STRING_SSL_CIPHER_LIST], result = setstropt(&data->set.str[STRING_SSL_CIPHER_LIST],
va_arg(param, char *)); va_arg(param, char *));
break; break;
@ -795,14 +795,14 @@ CURLcode Curl_setopt(struct SessionHandle *data, CURLoption option,
* This is the path name to a file that contains random data to seed * This is the path name to a file that contains random data to seed
* the random SSL stuff with. The file is only used for reading. * the random SSL stuff with. The file is only used for reading.
*/ */
result = Curl_setstropt(&data->set.str[STRING_SSL_RANDOM_FILE], result = setstropt(&data->set.str[STRING_SSL_RANDOM_FILE],
va_arg(param, char *)); va_arg(param, char *));
break; break;
case CURLOPT_EGDSOCKET: case CURLOPT_EGDSOCKET:
/* /*
* The Entropy Gathering Daemon socket pathname * The Entropy Gathering Daemon socket pathname
*/ */
result = Curl_setstropt(&data->set.str[STRING_SSL_EGDSOCKET], result = setstropt(&data->set.str[STRING_SSL_EGDSOCKET],
va_arg(param, char *)); va_arg(param, char *));
break; break;
case CURLOPT_MAXCONNECTS: case CURLOPT_MAXCONNECTS:
@ -926,7 +926,7 @@ CURLcode Curl_setopt(struct SessionHandle *data, CURLoption option,
/* /*
* Use this file instead of the $HOME/.netrc file * Use this file instead of the $HOME/.netrc file
*/ */
result = Curl_setstropt(&data->set.str[STRING_NETRC_FILE], result = setstropt(&data->set.str[STRING_NETRC_FILE],
va_arg(param, char *)); va_arg(param, char *));
break; break;
case CURLOPT_TRANSFERTEXT: case CURLOPT_TRANSFERTEXT:
@ -979,7 +979,7 @@ CURLcode Curl_setopt(struct SessionHandle *data, CURLoption option,
* *
*/ */
argptr = va_arg(param, char *); argptr = va_arg(param, char *);
result = Curl_setstropt(&data->set.str[STRING_ENCODING], result = setstropt(&data->set.str[STRING_ENCODING],
(argptr && !*argptr)? (argptr && !*argptr)?
(char *) ALL_CONTENT_ENCODINGS: argptr); (char *) ALL_CONTENT_ENCODINGS: argptr);
break; break;
@ -1036,7 +1036,7 @@ CURLcode Curl_setopt(struct SessionHandle *data, CURLoption option,
argptr = va_arg(param, char *); argptr = va_arg(param, char *);
if(!argptr || data->set.postfieldsize == -1) if(!argptr || data->set.postfieldsize == -1)
result = Curl_setstropt(&data->set.str[STRING_COPYPOSTFIELDS], argptr); result = setstropt(&data->set.str[STRING_COPYPOSTFIELDS], argptr);
else { else {
/* /*
* Check that requested length does not overflow the size_t type. * Check that requested length does not overflow the size_t type.
@ -1049,7 +1049,7 @@ CURLcode Curl_setopt(struct SessionHandle *data, CURLoption option,
else { else {
char * p; char * p;
(void) Curl_setstropt(&data->set.str[STRING_COPYPOSTFIELDS], NULL); (void) setstropt(&data->set.str[STRING_COPYPOSTFIELDS], NULL);
/* Allocate even when size == 0. This satisfies the need of possible /* Allocate even when size == 0. This satisfies the need of possible
later address compare to detect the COPYPOSTFIELDS mode, and later address compare to detect the COPYPOSTFIELDS mode, and
@ -1079,7 +1079,7 @@ CURLcode Curl_setopt(struct SessionHandle *data, CURLoption option,
*/ */
data->set.postfields = va_arg(param, void *); data->set.postfields = va_arg(param, void *);
/* Release old copied data. */ /* Release old copied data. */
(void) Curl_setstropt(&data->set.str[STRING_COPYPOSTFIELDS], NULL); (void) setstropt(&data->set.str[STRING_COPYPOSTFIELDS], NULL);
data->set.httpreq = HTTPREQ_POST; data->set.httpreq = HTTPREQ_POST;
break; break;
@ -1093,7 +1093,7 @@ CURLcode Curl_setopt(struct SessionHandle *data, CURLoption option,
if(data->set.postfieldsize < bigsize && if(data->set.postfieldsize < bigsize &&
data->set.postfields == data->set.str[STRING_COPYPOSTFIELDS]) { data->set.postfields == data->set.str[STRING_COPYPOSTFIELDS]) {
/* Previous CURLOPT_COPYPOSTFIELDS is no longer valid. */ /* Previous CURLOPT_COPYPOSTFIELDS is no longer valid. */
(void) Curl_setstropt(&data->set.str[STRING_COPYPOSTFIELDS], NULL); (void) setstropt(&data->set.str[STRING_COPYPOSTFIELDS], NULL);
data->set.postfields = NULL; data->set.postfields = NULL;
} }
@ -1110,7 +1110,7 @@ CURLcode Curl_setopt(struct SessionHandle *data, CURLoption option,
if(data->set.postfieldsize < bigsize && if(data->set.postfieldsize < bigsize &&
data->set.postfields == data->set.str[STRING_COPYPOSTFIELDS]) { data->set.postfields == data->set.str[STRING_COPYPOSTFIELDS]) {
/* Previous CURLOPT_COPYPOSTFIELDS is no longer valid. */ /* Previous CURLOPT_COPYPOSTFIELDS is no longer valid. */
(void) Curl_setstropt(&data->set.str[STRING_COPYPOSTFIELDS], NULL); (void) setstropt(&data->set.str[STRING_COPYPOSTFIELDS], NULL);
data->set.postfields = NULL; data->set.postfields = NULL;
} }
@ -1134,7 +1134,7 @@ CURLcode Curl_setopt(struct SessionHandle *data, CURLoption option,
free(data->change.referer); free(data->change.referer);
data->change.referer_alloc = FALSE; data->change.referer_alloc = FALSE;
} }
result = Curl_setstropt(&data->set.str[STRING_SET_REFERER], result = setstropt(&data->set.str[STRING_SET_REFERER],
va_arg(param, char *)); va_arg(param, char *));
data->change.referer = data->set.str[STRING_SET_REFERER]; data->change.referer = data->set.str[STRING_SET_REFERER];
break; break;
@ -1143,7 +1143,7 @@ CURLcode Curl_setopt(struct SessionHandle *data, CURLoption option,
/* /*
* String to use in the HTTP User-Agent field * String to use in the HTTP User-Agent field
*/ */
result = Curl_setstropt(&data->set.str[STRING_USERAGENT], result = setstropt(&data->set.str[STRING_USERAGENT],
va_arg(param, char *)); va_arg(param, char *));
break; break;
@ -1166,7 +1166,7 @@ CURLcode Curl_setopt(struct SessionHandle *data, CURLoption option,
/* /*
* Cookie string to send to the remote server in the request. * Cookie string to send to the remote server in the request.
*/ */
result = Curl_setstropt(&data->set.str[STRING_COOKIE], result = setstropt(&data->set.str[STRING_COOKIE],
va_arg(param, char *)); va_arg(param, char *));
break; break;
@ -1192,7 +1192,7 @@ CURLcode Curl_setopt(struct SessionHandle *data, CURLoption option,
/* /*
* Set cookie file name to dump all cookies to when we're done. * Set cookie file name to dump all cookies to when we're done.
*/ */
result = Curl_setstropt(&data->set.str[STRING_COOKIEJAR], result = setstropt(&data->set.str[STRING_COOKIEJAR],
va_arg(param, char *)); va_arg(param, char *));
/* /*
@ -1296,7 +1296,7 @@ CURLcode Curl_setopt(struct SessionHandle *data, CURLoption option,
/* /*
* Set a custom string to use as request * Set a custom string to use as request
*/ */
result = Curl_setstropt(&data->set.str[STRING_CUSTOMREQUEST], result = setstropt(&data->set.str[STRING_CUSTOMREQUEST],
va_arg(param, char *)); va_arg(param, char *));
/* we don't set /* we don't set
@ -1363,7 +1363,7 @@ CURLcode Curl_setopt(struct SessionHandle *data, CURLoption option,
* Setting it to NULL, means no proxy but allows the environment variables * Setting it to NULL, means no proxy but allows the environment variables
* to decide for us. * to decide for us.
*/ */
result = Curl_setstropt(&data->set.str[STRING_PROXY], result = setstropt(&data->set.str[STRING_PROXY],
va_arg(param, char *)); va_arg(param, char *));
break; break;
@ -1390,7 +1390,7 @@ CURLcode Curl_setopt(struct SessionHandle *data, CURLoption option,
/* /*
* Use FTP PORT, this also specifies which IP address to use * Use FTP PORT, this also specifies which IP address to use
*/ */
result = Curl_setstropt(&data->set.str[STRING_FTPPORT], result = setstropt(&data->set.str[STRING_FTPPORT],
va_arg(param, char *)); va_arg(param, char *));
data->set.ftp_use_port = (bool)(NULL != data->set.str[STRING_FTPPORT]); data->set.ftp_use_port = (bool)(NULL != data->set.str[STRING_FTPPORT]);
break; break;
@ -1475,7 +1475,7 @@ CURLcode Curl_setopt(struct SessionHandle *data, CURLoption option,
free(data->change.url); free(data->change.url);
data->change.url_alloc=FALSE; data->change.url_alloc=FALSE;
} }
result = Curl_setstropt(&data->set.str[STRING_SET_URL], result = setstropt(&data->set.str[STRING_SET_URL],
va_arg(param, char *)); va_arg(param, char *));
data->change.url = data->set.str[STRING_SET_URL]; data->change.url = data->set.str[STRING_SET_URL];
if(data->change.url) if(data->change.url)
@ -1514,7 +1514,7 @@ CURLcode Curl_setopt(struct SessionHandle *data, CURLoption option,
/* /*
* user:password to use in the operation * user:password to use in the operation
*/ */
result = Curl_setstropt(&data->set.str[STRING_USERPWD], result = setstropt(&data->set.str[STRING_USERPWD],
va_arg(param, char *)); va_arg(param, char *));
break; break;
case CURLOPT_POSTQUOTE: case CURLOPT_POSTQUOTE:
@ -1556,14 +1556,14 @@ CURLcode Curl_setopt(struct SessionHandle *data, CURLoption option,
/* /*
* user:password needed to use the proxy * user:password needed to use the proxy
*/ */
result = Curl_setstropt(&data->set.str[STRING_PROXYUSERPWD], result = setstropt(&data->set.str[STRING_PROXYUSERPWD],
va_arg(param, char *)); va_arg(param, char *));
break; break;
case CURLOPT_RANGE: case CURLOPT_RANGE:
/* /*
* What range of the file you want to transfer * What range of the file you want to transfer
*/ */
result = Curl_setstropt(&data->set.str[STRING_SET_RANGE], result = setstropt(&data->set.str[STRING_SET_RANGE],
va_arg(param, char *)); va_arg(param, char *));
break; break;
case CURLOPT_RESUME_FROM: case CURLOPT_RESUME_FROM:
@ -1661,35 +1661,35 @@ CURLcode Curl_setopt(struct SessionHandle *data, CURLoption option,
/* /*
* String that holds file name of the SSL certificate to use * String that holds file name of the SSL certificate to use
*/ */
result = Curl_setstropt(&data->set.str[STRING_CERT], result = setstropt(&data->set.str[STRING_CERT],
va_arg(param, char *)); va_arg(param, char *));
break; break;
case CURLOPT_SSLCERTTYPE: case CURLOPT_SSLCERTTYPE:
/* /*
* String that holds file type of the SSL certificate to use * String that holds file type of the SSL certificate to use
*/ */
result = Curl_setstropt(&data->set.str[STRING_CERT_TYPE], result = setstropt(&data->set.str[STRING_CERT_TYPE],
va_arg(param, char *)); va_arg(param, char *));
break; break;
case CURLOPT_SSLKEY: case CURLOPT_SSLKEY:
/* /*
* String that holds file name of the SSL certificate to use * String that holds file name of the SSL certificate to use
*/ */
result = Curl_setstropt(&data->set.str[STRING_KEY], result = setstropt(&data->set.str[STRING_KEY],
va_arg(param, char *)); va_arg(param, char *));
break; break;
case CURLOPT_SSLKEYTYPE: case CURLOPT_SSLKEYTYPE:
/* /*
* String that holds file type of the SSL certificate to use * String that holds file type of the SSL certificate to use
*/ */
result = Curl_setstropt(&data->set.str[STRING_KEY_TYPE], result = setstropt(&data->set.str[STRING_KEY_TYPE],
va_arg(param, char *)); va_arg(param, char *));
break; break;
case CURLOPT_KEYPASSWD: case CURLOPT_KEYPASSWD:
/* /*
* String that holds the SSL or SSH private key password. * String that holds the SSL or SSH private key password.
*/ */
result = Curl_setstropt(&data->set.str[STRING_KEY_PASSWD], result = setstropt(&data->set.str[STRING_KEY_PASSWD],
va_arg(param, char *)); va_arg(param, char *));
break; break;
case CURLOPT_SSLENGINE: case CURLOPT_SSLENGINE:
@ -1719,7 +1719,7 @@ CURLcode Curl_setopt(struct SessionHandle *data, CURLoption option,
* Set what interface or address/hostname to bind the socket to when * Set what interface or address/hostname to bind the socket to when
* performing an operation and thus what from-IP your connection will use. * performing an operation and thus what from-IP your connection will use.
*/ */
result = Curl_setstropt(&data->set.str[STRING_DEVICE], result = setstropt(&data->set.str[STRING_DEVICE],
va_arg(param, char *)); va_arg(param, char *));
break; break;
case CURLOPT_LOCALPORT: case CURLOPT_LOCALPORT:
@ -1738,7 +1738,7 @@ CURLcode Curl_setopt(struct SessionHandle *data, CURLoption option,
/* /*
* A string that defines the kerberos security level. * A string that defines the kerberos security level.
*/ */
result = Curl_setstropt(&data->set.str[STRING_KRB_LEVEL], result = setstropt(&data->set.str[STRING_KRB_LEVEL],
va_arg(param, char *)); va_arg(param, char *));
data->set.krb = (bool)(NULL != data->set.str[STRING_KRB_LEVEL]); data->set.krb = (bool)(NULL != data->set.str[STRING_KRB_LEVEL]);
break; break;
@ -1770,7 +1770,7 @@ CURLcode Curl_setopt(struct SessionHandle *data, CURLoption option,
/* /*
* Set CA info for SSL connection. Specify file name of the CA certificate * Set CA info for SSL connection. Specify file name of the CA certificate
*/ */
result = Curl_setstropt(&data->set.str[STRING_SSL_CAFILE], result = setstropt(&data->set.str[STRING_SSL_CAFILE],
va_arg(param, char *)); va_arg(param, char *));
break; break;
case CURLOPT_CAPATH: case CURLOPT_CAPATH:
@ -1779,7 +1779,7 @@ CURLcode Curl_setopt(struct SessionHandle *data, CURLoption option,
* certificates which have been prepared using openssl c_rehash utility. * certificates which have been prepared using openssl c_rehash utility.
*/ */
/* This does not work on windows. */ /* This does not work on windows. */
result = Curl_setstropt(&data->set.str[STRING_SSL_CAPATH], result = setstropt(&data->set.str[STRING_SSL_CAPATH],
va_arg(param, char *)); va_arg(param, char *));
break; break;
case CURLOPT_TELNETOPTIONS: case CURLOPT_TELNETOPTIONS:
@ -1929,7 +1929,7 @@ CURLcode Curl_setopt(struct SessionHandle *data, CURLoption option,
These former 3rd party transfer options are deprecated */ These former 3rd party transfer options are deprecated */
case CURLOPT_FTP_ACCOUNT: case CURLOPT_FTP_ACCOUNT:
result = Curl_setstropt(&data->set.str[STRING_FTP_ACCOUNT], result = setstropt(&data->set.str[STRING_FTP_ACCOUNT],
va_arg(param, char *)); va_arg(param, char *));
break; break;
@ -1945,7 +1945,7 @@ CURLcode Curl_setopt(struct SessionHandle *data, CURLoption option,
break; break;
case CURLOPT_FTP_ALTERNATIVE_TO_USER: case CURLOPT_FTP_ALTERNATIVE_TO_USER:
result = Curl_setstropt(&data->set.str[STRING_FTP_ALTERNATIVE_TO_USER], result = setstropt(&data->set.str[STRING_FTP_ALTERNATIVE_TO_USER],
va_arg(param, char *)); va_arg(param, char *));
break; break;
@ -1990,7 +1990,7 @@ CURLcode Curl_setopt(struct SessionHandle *data, CURLoption option,
/* /*
* Use this file instead of the $HOME/.ssh/id_dsa.pub file * Use this file instead of the $HOME/.ssh/id_dsa.pub file
*/ */
result = Curl_setstropt(&data->set.str[STRING_SSH_PUBLIC_KEY], result = setstropt(&data->set.str[STRING_SSH_PUBLIC_KEY],
va_arg(param, char *)); va_arg(param, char *));
break; break;
@ -1998,7 +1998,7 @@ CURLcode Curl_setopt(struct SessionHandle *data, CURLoption option,
/* /*
* Use this file instead of the $HOME/.ssh/id_dsa file * Use this file instead of the $HOME/.ssh/id_dsa file
*/ */
result = Curl_setstropt(&data->set.str[STRING_SSH_PRIVATE_KEY], result = setstropt(&data->set.str[STRING_SSH_PRIVATE_KEY],
va_arg(param, char *)); va_arg(param, char *));
break; break;
case CURLOPT_SSH_HOST_PUBLIC_KEY_MD5: case CURLOPT_SSH_HOST_PUBLIC_KEY_MD5:
@ -2006,7 +2006,7 @@ CURLcode Curl_setopt(struct SessionHandle *data, CURLoption option,
* Option to allow for the MD5 of the host public key to be checked * Option to allow for the MD5 of the host public key to be checked
* for validation purposes. * for validation purposes.
*/ */
result = Curl_setstropt(&data->set.str[STRING_SSH_HOST_PUBLIC_KEY_MD5], result = setstropt(&data->set.str[STRING_SSH_HOST_PUBLIC_KEY_MD5],
va_arg(param, char *)); va_arg(param, char *));
break; break;
case CURLOPT_HTTP_TRANSFER_DECODING: case CURLOPT_HTTP_TRANSFER_DECODING: