- 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
- 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
CheckOptions:
misc-header-include-cycle.IgnoredFilesList: 'curl/curl.h'
+ readability-inconsistent-declaration-parameter-name.Strict: true
HeaderFilterRegex: '.*' # Default in v22.1.0+
CURLHcode curl_easy_header(CURL *easy,
const char *name,
- size_t index,
+ size_t nameindex,
unsigned int origin,
int request,
struct curl_header **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
~~~c
#include <curl/curl.h>
-CURLcode curl_easy_pause(CURL *handle, int bitmask);
+CURLcode curl_easy_pause(CURL *handle, int action);
~~~
# DESCRIPTION
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
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.
* %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);
* 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 */
} 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.
* 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
* 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,
/* 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,
* 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);
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);
*
* 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()
*
* 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()
*
* 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,
*
* 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,
*
* 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,
*
* 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()
* 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);
/*
*
* 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()
* 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);
/*
*
* 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
*
* 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 */
*
* Returns: CURLM error code.
*/
-CURL_EXTERN CURLMcode curl_multi_setopt(CURLM *multi_handle,
+CURL_EXTERN CURLMcode curl_multi_setopt(CURLM *m,
CURLMoption option, ...);
/*
*
* 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);
/*
*
* 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 */
*
* 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);
*
* 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);
/*
* 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
* 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
* 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);
/*
* 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);
/*
* 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);
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
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,
/* 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. */
#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);
#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 */
};
/* 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);
* 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
* 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
* 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
* 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);
* 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;
* 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))
* 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;
* 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;
* 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;
* 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))
/*
* 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;
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;
#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;
#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 */
/* 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++;
* 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);
}
/* 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 */
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;
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;
}
/* 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;
/* 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);
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;
* 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,
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 */
}
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 */
#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
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
}
int curl_mvsnprintf(char *buffer, size_t maxlength, const char *format,
- va_list ap_save)
+ va_list args)
{
int retcode;
struct nsprintf info;
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) {
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;
}
}
/* 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;
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;
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;
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;
}
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;
}
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);
}
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))
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;
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)
}
}
-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,
***************************************************************************/
CURLcode Curl_rand_bytes(struct Curl_easy *data,
#ifdef DEBUGBUILD
- bool allow_env_override,
+ bool env_override,
#endif
unsigned char *rnd, size_t num);
*/
#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;
}
const char *userp,
const char *passwdp,
const char *service,
- const char *hostname,
+ const char *host,
struct ntlmdata *ntlm,
struct bufref *out)
{
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;
(void)userp;
(void)passwdp;
(void)service;
- (void)hostname;
+ (void)host;
/* Clean up any former leftovers and initialise to defaults */
Curl_auth_cleanup_ntlm(ntlm);
SHORTPAIR(hostlen),
SHORTPAIR(hostoff),
0, 0,
- host, /* this is empty */
+ hostname, /* this is empty */
domain /* this is empty */);
if(!ntlmbuf)
* 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;
}
const char *userp,
const char *passwdp,
const char *service,
- const char *hostname,
+ const char *host,
struct ntlmdata *ntlm,
struct bufref *out);
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);
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,
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,
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;
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. */
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)
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;
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;
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;
#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;
}
***************************************************************************/
#include "tool_setup.h"
-CURLcode create_dir_hierarchy(const char *outfileo);
+CURLcode create_dir_hierarchy(const char *outfile);
#endif /* HEADER_CURL_TOOL_DIRHIE_H */
* data.
*/
-ParameterError secs2ms(long *valp, const char *str)
+ParameterError secs2ms(long *val, const char *str)
{
curl_off_t secs;
long ms = 0;
ms = ((long)fracs * 100) / digs[len - 1];
}
- *valp = ((long)secs * 1000) + ms;
+ *val = ((long)secs * 1000) + ms;
return PARAM_OK;
}
/* 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,
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);
projects / thirdparty / curl.git / commitdiff
