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

4
include/curl/multi.h
View File

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

8
lib/doh.c
View File

@ -239,13 +239,13 @@ static int doh_done(struct Curl_easy *doh, CURLcode result)
}
#define ERROR_CHECK_SETOPT(x,y) \
do { \
result = curl_easy_setopt(doh, x, y); \
do { \
result = curl_easy_setopt((CURL *)doh, x, y); \
if(result && \
result != CURLE_NOT_BUILT_IN && \
result != CURLE_UNKNOWN_OPTION) \
goto error; \
} while(0)
} while(0)
static CURLcode doh_run_probe(struct Curl_easy *data,
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);
#endif
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)
ERROR_CHECK_SETOPT(CURLOPT_STDERR, data->set.err);
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
* 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;
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
* transfer as previously setup.
*/
CURLcode curl_easy_perform(struct Curl_easy *data)
CURLcode curl_easy_perform(CURL *data)
{
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
* 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)) {
SIGPIPE_VARIABLE(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.
*/
#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;
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
* 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));
if(!outcurl)
goto fail;
@ -1066,8 +1068,9 @@ fail:
* curl_easy_reset() is an external interface that allows an app to re-
* 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);
/* 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
* within a callback.
*/
CURLcode curl_easy_pause(struct Curl_easy *data, int action)
CURLcode curl_easy_pause(CURL *d, int action)
{
struct SingleRequest *k;
CURLcode result = CURLE_OK;
@ -1115,6 +1118,7 @@ CURLcode curl_easy_pause(struct Curl_easy *data, int action)
int newstate;
bool recursive = FALSE;
bool keep_changed, unpause_read, not_all_paused;
struct Curl_easy *data = d;
if(!GOOD_EASY_HANDLE(data) || !data->conn)
/* 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.
* Returns CURLE_OK on success, error code on error.
*/
CURLcode curl_easy_recv(struct Curl_easy *data, void *buffer, size_t buflen,
size_t *n)
CURLcode curl_easy_recv(CURL *d, void *buffer, size_t buflen, size_t *n)
{
CURLcode result;
ssize_t n1;
struct connectdata *c;
struct Curl_easy *data = d;
if(Curl_is_in_callback(data))
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
* curl_easy_perform() with CURLOPT_CONNECT_ONLY option.
*/
CURLcode curl_easy_send(struct Curl_easy *data, const void *buffer,
size_t buflen, size_t *n)
CURLcode curl_easy_send(CURL *d, const void *buffer, size_t buflen, size_t *n)
{
size_t written = 0;
CURLcode result;
struct Curl_easy *data = d;
if(Curl_is_in_callback(data))
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.
*/
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. */
if(!GOOD_EASY_HANDLE(data))
return CURLE_BAD_FUNCTION_ARGUMENT;

6
lib/escape.c
View File

@ -29,6 +29,8 @@
#include <curl/curl.h>
struct Curl_easy;
#include "urldata.h"
#include "warnless.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.
* '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)
{
size_t length;
@ -176,7 +178,7 @@ CURLcode Curl_urldecode(const char *string, size_t length,
* If olen == NULL, no output length is stored.
* '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)
{
char *str = NULL;

4
lib/formdata.c
View File

@ -26,6 +26,8 @@
#include <curl/curl.h>
struct Curl_easy;
#include "formdata.h"
#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.
*/
CURLcode Curl_getformdata(struct Curl_easy *data,
CURLcode Curl_getformdata(CURL *data,
curl_mimepart *finalform,
struct curl_httppost *post,
curl_read_callback fread_func)

2
lib/formdata.h
View File

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

4
lib/mime.c
View File

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

64
lib/multi.c
View File

@ -451,7 +451,7 @@ error:
return NULL;
}
struct Curl_multi *curl_multi_init(void)
CURLM *curl_multi_init(void)
{
return Curl_multi_handle(CURL_SOCKET_HASH_TABLE_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
#endif
CURLMcode curl_multi_add_handle(struct Curl_multi *multi,
struct Curl_easy *data)
CURLMcode curl_multi_add_handle(CURLM *m, CURL *d)
{
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 */
if(!GOOD_MULTI_HANDLE(multi))
return CURLM_BAD_HANDLE;
@ -772,10 +773,10 @@ static void close_connect_only(struct connectdata *conn,
connclose(conn, "Removing connect-only easy handle");
}
CURLMcode curl_multi_remove_handle(struct Curl_multi *multi,
struct Curl_easy *data)
CURLMcode curl_multi_remove_handle(CURLM *m, CURL *d)
{
struct Curl_easy *easy = data;
struct Curl_multi *multi = m;
struct Curl_easy *data = d;
bool premature;
struct Curl_llist_node *e;
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
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 */
/* 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)) {
struct Curl_message *msg = Curl_node_elem(e);
if(msg->extmsg.easy_handle == easy) {
if(msg->extmsg.easy_handle == data) {
Curl_node_remove(e);
/* there can only be one from this specific handle */
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 *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. */
int this_max_fd = -1;
struct Curl_llist_node *e;
struct Curl_multi *multi = m;
(void)exc_fd_set; /* not used */
if(!GOOD_MULTI_HANDLE(multi))
@ -1182,7 +1184,7 @@ CURLMcode curl_multi_fdset(struct Curl_multi *multi,
return CURLM_OK;
}
CURLMcode curl_multi_waitfds(struct Curl_multi *multi,
CURLMcode curl_multi_waitfds(CURLM *m,
struct curl_waitfd *ufds,
unsigned int size,
unsigned int *fd_count)
@ -1190,6 +1192,7 @@ CURLMcode curl_multi_waitfds(struct Curl_multi *multi,
struct curl_waitfds cwfds;
CURLMcode result = CURLM_OK;
struct Curl_llist_node *e;
struct Curl_multi *multi = m;
if(!ufds)
return CURLM_BAD_FUNCTION_ARGUMENT;
@ -1487,7 +1490,7 @@ out:
return result;
}
CURLMcode curl_multi_wait(struct Curl_multi *multi,
CURLMcode curl_multi_wait(CURLM *multi,
struct curl_waitfd extra_fds[],
unsigned int extra_nfds,
int timeout_ms,
@ -1497,7 +1500,7 @@ CURLMcode curl_multi_wait(struct Curl_multi *multi,
FALSE);
}
CURLMcode curl_multi_poll(struct Curl_multi *multi,
CURLMcode curl_multi_poll(CURLM *multi,
struct curl_waitfd extra_fds[],
unsigned int extra_nfds,
int timeout_ms,
@ -1507,11 +1510,12 @@ CURLMcode curl_multi_poll(struct Curl_multi *multi,
TRUE);
}
CURLMcode curl_multi_wakeup(struct Curl_multi *multi)
CURLMcode curl_multi_wakeup(CURLM *m)
{
/* this function is usually called from another thread,
it has to be careful only to access parts of the
Curl_multi struct that are constant */
struct Curl_multi *multi = m;
#if defined(ENABLE_WAKEUP) && !defined(USE_WINSOCK)
#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;
struct Curl_tree *t = NULL;
struct curltime now = Curl_now();
struct Curl_llist_node *e;
struct Curl_llist_node *n = NULL;
struct Curl_multi *multi = m;
SIGPIPE_VARIABLE(pipe_st);
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)) {
struct Curl_llist_node *e;
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).
*/
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_multi *multi = m;
*msgs_in_queue = 0; /* default to none */
@ -3556,12 +3563,13 @@ out:
}
#undef curl_multi_setopt
CURLMcode curl_multi_setopt(struct Curl_multi *multi,
CURLMcode curl_multi_setopt(CURLM *m,
CURLMoption option, ...)
{
CURLMcode res = CURLM_OK;
va_list param;
unsigned long uarg;
struct Curl_multi *multi = m;
if(!GOOD_MULTI_HANDLE(multi))
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 */
#undef curl_multi_socket
CURLMcode curl_multi_socket(struct Curl_multi *multi, curl_socket_t s,
int *running_handles)
CURLMcode curl_multi_socket(CURLM *m, curl_socket_t s, int *running_handles)
{
struct Curl_multi *multi = m;
if(multi->in_callback)
return CURLM_RECURSIVE_API_CALL;
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)
{
struct Curl_multi *multi = m;
if(multi->in_callback)
return CURLM_RECURSIVE_API_CALL;
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)
return CURLM_RECURSIVE_API_CALL;
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;
}
CURLMcode curl_multi_timeout(struct Curl_multi *multi,
CURLMcode curl_multi_timeout(CURLM *m,
long *timeout_ms)
{
struct curltime expire_time;
struct Curl_multi *multi = m;
/* First, make some basic checks that the CURLM handle is a good handle */
if(!GOOD_MULTI_HANDLE(multi))
@ -3984,10 +3995,11 @@ bool Curl_expire_clear(struct Curl_easy *data)
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)
{
struct Curl_sh_entry *there = NULL;
struct Curl_multi *multi = m;
if(!GOOD_MULTI_HANDLE(multi))
return CURLM_BAD_HANDLE;
@ -4058,10 +4070,10 @@ unsigned int Curl_multi_max_concurrent_streams(struct Curl_multi *multi)
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 *) *
(multi->num_easy + 1));
struct Curl_multi *multi = m;
CURL **a = malloc(sizeof(struct Curl_easy *) * (multi->num_easy + 1));
if(a) {
unsigned int i = 0;
struct Curl_llist_node *e;

2
lib/psl.h
View File

@ -27,6 +27,8 @@
#ifdef USE_LIBPSL
#include <libpsl.h>
struct Curl_easy;
#define PSL_TTL (72 * 3600) /* PSL time to live before a refresh. */
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
CURLcode curl_easy_setopt(struct Curl_easy *data, CURLoption tag, ...)
CURLcode curl_easy_setopt(CURL *d, CURLoption tag, ...)
{
va_list arg;
CURLcode result;
struct Curl_easy *data = d;
if(!data)
return CURLE_BAD_FUNCTION_ARGUMENT;

8
lib/share.c
View File

@ -38,7 +38,7 @@
#include "curl_memory.h"
#include "memdebug.h"
struct Curl_share *
CURLSH *
curl_share_init(void)
{
struct Curl_share *share = calloc(1, sizeof(struct Curl_share));
@ -53,7 +53,7 @@ curl_share_init(void)
#undef curl_share_setopt
CURLSHcode
curl_share_setopt(struct Curl_share *share, CURLSHoption option, ...)
curl_share_setopt(CURLSH *sh, CURLSHoption option, ...)
{
va_list param;
int type;
@ -61,6 +61,7 @@ curl_share_setopt(struct Curl_share *share, CURLSHoption option, ...)
curl_unlock_function unlockfunc;
void *ptr;
CURLSHcode res = CURLSHE_OK;
struct Curl_share *share = sh;
if(!GOOD_SHARE_HANDLE(share))
return CURLSHE_INVALID;
@ -214,8 +215,9 @@ curl_share_setopt(struct Curl_share *share, CURLSHoption option, ...)
}
CURLSHcode
curl_share_cleanup(struct Curl_share *share)
curl_share_cleanup(CURLSH *sh)
{
struct Curl_share *share = sh;
if(!GOOD_SHARE_HANDLE(share))
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
static int sshkeycallback(struct Curl_easy *easy,
static int sshkeycallback(CURL *easy,
const struct curl_khkey *knownkey, /* known */
const struct curl_khkey *foundkey, /* found */
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;
}
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,
const struct curl_ws_frame **metap)
{
struct Curl_easy *data = d;
struct connectdata *conn = data->conn;
struct websocket *ws;
struct ws_collect ctx;
@ -1047,11 +1048,12 @@ static CURLcode ws_flush(struct Curl_easy *data, struct websocket *ws,
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)
{
CURLcode result = CURLE_OK;
size_t nwritten;
struct Curl_easy *data = d;
(void)ws;
while(buflen) {
@ -1088,7 +1090,7 @@ static CURLcode ws_send_raw_blocking(CURL *data, struct websocket *ws,
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)
{
struct websocket *ws = data->conn->proto.ws;
@ -1124,7 +1126,7 @@ static CURLcode ws_send_raw(CURL *data, const void *buffer,
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,
curl_off_t fragsize,
unsigned int flags)
@ -1133,6 +1135,7 @@ CURL_EXTERN CURLcode curl_ws_send(CURL *data, const void *buffer,
ssize_t n;
size_t space, payload_added;
CURLcode result;
struct Curl_easy *data = d;
CURL_TRC_WS(data, "curl_ws_send(len=%zu, fragsize=%" FMT_OFF_T
", flags=%x), raw=%d",
@ -1289,10 +1292,11 @@ static CURLcode ws_disconnect(struct Curl_easy *data,
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
when not using raw mode */
struct Curl_easy *data = d;
if(GOOD_EASY_HANDLE(data) && Curl_is_in_callback(data) && data->conn &&
data->conn->proto.ws && !data->set.ws_raw_mode)
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;
}
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;
return NULL;

3
src/tool_operate.c
View File

@ -98,7 +98,8 @@
#include "tool_ipfs.h"
#include "dynbuf.h"
#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
#include "memdebug.h" /* keep this as LAST include */