From df6014894b789768b139fff27e8aed9dbc46ed79 Mon Sep 17 00:00:00 2001 From: Viktor Szakats Date: Tue, 3 Mar 2026 01:58:29 +0100 Subject: [PATCH] clang-tidy: enable more checks, fix fallouts - 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 --- .clang-tidy.yml | 11 +++++ docs/libcurl/curl_easy_header.md | 10 ++--- docs/libcurl/curl_easy_pause.md | 4 +- docs/libcurl/curl_multi_timeout.md | 2 +- include/curl/curl.h | 21 +++++----- include/curl/header.h | 6 +-- include/curl/multi.h | 50 +++++++++++----------- include/curl/urlapi.h | 6 +-- include/curl/websockets.h | 2 +- lib/curl_gssapi.h | 2 +- lib/curl_setup.h | 3 +- lib/curlx/dynbuf.h | 2 +- lib/curlx/fopen.h | 2 +- lib/curlx/inet_ntop.h | 10 ++--- lib/dnscache.h | 2 +- lib/doh.h | 3 +- lib/easy.c | 53 ++++++++++++------------ lib/escape.c | 35 ++++++++-------- lib/headers.c | 24 +++++------ lib/hostip.c | 16 ++++---- lib/ldap.c | 2 +- lib/mprintf.c | 66 +++++++++++++++--------------- lib/multi.c | 22 +++++----- lib/rand.h | 2 +- lib/setopt.c | 10 ++--- lib/vauth/ntlm.c | 8 ++-- lib/vauth/ntlm_sspi.c | 10 ++--- lib/vauth/vauth.h | 4 +- lib/vtls/gtls.h | 2 +- lib/vtls/wolfssl.h | 2 +- lib/ws.c | 28 ++++++------- src/tool_dirhie.h | 2 +- src/tool_paramhlp.c | 4 +- src/tool_setopt.h | 5 ++- 34 files changed, 222 insertions(+), 209 deletions(-) diff --git a/.clang-tidy.yml b/.clang-tidy.yml index 0a1aee8e49..5f523fb50b 100644 --- a/.clang-tidy.yml +++ b/.clang-tidy.yml @@ -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+ diff --git a/docs/libcurl/curl_easy_header.md b/docs/libcurl/curl_easy_header.md index bdab170708..1e48a728c2 100644 --- a/docs/libcurl/curl_easy_header.md +++ b/docs/libcurl/curl_easy_header.md @@ -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 diff --git a/docs/libcurl/curl_easy_pause.md b/docs/libcurl/curl_easy_pause.md index f80abd5523..31e1cffe77 100644 --- a/docs/libcurl/curl_easy_pause.md +++ b/docs/libcurl/curl_easy_pause.md @@ -21,7 +21,7 @@ curl_easy_pause - pause and unpause a connection ~~~c #include -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 diff --git a/docs/libcurl/curl_multi_timeout.md b/docs/libcurl/curl_multi_timeout.md index 5995f6528c..a4a7fa66fa 100644 --- a/docs/libcurl/curl_multi_timeout.md +++ b/docs/libcurl/curl_multi_timeout.md @@ -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. diff --git a/include/curl/curl.h b/include/curl/curl.h index aa3110ff3c..6961a6c4c1 100644 --- a/include/curl/curl.h +++ b/include/curl/curl.h @@ -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); diff --git a/include/curl/header.h b/include/curl/header.h index 85c10c8d78..5c3281a531 100644 --- a/include/curl/header.h +++ b/include/curl/header.h @@ -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); diff --git a/include/curl/multi.h b/include/curl/multi.h index 412fdb94af..060b73eeec 100644 --- a/include/curl/multi.h +++ b/include/curl/multi.h @@ -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 diff --git a/include/curl/urlapi.h b/include/curl/urlapi.h index f8c3a4cad5..b1f3a2316b 100644 --- a/include/curl/urlapi.h +++ b/include/curl/urlapi.h @@ -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); /* diff --git a/include/curl/websockets.h b/include/curl/websockets.h index 402a2ca0f5..bf93715abf 100644 --- a/include/curl/websockets.h +++ b/include/curl/websockets.h @@ -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); diff --git a/lib/curl_gssapi.h b/lib/curl_gssapi.h index 0d3609715a..fc3759ebcb 100644 --- a/lib/curl_gssapi.h +++ b/lib/curl_gssapi.h @@ -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 diff --git a/lib/curl_setup.h b/lib/curl_setup.h index 5668340dd1..0d4a8fa577 100644 --- a/lib/curl_setup.h +++ b/lib/curl_setup.h @@ -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, diff --git a/lib/curlx/dynbuf.h b/lib/curlx/dynbuf.h index 6f09e1322e..0cf4a2c576 100644 --- a/lib/curlx/dynbuf.h +++ b/lib/curlx/dynbuf.h @@ -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. */ diff --git a/lib/curlx/fopen.h b/lib/curlx/fopen.h index d89830edd3..b64fbf6514 100644 --- a/lib/curlx/fopen.h +++ b/lib/curlx/fopen.h @@ -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); diff --git a/lib/curlx/inet_ntop.h b/lib/curlx/inet_ntop.h index 2e3419f02b..ba8299fe4e 100644 --- a/lib/curlx/inet_ntop.h +++ b/lib/curlx/inet_ntop.h @@ -36,15 +36,15 @@ #include #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 */ diff --git a/lib/dnscache.h b/lib/dnscache.h index a9f42356c7..ebe25f6dd4 100644 --- a/lib/dnscache.h +++ b/lib/dnscache.h @@ -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); diff --git a/lib/doh.h b/lib/doh.h index 00774465b7..428b230a58 100644 --- a/lib/doh.h +++ b/lib/doh.h @@ -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 diff --git a/lib/easy.c b/lib/easy.c index 461b1dfc46..b2096fb8d3 100644 --- a/lib/easy.c +++ b/lib/easy.c @@ -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; diff --git a/lib/escape.c b/lib/escape.c index 0427faed1f..4aff583de1 100644 --- a/lib/escape.c +++ b/lib/escape.c @@ -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); diff --git a/lib/headers.c b/lib/headers.c index 5a6b120c96..195e12b371 100644 --- a/lib/headers.c +++ b/lib/headers.c @@ -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; diff --git a/lib/hostip.c b/lib/hostip.c index d6052a45f8..7dac8790e0 100644 --- a/lib/hostip.c +++ b/lib/hostip.c @@ -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 diff --git a/lib/ldap.c b/lib/ldap.c index a816b1c3fa..f8e7ff6a70 100644 --- a/lib/ldap.c +++ b/lib/ldap.c @@ -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 diff --git a/lib/mprintf.c b/lib/mprintf.c index f2348aae0e..66ccae2190 100644 --- a/lib/mprintf.c +++ b/lib/mprintf.c @@ -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); } diff --git a/lib/multi.c b/lib/multi.c index 10be2b56ab..f6d719287f 100644 --- a/lib/multi.c +++ b/lib/multi.c @@ -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, diff --git a/lib/rand.h b/lib/rand.h index 86765806f9..afccd0aac1 100644 --- a/lib/rand.h +++ b/lib/rand.h @@ -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); diff --git a/lib/setopt.c b/lib/setopt.c index cf3ac99a2c..dae4218b70 100644 --- a/lib/setopt.c +++ b/lib/setopt.c @@ -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; } diff --git a/lib/vauth/ntlm.c b/lib/vauth/ntlm.c index afd165bc9a..1e485ed34d 100644 --- a/lib/vauth/ntlm.c +++ b/lib/vauth/ntlm.c @@ -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) diff --git a/lib/vauth/ntlm_sspi.c b/lib/vauth/ntlm_sspi.c index 8a0e45ea65..4c41eb21f4 100644 --- a/lib/vauth/ntlm_sspi.c +++ b/lib/vauth/ntlm_sspi.c @@ -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; } diff --git a/lib/vauth/vauth.h b/lib/vauth/vauth.h index 3e66c89cb5..b5ff31414f 100644 --- a/lib/vauth/vauth.h +++ b/lib/vauth/vauth.h @@ -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); diff --git a/lib/vtls/gtls.h b/lib/vtls/gtls.h index a5e55cd4f9..49106dd869 100644 --- a/lib/vtls/gtls.h +++ b/lib/vtls/gtls.h @@ -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, diff --git a/lib/vtls/wolfssl.h b/lib/vtls/wolfssl.h index c29ca4163c..778002840d 100644 --- a/lib/vtls/wolfssl.h +++ b/lib/vtls/wolfssl.h @@ -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, diff --git a/lib/ws.c b/lib/ws.c index e14bee46f7..e3b8f6ce9b 100644 --- a/lib/ws.c +++ b/lib/ws.c @@ -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; } diff --git a/src/tool_dirhie.h b/src/tool_dirhie.h index 8503f5e4f3..d48615a0c0 100644 --- a/src/tool_dirhie.h +++ b/src/tool_dirhie.h @@ -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 */ diff --git a/src/tool_paramhlp.c b/src/tool_paramhlp.c index 970d42192a..18e2d1a625 100644 --- a/src/tool_paramhlp.c +++ b/src/tool_paramhlp.c @@ -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; } diff --git a/src/tool_setopt.h b/src/tool_setopt.h index bb85ae7088..ee4d2a6cd1 100644 --- a/src/tool_setopt.h +++ b/src/tool_setopt.h @@ -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);