git-market/curl-curl
1
0
Fork 0
mirror of https://github.com/curl/curl.git synced 2026-04-14 13:01:42 +08:00
Code Issues Actions 15 Packages Projects Releases Wiki Activity

clang-tidy: enable more checks, fix fallouts

Browse Source 
- enable three checks:
  - bugprone-invalid-enum-default-initialization
  - bugprone-sizeof-expression
  - readability-inconsistent-declaration-parameter-name (strict)
- fix remaining discrepancies with arg names in prototypes
  and implementation, in strict mode.
- document reason for some checks tested but not enabled.

Closes #20794
This commit is contained in:
Viktor Szakats 2026-03-03 01:58:29 +01:00
parent e0dd6eb4a4
commit df6014894b
No known key found for this signature in database
34 changed files with 222 additions and 209 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
.clang-tidy.yml
View File

@ -16,6 +16,7 @@ Checks:
- bugprone-assignment-in-if-condition
- bugprone-chained-comparison
- bugprone-dynamic-static-initializers
- bugprone-invalid-enum-default-initialization
- bugprone-macro-parentheses
- bugprone-macro-repeated-side-effects
- bugprone-misplaced-operator-in-strlen-in-alloc
@ -24,16 +25,25 @@ Checks:
- bugprone-posix-return
- bugprone-redundant-branch-condition
- bugprone-signed-char-misuse
- bugprone-sizeof-expression
- bugprone-suspicious-enum-usage
- bugprone-suspicious-memset-usage
- bugprone-suspicious-missing-comma
- bugprone-suspicious-realloc-usage
- bugprone-suspicious-semicolon
# bugprone-unchecked-string-to-number-conversion # needs converting sscanf to strtol or curlx_str_*
- misc-const-correctness
- misc-header-include-cycle
# misc-redundant-expression # undesired hits due to system macros, e.g. due to POLLIN == POLLRDNORM | POLLRDBAND, then or-ing all three
- portability-*
- readability-duplicate-include
# readability-else-after-return
# readability-enum-initial-value
# readability-function-cognitive-complexity
- readability-inconsistent-declaration-parameter-name
# readability-misleading-indentation # too many false positives and oddball/conditional source
- readability-named-parameter
# readability-redundant-casting # false positives in types that change from platform to platform, even with IgnoreTypeAliases: true
- readability-redundant-control-flow
- readability-redundant-declaration
- readability-redundant-function-ptr-dereference
@ -44,5 +54,6 @@ Checks:
CheckOptions:
misc-header-include-cycle.IgnoredFilesList: 'curl/curl.h'
readability-inconsistent-declaration-parameter-name.Strict: true
HeaderFilterRegex: '.*' # Default in v22.1.0+

10
docs/libcurl/curl_easy_header.md
View File

@ -26,7 +26,7 @@ curl_easy_header - get an HTTP header
CURLHcode curl_easy_header(CURL *easy,
const char *name,
size_t index,
size_t nameindex,
unsigned int origin,
int request,
struct curl_header **hout);
@ -38,10 +38,10 @@ curl_easy_header(3) returns a pointer to a "curl_header" struct in **hout**
with data for the HTTP response header *name*. The case insensitive
null-terminated header name should be specified without colon.
*index* 0 means asking for the first instance of the header. If the returned
header struct has **amount** set larger than 1, it means there are more
instances of the same header name available to get. Asking for a too big index
makes **CURLHE_BADINDEX** get returned.
*nameindex* 0 means asking for the first instance of the header. If the
returned header struct has **amount** set larger than 1, it means there are
more instances of the same header name available to get. Asking for a too big
index makes **CURLHE_BADINDEX** get returned.
The *origin* argument is for specifying which headers to receive, as a single
HTTP transfer might provide headers from several different places and they may

4
docs/libcurl/curl_easy_pause.md
View File

@ -21,7 +21,7 @@ curl_easy_pause - pause and unpause a connection
~~~c
#include <curl/curl.h>
CURLcode curl_easy_pause(CURL *handle, int bitmask);
CURLcode curl_easy_pause(CURL *handle, int action);
~~~
# DESCRIPTION
@ -54,7 +54,7 @@ A paused transfer is excluded from low speed cancels via the
CURLOPT_LOW_SPEED_LIMIT(3) option and unpausing a transfer resets the
time period required for the low speed limit to be met.
The **bitmask** argument is a set of bits that sets the new state of the
The **action** argument is a set of bits that sets the new state of the
connection. The following bits can be used:
## CURLPAUSE_RECV

2
docs/libcurl/curl_multi_timeout.md
View File

@ -37,7 +37,7 @@ curl_multi_socket_action(3) function with the **sockfd** argument set
to CURL_SOCKET_TIMEOUT, or call curl_multi_perform(3) if you are using
the simpler and older multi interface approach.
The timeout value returned in the long **timeout** points to, is in number
The timeout value returned in the long **timeout_ms** points to, is in number
of milliseconds at this moment. If 0, it means you should proceed immediately
without waiting for anything. If it returns -1, there is no timeout at all set.

21
include/curl/curl.h
View File

