mirror/curl
2
0
Fork 0
mirror of https://github.com/curl/curl.git synced 2025-04-24 16:40:32 +08:00
Code Issues Packages Projects Releases Wiki Activity

curl.h: remove the struct pointer for CURL/CURLSH/CURLM typedefs

Browse Source 
It makes the callbacks get different signnatures when used from within
libcurl vs outside of it by libcurl-using applications (such as the
libtests) and this triggers UndefinedBehaviorSanitizer errors.

Closes #15289
This commit is contained in:
Daniel Stenberg 2024-10-14 14:09:59 +02:00
parent ad1c49bc0e
commit eed3c8f4b7
No known key found for this signature in database
GPG Key ID: 5CC908FDB71E12C2
15 changed files with 98 additions and 74 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
include/curl/curl.h
View File

@ -30,7 +30,7 @@
*/ */
#ifdef CURL_NO_OLDIES #ifdef CURL_NO_OLDIES
#define CURL_STRICTER #define CURL_STRICTER /* not used since 8.11.0 */
#endif #endif
/* Compile-time deprecation macros. */ /* Compile-time deprecation macros. */
@ -114,13 +114,8 @@
extern "C" { extern "C" {
#endif #endif
#if defined(BUILDING_LIBCURL) || defined(CURL_STRICTER)
typedef struct Curl_easy CURL;
typedef struct Curl_share CURLSH;
#else
typedef void CURL; typedef void CURL;
typedef void CURLSH; typedef void CURLSH;
#endif
/* /*
* libcurl external API function linkage decorations. * libcurl external API function linkage decorations.

4
include/curl/multi.h
View File

@ -54,11 +54,7 @@
extern "C" { extern "C" {
#endif #endif
#if defined(BUILDING_LIBCURL) || defined(CURL_STRICTER)
typedef struct Curl_multi CURLM;
#else
typedef void CURLM; typedef void CURLM;
#endif
typedef enum { typedef enum {
CURLM_CALL_MULTI_PERFORM = -1, /* please call curl_multi_perform() or CURLM_CALL_MULTI_PERFORM = -1, /* please call curl_multi_perform() or

18
lib/doh.c
View File

@ -238,14 +238,14 @@ static int doh_done(struct Curl_easy *doh, CURLcode result)
return 0; return 0;
} }
#define ERROR_CHECK_SETOPT(x,y) \ #define ERROR_CHECK_SETOPT(x,y) \
do { \ do { \
result = curl_easy_setopt(doh, x, y); \ result = curl_easy_setopt((CURL *)doh, x, y); \
if(result && \ if(result && \
result != CURLE_NOT_BUILT_IN && \ result != CURLE_NOT_BUILT_IN && \
result != CURLE_UNKNOWN_OPTION) \ result != CURLE_UNKNOWN_OPTION) \
goto error; \ goto error; \
} while(0) } while(0)
static CURLcode doh_run_probe(struct Curl_easy *data, static CURLcode doh_run_probe(struct Curl_easy *data,
struct doh_probe *p, DNStype dnstype, struct doh_probe *p, DNStype dnstype,
@ -301,7 +301,7 @@ static CURLcode doh_run_probe(struct Curl_easy *data,
ERROR_CHECK_SETOPT(CURLOPT_PROTOCOLS, CURLPROTO_HTTP|CURLPROTO_HTTPS); ERROR_CHECK_SETOPT(CURLOPT_PROTOCOLS, CURLPROTO_HTTP|CURLPROTO_HTTPS);
#endif #endif
ERROR_CHECK_SETOPT(CURLOPT_TIMEOUT_MS, (long)timeout_ms); ERROR_CHECK_SETOPT(CURLOPT_TIMEOUT_MS, (long)timeout_ms);
ERROR_CHECK_SETOPT(CURLOPT_SHARE, data->share); ERROR_CHECK_SETOPT(CURLOPT_SHARE, (CURLSH *)data->share);
if(data->set.err && data->set.err != stderr) if(data->set.err && data->set.err != stderr)
ERROR_CHECK_SETOPT(CURLOPT_STDERR, data->set.err); ERROR_CHECK_SETOPT(CURLOPT_STDERR, data->set.err);
if(Curl_trc_ft_is_verbose(data, &Curl_doh_trc)) if(Curl_trc_ft_is_verbose(data, &Curl_doh_trc))

29
lib/easy.c
View File

@ -347,7 +347,7 @@ CURLsslset curl_global_sslset(curl_sslbackend id, const char *name,
* curl_easy_init() is the external interface to alloc, setup and init an * curl_easy_init() is the external interface to alloc, setup and init an
* easy handle that is returned. If anything goes wrong, NULL is returned. * easy handle that is returned. If anything goes wrong, NULL is returned.
*/ */
struct Curl_easy *curl_easy_init(void) CURL *curl_easy_init(void)
{ {
CURLcode result; CURLcode result;
struct Curl_easy *data; struct Curl_easy *data;
@ -809,7 +809,7 @@ static CURLcode easy_perform(struct Curl_easy *data, bool events)
* curl_easy_perform() is the external interface that performs a blocking * curl_easy_perform() is the external interface that performs a blocking
* transfer as previously setup. * transfer as previously setup.
*/ */
CURLcode curl_easy_perform(struct Curl_easy *data) CURLcode curl_easy_perform(CURL *data)
{ {
return easy_perform(data, FALSE); return easy_perform(data, FALSE);
} }
@ -830,8 +830,9 @@ CURLcode curl_easy_perform_ev(struct Curl_easy *data)
* curl_easy_cleanup() is the external interface to cleaning/freeing the given * curl_easy_cleanup() is the external interface to cleaning/freeing the given
* easy handle. * easy handle.
*/ */
void curl_easy_cleanup(struct Curl_easy *data) void curl_easy_cleanup(CURL *ptr)
{ {
struct Curl_easy *data = ptr;
if(GOOD_EASY_HANDLE(data)) { if(GOOD_EASY_HANDLE(data)) {
SIGPIPE_VARIABLE(pipe_st); SIGPIPE_VARIABLE(pipe_st);
sigpipe_ignore(data, &pipe_st); sigpipe_ignore(data, &pipe_st);
@ -845,7 +846,7 @@ void curl_easy_cleanup(struct Curl_easy *data)
* information from a performed transfer and similar. * information from a performed transfer and similar.
*/ */
#undef curl_easy_getinfo #undef curl_easy_getinfo
CURLcode curl_easy_getinfo(struct Curl_easy *data, CURLINFO info, ...) CURLcode curl_easy_getinfo(CURL *data, CURLINFO info, ...)
{ {
va_list arg; va_list arg;
void *paramp; void *paramp;
@ -919,8 +920,9 @@ static CURLcode dupset(struct Curl_easy *dst, struct Curl_easy *src)
* given input easy handle. The returned handle will be a new working handle * given input easy handle. The returned handle will be a new working handle
* with all options set exactly as the input source handle. * with all options set exactly as the input source handle.
*/ */
struct Curl_easy *curl_easy_duphandle(struct Curl_easy *data) CURL *curl_easy_duphandle(CURL *d)
{ {
struct Curl_easy *data = d;
struct Curl_easy *outcurl = calloc(1, sizeof(struct Curl_easy)); struct Curl_easy *outcurl = calloc(1, sizeof(struct Curl_easy));
if(!outcurl) if(!outcurl)
goto fail; goto fail;
@ -1066,8 +1068,9 @@ fail:
* curl_easy_reset() is an external interface that allows an app to re- * curl_easy_reset() is an external interface that allows an app to re-
* initialize a session handle to the default values. * initialize a session handle to the default values.
*/ */
void curl_easy_reset(struct Curl_easy *data) void curl_easy_reset(CURL *d)
{ {
struct Curl_easy *data = d;
Curl_req_hard_reset(&data->req, data); Curl_req_hard_reset(&data->req, data);
/* zero out UserDefined data: */ /* zero out UserDefined data: */
@ -1107,7 +1110,7 @@ void curl_easy_reset(struct Curl_easy *data)
* NOTE: This is one of few API functions that are allowed to be called from * NOTE: This is one of few API functions that are allowed to be called from
* within a callback. * within a callback.
*/ */
CURLcode curl_easy_pause(struct Curl_easy *data, int action) CURLcode curl_easy_pause(CURL *d, int action)
{ {
struct SingleRequest *k; struct SingleRequest *k;
CURLcode result = CURLE_OK; CURLcode result = CURLE_OK;
@ -1115,6 +1118,7 @@ CURLcode curl_easy_pause(struct Curl_easy *data, int action)
int newstate; int newstate;
bool recursive = FALSE; bool recursive = FALSE;
bool keep_changed, unpause_read, not_all_paused; bool keep_changed, unpause_read, not_all_paused;
struct Curl_easy *data = d;
if(!GOOD_EASY_HANDLE(data) || !data->conn) if(!GOOD_EASY_HANDLE(data) || !data->conn)
/* crazy input, do not continue */ /* crazy input, do not continue */
@ -1218,12 +1222,12 @@ static CURLcode easy_connection(struct Curl_easy *data,
* curl_easy_perform() with CURLOPT_CONNECT_ONLY option. * curl_easy_perform() with CURLOPT_CONNECT_ONLY option.
* Returns CURLE_OK on success, error code on error. * Returns CURLE_OK on success, error code on error.
*/ */
CURLcode curl_easy_recv(struct Curl_easy *data, void *buffer, size_t buflen, CURLcode curl_easy_recv(CURL *d, void *buffer, size_t buflen, size_t *n)
size_t *n)
{ {
CURLcode result; CURLcode result;
ssize_t n1; ssize_t n1;
struct connectdata *c; struct connectdata *c;
struct Curl_easy *data = d;
if(Curl_is_in_callback(data)) if(Curl_is_in_callback(data))
return CURLE_RECURSIVE_API_CALL; return CURLE_RECURSIVE_API_CALL;
@ -1301,11 +1305,11 @@ CURLcode Curl_senddata(struct Curl_easy *data, const void *buffer,
* Sends data over the connected socket. Use after successful * Sends data over the connected socket. Use after successful
* curl_easy_perform() with CURLOPT_CONNECT_ONLY option. * curl_easy_perform() with CURLOPT_CONNECT_ONLY option.
*/ */
CURLcode curl_easy_send(struct Curl_easy *data, const void *buffer, CURLcode curl_easy_send(CURL *d, const void *buffer, size_t buflen, size_t *n)
size_t buflen, size_t *n)
{ {
size_t written = 0; size_t written = 0;
CURLcode result; CURLcode result;
struct Curl_easy *data = d;
if(Curl_is_in_callback(data)) if(Curl_is_in_callback(data))
return CURLE_RECURSIVE_API_CALL; return CURLE_RECURSIVE_API_CALL;
@ -1317,8 +1321,9 @@ CURLcode curl_easy_send(struct Curl_easy *data, const void *buffer,
/* /*
* Performs connection upkeep for the given session handle. * Performs connection upkeep for the given session handle.
*/ */
CURLcode curl_easy_upkeep(struct Curl_easy *data) CURLcode curl_easy_upkeep(CURL *d)
{ {
struct Curl_easy *data = d;
/* Verify that we got an easy handle we can work with. */ /* Verify that we got an easy handle we can work with. */
if(!GOOD_EASY_HANDLE(data)) if(!GOOD_EASY_HANDLE(data))
return CURLE_BAD_FUNCTION_ARGUMENT; return CURLE_BAD_FUNCTION_ARGUMENT;

6
lib/escape.c
View File

@ -29,6 +29,8 @@
#include <curl/curl.h> #include <curl/curl.h>
struct Curl_easy;
#include "urldata.h" #include "urldata.h"
#include "warnless.h" #include "warnless.h"
#include "escape.h" #include "escape.h"
@ -53,7 +55,7 @@ char *curl_unescape(const char *string, int length)
/* Escapes for URL the given unescaped string of given length. /* Escapes for URL the given unescaped string of given length.
* 'data' is ignored since 7.82.0. * 'data' is ignored since 7.82.0.
*/ */
char *curl_easy_escape(struct Curl_easy *data, const char *string, char *curl_easy_escape(CURL *data, const char *string,
int inlength) int inlength)
{ {
size_t length; size_t length;
@ -176,7 +178,7 @@ CURLcode Curl_urldecode(const char *string, size_t length,
* If olen == NULL, no output length is stored. * If olen == NULL, no output length is stored.
* 'data' is ignored since 7.82.0. * 'data' is ignored since 7.82.0.
*/ */
char *curl_easy_unescape(struct Curl_easy *data, const char *string, char *curl_easy_unescape(CURL *data, const char *string,
int length, int *olen) int length, int *olen)
{ {
char *str = NULL; char *str = NULL;

4
lib/formdata.c
View File

@ -26,6 +26,8 @@
#include <curl/curl.h> #include <curl/curl.h>
struct Curl_easy;
#include "formdata.h" #include "formdata.h"
#if !defined(CURL_DISABLE_HTTP) && !defined(CURL_DISABLE_FORM_API) #if !defined(CURL_DISABLE_HTTP) && !defined(CURL_DISABLE_FORM_API)
@ -812,7 +814,7 @@ static int fseeko_wrapper(void *stream, curl_off_t offset, int whence)
* a NULL pointer in the 'data' argument. * a NULL pointer in the 'data' argument.
*/ */
CURLcode Curl_getformdata(struct Curl_easy *data, CURLcode Curl_getformdata(CURL *data,
curl_mimepart *finalform, curl_mimepart *finalform,
struct curl_httppost *post, struct curl_httppost *post,
curl_read_callback fread_func) curl_read_callback fread_func)

2
lib/formdata.h
View File

@ -49,7 +49,7 @@ struct FormInfo {
bool showfilename_alloc; bool showfilename_alloc;
}; };
CURLcode Curl_getformdata(struct Curl_easy *data, CURLcode Curl_getformdata(CURL *data,
curl_mimepart *, curl_mimepart *,
struct curl_httppost *post, struct curl_httppost *post,
curl_read_callback fread_func); curl_read_callback fread_func);

4
lib/mime.c
View File

@ -26,6 +26,8 @@
#include <curl/curl.h> #include <curl/curl.h>
struct Curl_easy;
#include "mime.h" #include "mime.h"
#include "warnless.h" #include "warnless.h"
#include "urldata.h" #include "urldata.h"
@ -1279,7 +1281,7 @@ CURLcode Curl_mime_duppart(struct Curl_easy *data,
*/ */
/* Create a mime handle. */ /* Create a mime handle. */
curl_mime *curl_mime_init(struct Curl_easy *easy) curl_mime *curl_mime_init(void *easy)
{ {
curl_mime *mime; curl_mime *mime;

64
lib/multi.c
View File

@ -451,7 +451,7 @@ error:
return NULL; return NULL;
} }
struct Curl_multi *curl_multi_init(void) CURLM *curl_multi_init(void)
{ {
return Curl_multi_handle(CURL_SOCKET_HASH_TABLE_SIZE, return Curl_multi_handle(CURL_SOCKET_HASH_TABLE_SIZE,
CURL_CONNECTION_HASH_SIZE, CURL_CONNECTION_HASH_SIZE,
@ -472,10 +472,11 @@ static void multi_warn_debug(struct Curl_multi *multi, struct Curl_easy *data)
#define multi_warn_debug(x,y) Curl_nop_stmt #define multi_warn_debug(x,y) Curl_nop_stmt
#endif #endif
CURLMcode curl_multi_add_handle(struct Curl_multi *multi, CURLMcode curl_multi_add_handle(CURLM *m, CURL *d)
struct Curl_easy *data)
{ {
CURLMcode rc; CURLMcode rc;
struct Curl_multi *multi = m;
struct Curl_easy *data = d;
/* First, make some basic checks that the CURLM handle is a good handle */ /* First, make some basic checks that the CURLM handle is a good handle */
if(!GOOD_MULTI_HANDLE(multi)) if(!GOOD_MULTI_HANDLE(multi))
return CURLM_BAD_HANDLE; return CURLM_BAD_HANDLE;
@ -772,10 +773,10 @@ static void close_connect_only(struct connectdata *conn,
connclose(conn, "Removing connect-only easy handle"); connclose(conn, "Removing connect-only easy handle");
} }
CURLMcode curl_multi_remove_handle(struct Curl_multi *multi, CURLMcode curl_multi_remove_handle(CURLM *m, CURL *d)
struct Curl_easy *data)
{ {
struct Curl_easy *easy = data; struct Curl_multi *multi = m;
struct Curl_easy *data = d;
bool premature; bool premature;
struct Curl_llist_node *e; struct Curl_llist_node *e;
CURLMcode rc; CURLMcode rc;
@ -850,7 +851,7 @@ CURLMcode curl_multi_remove_handle(struct Curl_multi *multi,
/* This ignores the return code even in case of problems because there is /* This ignores the return code even in case of problems because there is
nothing more to do about that, here */ nothing more to do about that, here */
(void)singlesocket(multi, easy); /* to let the application know what sockets (void)singlesocket(multi, data); /* to let the application know what sockets
that vanish with this handle */ that vanish with this handle */
/* Remove the association between the connection and the handle */ /* Remove the association between the connection and the handle */
@ -890,7 +891,7 @@ CURLMcode curl_multi_remove_handle(struct Curl_multi *multi,
for(e = Curl_llist_head(&multi->msglist); e; e = Curl_node_next(e)) { for(e = Curl_llist_head(&multi->msglist); e; e = Curl_node_next(e)) {
struct Curl_message *msg = Curl_node_elem(e); struct Curl_message *msg = Curl_node_elem(e);
if(msg->extmsg.easy_handle == easy) { if(msg->extmsg.easy_handle == data) {
Curl_node_remove(e); Curl_node_remove(e);
/* there can only be one from this specific handle */ /* there can only be one from this specific handle */
break; break;
@ -1141,7 +1142,7 @@ static void multi_getsock(struct Curl_easy *data,
} }
} }
CURLMcode curl_multi_fdset(struct Curl_multi *multi, CURLMcode curl_multi_fdset(CURLM *m,
fd_set *read_fd_set, fd_set *write_fd_set, fd_set *read_fd_set, fd_set *write_fd_set,
fd_set *exc_fd_set, int *max_fd) fd_set *exc_fd_set, int *max_fd)
{ {
@ -1150,6 +1151,7 @@ CURLMcode curl_multi_fdset(struct Curl_multi *multi,
and then we must make sure that is done. */ and then we must make sure that is done. */
int this_max_fd = -1; int this_max_fd = -1;
struct Curl_llist_node *e; struct Curl_llist_node *e;
struct Curl_multi *multi = m;
(void)exc_fd_set; /* not used */ (void)exc_fd_set; /* not used */
if(!GOOD_MULTI_HANDLE(multi)) if(!GOOD_MULTI_HANDLE(multi))
@ -1182,7 +1184,7 @@ CURLMcode curl_multi_fdset(struct Curl_multi *multi,
return CURLM_OK; return CURLM_OK;
} }
CURLMcode curl_multi_waitfds(struct Curl_multi *multi, CURLMcode curl_multi_waitfds(CURLM *m,
struct curl_waitfd *ufds, struct curl_waitfd *ufds,
unsigned int size, unsigned int size,
unsigned int *fd_count) unsigned int *fd_count)
@ -1190,6 +1192,7 @@ CURLMcode curl_multi_waitfds(struct Curl_multi *multi,
struct curl_waitfds cwfds; struct curl_waitfds cwfds;
CURLMcode result = CURLM_OK; CURLMcode result = CURLM_OK;
struct Curl_llist_node *e; struct Curl_llist_node *e;
struct Curl_multi *multi = m;
if(!ufds) if(!ufds)
return CURLM_BAD_FUNCTION_ARGUMENT; return CURLM_BAD_FUNCTION_ARGUMENT;
@ -1487,7 +1490,7 @@ out:
return result; return result;
} }
CURLMcode curl_multi_wait(struct Curl_multi *multi, CURLMcode curl_multi_wait(CURLM *multi,
struct curl_waitfd extra_fds[], struct curl_waitfd extra_fds[],
unsigned int extra_nfds, unsigned int extra_nfds,
int timeout_ms, int timeout_ms,
@ -1497,7 +1500,7 @@ CURLMcode curl_multi_wait(struct Curl_multi *multi,
FALSE); FALSE);
} }
CURLMcode curl_multi_poll(struct Curl_multi *multi, CURLMcode curl_multi_poll(CURLM *multi,
struct curl_waitfd extra_fds[], struct curl_waitfd extra_fds[],
unsigned int extra_nfds, unsigned int extra_nfds,
int timeout_ms, int timeout_ms,
@ -1507,11 +1510,12 @@ CURLMcode curl_multi_poll(struct Curl_multi *multi,
TRUE); TRUE);
} }
CURLMcode curl_multi_wakeup(struct Curl_multi *multi) CURLMcode curl_multi_wakeup(CURLM *m)
{ {
/* this function is usually called from another thread, /* this function is usually called from another thread,
it has to be careful only to access parts of the it has to be careful only to access parts of the
Curl_multi struct that are constant */ Curl_multi struct that are constant */
struct Curl_multi *multi = m;
#if defined(ENABLE_WAKEUP) && !defined(USE_WINSOCK) #if defined(ENABLE_WAKEUP) && !defined(USE_WINSOCK)
#ifdef USE_EVENTFD #ifdef USE_EVENTFD
@ -2922,13 +2926,14 @@ statemachine_end:
} }
CURLMcode curl_multi_perform(struct Curl_multi *multi, int *running_handles) CURLMcode curl_multi_perform(CURLM *m, int *running_handles)
{ {
CURLMcode returncode = CURLM_OK; CURLMcode returncode = CURLM_OK;
struct Curl_tree *t = NULL; struct Curl_tree *t = NULL;
struct curltime now = Curl_now(); struct curltime now = Curl_now();
struct Curl_llist_node *e; struct Curl_llist_node *e;
struct Curl_llist_node *n = NULL; struct Curl_llist_node *n = NULL;
struct Curl_multi *multi = m;
SIGPIPE_VARIABLE(pipe_st); SIGPIPE_VARIABLE(pipe_st);
if(!GOOD_MULTI_HANDLE(multi)) if(!GOOD_MULTI_HANDLE(multi))
@ -3014,8 +3019,9 @@ static void unlink_all_msgsent_handles(struct Curl_multi *multi)
} }
} }
CURLMcode curl_multi_cleanup(struct Curl_multi *multi) CURLMcode curl_multi_cleanup(CURLM *m)
{ {
struct Curl_multi *multi = m;
if(GOOD_MULTI_HANDLE(multi)) { if(GOOD_MULTI_HANDLE(multi)) {
struct Curl_llist_node *e; struct Curl_llist_node *e;
struct Curl_llist_node *n; struct Curl_llist_node *n;
@ -3091,9 +3097,10 @@ CURLMcode curl_multi_cleanup(struct Curl_multi *multi)
* beyond. The current design is fully O(1). * beyond. The current design is fully O(1).
*/ */
CURLMsg *curl_multi_info_read(struct Curl_multi *multi, int *msgs_in_queue) CURLMsg *curl_multi_info_read(CURLM *m, int *msgs_in_queue)
{ {
struct Curl_message *msg; struct Curl_message *msg;
struct Curl_multi *multi = m;
*msgs_in_queue = 0; /* default to none */ *msgs_in_queue = 0; /* default to none */
@ -3556,12 +3563,13 @@ out:
} }
#undef curl_multi_setopt #undef curl_multi_setopt
CURLMcode curl_multi_setopt(struct Curl_multi *multi, CURLMcode curl_multi_setopt(CURLM *m,
CURLMoption option, ...) CURLMoption option, ...)
{ {
CURLMcode res = CURLM_OK; CURLMcode res = CURLM_OK;
va_list param; va_list param;
unsigned long uarg; unsigned long uarg;
struct Curl_multi *multi = m;
if(!GOOD_MULTI_HANDLE(multi)) if(!GOOD_MULTI_HANDLE(multi))
return CURLM_BAD_HANDLE; return CURLM_BAD_HANDLE;
@ -3637,24 +3645,26 @@ CURLMcode curl_multi_setopt(struct Curl_multi *multi,
/* we define curl_multi_socket() in the public multi.h header */ /* we define curl_multi_socket() in the public multi.h header */
#undef curl_multi_socket #undef curl_multi_socket
CURLMcode curl_multi_socket(struct Curl_multi *multi, curl_socket_t s, CURLMcode curl_multi_socket(CURLM *m, curl_socket_t s, int *running_handles)
int *running_handles)
{ {
struct Curl_multi *multi = m;
if(multi->in_callback) if(multi->in_callback)
return CURLM_RECURSIVE_API_CALL; return CURLM_RECURSIVE_API_CALL;
return multi_socket(multi, FALSE, s, 0, running_handles); return multi_socket(multi, FALSE, s, 0, running_handles);
} }
CURLMcode curl_multi_socket_action(struct Curl_multi *multi, curl_socket_t s, CURLMcode curl_multi_socket_action(CURLM *m, curl_socket_t s,
int ev_bitmask, int *running_handles) int ev_bitmask, int *running_handles)
{ {
struct Curl_multi *multi = m;
if(multi->in_callback) if(multi->in_callback)
return CURLM_RECURSIVE_API_CALL; return CURLM_RECURSIVE_API_CALL;
return multi_socket(multi, FALSE, s, ev_bitmask, running_handles); return multi_socket(multi, FALSE, s, ev_bitmask, running_handles);
} }
CURLMcode curl_multi_socket_all(struct Curl_multi *multi, int *running_handles) CURLMcode curl_multi_socket_all(CURLM *m, int *running_handles)
{ {
struct Curl_multi *multi = m;
if(multi->in_callback) if(multi->in_callback)
return CURLM_RECURSIVE_API_CALL; return CURLM_RECURSIVE_API_CALL;
return multi_socket(multi, TRUE, CURL_SOCKET_BAD, 0, running_handles); return multi_socket(multi, TRUE, CURL_SOCKET_BAD, 0, running_handles);
@ -3704,10 +3714,11 @@ static CURLMcode multi_timeout(struct Curl_multi *multi,
return CURLM_OK; return CURLM_OK;
} }
CURLMcode curl_multi_timeout(struct Curl_multi *multi, CURLMcode curl_multi_timeout(CURLM *m,
long *timeout_ms) long *timeout_ms)
{ {
struct curltime expire_time; struct curltime expire_time;
struct Curl_multi *multi = m;
/* First, make some basic checks that the CURLM handle is a good handle */ /* First, make some basic checks that the CURLM handle is a good handle */
if(!GOOD_MULTI_HANDLE(multi)) if(!GOOD_MULTI_HANDLE(multi))
@ -3984,10 +3995,11 @@ bool Curl_expire_clear(struct Curl_easy *data)
return FALSE; return FALSE;
} }
CURLMcode curl_multi_assign(struct Curl_multi *multi, curl_socket_t s, CURLMcode curl_multi_assign(CURLM *m, curl_socket_t s,
void *hashp) void *hashp)
{ {
struct Curl_sh_entry *there = NULL; struct Curl_sh_entry *there = NULL;
struct Curl_multi *multi = m;
if(!GOOD_MULTI_HANDLE(multi)) if(!GOOD_MULTI_HANDLE(multi))
return CURLM_BAD_HANDLE; return CURLM_BAD_HANDLE;
@ -4058,10 +4070,10 @@ unsigned int Curl_multi_max_concurrent_streams(struct Curl_multi *multi)
return multi->max_concurrent_streams; return multi->max_concurrent_streams;
} }
struct Curl_easy **curl_multi_get_handles(struct Curl_multi *multi) CURL **curl_multi_get_handles(CURLM *m)
{ {
struct Curl_easy **a = malloc(sizeof(struct Curl_easy *) * struct Curl_multi *multi = m;
(multi->num_easy + 1)); CURL **a = malloc(sizeof(struct Curl_easy *) * (multi->num_easy + 1));
if(a) { if(a) {
unsigned int i = 0; unsigned int i = 0;
struct Curl_llist_node *e; struct Curl_llist_node *e;

2
lib/psl.h
View File

@ -27,6 +27,8 @@
#ifdef USE_LIBPSL #ifdef USE_LIBPSL
#include <libpsl.h> #include <libpsl.h>
struct Curl_easy;
#define PSL_TTL (72 * 3600) /* PSL time to live before a refresh. */ #define PSL_TTL (72 * 3600) /* PSL time to live before a refresh. */
struct PslCache { struct PslCache {

3
lib/setopt.c
View File

@ -3213,10 +3213,11 @@ CURLcode Curl_vsetopt(struct Curl_easy *data, CURLoption option, va_list param)
*/ */
#undef curl_easy_setopt #undef curl_easy_setopt
CURLcode curl_easy_setopt(struct Curl_easy *data, CURLoption tag, ...) CURLcode curl_easy_setopt(CURL *d, CURLoption tag, ...)
{ {
va_list arg; va_list arg;
CURLcode result; CURLcode result;
struct Curl_easy *data = d;
if(!data) if(!data)
return CURLE_BAD_FUNCTION_ARGUMENT; return CURLE_BAD_FUNCTION_ARGUMENT;

8
lib/share.c
View File

@ -38,7 +38,7 @@
#include "curl_memory.h" #include "curl_memory.h"
#include "memdebug.h" #include "memdebug.h"
struct Curl_share * CURLSH *
curl_share_init(void) curl_share_init(void)
{ {
struct Curl_share *share = calloc(1, sizeof(struct Curl_share)); struct Curl_share *share = calloc(1, sizeof(struct Curl_share));
@ -53,7 +53,7 @@ curl_share_init(void)
#undef curl_share_setopt #undef curl_share_setopt
CURLSHcode CURLSHcode
curl_share_setopt(struct Curl_share *share, CURLSHoption option, ...) curl_share_setopt(CURLSH *sh, CURLSHoption option, ...)
{ {
va_list param; va_list param;
int type; int type;
@ -61,6 +61,7 @@ curl_share_setopt(struct Curl_share *share, CURLSHoption option, ...)
curl_unlock_function unlockfunc; curl_unlock_function unlockfunc;
void *ptr; void *ptr;
CURLSHcode res = CURLSHE_OK; CURLSHcode res = CURLSHE_OK;
struct Curl_share *share = sh;
if(!GOOD_SHARE_HANDLE(share)) if(!GOOD_SHARE_HANDLE(share))
return CURLSHE_INVALID; return CURLSHE_INVALID;
@ -214,8 +215,9 @@ curl_share_setopt(struct Curl_share *share, CURLSHoption option, ...)
} }
CURLSHcode CURLSHcode
curl_share_cleanup(struct Curl_share *share) curl_share_cleanup(CURLSH *sh)
{ {
struct Curl_share *share = sh;
if(!GOOD_SHARE_HANDLE(share)) if(!GOOD_SHARE_HANDLE(share))
return CURLSHE_INVALID; return CURLSHE_INVALID;

2
lib/vssh/libssh2.c
View File

@ -389,7 +389,7 @@ static void state(struct Curl_easy *data, sshstate nowstate)
#ifdef HAVE_LIBSSH2_KNOWNHOST_API #ifdef HAVE_LIBSSH2_KNOWNHOST_API
static int sshkeycallback(struct Curl_easy *easy, static int sshkeycallback(CURL *easy,
const struct curl_khkey *knownkey, /* known */ const struct curl_khkey *knownkey, /* known */
const struct curl_khkey *foundkey, /* found */ const struct curl_khkey *foundkey, /* found */
enum curl_khmatch match, enum curl_khmatch match,

16
lib/ws.c
View File

@ -924,10 +924,11 @@ static ssize_t nw_in_recv(void *reader_ctx,
return (ssize_t)nread; return (ssize_t)nread;
} }
CURL_EXTERN CURLcode curl_ws_recv(struct Curl_easy *data, void *buffer, CURL_EXTERN CURLcode curl_ws_recv(CURL *d, void *buffer,
size_t buflen, size_t *nread, size_t buflen, size_t *nread,
const struct curl_ws_frame **metap) const struct curl_ws_frame **metap)
{ {
struct Curl_easy *data = d;
struct connectdata *conn = data->conn; struct connectdata *conn = data->conn;
struct websocket *ws; struct websocket *ws;
struct ws_collect ctx; struct ws_collect ctx;
@ -1047,11 +1048,12 @@ static CURLcode ws_flush(struct Curl_easy *data, struct websocket *ws,
return CURLE_OK; return CURLE_OK;
} }
static CURLcode ws_send_raw_blocking(CURL *data, struct websocket *ws, static CURLcode ws_send_raw_blocking(CURL *d, struct websocket *ws,
const char *buffer, size_t buflen) const char *buffer, size_t buflen)
{ {
CURLcode result = CURLE_OK; CURLcode result = CURLE_OK;
size_t nwritten; size_t nwritten;
struct Curl_easy *data = d;
(void)ws; (void)ws;
while(buflen) { while(buflen) {
@ -1088,7 +1090,7 @@ static CURLcode ws_send_raw_blocking(CURL *data, struct websocket *ws,
return result; return result;
} }
static CURLcode ws_send_raw(CURL *data, const void *buffer, static CURLcode ws_send_raw(struct Curl_easy *data, const void *buffer,
size_t buflen, size_t *pnwritten) size_t buflen, size_t *pnwritten)
{ {
struct websocket *ws = data->conn->proto.ws; struct websocket *ws = data->conn->proto.ws;
@ -1124,7 +1126,7 @@ static CURLcode ws_send_raw(CURL *data, const void *buffer,
return result; return result;
} }
CURL_EXTERN CURLcode curl_ws_send(CURL *data, const void *buffer, CURL_EXTERN CURLcode curl_ws_send(CURL *d, const void *buffer,
size_t buflen, size_t *sent, size_t buflen, size_t *sent,
curl_off_t fragsize, curl_off_t fragsize,
unsigned int flags) unsigned int flags)
@ -1133,6 +1135,7 @@ CURL_EXTERN CURLcode curl_ws_send(CURL *data, const void *buffer,
ssize_t n; ssize_t n;
size_t space, payload_added; size_t space, payload_added;
CURLcode result; CURLcode result;
struct Curl_easy *data = d;
CURL_TRC_WS(data, "curl_ws_send(len=%zu, fragsize=%" FMT_OFF_T CURL_TRC_WS(data, "curl_ws_send(len=%zu, fragsize=%" FMT_OFF_T
", flags=%x), raw=%d", ", flags=%x), raw=%d",
@ -1289,10 +1292,11 @@ static CURLcode ws_disconnect(struct Curl_easy *data,
return CURLE_OK; return CURLE_OK;
} }
CURL_EXTERN const struct curl_ws_frame *curl_ws_meta(struct Curl_easy *data) CURL_EXTERN const struct curl_ws_frame *curl_ws_meta(CURL *d)
{ {
/* we only return something for websocket, called from within the callback /* we only return something for websocket, called from within the callback
when not using raw mode */ when not using raw mode */
struct Curl_easy *data = d;
if(GOOD_EASY_HANDLE(data) && Curl_is_in_callback(data) && data->conn && if(GOOD_EASY_HANDLE(data) && Curl_is_in_callback(data) && data->conn &&
data->conn->proto.ws && !data->set.ws_raw_mode) data->conn->proto.ws && !data->set.ws_raw_mode)
return &data->conn->proto.ws->frame; return &data->conn->proto.ws->frame;
@ -1380,7 +1384,7 @@ CURL_EXTERN CURLcode curl_ws_send(CURL *curl, const void *buffer,
return CURLE_NOT_BUILT_IN; return CURLE_NOT_BUILT_IN;
} }
CURL_EXTERN const struct curl_ws_frame *curl_ws_meta(struct Curl_easy *data) CURL_EXTERN const struct curl_ws_frame *curl_ws_meta(CURL *data)
{ {
(void)data; (void)data;
return NULL; return NULL;

3
src/tool_operate.c
View File

@ -98,7 +98,8 @@
#include "tool_ipfs.h" #include "tool_ipfs.h"
#include "dynbuf.h" #include "dynbuf.h"
#ifdef DEBUGBUILD #ifdef DEBUGBUILD
#include "easyif.h" /* for libcurl's debug-only curl_easy_perform_ev() */ /* libcurl's debug-only curl_easy_perform_ev() */
CURL_EXTERN CURLcode curl_easy_perform_ev(CURL *easy);
#endif #endif
#include "memdebug.h" /* keep this as LAST include */ #include "memdebug.h" /* keep this as LAST include */