@ -2695,7 +2695,7 @@ CURL_EXTERN char *curl_version(void);
* %XX versions). This function returns a new allocated string or NULL if an
* error occurred.
*/
CURL_EXTERN char *curl_easy_escape(CURL *handle,
CURL_EXTERN char *curl_easy_escape(CURL *curl,
const char *string,
int length);
@ -2714,9 +2714,9 @@ CURL_EXTERN char *curl_escape(const char *string,
* Conversion Note: On non-ASCII platforms the ASCII %XX codes are
* converted into the host encoding.
*/
CURL_EXTERN char *curl_easy_unescape(CURL *handle,
CURL_EXTERN char *curl_easy_unescape(CURL *curl,
const char *string,
int length,
int inlength,
int *outlength);
/* the previous version */
@ -3076,9 +3076,8 @@ typedef enum {
} CURLSHoption;
CURL_EXTERN CURLSH *curl_share_init(void);
CURL_EXTERN CURLSHcode curl_share_setopt(CURLSH *share, CURLSHoption option,
...);
CURL_EXTERN CURLSHcode curl_share_cleanup(CURLSH *share);
CURL_EXTERN CURLSHcode curl_share_setopt(CURLSH *sh, CURLSHoption option, ...);
CURL_EXTERN CURLSHcode curl_share_cleanup(CURLSH *sh);
/****************************************************************************
* Structures for querying information about the curl library at runtime.
@ -3246,10 +3245,10 @@ CURL_EXTERN const char *curl_share_strerror(CURLSHcode error);
* DESCRIPTION
*
* The curl_easy_pause function pauses or unpauses transfers. Select the new
* state by setting the bitmask, use the convenience defines below.
* state by setting the action bitmask, use the convenience defines below.
*
*/
CURL_EXTERN CURLcode curl_easy_pause(CURL *handle, int bitmask);
CURL_EXTERN CURLcode curl_easy_pause(CURL *curl, int action);
#define CURLPAUSE_RECV (1 << 0)
#define CURLPAUSE_RECV_CONT 0
@ -3268,7 +3267,7 @@ CURL_EXTERN CURLcode curl_easy_pause(CURL *handle, int bitmask);
* The curl_easy_ssls_import function adds a previously exported SSL session
* to the SSL session cache of the easy handle (or the underlying share).
*/
CURL_EXTERN CURLcode curl_easy_ssls_import(CURL *handle,
CURL_EXTERN CURLcode curl_easy_ssls_import(CURL *curl,
const char *session_key,
const unsigned char *shmac,
size_t shmac_len,
@ -3277,7 +3276,7 @@ CURL_EXTERN CURLcode curl_easy_ssls_import(CURL *handle,
/* This is the curl_ssls_export_cb callback prototype. It
* is passed to curl_easy_ssls_export() to extract SSL sessions/tickets. */
typedef CURLcode curl_ssls_export_cb(CURL *handle,
typedef CURLcode curl_ssls_export_cb(CURL *curl,
void *userptr,
const char *session_key,
const unsigned char *shmac,
@ -3299,7 +3298,7 @@ typedef CURLcode curl_ssls_export_cb(CURL *handle,
* callback.
*
*/
CURL_EXTERN CURLcode curl_easy_ssls_export(CURL *handle,
CURL_EXTERN CURLcode curl_easy_ssls_export(CURL *curl,
curl_ssls_export_cb *export_fn,
void *userptr);

6
include/curl/header.h
View File

@ -55,14 +55,14 @@ typedef enum {
CURLHE_NOT_BUILT_IN /* if API was disabled in the build */
} CURLHcode;
CURL_EXTERN CURLHcode curl_easy_header(CURL *easy,
CURL_EXTERN CURLHcode curl_easy_header(CURL *curl,
const char *name,
size_t index,
size_t nameindex,
unsigned int origin,
int request,
struct curl_header **hout);
CURL_EXTERN struct curl_header *curl_easy_nextheader(CURL *easy,
CURL_EXTERN struct curl_header *curl_easy_nextheader(CURL *curl,
unsigned int origin,
int request,
struct curl_header *prev);

50
include/curl/multi.h
View File

@ -132,8 +132,8 @@ CURL_EXTERN CURLM *curl_multi_init(void);
*
* Returns: CURLMcode type, general multi error code.
*/
CURL_EXTERN CURLMcode curl_multi_add_handle(CURLM *multi_handle,
CURL *curl_handle);
CURL_EXTERN CURLMcode curl_multi_add_handle(CURLM *m,
CURL *curl);
/*
* Name: curl_multi_remove_handle()
@ -142,8 +142,8 @@ CURL_EXTERN CURLMcode curl_multi_add_handle(CURLM *multi_handle,
*
* Returns: CURLMcode type, general multi error code.
*/
CURL_EXTERN CURLMcode curl_multi_remove_handle(CURLM *multi_handle,
CURL *curl_handle);
CURL_EXTERN CURLMcode curl_multi_remove_handle(CURLM *m,
CURL *curl);
/*
* Name: curl_multi_fdset()
@ -154,7 +154,7 @@ CURL_EXTERN CURLMcode curl_multi_remove_handle(CURLM *multi_handle,
*
* Returns: CURLMcode type, general multi error code.
*/
CURL_EXTERN CURLMcode curl_multi_fdset(CURLM *multi_handle,
CURL_EXTERN CURLMcode curl_multi_fdset(CURLM *m,
fd_set *read_fd_set,
fd_set *write_fd_set,
fd_set *exc_fd_set,
@ -168,7 +168,7 @@ CURL_EXTERN CURLMcode curl_multi_fdset(CURLM *multi_handle,
*
* Returns: CURLMcode type, general multi error code.
*/
CURL_EXTERN CURLMcode curl_multi_wait(CURLM *multi_handle,
CURL_EXTERN CURLMcode curl_multi_wait(CURLM *m,
struct curl_waitfd extra_fds[],
unsigned int extra_nfds,
int timeout_ms,
@ -182,7 +182,7 @@ CURL_EXTERN CURLMcode curl_multi_wait(CURLM *multi_handle,
*
* Returns: CURLMcode type, general multi error code.
*/
CURL_EXTERN CURLMcode curl_multi_poll(CURLM *multi_handle,
CURL_EXTERN CURLMcode curl_multi_poll(CURLM *m,
struct curl_waitfd extra_fds[],
unsigned int extra_nfds,
int timeout_ms,
@ -195,7 +195,7 @@ CURL_EXTERN CURLMcode curl_multi_poll(CURLM *multi_handle,
*
* Returns: CURLMcode type, general multi error code.
*/
CURL_EXTERN CURLMcode curl_multi_wakeup(CURLM *multi_handle);
CURL_EXTERN CURLMcode curl_multi_wakeup(CURLM *m);
/*
* Name: curl_multi_perform()
@ -213,7 +213,7 @@ CURL_EXTERN CURLMcode curl_multi_wakeup(CURLM *multi_handle);
* still have occurred problems on individual transfers even when
* this returns OK.
*/
CURL_EXTERN CURLMcode curl_multi_perform(CURLM *multi_handle,
CURL_EXTERN CURLMcode curl_multi_perform(CURLM *m,
int *running_handles);
/*
@ -226,7 +226,7 @@ CURL_EXTERN CURLMcode curl_multi_perform(CURLM *multi_handle,
*
* Returns: CURLMcode type, general multi error code.
*/
CURL_EXTERN CURLMcode curl_multi_cleanup(CURLM *multi_handle);
CURL_EXTERN CURLMcode curl_multi_cleanup(CURLM *m);
/*
* Name: curl_multi_info_read()
@ -256,7 +256,7 @@ CURL_EXTERN CURLMcode curl_multi_cleanup(CURLM *multi_handle);
* queue (after this read) in the integer the second argument points
* to.
*/
CURL_EXTERN CURLMsg *curl_multi_info_read(CURLM *multi_handle,
CURL_EXTERN CURLMsg *curl_multi_info_read(CURLM *m,
int *msgs_in_queue);
/*
@ -308,21 +308,21 @@ typedef int (*curl_socket_callback)(CURL *easy, /* easy handle */
*
* Returns: The callback should return zero.
*/
typedef int (*curl_multi_timer_callback)(CURLM *multi, /* multi handle */
typedef int (*curl_multi_timer_callback)(CURLM *m, /* multi handle */
long timeout_ms, /* see above */
void *userp); /* private callback
pointer */
CURL_EXTERN CURLMcode CURL_DEPRECATED(7.19.5, "Use curl_multi_socket_action()")
curl_multi_socket(CURLM *multi_handle, curl_socket_t s, int *running_handles);
curl_multi_socket(CURLM *m, curl_socket_t s, int *running_handles);
CURL_EXTERN CURLMcode curl_multi_socket_action(CURLM *multi_handle,
CURL_EXTERN CURLMcode curl_multi_socket_action(CURLM *m,
curl_socket_t s,
int ev_bitmask,
int *running_handles);
CURL_EXTERN CURLMcode CURL_DEPRECATED(7.19.5, "Use curl_multi_socket_action()")
curl_multi_socket_all(CURLM *multi_handle, int *running_handles);
curl_multi_socket_all(CURLM *m, int *running_handles);
#ifndef CURL_ALLOW_OLD_MULTI_SOCKET
/* This macro below was added in 7.16.3 to push users who recompile to use
@ -340,8 +340,8 @@ curl_multi_socket_all(CURLM *multi_handle, int *running_handles);
*
* Returns: CURLM error code.
*/
CURL_EXTERN CURLMcode curl_multi_timeout(CURLM *multi_handle,
long *milliseconds);
CURL_EXTERN CURLMcode curl_multi_timeout(CURLM *m,
long *timeout_ms);
typedef enum {
/* This is the socket callback function pointer */
@ -435,7 +435,7 @@ typedef enum {
*
* Returns: CURLM error code.
*/
CURL_EXTERN CURLMcode curl_multi_setopt(CURLM *multi_handle,
CURL_EXTERN CURLMcode curl_multi_setopt(CURLM *m,
CURLMoption option, ...);
/*
@ -447,7 +447,7 @@ CURL_EXTERN CURLMcode curl_multi_setopt(CURLM *multi_handle,
*
* Returns: CURLM error code.
*/
CURL_EXTERN CURLMcode curl_multi_assign(CURLM *multi_handle,
CURL_EXTERN CURLMcode curl_multi_assign(CURLM *m,
curl_socket_t sockfd, void *sockp);
/*
@ -460,7 +460,7 @@ CURL_EXTERN CURLMcode curl_multi_assign(CURLM *multi_handle,
*
* Returns: NULL on failure, otherwise a CURL **array pointer
*/
CURL_EXTERN CURL **curl_multi_get_handles(CURLM *multi_handle);
CURL_EXTERN CURL **curl_multi_get_handles(CURLM *m);
typedef enum {
CURLMINFO_NONE, /* first, never use this */
@ -489,7 +489,7 @@ typedef enum {
*
* Returns: CULRM_OK or error when value could not be obtained.
*/
CURL_EXTERN CURLMcode curl_multi_get_offt(CURLM *multi_handle,
CURL_EXTERN CURLMcode curl_multi_get_offt(CURLM *m,
CURLMinfo_offt info,
curl_off_t *pvalue);
@ -528,7 +528,7 @@ typedef int (*curl_push_callback)(CURL *parent,
*
* Returns: CURLMcode type, general multi error code.
*/
CURL_EXTERN CURLMcode curl_multi_waitfds(CURLM *multi,
CURL_EXTERN CURLMcode curl_multi_waitfds(CURLM *m,
struct curl_waitfd *ufds,
unsigned int size,
unsigned int *fd_count);
@ -542,15 +542,15 @@ CURL_EXTERN CURLMcode curl_multi_waitfds(CURLM *multi,
/*
* Callback to install via CURLMOPT_NOTIFYFUNCTION.
*/
typedef void (*curl_notify_callback)(CURLM *multi,
typedef void (*curl_notify_callback)(CURLM *m,
unsigned int notification,
CURL *easy,
void *user_data);
CURL_EXTERN CURLMcode curl_multi_notify_disable(CURLM *multi,
CURL_EXTERN CURLMcode curl_multi_notify_disable(CURLM *m,
unsigned int notification);
CURL_EXTERN CURLMcode curl_multi_notify_enable(CURLM *multi,
CURL_EXTERN CURLMcode curl_multi_notify_enable(CURLM *m,
unsigned int notification);
#ifdef __cplusplus

6
include/curl/urlapi.h
View File

@ -117,7 +117,7 @@ CURL_EXTERN CURLU *curl_url(void);
* the URL parsing. It does not free strings previously returned with the URL
* API.
*/
CURL_EXTERN void curl_url_cleanup(CURLU *handle);
CURL_EXTERN void curl_url_cleanup(CURLU *u);
/*
* curl_url_dup() duplicates a CURLU handle and returns a new copy. The new
@ -130,7 +130,7 @@ CURL_EXTERN CURLU *curl_url_dup(const CURLU *in);
* handle. Returns error code. The returned pointer MUST be freed with
* curl_free() afterwards.
*/
CURL_EXTERN CURLUcode curl_url_get(const CURLU *handle, CURLUPart what,
CURL_EXTERN CURLUcode curl_url_get(const CURLU *u, CURLUPart what,
char **part, unsigned int flags);
/*
@ -138,7 +138,7 @@ CURL_EXTERN CURLUcode curl_url_get(const CURLU *handle, CURLUPart what,
* error code. The passed in string is copied. Passing a NULL instead of
* a part string, clears that part.
*/
CURL_EXTERN CURLUcode curl_url_set(CURLU *handle, CURLUPart what,
CURL_EXTERN CURLUcode curl_url_set(CURLU *u, CURLUPart what,
const char *part, unsigned int flags);
/*

2
include/curl/websockets.h
View File

@ -67,7 +67,7 @@ CURL_EXTERN CURLcode curl_ws_recv(CURL *curl, void *buffer, size_t buflen,
* Sends data over the websocket connection. Use after successful
* curl_easy_perform() with CURLOPT_CONNECT_ONLY option.
*/
CURL_EXTERN CURLcode curl_ws_send(CURL *curl, const void *buffer,
CURL_EXTERN CURLcode curl_ws_send(CURL *curl, const void *buffer_arg,
size_t buflen, size_t *sent,
curl_off_t fragsize,
unsigned int flags);

2
lib/curl_gssapi.h
View File

@ -44,7 +44,7 @@ OM_uint32 Curl_gss_init_sec_context(struct Curl_easy *data,
OM_uint32 *ret_flags);
OM_uint32 Curl_gss_delete_sec_context(OM_uint32 *min,
gss_ctx_id_t *context_handle,
gss_ctx_id_t *context,
gss_buffer_t output_token);
#ifdef CURLVERBOSE

3
lib/curl_setup.h
View File

@ -1387,7 +1387,8 @@ CURL_EXTERN void curl_dbg_mark_sclose(curl_socket_t sockfd,
int line, const char *source);
CURL_EXTERN int curl_dbg_sclose(curl_socket_t sockfd,
int line, const char *source);
CURL_EXTERN curl_socket_t curl_dbg_accept(curl_socket_t s, void *a, void *alen,
CURL_EXTERN curl_socket_t curl_dbg_accept(curl_socket_t s,
void *saddr, void *saddrlen,
int line, const char *source);
#ifdef HAVE_ACCEPT4
CURL_EXTERN curl_socket_t curl_dbg_accept4(curl_socket_t s, void *saddr,

2
lib/curlx/dynbuf.h
View File

@ -53,7 +53,7 @@ size_t curlx_dyn_len(const struct dynbuf *s);
/* returns 0 on success, -1 on error */
/* The implementation of this function exists in mprintf.c */
int curlx_dyn_vprintf(struct dynbuf *dyn, const char *format, va_list ap_save);
int curlx_dyn_vprintf(struct dynbuf *dyn, const char *format, va_list args);
/* Take the buffer out of the dynbuf. Caller has ownership and
* dynbuf resets to initial state. */

2
lib/curlx/fopen.h
View File

@ -47,7 +47,7 @@ HANDLE curlx_CreateFile(const char *filename,
#define curlx_fstat _fstati64
#define curlx_struct_stat struct _stati64
FILE *curlx_win32_fopen(const char *filename, const char *mode);
FILE *curlx_win32_freopen(const char *filename, const char *mode, FILE *fh);
FILE *curlx_win32_freopen(const char *filename, const char *mode, FILE *fp);
int curlx_win32_stat(const char *path, curlx_struct_stat *buffer);
int curlx_win32_open(const char *filename, int oflag, ...);
int curlx_win32_rename(const char *oldpath, const char *newpath);

10
lib/curlx/inet_ntop.h
View File

@ -36,15 +36,15 @@
#include <arpa/inet.h>
#endif
#ifdef __AMIGA__
#define curlx_inet_ntop(af, addr, buf, size) \
(char *)inet_ntop(af, CURL_UNCONST(addr), (unsigned char *)(buf), \
#define curlx_inet_ntop(af, src, buf, size) \
(char *)inet_ntop(af, CURL_UNCONST(src), (unsigned char *)(buf), \
(curl_socklen_t)(size))
#else
#define curlx_inet_ntop(af, addr, buf, size) \
inet_ntop(af, addr, buf, (curl_socklen_t)(size))
#define curlx_inet_ntop(af, src, buf, size) \
inet_ntop(af, src, buf, (curl_socklen_t)(size))
#endif
#else
char *curlx_inet_ntop(int af, const void *addr, char *buf, size_t size);
char *curlx_inet_ntop(int af, const void *src, char *buf, size_t size);
#endif /* HAVE_INET_NTOP */
#endif /* HEADER_CURL_INET_NTOP_H */

2
lib/dnscache.h
View File

@ -95,7 +95,7 @@ struct Curl_dnscache {
};
/* init a new dns cache */
void Curl_dnscache_init(struct Curl_dnscache *dns, size_t hashsize);
void Curl_dnscache_init(struct Curl_dnscache *dns, size_t size);
void Curl_dnscache_destroy(struct Curl_dnscache *dns);

3
lib/doh.h
View File

@ -117,13 +117,12 @@ struct doh_probes {
* Curl_doh() starts a name resolve using DoH (DNS-over-HTTPS). It resolves a
* name and returns a 'Curl_addrinfo *' with the address information.
*/
CURLcode Curl_doh(struct Curl_easy *data,
struct Curl_resolv_async *async);
CURLcode Curl_doh_take_result(struct Curl_easy *data,
struct Curl_resolv_async *async,
struct Curl_dns_entry **dns);
struct Curl_dns_entry **pdns);
#define DOH_MAX_ADDR 24
#define DOH_MAX_CNAME 4

53
lib/easy.c
View File

@ -815,9 +815,9 @@ 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(CURL *data)
CURLcode curl_easy_perform(CURL *curl)
{
return easy_perform(data, FALSE);
return easy_perform(curl, FALSE);
}
#ifdef DEBUGBUILD
@ -825,9 +825,9 @@ CURLcode curl_easy_perform(CURL *data)
* curl_easy_perform_ev() is the external interface that performs a blocking
* transfer using the event-based API internally.
*/
CURLcode curl_easy_perform_ev(struct Curl_easy *data)
CURLcode curl_easy_perform_ev(struct Curl_easy *easy)
{
return easy_perform(data, TRUE);
return easy_perform(easy, TRUE);
}
#endif
@ -835,9 +835,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(CURL *ptr)
void curl_easy_cleanup(CURL *curl)
{
struct Curl_easy *data = ptr;
struct Curl_easy *data = curl;
if(GOOD_EASY_HANDLE(data)) {
struct Curl_sigpipe_ctx sigpipe_ctx;
sigpipe_ignore(data, &sigpipe_ctx);
@ -851,9 +851,9 @@ void curl_easy_cleanup(CURL *ptr)
* information from a performed transfer and similar.
*/
#undef curl_easy_getinfo
CURLcode curl_easy_getinfo(CURL *easy, CURLINFO info, ...)
CURLcode curl_easy_getinfo(CURL *curl, CURLINFO info, ...)
{
struct Curl_easy *data = easy;
struct Curl_easy *data = curl;
va_list arg;
void *paramp;
CURLcode result;
@ -950,9 +950,9 @@ static void dupeasy_meta_freeentry(void *p)
* given input easy handle. The returned handle will be a new working handle
* with all options set exactly as the input source handle.
*/
CURL *curl_easy_duphandle(CURL *d)
CURL *curl_easy_duphandle(CURL *curl)
{
struct Curl_easy *data = d;
struct Curl_easy *data = curl;
struct Curl_easy *outcurl = NULL;
if(!GOOD_EASY_HANDLE(data))
@ -1081,9 +1081,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(CURL *d)
void curl_easy_reset(CURL *curl)
{
struct Curl_easy *data = d;
struct Curl_easy *data = curl;
if(!GOOD_EASY_HANDLE(data))
return;
@ -1130,12 +1130,12 @@ void curl_easy_reset(CURL *d)
* NOTE: This is one of few API functions that are allowed to be called from
* within a callback.
*/
CURLcode curl_easy_pause(CURL *d, int action)
CURLcode curl_easy_pause(CURL *curl, int action)
{
CURLcode result = CURLE_OK;
bool recursive = FALSE;
bool changed = FALSE;
struct Curl_easy *data = d;
struct Curl_easy *data = curl;
bool recv_paused, recv_paused_new;
bool send_paused, send_paused_new;
@ -1220,11 +1220,11 @@ 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(CURL *d, void *buffer, size_t buflen, size_t *n)
CURLcode curl_easy_recv(CURL *curl, void *buffer, size_t buflen, size_t *n)
{
CURLcode result;
struct connectdata *c;
struct Curl_easy *data = d;
struct Curl_easy *data = curl;
if(!GOOD_EASY_HANDLE(data))
return CURLE_BAD_FUNCTION_ARGUMENT;
@ -1298,11 +1298,12 @@ 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(CURL *d, const void *buffer, size_t buflen, size_t *n)
CURLcode curl_easy_send(CURL *curl, const void *buffer, size_t buflen,
size_t *n)
{
size_t written = 0;
CURLcode result;
struct Curl_easy *data = d;
struct Curl_easy *data = curl;
if(!GOOD_EASY_HANDLE(data))
return CURLE_BAD_FUNCTION_ARGUMENT;
if(Curl_is_in_callback(data))
@ -1316,9 +1317,9 @@ CURLcode curl_easy_send(CURL *d, const void *buffer, size_t buflen, size_t *n)
/*
* Performs connection upkeep for the given session handle.
*/
CURLcode curl_easy_upkeep(CURL *d)
CURLcode curl_easy_upkeep(CURL *curl)
{
struct Curl_easy *data = d;
struct Curl_easy *data = curl;
/* Verify that we got an easy handle we can work with. */
if(!GOOD_EASY_HANDLE(data))
return CURLE_BAD_FUNCTION_ARGUMENT;
@ -1330,18 +1331,18 @@ CURLcode curl_easy_upkeep(CURL *d)
return Curl_cpool_upkeep(data);
}
CURLcode curl_easy_ssls_import(CURL *d, const char *session_key,
CURLcode curl_easy_ssls_import(CURL *curl, const char *session_key,
const unsigned char *shmac, size_t shmac_len,
const unsigned char *sdata, size_t sdata_len)
{
#if defined(USE_SSL) && defined(USE_SSLS_EXPORT)
struct Curl_easy *data = d;
struct Curl_easy *data = curl;
if(!GOOD_EASY_HANDLE(data))
return CURLE_BAD_FUNCTION_ARGUMENT;
return Curl_ssl_session_import(data, session_key,
shmac, shmac_len, sdata, sdata_len);
#else
(void)d;
(void)curl;
(void)session_key;
(void)shmac;
(void)shmac_len;
@ -1351,17 +1352,17 @@ CURLcode curl_easy_ssls_import(CURL *d, const char *session_key,
#endif
}
CURLcode curl_easy_ssls_export(CURL *d,
CURLcode curl_easy_ssls_export(CURL *curl,
curl_ssls_export_cb *export_fn,
void *userptr)
{
#if defined(USE_SSL) && defined(USE_SSLS_EXPORT)
struct Curl_easy *data = d;
struct Curl_easy *data = curl;
if(!GOOD_EASY_HANDLE(data))
return CURLE_BAD_FUNCTION_ARGUMENT;
return Curl_ssl_session_export(data, export_fn, userptr);
#else
(void)d;
(void)curl;
(void)export_fn;
(void)userptr;
return CURLE_NOT_BUILT_IN;

35
lib/escape.c
View File

@ -33,9 +33,9 @@ struct Curl_easy;
#include "curl_printf.h"
/* for ABI-compatibility with previous versions */
char *curl_escape(const char *string, int inlength)
char *curl_escape(const char *string, int length)
{
return curl_easy_escape(NULL, string, inlength);
return curl_easy_escape(NULL, string, length);
}
/* for ABI-compatibility with previous versions */
@ -47,25 +47,25 @@ 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(CURL *data, const char *string, int inlength)
char *curl_easy_escape(CURL *curl, const char *string, int length)
{
size_t length;
size_t len;
struct dynbuf d;
(void)data;
(void)curl;
if(!string || (inlength < 0))
if(!string || (length < 0))
return NULL;
length = (inlength ? (size_t)inlength : strlen(string));
if(!length)
len = (length ? (size_t)length : strlen(string));
if(!len)
return curlx_strdup("");
if(length > SIZE_MAX / 16)
if(len > SIZE_MAX / 16)
return NULL;
curlx_dyn_init(&d, (length * 3) + 1);
curlx_dyn_init(&d, (len * 3) + 1);
while(length--) {
while(len--) {
/* treat the characters unsigned */
unsigned char in = (unsigned char)*string++;
@ -160,21 +160,22 @@ 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(CURL *data, const char *string, int length, int *olen)
char *curl_easy_unescape(CURL *curl, const char *string, int inlength,
int *outlength)
{
char *str = NULL;
(void)data;
if(string && (length >= 0)) {
size_t inputlen = (size_t)length;
(void)curl;
if(string && (inlength >= 0)) {
size_t inputlen = (size_t)inlength;
size_t outputlen;
CURLcode res = Curl_urldecode(string, inputlen, &str, &outputlen,
REJECT_NADA);
if(res)
return NULL;
if(olen) {
if(outlength) {
if(outputlen <= (size_t)INT_MAX)
*olen = curlx_uztosi(outputlen);
*outlength = curlx_uztosi(outputlen);
else
/* too large to return in an int, fail! */
curlx_safefree(str);

24
lib/headers.c
View File

@ -52,23 +52,23 @@ static void copy_header_external(struct Curl_header_store *hs,
}
/* public API */
CURLHcode curl_easy_header(CURL *easy,
CURLHcode curl_easy_header(CURL *curl,
const char *name,
size_t nameindex,
unsigned int type,
unsigned int origin,
int request,
struct curl_header **hout)
{
struct Curl_llist_node *e;
struct Curl_llist_node *e_pick = NULL;
struct Curl_easy *data = easy;
struct Curl_easy *data = curl;
size_t match = 0;
size_t amount = 0;
struct Curl_header_store *hs = NULL;
struct Curl_header_store *pick = NULL;
if(!name || !hout || !data ||
(type > (CURLH_HEADER | CURLH_TRAILER | CURLH_CONNECT | CURLH_1XX |
CURLH_PSEUDO)) || !type || (request < -1))
(origin > (CURLH_HEADER | CURLH_TRAILER | CURLH_CONNECT | CURLH_1XX |
CURLH_PSEUDO)) || !origin || (request < -1))
return CURLHE_BAD_ARGUMENT;
if(!Curl_llist_count(&data->state.httphdrs))
return CURLHE_NOHEADERS; /* no headers available */
@ -81,7 +81,7 @@ CURLHcode curl_easy_header(CURL *easy,
for(e = Curl_llist_head(&data->state.httphdrs); e; e = Curl_node_next(e)) {
hs = Curl_node_elem(e);
if(curl_strequal(hs->name, name) &&
(hs->type & type) &&
(hs->type & origin) &&
(hs->request == request)) {
amount++;
pick = hs;
@ -100,7 +100,7 @@ CURLHcode curl_easy_header(CURL *easy,
for(e = Curl_llist_head(&data->state.httphdrs); e; e = Curl_node_next(e)) {
hs = Curl_node_elem(e);
if(curl_strequal(hs->name, name) &&
(hs->type & type) &&
(hs->type & origin) &&
(hs->request == request) &&
(match++ == nameindex)) {
e_pick = e;
@ -118,12 +118,12 @@ CURLHcode curl_easy_header(CURL *easy,
}
/* public API */
struct curl_header *curl_easy_nextheader(CURL *easy,
unsigned int type,
struct curl_header *curl_easy_nextheader(CURL *curl,
unsigned int origin,
int request,
struct curl_header *prev)
{
struct Curl_easy *data = easy;
struct Curl_easy *data = curl;
struct Curl_llist_node *pick;
struct Curl_llist_node *e;
struct Curl_header_store *hs;
@ -149,7 +149,7 @@ struct curl_header *curl_easy_nextheader(CURL *easy,
/* make sure it is the next header of the desired type */
do {
hs = Curl_node_elem(pick);
if((hs->type & type) && (hs->request == request))
if((hs->type & origin) && (hs->request == request))
break;
pick = Curl_node_next(pick);
} while(pick);
@ -167,7 +167,7 @@ struct curl_header *curl_easy_nextheader(CURL *easy,
struct Curl_header_store *check = Curl_node_elem(e);
if(curl_strequal(hs->name, check->name) &&
(check->request == request) &&
(check->type & type))
(check->type & origin))
amount++;
if(e == pick)
index = amount - 1;

16
lib/hostip.c
View File

@ -914,10 +914,10 @@ clean_up:
* is ignored.
*
* Return codes:
* CURLE_OK = success, *entry set to non-NULL
* CURLE_AGAIN = resolving in progress, *entry == NULL
* CURLE_COULDNT_RESOLVE_HOST = error, *entry == NULL
* CURLE_OPERATION_TIMEDOUT = timeout expired, *entry == NULL
* CURLE_OK = success, *pdns set to non-NULL
* CURLE_AGAIN = resolving in progress, *pdns == NULL
* CURLE_COULDNT_RESOLVE_HOST = error, *pdns == NULL
* CURLE_OPERATION_TIMEDOUT = timeout expired, *pdns == NULL
*/
CURLcode Curl_resolv(struct Curl_easy *data,
uint8_t dns_queries,
@ -926,11 +926,11 @@ CURLcode Curl_resolv(struct Curl_easy *data,
uint8_t transport,
timediff_t timeout_ms,
uint32_t *presolv_id,
struct Curl_dns_entry **entry)
struct Curl_dns_entry **pdns)
{
DEBUGASSERT(hostname && *hostname);
*presolv_id = 0;
*entry = NULL;
*pdns = NULL;
if(timeout_ms < 0)
/* got an already expired timeout */
@ -945,7 +945,7 @@ CURLcode Curl_resolv(struct Curl_easy *data,
}
if(timeout_ms && !Curl_doh_wanted(data)) {
return resolv_alarm_timeout(data, dns_queries, hostname, port, transport,
timeout_ms, presolv_id, entry);
timeout_ms, presolv_id, pdns);
}
#endif /* !USE_ALARM_TIMEOUT */
@ -955,7 +955,7 @@ CURLcode Curl_resolv(struct Curl_easy *data,
#endif
return hostip_resolv(data, dns_queries, hostname, port, transport,
timeout_ms, TRUE, presolv_id, entry);
timeout_ms, TRUE, presolv_id, pdns);
}
#ifdef USE_CURL_ASYNC

2
lib/ldap.c
View File

@ -115,7 +115,7 @@ struct ldap_urldesc {
static curl_ldap_num_t ldap_url_parse_low(struct Curl_easy *data,
const struct connectdata *conn,
LDAPURLDesc **ludp);
LDAPURLDesc **ludpp);
static void ldap_free_urldesc_low(LDAPURLDesc *ludp);
#undef ldap_free_urldesc

66
lib/mprintf.c
View File

@ -1071,7 +1071,7 @@ static int addbyter(unsigned char outc, void *f)
}
int curl_mvsnprintf(char *buffer, size_t maxlength, const char *format,
va_list ap_save)
va_list args)
{
int retcode;
struct nsprintf info;
@ -1080,7 +1080,7 @@ int curl_mvsnprintf(char *buffer, size_t maxlength, const char *format,
info.length = 0;
info.max = maxlength;
retcode = formatf(&info, addbyter, format, ap_save);
retcode = formatf(&info, addbyter, format, args);
if(info.max) {
/* we terminate this with a zero byte */
if(info.max == info.length) {
@ -1098,10 +1098,10 @@ int curl_mvsnprintf(char *buffer, size_t maxlength, const char *format,
int curl_msnprintf(char *buffer, size_t maxlength, const char *format, ...)
{
int retcode;
va_list ap_save; /* argument pointer */
va_start(ap_save, format);
retcode = curl_mvsnprintf(buffer, maxlength, format, ap_save);
va_end(ap_save);
va_list args; /* argument pointer */
va_start(args, format);
retcode = curl_mvsnprintf(buffer, maxlength, format, args);
va_end(args);
return retcode;
}
@ -1118,13 +1118,13 @@ static int alloc_addbyter(unsigned char outc, void *f)
}
/* appends the formatted string, returns MERR error code */
int curlx_dyn_vprintf(struct dynbuf *dyn, const char *format, va_list ap_save)
int curlx_dyn_vprintf(struct dynbuf *dyn, const char *format, va_list args)
{
struct asprintf info;
info.b = dyn;
info.merr = MERR_OK;
(void)formatf(&info, alloc_addbyter, format, ap_save);
(void)formatf(&info, alloc_addbyter, format, args);
if(info.merr) {
curlx_dyn_free(info.b);
return info.merr;
@ -1132,7 +1132,7 @@ int curlx_dyn_vprintf(struct dynbuf *dyn, const char *format, va_list ap_save)
return 0;
}
char *curl_mvaprintf(const char *format, va_list ap_save)
char *curl_mvaprintf(const char *format, va_list args)
{
struct asprintf info;
struct dynbuf dyn;
@ -1140,7 +1140,7 @@ char *curl_mvaprintf(const char *format, va_list ap_save)
curlx_dyn_init(info.b, DYN_APRINTF);
info.merr = MERR_OK;
(void)formatf(&info, alloc_addbyter, format, ap_save);
(void)formatf(&info, alloc_addbyter, format, args);
if(info.merr) {
curlx_dyn_free(info.b);
return NULL;
@ -1152,11 +1152,11 @@ char *curl_mvaprintf(const char *format, va_list ap_save)
char *curl_maprintf(const char *format, ...)
{
va_list ap_save;
va_list args;
char *s;
va_start(ap_save, format);
s = curl_mvaprintf(format, ap_save);
va_end(ap_save);
va_start(args, format);
s = curl_mvaprintf(format, args);
va_end(args);
return s;
}
@ -1170,11 +1170,11 @@ static int storebuffer(unsigned char outc, void *f)
int curl_msprintf(char *buffer, const char *format, ...)
{
va_list ap_save; /* argument pointer */
va_list args; /* argument pointer */
int retcode;
va_start(ap_save, format);
retcode = formatf(&buffer, storebuffer, format, ap_save);
va_end(ap_save);
va_start(args, format);
retcode = formatf(&buffer, storebuffer, format, args);
va_end(args);
*buffer = 0; /* we terminate this with a zero byte */
return retcode;
}
@ -1190,36 +1190,36 @@ static int fputc_wrapper(unsigned char outc, void *f)
int curl_mprintf(const char *format, ...)
{
int retcode;
va_list ap_save; /* argument pointer */
va_start(ap_save, format);
retcode = formatf(stdout, fputc_wrapper, format, ap_save);
va_end(ap_save);
va_list args; /* argument pointer */
va_start(args, format);
retcode = formatf(stdout, fputc_wrapper, format, args);
va_end(args);
return retcode;
}
int curl_mfprintf(FILE *whereto, const char *format, ...)
int curl_mfprintf(FILE *fd, const char *format, ...)
{
int retcode;
va_list ap_save; /* argument pointer */
va_start(ap_save, format);
retcode = formatf(whereto, fputc_wrapper, format, ap_save);
va_end(ap_save);
va_list args; /* argument pointer */
va_start(args, format);
retcode = formatf(fd, fputc_wrapper, format, args);
va_end(args);
return retcode;
}
int curl_mvsprintf(char *buffer, const char *format, va_list ap_save)
int curl_mvsprintf(char *buffer, const char *format, va_list args)
{
int retcode = formatf(&buffer, storebuffer, format, ap_save);
int retcode = formatf(&buffer, storebuffer, format, args);
*buffer = 0; /* we terminate this with a zero byte */
return retcode;
}
int curl_mvprintf(const char *format, va_list ap_save)
int curl_mvprintf(const char *format, va_list args)
{
return formatf(stdout, fputc_wrapper, format, ap_save);
return formatf(stdout, fputc_wrapper, format, args);
}
int curl_mvfprintf(FILE *whereto, const char *format, va_list ap_save)
int curl_mvfprintf(FILE *fd, const char *format, va_list args)
{
return formatf(whereto, fputc_wrapper, format, ap_save);
return formatf(fd, fputc_wrapper, format, args);
}

22
lib/multi.c
View File

@ -453,11 +453,11 @@ static CURLMcode multi_xfers_add(struct Curl_multi *multi,
return CURLM_OK;
}
CURLMcode curl_multi_add_handle(CURLM *m, CURL *d)
CURLMcode curl_multi_add_handle(CURLM *m, CURL *curl)
{
CURLMcode mresult;
struct Curl_multi *multi = m;
struct Curl_easy *data = d;
struct Curl_easy *data = curl;
/* First, make some basic checks that the CURLM handle is a good handle */
if(!GOOD_MULTI_HANDLE(multi))
@ -775,10 +775,10 @@ static void close_connect_only(struct connectdata *conn,
connclose(conn, "Removing connect-only easy handle");
}
CURLMcode curl_multi_remove_handle(CURLM *m, CURL *d)
CURLMcode curl_multi_remove_handle(CURLM *m, CURL *curl)
{
struct Curl_multi *multi = m;
struct Curl_easy *data = d;
struct Curl_easy *data = curl;
bool premature;
struct Curl_llist_node *e;
CURLMcode mresult;
@ -1655,22 +1655,22 @@ out:
return mresult;
}
CURLMcode curl_multi_wait(CURLM *multi,
CURLMcode curl_multi_wait(CURLM *m,
struct curl_waitfd extra_fds[],
unsigned int extra_nfds,
int timeout_ms,
int *ret)
{
return multi_wait(multi, extra_fds, extra_nfds, timeout_ms, ret, FALSE);
return multi_wait(m, extra_fds, extra_nfds, timeout_ms, ret, FALSE);
}
CURLMcode curl_multi_poll(CURLM *multi,
CURLMcode curl_multi_poll(CURLM *m,
struct curl_waitfd extra_fds[],
unsigned int extra_nfds,
int timeout_ms,
int *ret)
{
return multi_wait(multi, extra_fds, extra_nfds, timeout_ms, ret, TRUE);
return multi_wait(m, extra_fds, extra_nfds, timeout_ms, ret, TRUE);
}
CURLMcode curl_multi_wakeup(CURLM *m)
@ -3723,14 +3723,14 @@ void Curl_expire_clear(struct Curl_easy *data)
}
}
CURLMcode curl_multi_assign(CURLM *m, curl_socket_t s,
void *hashp)
CURLMcode curl_multi_assign(CURLM *m, curl_socket_t sockfd,
void *sockp)
{
struct Curl_multi *multi = m;
if(!GOOD_MULTI_HANDLE(multi))
return CURLM_BAD_HANDLE;
return Curl_multi_ev_assign(multi, s, hashp);
return Curl_multi_ev_assign(multi, sockfd, sockp);
}
static void move_pending_to_connect(struct Curl_multi *multi,

2
lib/rand.h
View File

@ -25,7 +25,7 @@
***************************************************************************/
CURLcode Curl_rand_bytes(struct Curl_easy *data,
#ifdef DEBUGBUILD
bool allow_env_override,
bool env_override,
#endif
unsigned char *rnd, size_t num);

10
lib/setopt.c
View File

@ -2901,21 +2901,21 @@ CURLcode Curl_vsetopt(struct Curl_easy *data, CURLoption option, va_list param)
*/
#undef curl_easy_setopt
CURLcode curl_easy_setopt(CURL *d, CURLoption tag, ...)
CURLcode curl_easy_setopt(CURL *curl, CURLoption option, ...)
{
va_list arg;
CURLcode result;
struct Curl_easy *data = d;
struct Curl_easy *data = curl;
if(!data)
return CURLE_BAD_FUNCTION_ARGUMENT;
va_start(arg, tag);
va_start(arg, option);
result = Curl_vsetopt(data, tag, arg);
result = Curl_vsetopt(data, option, arg);
va_end(arg);
if(result == CURLE_BAD_FUNCTION_ARGUMENT)
failf(data, "setopt 0x%x got bad argument", tag);
failf(data, "setopt 0x%x got bad argument", option);
return result;
}

8
lib/vauth/ntlm.c
View File

@ -424,7 +424,7 @@ CURLcode Curl_auth_create_ntlm_type1_message(struct Curl_easy *data,
const char *userp,
const char *passwdp,
const char *service,
const char *hostname,
const char *host,
struct ntlmdata *ntlm,
struct bufref *out)
{
@ -445,7 +445,7 @@ CURLcode Curl_auth_create_ntlm_type1_message(struct Curl_easy *data,
size_t size;
char *ntlmbuf;
const char *host = ""; /* empty */
const char *hostname = ""; /* empty */
const char *domain = ""; /* empty */
size_t hostlen = 0;
size_t domlen = 0;
@ -456,7 +456,7 @@ CURLcode Curl_auth_create_ntlm_type1_message(struct Curl_easy *data,
(void)userp;
(void)passwdp;
(void)service;
(void)hostname;
(void)host;
/* Clean up any former leftovers and initialise to defaults */
Curl_auth_cleanup_ntlm(ntlm);
@ -490,7 +490,7 @@ CURLcode Curl_auth_create_ntlm_type1_message(struct Curl_easy *data,
SHORTPAIR(hostlen),
SHORTPAIR(hostoff),
0, 0,
host, /* this is empty */
hostname, /* this is empty */
domain /* this is empty */);
if(!ntlmbuf)

10
lib/vauth/ntlm_sspi.c
View File

@ -191,21 +191,21 @@ CURLcode Curl_auth_create_ntlm_type1_message(struct Curl_easy *data,
* Returns CURLE_OK on success.
*/
CURLcode Curl_auth_decode_ntlm_type2_message(struct Curl_easy *data,
const struct bufref *type2,
const struct bufref *type2ref,
struct ntlmdata *ntlm)
{
/* Ensure we have a valid type-2 message */
if(!Curl_bufref_len(type2)) {
if(!Curl_bufref_len(type2ref)) {
infof(data, "NTLM handshake failure (empty type-2 message)");
return CURLE_BAD_CONTENT_ENCODING;
}
/* Store the challenge for later use */
ntlm->input_token = curlx_memdup0(Curl_bufref_ptr(type2),
Curl_bufref_len(type2));
ntlm->input_token = curlx_memdup0(Curl_bufref_ptr(type2ref),
Curl_bufref_len(type2ref));
if(!ntlm->input_token)
return CURLE_OUT_OF_MEMORY;
ntlm->input_token_len = Curl_bufref_len(type2);
ntlm->input_token_len = Curl_bufref_len(type2ref);
return CURLE_OK;
}

4
lib/vauth/vauth.h
View File

@ -199,7 +199,7 @@ CURLcode Curl_auth_create_ntlm_type1_message(struct Curl_easy *data,
const char *userp,
const char *passwdp,
const char *service,
const char *hostname,
const char *host,
struct ntlmdata *ntlm,
struct bufref *out);
@ -263,7 +263,7 @@ CURLcode Curl_auth_create_gssapi_user_message(struct Curl_easy *data,
const char *passwdp,
const char *service,
const char *host,
const bool mutual,
const bool mutual_auth,
const struct bufref *chlg,
struct kerberos5data *krb5,
struct bufref *out);

2
lib/vtls/gtls.h
View File

@ -89,7 +89,7 @@ CURLcode Curl_gtls_ctx_init(struct gtls_ctx *gctx,
struct Curl_cfilter *cf,
struct Curl_easy *data,
struct ssl_peer *peer,
const struct alpn_spec *alpns,
const struct alpn_spec *alpns_requested,
Curl_gtls_ctx_setup_cb *cb_setup,
void *cb_user_data,
void *ssl_user_data,

2
lib/vtls/wolfssl.h
View File

@ -65,7 +65,7 @@ CURLcode Curl_wssl_ctx_init(struct wssl_ctx *wctx,
struct Curl_cfilter *cf,
struct Curl_easy *data,
struct ssl_peer *peer,
const struct alpn_spec *alpns,
const struct alpn_spec *alpns_requested,
Curl_wssl_ctx_setup_cb *cb_setup,
void *cb_user_data,
void *ssl_user_data,

28
lib/ws.c
View File

@ -1527,16 +1527,16 @@ static CURLcode nw_in_recv(void *reader_ctx,
return curl_easy_recv(data, buf, buflen, pnread);
}
CURLcode curl_ws_recv(CURL *d, void *buffer,
size_t buflen, size_t *nread,
CURLcode curl_ws_recv(CURL *curl, void *buffer,
size_t buflen, size_t *recv,
const struct curl_ws_frame **metap)
{
struct Curl_easy *data = d;
struct Curl_easy *data = curl;
struct connectdata *conn;
struct websocket *ws;
struct ws_collect ctx;
*nread = 0;
*recv = 0;
*metap = NULL;
if(!GOOD_EASY_HANDLE(data) || (buflen && !buffer))
return CURLE_BAD_FUNCTION_ARGUMENT;
@ -1609,10 +1609,10 @@ CURLcode curl_ws_recv(CURL *d, void *buffer,
update_meta(ws, ctx.frame_age, ctx.frame_flags, ctx.payload_offset,
ctx.payload_len, ctx.bufidx);
*metap = &ws->recvframe;
*nread = ws->recvframe.len;
*recv = ws->recvframe.len;
CURL_TRC_WS(data, "curl_ws_recv(len=%zu) -> %zu bytes (frame at %"
FMT_OFF_T ", %" FMT_OFF_T " left)",
buflen, *nread, ws->recvframe.offset,
buflen, *recv, ws->recvframe.offset,
ws->recvframe.bytesleft);
/* all's well, try to send any pending control. we do not know
* when the application will call `curl_ws_send()` again. */
@ -1763,7 +1763,7 @@ static CURLcode ws_send_raw(struct Curl_easy *data, const void *buffer,
return result;
}
CURLcode curl_ws_send(CURL *d, const void *buffer_arg,
CURLcode curl_ws_send(CURL *curl, const void *buffer_arg,
size_t buflen, size_t *sent,
curl_off_t fragsize,
unsigned int flags)
@ -1771,7 +1771,7 @@ CURLcode curl_ws_send(CURL *d, const void *buffer_arg,
struct websocket *ws;
const uint8_t *buffer = buffer_arg;
CURLcode result = CURLE_OK;
struct Curl_easy *data = d;
struct Curl_easy *data = curl;
size_t ndummy;
size_t *pnsent = sent ? sent : &ndummy;
@ -1851,11 +1851,11 @@ static CURLcode ws_setup_conn(struct Curl_easy *data,
return Curl_http_setup_conn(data, conn);
}
const struct curl_ws_frame *curl_ws_meta(CURL *d)
const struct curl_ws_frame *curl_ws_meta(CURL *curl)
{
/* we only return something for websocket, called from within the callback
when not using raw mode */
struct Curl_easy *data = d;
struct Curl_easy *data = curl;
if(GOOD_EASY_HANDLE(data) && Curl_is_in_callback(data) &&
data->conn && !data->set.ws_raw_mode) {
struct websocket *ws;
@ -1866,13 +1866,13 @@ const struct curl_ws_frame *curl_ws_meta(CURL *d)
return NULL;
}
CURL_EXTERN CURLcode curl_ws_start_frame(CURL *d,
CURL_EXTERN CURLcode curl_ws_start_frame(CURL *curl,
unsigned int flags,
curl_off_t frame_len)
{
struct websocket *ws;
CURLcode result = CURLE_OK;
struct Curl_easy *data = d;
struct Curl_easy *data = curl;
if(!GOOD_EASY_HANDLE(data))
return CURLE_BAD_FUNCTION_ARGUMENT;
@ -1941,13 +1941,13 @@ const struct Curl_protocol Curl_protocol_ws = {
#else
CURLcode curl_ws_recv(CURL *curl, void *buffer, size_t buflen,
size_t *nread,
size_t *recv,
const struct curl_ws_frame **metap)
{
(void)curl;
(void)buffer;
(void)buflen;
(void)nread;
(void)recv;
(void)metap;
return CURLE_NOT_BUILT_IN;
}

2
src/tool_dirhie.h
View File

@ -25,6 +25,6 @@
***************************************************************************/
#include "tool_setup.h"
CURLcode create_dir_hierarchy(const char *outfileo);
CURLcode create_dir_hierarchy(const char *outfile);
#endif /* HEADER_CURL_TOOL_DIRHIE_H */

4
src/tool_paramhlp.c
View File

@ -294,7 +294,7 @@ ParameterError str2unummax(long *val, const char *str, long max)
* data.
*/
ParameterError secs2ms(long *valp, const char *str)
ParameterError secs2ms(long *val, const char *str)
{
curl_off_t secs;
long ms = 0;
@ -326,7 +326,7 @@ ParameterError secs2ms(long *valp, const char *str)
ms = ((long)fracs * 100) / digs[len - 1];
}
*valp = ((long)secs * 1000) + ms;
*val = ((long)secs * 1000) + ms;
return PARAM_OK;
}

5
src/tool_setopt.h
View File

@ -78,7 +78,7 @@ extern const struct NameValueUnsigned setopt_nv_CURLHSTS[];
/* Intercept setopt calls for --libcurl */
CURLcode tool_setopt_enum(CURL *curl, const char *name, CURLoption tag,
const struct NameValue *nv, long lval);
const struct NameValue *nvlist, long lval);
CURLcode tool_setopt_SSLVERSION(CURL *curl, const char *name, CURLoption tag,
long lval);
CURLcode tool_setopt_flags(CURL *curl, struct OperationConfig *config,
@ -86,7 +86,8 @@ CURLcode tool_setopt_flags(CURL *curl, struct OperationConfig *config,
const struct NameValue *nv, long lval);
CURLcode tool_setopt_bitmask(CURL *curl,
const char *name, CURLoption tag,
const struct NameValueUnsigned *nv, long lval);
const struct NameValueUnsigned *nvlist,
long lval);
CURLcode tool_setopt_mimepost(CURL *curl, struct OperationConfig *config,
const char *name, CURLoption tag,
curl_mime *mimepost);