Move curlx_ functions into its own subdir.
The idea is to use the curlx_ prefix proper on these functions, and use
these same function names both in tool, lib and test suite source code.
Stop the previous special #define setup for curlx_ names.
The printf defines are now done for the library alone. Tests no longer
use the printf defines. The tool code sets its own defines. The printf
functions are not curlx, they are publicly available.
The strcase defines are not curlx_ functions and should not be used by
tool or server code.
dynbuf, warnless, base64, strparse, timeval, timediff are now proper
curlx functions.
When libcurl is built statically, the functions from the library can be
used as-is. The key is then that the functions must work as-is, without
having to be recompiled for use in tool/tests. This avoids symbol
collisions - when libcurl is built statically, we use those functions
directly when building the tool/tests. When libcurl is shared, we
build/link them separately for the tool/tests.
Assisted-by: Jay Satiro
Closes #17253
buffer. The members of that struct **MUST NOT** be accessed or modified
without using the dedicated dynbuf API.
-## `Curl_dyn_init`
+## `curlx_dyn_init`
```c
-void Curl_dyn_init(struct dynbuf *s, size_t toobig);
+void curlx_dyn_init(struct dynbuf *s, size_t toobig);
```
This initializes a struct to use for dynbuf and it cannot fail. The `toobig`
grow to. The functions below return `CURLE_OUT_OF_MEMORY` when hitting this
limit.
-## `Curl_dyn_free`
+## `curlx_dyn_free`
```c
-void Curl_dyn_free(struct dynbuf *s);
+void curlx_dyn_free(struct dynbuf *s);
```
Free the associated memory and clean up. After a free, the `dynbuf` struct can
be reused to start appending new data to.
-## `Curl_dyn_addn`
+## `curlx_dyn_addn`
```c
-CURLcode Curl_dyn_addn(struct dynbuf *s, const void *mem, size_t len);
+CURLcode curlx_dyn_addn(struct dynbuf *s, const void *mem, size_t len);
```
Append arbitrary data of a given length to the end of the buffer.
-If this function fails it calls `Curl_dyn_free` on `dynbuf`.
+If this function fails it calls `curlx_dyn_free` on `dynbuf`.
-## `Curl_dyn_add`
+## `curlx_dyn_add`
```c
-CURLcode Curl_dyn_add(struct dynbuf *s, const char *str);
+CURLcode curlx_dyn_add(struct dynbuf *s, const char *str);
```
Append a C string to the end of the buffer.
-If this function fails it calls `Curl_dyn_free` on `dynbuf`.
+If this function fails it calls `curlx_dyn_free` on `dynbuf`.
-## `Curl_dyn_addf`
+## `curlx_dyn_addf`
```c
-CURLcode Curl_dyn_addf(struct dynbuf *s, const char *fmt, ...);
+CURLcode curlx_dyn_addf(struct dynbuf *s, const char *fmt, ...);
```
Append a `printf()`-style string to the end of the buffer.
-If this function fails it calls `Curl_dyn_free` on `dynbuf`.
+If this function fails it calls `curlx_dyn_free` on `dynbuf`.
-## `Curl_dyn_vaddf`
+## `curlx_dyn_vaddf`
```c
-CURLcode Curl_dyn_vaddf(struct dynbuf *s, const char *fmt, va_list ap);
+CURLcode curlx_dyn_vaddf(struct dynbuf *s, const char *fmt, va_list ap);
```
Append a `vprintf()`-style string to the end of the buffer.
-If this function fails it calls `Curl_dyn_free` on `dynbuf`.
+If this function fails it calls `curlx_dyn_free` on `dynbuf`.
-## `Curl_dyn_reset`
+## `curlx_dyn_reset`
```c
-void Curl_dyn_reset(struct dynbuf *s);
+void curlx_dyn_reset(struct dynbuf *s);
```
Reset the buffer length, but leave the allocation.
-## `Curl_dyn_tail`
+## `curlx_dyn_tail`
```c
-CURLcode Curl_dyn_tail(struct dynbuf *s, size_t length);
+CURLcode curlx_dyn_tail(struct dynbuf *s, size_t length);
```
Keep `length` bytes of the buffer tail (the last `length` bytes of the
buffer). The rest of the buffer is dropped. The specified `length` must not be
larger than the buffer length. To instead keep the leading part, see
-`Curl_dyn_setlen()`.
+`curlx_dyn_setlen()`.
-## `Curl_dyn_ptr`
+## `curlx_dyn_ptr`
```c
-char *Curl_dyn_ptr(const struct dynbuf *s);
+char *curlx_dyn_ptr(const struct dynbuf *s);
```
Returns a `char *` to the buffer if it has a length, otherwise may return
NULL. Since the buffer may be reallocated, this pointer should not be trusted
or used anymore after the next buffer manipulation call.
-## `Curl_dyn_uptr`
+## `curlx_dyn_uptr`
```c
-unsigned char *Curl_dyn_uptr(const struct dynbuf *s);
+unsigned char *curlx_dyn_uptr(const struct dynbuf *s);
```
Returns an `unsigned char *` to the buffer if it has a length, otherwise may
return NULL. Since the buffer may be reallocated, this pointer should not be
trusted or used anymore after the next buffer manipulation call.
-## `Curl_dyn_len`
+## `curlx_dyn_len`
```c
-size_t Curl_dyn_len(const struct dynbuf *s);
+size_t curlx_dyn_len(const struct dynbuf *s);
```
Returns the length of the buffer in bytes. Does not include the terminating
zero byte.
-## `Curl_dyn_setlen`
+## `curlx_dyn_setlen`
```c
-CURLcode Curl_dyn_setlen(struct dynbuf *s, size_t len);
+CURLcode curlx_dyn_setlen(struct dynbuf *s, size_t len);
```
Sets the new shorter length of the buffer in number of bytes. Keeps the
leftmost set number of bytes, discards the rest. To instead keep the tail part
-of the buffer, see `Curl_dyn_tail()`.
+of the buffer, see `curlx_dyn_tail()`.
-## `Curl_dyn_take`
+## `curlx_dyn_take`
```c
-char *Curl_dyn_take(struct dynbuf *s, size_t *plen);
+char *curlx_dyn_take(struct dynbuf *s, size_t *plen);
```
Transfers ownership of the internal buffer to the caller. The dynbuf
second word:
~~~c
-if(Curl_str_word(&line, &word1, MAX) ||
- Curl_str_singlespace(&line) ||
- Curl_str_word(&line, &word2, MAX))
+if(curlx_str_word(&line, &word1, MAX) ||
+ curlx_str_singlespace(&line) ||
+ curlx_str_word(&line, &word2, MAX))
fprintf(stderr, "ERROR\n");
~~~
};
~~~
-Access the struct fields with `Curl_str()` for the pointer and `Curl_strlen()`
+Access the struct fields with `curlx_str()` for the pointer and `curlx_strlen()`
for the length rather than using the struct fields directly.
-## `Curl_str_init`
+## `curlx_str_init`
~~~c
-void Curl_str_init(struct Curl_str *out)
+void curlx_str_init(struct Curl_str *out)
~~~
This initiates a string struct. The parser functions that store info in
strings always init the string themselves, so this stand-alone use is often
not necessary.
-## `Curl_str_assign`
+## `curlx_str_assign`
~~~c
-void Curl_str_assign(struct Curl_str *out, const char *str, size_t len)
+void curlx_str_assign(struct Curl_str *out, const char *str, size_t len)
~~~
Set a pointer and associated length in the string struct.
-## `Curl_str_word`
+## `curlx_str_word`
~~~c
-int Curl_str_word(char **linep, struct Curl_str *out, const size_t max);
+int curlx_str_word(char **linep, struct Curl_str *out, const size_t max);
~~~
Get a sequence of bytes until the first space or the end of the string. Return
On a successful return, `linep` is updated to point to the byte immediately
following the parsed word.
-## `Curl_str_until`
+## `curlx_str_until`
~~~c
-int Curl_str_until(char **linep, struct Curl_str *out, const size_t max,
+int curlx_str_until(char **linep, struct Curl_str *out, const size_t max,
char delim);
~~~
-Like `Curl_str_word` but instead of parsing to space, it parses to a given
+Like `curlx_str_word` but instead of parsing to space, it parses to a given
custom delimiter non-zero byte `delim`.
`max` is the longest accepted word, or it returns error.
The parsed word must be at least one byte, otherwise it is considered an
error.
-## `Curl_str_untilnl`
+## `curlx_str_untilnl`
~~~c
-int Curl_str_untilnl(char **linep, struct Curl_str *out, const size_t max);
+int curlx_str_untilnl(char **linep, struct Curl_str *out, const size_t max);
~~~
-Like `Curl_str_untilnl` but instead parses until it finds a "newline byte".
+Like `curlx_str_untilnl` but instead parses until it finds a "newline byte".
That means either a CR (ASCII 13) or an LF (ASCII 10) octet.
`max` is the longest accepted word, or it returns error.
The parsed word must be at least one byte, otherwise it is considered an
error.
-## `Curl_str_cspn`
+## `curlx_str_cspn`
~~~c
-int Curl_str_cspn(const char **linep, struct Curl_str *out, const char *cspn);
+int curlx_str_cspn(const char **linep, struct Curl_str *out, const char *cspn);
~~~
Get a sequence of characters until one of the bytes in the `cspn` string
matches. Similar to the `strcspn` function.
-## `Curl_str_quotedword`
+## `curlx_str_quotedword`
~~~c
-int Curl_str_quotedword(char **linep, struct Curl_str *out, const size_t max);
+int curlx_str_quotedword(char **linep, struct Curl_str *out, const size_t max);
~~~
Get a "quoted" word. This means everything that is provided within a leading
The parsed word must be at least one byte, otherwise it is considered an
error.
-## `Curl_str_single`
+## `curlx_str_single`
~~~c
-int Curl_str_single(char **linep, char byte);
+int curlx_str_single(char **linep, char byte);
~~~
Advance over a single character provided in `byte`. Return non-zero on error.
-## `Curl_str_singlespace`
+## `curlx_str_singlespace`
~~~c
-int Curl_str_singlespace(char **linep);
+int curlx_str_singlespace(char **linep);
~~~
Advance over a single ASCII space. Return non-zero on error.
-## `Curl_str_passblanks`
+## `curlx_str_passblanks`
~~~c
-void Curl_str_passblanks(char **linep);
+void curlx_str_passblanks(char **linep);
~~~
Advance over all spaces and tabs.
-## `Curl_str_trimblanks`
+## `curlx_str_trimblanks`
~~~c
-void Curl_str_trimblanks(struct Curl_str *out);
+void curlx_str_trimblanks(struct Curl_str *out);
~~~
Trim off blanks (spaces and tabs) from the start and the end of the given
string.
-## `Curl_str_number`
+## `curlx_str_number`
~~~c
-int Curl_str_number(char **linep, curl_size_t *nump, size_t max);
+int curlx_str_number(char **linep, curl_size_t *nump, size_t max);
~~~
Get an unsigned decimal number not larger than `max`. Leading zeroes are just
swallowed. Return non-zero on error. Returns error if there was not a single
digit.
-## `Curl_str_numblanks`
+## `curlx_str_numblanks`
~~~c
-int Curl_str_numblanks(char **linep, curl_size_t *nump);
+int curlx_str_numblanks(char **linep, curl_size_t *nump);
~~~
Get an unsigned 63-bit decimal number. Leading blanks and zeroes are skipped.
Returns non-zero on error. Returns error if there was not a single digit.
-## `Curl_str_hex`
+## `curlx_str_hex`
~~~c
-int Curl_str_hex(char **linep, curl_size_t *nump, size_t max);
+int curlx_str_hex(char **linep, curl_size_t *nump, size_t max);
~~~
Get an unsigned hexadecimal number not larger than `max`. Leading zeroes are
just swallowed. Return non-zero on error. Returns error if there was not a
single digit. Does *not* handled `0x` prefix.
-## `Curl_str_octal`
+## `curlx_str_octal`
~~~c
-int Curl_str_octal(char **linep, curl_size_t *nump, size_t max);
+int curlx_str_octal(char **linep, curl_size_t *nump, size_t max);
~~~
Get an unsigned octal number not larger than `max`. Leading zeroes are just
swallowed. Return non-zero on error. Returns error if there was not a single
digit.
-## `Curl_str_newline`
+## `curlx_str_newline`
~~~c
-int Curl_str_newline(char **linep);
+int curlx_str_newline(char **linep);
~~~
Check for a single CR or LF. Return non-zero on error */
-## `Curl_str_casecompare`
+## `curlx_str_casecompare`
~~~c
-int Curl_str_casecompare(struct Curl_str *str, const char *check);
+int curlx_str_casecompare(struct Curl_str *str, const char *check);
~~~
Returns true if the provided string in the `str` argument matches the `check`
string case insensitively.
-## `Curl_str_cmp`
+## `curlx_str_cmp`
~~~c
-int Curl_str_cmp(struct Curl_str *str, const char *check);
+int curlx_str_cmp(struct Curl_str *str, const char *check);
~~~
Returns true if the provided string in the `str` argument matches the `check`
string case sensitively. This is *not* the same return code as `strcmp`.
-## `Curl_str_nudge`
+## `curlx_str_nudge`
~~~c
-int Curl_str_nudge(struct Curl_str *str, size_t num);
+int curlx_str_nudge(struct Curl_str *str, size_t num);
~~~
Removes `num` bytes from the beginning (left) of the string kept in `str`. If
#include "options.h"
#include "header.h"
#include "websockets.h"
-#ifndef CURL_SKIP_INCLUDE_MPRINTF
#include "mprintf.h"
-#endif
/* the typechecker does not work in C++ (yet) */
#if defined(__GNUC__) && defined(__GNUC_MINOR__) && \
# The rest of the build
-set_property(DIRECTORY APPEND PROPERTY INCLUDE_DIRECTORIES "${PROJECT_BINARY_DIR}/lib") # for "curl_config.h"
+set_property(DIRECTORY APPEND PROPERTY INCLUDE_DIRECTORIES
+ "${PROJECT_BINARY_DIR}/lib" # for "curl_config.h"
+)
if(USE_ARES)
include_directories(SYSTEM ${CARES_INCLUDE_DIRS})
EXTRA_DIST = config-mac.h config-os400.h config-plan9.h config-riscos.h \
config-win32.h curl_config.h.in libcurl.rc libcurl.def \
- $(CMAKE_DIST) Makefile.soname optiontable.pl $(CHECKSRC_DIST)
+ $(CMAKE_DIST) Makefile.soname optiontable.pl $(CHECKSRC_DIST) \
+ curlx/README.md
lib_LTLIBRARIES = libcurl.la
# $(top_srcdir)/include is for libcurl's external include files
# $(top_builddir)/lib is for libcurl's generated lib/curl_config.h file
-AM_CPPFLAGS = -I$(top_srcdir)/include \
+AM_CPPFLAGS = -I$(top_srcdir)/include \
-I$(top_builddir)/lib
# Prevent LIBS from being used for all link targets
if USE_UNITY
# Keep these separate to avoid duplicate definitions when linking libtests
# in static mode.
-curl_EXCLUDE = curl_threads.c timediff.c warnless.c
+curl_EXCLUDE = curl_threads.c curlx/timediff.c curlx/warnless.c
if CURLDEBUG
# We must compile this source separately to avoid memdebug.h redefinitions
# applying to it.
#
###########################################################################
+LIB_CURLX_CFILES = \
+ curlx/base64.c \
+ curlx/dynbuf.c \
+ curlx/strparse.c \
+ curlx/timediff.c \
+ curlx/timeval.c \
+ curlx/warnless.c
+
+LIB_CURLX_HFILES = \
+ curlx/base64.h \
+ curlx/curlx.h \
+ curlx/dynbuf.h \
+ curlx/strparse.h \
+ curlx/timediff.h \
+ curlx/timeval.h \
+ curlx/warnless.h
+
LIB_VAUTH_CFILES = \
vauth/cleartext.c \
vauth/cram.c \
asyn-ares.c \
asyn-base.c \
asyn-thrdd.c \
- base64.c \
bufq.c \
bufref.c \
cf-h1-proxy.c \
cw-pause.c \
dict.c \
doh.c \
- dynbuf.c \
dynhds.c \
easy.c \
easygetopt.c \
strdup.c \
strequal.c \
strerror.c \
- strparse.c \
system_win32.c \
telnet.c \
tftp.c \
- timediff.c \
- timeval.c \
transfer.c \
uint-bset.c \
uint-hash.c \
urlapi.c \
version.c \
version_win32.c \
- warnless.c \
ws.c
LIB_HFILES = \
content_encoding.h \
cookie.h \
curl_addrinfo.h \
- curl_base64.h \
curl_ctype.h \
curl_des.h \
curl_endian.h \
curl_sspi.h \
curl_threads.h \
curl_trc.h \
- curlx.h \
cw-out.h \
cw-pause.h \
dict.h \
doh.h \
- dynbuf.h \
dynhds.h \
easy_lock.h \
easyif.h \
strcase.h \
strdup.h \
strerror.h \
- strparse.h \
system_win32.h \
telnet.h \
tftp.h \
- timediff.h \
- timeval.h \
transfer.h \
uint-bset.h \
uint-hash.h \
urlapi-int.h \
urldata.h \
version_win32.h \
- warnless.h \
ws.h
LIB_RCFILES = libcurl.rc
CSOURCES = $(LIB_CFILES) $(LIB_VAUTH_CFILES) $(LIB_VTLS_CFILES) \
- $(LIB_VQUIC_CFILES) $(LIB_VSSH_CFILES)
+ $(LIB_VQUIC_CFILES) $(LIB_VSSH_CFILES) $(LIB_CURLX_CFILES)
HHEADERS = $(LIB_HFILES) $(LIB_VAUTH_HFILES) $(LIB_VTLS_HFILES) \
- $(LIB_VQUIC_HFILES) $(LIB_VSSH_HFILES)
+ $(LIB_VQUIC_HFILES) $(LIB_VSSH_HFILES) $(LIB_CURLX_HFILES)
#include "strcase.h"
#include "parsedate.h"
#include "sendf.h"
-#include "warnless.h"
+#include "curlx/warnless.h"
#include "fopen.h"
#include "rename.h"
#include "strdup.h"
#include "inet_pton.h"
-#include "strparse.h"
+#include "curlx/strparse.h"
#include "connect.h"
/* The last 3 #include files should be in this order */
size_t dstport)
{
enum alpnid dstalpnid =
- Curl_alpn2alpnid(Curl_str(dstalpn), Curl_strlen(dstalpn));
+ Curl_alpn2alpnid(curlx_str(dstalpn), curlx_strlen(dstalpn));
enum alpnid srcalpnid =
- Curl_alpn2alpnid(Curl_str(srcalpn), Curl_strlen(srcalpn));
+ Curl_alpn2alpnid(curlx_str(srcalpn), curlx_strlen(srcalpn));
if(!srcalpnid || !dstalpnid)
return NULL;
- return altsvc_createid(Curl_str(srchost), Curl_strlen(srchost),
- Curl_str(dsthost), Curl_strlen(dsthost),
+ return altsvc_createid(curlx_str(srchost), curlx_strlen(srchost),
+ curlx_str(dsthost), curlx_strlen(dsthost),
srcalpnid, dstalpnid,
srcport, dstport);
}
curl_off_t persist;
curl_off_t prio;
- if(Curl_str_word(&line, &srcalpn, MAX_ALTSVC_ALPNLEN) ||
- Curl_str_singlespace(&line) ||
- Curl_str_word(&line, &srchost, MAX_ALTSVC_HOSTLEN) ||
- Curl_str_singlespace(&line) ||
- Curl_str_number(&line, &srcport, 65535) ||
- Curl_str_singlespace(&line) ||
- Curl_str_word(&line, &dstalpn, MAX_ALTSVC_ALPNLEN) ||
- Curl_str_singlespace(&line) ||
- Curl_str_word(&line, &dsthost, MAX_ALTSVC_HOSTLEN) ||
- Curl_str_singlespace(&line) ||
- Curl_str_number(&line, &dstport, 65535) ||
- Curl_str_singlespace(&line) ||
- Curl_str_quotedword(&line, &date, MAX_ALTSVC_DATELEN) ||
- Curl_str_singlespace(&line) ||
- Curl_str_number(&line, &persist, 1) ||
- Curl_str_singlespace(&line) ||
- Curl_str_number(&line, &prio, 0) ||
- Curl_str_newline(&line))
+ if(curlx_str_word(&line, &srcalpn, MAX_ALTSVC_ALPNLEN) ||
+ curlx_str_singlespace(&line) ||
+ curlx_str_word(&line, &srchost, MAX_ALTSVC_HOSTLEN) ||
+ curlx_str_singlespace(&line) ||
+ curlx_str_number(&line, &srcport, 65535) ||
+ curlx_str_singlespace(&line) ||
+ curlx_str_word(&line, &dstalpn, MAX_ALTSVC_ALPNLEN) ||
+ curlx_str_singlespace(&line) ||
+ curlx_str_word(&line, &dsthost, MAX_ALTSVC_HOSTLEN) ||
+ curlx_str_singlespace(&line) ||
+ curlx_str_number(&line, &dstport, 65535) ||
+ curlx_str_singlespace(&line) ||
+ curlx_str_quotedword(&line, &date, MAX_ALTSVC_DATELEN) ||
+ curlx_str_singlespace(&line) ||
+ curlx_str_number(&line, &persist, 1) ||
+ curlx_str_singlespace(&line) ||
+ curlx_str_number(&line, &prio, 0) ||
+ curlx_str_newline(&line))
;
else {
struct altsvc *as;
time_t expires;
/* The date parser works on a null terminated string. The maximum length
- is upheld by Curl_str_quotedword(). */
- memcpy(dbuf, Curl_str(&date), Curl_strlen(&date));
- dbuf[Curl_strlen(&date)] = 0;
+ is upheld by curlx_str_quotedword(). */
+ memcpy(dbuf, curlx_str(&date), curlx_strlen(&date));
+ dbuf[curlx_strlen(&date)] = 0;
expires = Curl_getdate_capped(dbuf);
as = altsvc_create(&srchost, &dsthost, &srcalpn, &dstalpn,
(size_t)srcport, (size_t)dstport);
fp = fopen(file, FOPEN_READTEXT);
if(fp) {
struct dynbuf buf;
- Curl_dyn_init(&buf, MAX_ALTSVC_LINE);
+ curlx_dyn_init(&buf, MAX_ALTSVC_LINE);
while(Curl_get_line(&buf, fp)) {
- const char *lineptr = Curl_dyn_ptr(&buf);
- Curl_str_passblanks(&lineptr);
- if(Curl_str_single(&lineptr, '#'))
+ const char *lineptr = curlx_dyn_ptr(&buf);
+ curlx_str_passblanks(&lineptr);
+ if(curlx_str_single(&lineptr, '#'))
altsvc_add(asi, lineptr);
}
- Curl_dyn_free(&buf); /* free the line buffer */
+ curlx_dyn_free(&buf); /* free the line buffer */
fclose(fp);
}
return result;
(void)unused;
if(timestr) {
curl_off_t val;
- Curl_str_number(×tr, &val, TIME_T_MAX);
+ curlx_str_number(×tr, &val, TIME_T_MAX);
return (time_t)val;
}
return time(NULL);
DEBUGASSERT(asi);
/* initial check for "clear" */
- if(!Curl_str_until(&p, &alpn, MAX_ALTSVC_LINE, ';') &&
- !Curl_str_single(&p, ';')) {
- Curl_str_trimblanks(&alpn);
+ if(!curlx_str_until(&p, &alpn, MAX_ALTSVC_LINE, ';') &&
+ !curlx_str_single(&p, ';')) {
+ curlx_str_trimblanks(&alpn);
/* "clear" is a magic keyword */
- if(Curl_str_casecompare(&alpn, "clear")) {
+ if(curlx_str_casecompare(&alpn, "clear")) {
/* Flush cached alternatives for this source origin */
altsvc_flush(asi, srcalpnid, srchost, srcport);
return CURLE_OK;
p = value;
- if(Curl_str_until(&p, &alpn, MAX_ALTSVC_LINE, '='))
+ if(curlx_str_until(&p, &alpn, MAX_ALTSVC_LINE, '='))
return CURLE_OK; /* strange line */
- Curl_str_trimblanks(&alpn);
+ curlx_str_trimblanks(&alpn);
/* Handle the optional 'ma' and 'persist' flags once first, as they need to
be known for each alternative service. Unknown flags are skipped. */
curl_off_t num;
bool quoted;
/* allow some extra whitespaces around name and value */
- if(Curl_str_until(&sp, &name, 20, '=') ||
- Curl_str_single(&sp, '=') ||
- Curl_str_until(&sp, &val, 80, ';'))
+ if(curlx_str_until(&sp, &name, 20, '=') ||
+ curlx_str_single(&sp, '=') ||
+ curlx_str_until(&sp, &val, 80, ';'))
break;
- Curl_str_trimblanks(&name);
- Curl_str_trimblanks(&val);
+ curlx_str_trimblanks(&name);
+ curlx_str_trimblanks(&val);
/* the value might be quoted */
- vp = Curl_str(&val);
+ vp = curlx_str(&val);
quoted = (*vp == '\"');
if(quoted)
vp++;
- if(!Curl_str_number(&vp, &num, TIME_T_MAX)) {
- if(Curl_str_casecompare(&name, "ma"))
+ if(!curlx_str_number(&vp, &num, TIME_T_MAX)) {
+ if(curlx_str_casecompare(&name, "ma"))
maxage = (time_t)num;
- else if(Curl_str_casecompare(&name, "persist") && (num == 1))
+ else if(curlx_str_casecompare(&name, "persist") && (num == 1))
persist = TRUE;
}
- if(quoted && Curl_str_single(&sp, '\"'))
+ if(quoted && curlx_str_single(&sp, '\"'))
break;
- if(Curl_str_single(&sp, ';'))
+ if(curlx_str_single(&sp, ';'))
break;
}
}
do {
- if(!Curl_str_single(&p, '=')) {
+ if(!curlx_str_single(&p, '=')) {
/* [protocol]="[host][:port], [protocol]="[host][:port]" */
enum alpnid dstalpnid =
- Curl_alpn2alpnid(Curl_str(&alpn), Curl_strlen(&alpn));
- if(!Curl_str_single(&p, '\"')) {
+ Curl_alpn2alpnid(curlx_str(&alpn), curlx_strlen(&alpn));
+ if(!curlx_str_single(&p, '\"')) {
struct Curl_str dsthost;
curl_off_t port = 0;
- if(Curl_str_single(&p, ':')) {
+ if(curlx_str_single(&p, ':')) {
/* hostname starts here */
- if(Curl_str_single(&p, '[')) {
- if(Curl_str_until(&p, &dsthost, MAX_ALTSVC_HOSTLEN, ':')) {
+ if(curlx_str_single(&p, '[')) {
+ if(curlx_str_until(&p, &dsthost, MAX_ALTSVC_HOSTLEN, ':')) {
infof(data, "Bad alt-svc hostname, ignoring.");
break;
}
}
else {
/* IPv6 host name */
- if(Curl_str_until(&p, &dsthost, MAX_IPADR_LEN, ']') ||
- Curl_str_single(&p, ']')) {
+ if(curlx_str_until(&p, &dsthost, MAX_IPADR_LEN, ']') ||
+ curlx_str_single(&p, ']')) {
infof(data, "Bad alt-svc IPv6 hostname, ignoring.");
break;
}
}
- if(Curl_str_single(&p, ':'))
+ if(curlx_str_single(&p, ':'))
break;
}
else
/* no destination name, use source host */
- Curl_str_assign(&dsthost, srchost, strlen(srchost));
+ curlx_str_assign(&dsthost, srchost, strlen(srchost));
- if(Curl_str_number(&p, &port, 0xffff)) {
+ if(curlx_str_number(&p, &port, 0xffff)) {
infof(data, "Unknown alt-svc port number, ignoring.");
break;
}
dstport = (unsigned short)port;
- if(Curl_str_single(&p, '\"'))
+ if(curlx_str_single(&p, '\"'))
break;
if(dstalpnid) {
altsvc_flush(asi, srcalpnid, srchost, srcport);
as = altsvc_createid(srchost, strlen(srchost),
- Curl_str(&dsthost),
- Curl_strlen(&dsthost),
+ curlx_str(&dsthost),
+ curlx_strlen(&dsthost),
srcalpnid, dstalpnid,
srcport, dstport);
if(as) {
as->persist = persist;
Curl_llist_append(&asi->list, as, &as->node);
infof(data, "Added alt-svc: %.*s:%d over %s",
- (int)Curl_strlen(&dsthost), Curl_str(&dsthost),
+ (int)curlx_strlen(&dsthost), curlx_str(&dsthost),
dstport, Curl_alpnid2str(dstalpnid));
}
}
/* after the double quote there can be a comma if there is another
string or a semicolon if no more */
- if(Curl_str_single(&p, ','))
+ if(curlx_str_single(&p, ','))
break;
/* comma means another alternative is present */
- if(Curl_str_until(&p, &alpn, MAX_ALTSVC_LINE, '='))
+ if(curlx_str_until(&p, &alpn, MAX_ALTSVC_LINE, '='))
break;
- Curl_str_trimblanks(&alpn);
+ curlx_str_trimblanks(&alpn);
}
else
break;
#include "connect.h"
#include "select.h"
#include "progress.h"
-#include "timediff.h"
+#include "curlx/timediff.h"
#include "httpsrr.h"
#include "strdup.h"
/* This is only set to non-zero if the timer was started. */
&& (ares->happy_eyeballs_dns_time.tv_sec
|| ares->happy_eyeballs_dns_time.tv_usec)
- && (Curl_timediff(Curl_now(), ares->happy_eyeballs_dns_time)
+ && (curlx_timediff(curlx_now(), ares->happy_eyeballs_dns_time)
>= HAPPY_EYEBALLS_DNS_TIMEOUT)) {
/* Remember that the EXPIRE_HAPPY_EYEBALLS_DNS timer is no longer
running. */
struct async_ares_ctx *ares = &data->state.async.ares;
CURLcode result = CURLE_OK;
timediff_t timeout;
- struct curltime now = Curl_now();
+ struct curltime now = curlx_now();
DEBUGASSERT(entry);
*entry = NULL; /* clear on entry */
if(Curl_pgrsUpdate(data))
result = CURLE_ABORTED_BY_CALLBACK;
else {
- struct curltime now2 = Curl_now();
- timediff_t timediff = Curl_timediff(now2, now); /* spent time */
+ struct curltime now2 = curlx_now();
+ timediff_t timediff = curlx_timediff(now2, now); /* spent time */
if(timediff <= 0)
timeout -= 1; /* always deduct at least 1 */
else if(timediff > timeout)
timeout to prevent it. After all, we do not even know where in the
c-ares retry cycle each request is.
*/
- ares->happy_eyeballs_dns_time = Curl_now();
+ ares->happy_eyeballs_dns_time = curlx_now();
Curl_expire(data, HAPPY_EYEBALLS_DNS_TIMEOUT,
EXPIRE_HAPPY_EYEBALLS_DNS);
}
Curl_mutex_acquire(&addr_ctx->mutx);
DEBUGASSERT(addr_ctx->ref_count == 1);
/* passing addr_ctx to the thread adds a reference */
- addr_ctx->start = Curl_now();
+ addr_ctx->start = curlx_now();
++addr_ctx->ref_count;
#ifdef HAVE_GETADDRINFO
addr_ctx->thread_hnd = Curl_thread_create(getaddrinfo_thread, addr_ctx);
else {
/* poll for name lookup done with exponential backoff up to 250ms */
/* should be fine even if this converts to 32-bit */
- timediff_t elapsed = Curl_timediff(Curl_now(),
+ timediff_t elapsed = curlx_timediff(curlx_now(),
data->progress.t_startsingle);
if(elapsed < 0)
elapsed = 0;
#endif
{
timediff_t milli;
- timediff_t ms = Curl_timediff(Curl_now(), thrdd->addr->start);
+ timediff_t ms = curlx_timediff(curlx_now(), thrdd->addr->start);
if(ms < 3)
milli = 0;
else if(ms <= 50)
#include <curl/curl.h>
#include "urldata.h"
-#include "dynbuf.h"
+#include "curlx/dynbuf.h"
#include "sendf.h"
#include "http.h"
#include "http1.h"
#include "cf-h1-proxy.h"
#include "connect.h"
#include "curl_trc.h"
-#include "curlx.h"
+#include "strcase.h"
#include "vtls/vtls.h"
#include "transfer.h"
#include "multiif.h"
-#include "strparse.h"
+#include "curlx/strparse.h"
/* The last 3 #include files should be in this order */
#include "curl_printf.h"
(void)data;
(void)cf;
DEBUGASSERT(ts);
- Curl_dyn_reset(&ts->rcvbuf);
- Curl_dyn_reset(&ts->request_data);
+ curlx_dyn_reset(&ts->rcvbuf);
+ curlx_dyn_reset(&ts->request_data);
ts->tunnel_state = H1_TUNNEL_INIT;
ts->keepon = KEEPON_CONNECT;
ts->cl = 0;
infof(data, "allocate connect buffer");
- Curl_dyn_init(&ts->rcvbuf, DYN_PROXY_CONNECT_HEADERS);
- Curl_dyn_init(&ts->request_data, DYN_HTTP_REQUEST);
+ curlx_dyn_init(&ts->rcvbuf, DYN_PROXY_CONNECT_HEADERS);
+ curlx_dyn_init(&ts->request_data, DYN_HTTP_REQUEST);
Curl_httpchunk_init(data, &ts->ch, TRUE);
*pts = ts;
CURL_TRC_CF(data, cf, "new tunnel state 'connect'");
ts->tunnel_state = H1_TUNNEL_CONNECT;
ts->keepon = KEEPON_CONNECT;
- Curl_dyn_reset(&ts->rcvbuf);
+ curlx_dyn_reset(&ts->rcvbuf);
break;
case H1_TUNNEL_RECEIVE:
if(new_state == H1_TUNNEL_FAILED)
CURL_TRC_CF(data, cf, "new tunnel state 'failed'");
ts->tunnel_state = new_state;
- Curl_dyn_reset(&ts->rcvbuf);
- Curl_dyn_reset(&ts->request_data);
+ curlx_dyn_reset(&ts->rcvbuf);
+ curlx_dyn_reset(&ts->request_data);
/* restore the protocol pointer */
data->info.httpcode = 0; /* clear it as it might've been used for the
proxy */
struct h1_tunnel_state *ts = cf->ctx;
if(ts) {
h1_tunnel_go_state(cf, ts, H1_TUNNEL_FAILED, data);
- Curl_dyn_free(&ts->rcvbuf);
- Curl_dyn_free(&ts->request_data);
+ curlx_dyn_free(&ts->rcvbuf);
+ curlx_dyn_free(&ts->request_data);
Curl_httpchunk_free(data, &ts->ch);
free(ts);
cf->ctx = NULL;
infof(data, "Establish HTTP proxy tunnel to %s", req->authority);
- Curl_dyn_reset(&ts->request_data);
+ curlx_dyn_reset(&ts->request_data);
ts->nsent = 0;
ts->headerlines = 0;
http_minor = (cf->conn->http_proxy.proxytype == CURLPROXY_HTTP_1_0) ? 0 : 1;
struct h1_tunnel_state *ts,
bool *done)
{
- char *buf = Curl_dyn_ptr(&ts->request_data);
- size_t request_len = Curl_dyn_len(&ts->request_data);
+ char *buf = curlx_dyn_ptr(&ts->request_data);
+ size_t request_len = curlx_dyn_len(&ts->request_data);
size_t blen = request_len;
CURLcode result = CURLE_OK;
ssize_t nwritten;
}
else {
const char *p = header + strlen("Content-Length:");
- if(Curl_str_numblanks(&p, &ts->cl)) {
+ if(curlx_str_numblanks(&p, &ts->cl)) {
failf(data, "Unsupported Content-Length value");
return CURLE_WEIRD_SERVER_REPLY;
}
continue;
}
- if(Curl_dyn_addn(&ts->rcvbuf, &byte, 1)) {
+ if(curlx_dyn_addn(&ts->rcvbuf, &byte, 1)) {
failf(data, "CONNECT response too large");
return CURLE_RECV_ERROR;
}
continue;
ts->headerlines++;
- linep = Curl_dyn_ptr(&ts->rcvbuf);
- line_len = Curl_dyn_len(&ts->rcvbuf); /* amount of bytes in this line */
+ linep = curlx_dyn_ptr(&ts->rcvbuf);
+ line_len = curlx_dyn_len(&ts->rcvbuf); /* amount of bytes in this line */
/* output debug if that is requested */
Curl_debug(data, CURLINFO_HEADER_IN, linep, line_len);
if(result)
return result;
- Curl_dyn_reset(&ts->rcvbuf);
+ curlx_dyn_reset(&ts->rcvbuf);
} /* while there is buffer left and loop is requested */
if(error)
#include "connect.h"
#include "curl_trc.h"
#include "bufq.h"
-#include "dynbuf.h"
+#include "curlx/dynbuf.h"
#include "dynhds.h"
#include "http1.h"
#include "http2.h"
{
DEBUGASSERT(ctx);
ctx->state = HAPROXY_INIT;
- Curl_dyn_reset(&ctx->data_out);
+ curlx_dyn_reset(&ctx->data_out);
}
static void cf_haproxy_ctx_free(struct cf_haproxy_ctx *ctx)
{
if(ctx) {
- Curl_dyn_free(&ctx->data_out);
+ curlx_dyn_free(&ctx->data_out);
free(ctx);
}
}
#ifdef USE_UNIX_SOCKETS
if(cf->conn->unix_domain_socket)
/* the buffer is large enough to hold this! */
- result = Curl_dyn_addn(&ctx->data_out, STRCONST("PROXY UNKNOWN\r\n"));
+ result = curlx_dyn_addn(&ctx->data_out, STRCONST("PROXY UNKNOWN\r\n"));
else {
#endif /* USE_UNIX_SOCKETS */
result = Curl_conn_cf_get_ip_info(cf->next, data, &is_ipv6, &ipquad);
else
client_ip = ipquad.local_ip;
- result = Curl_dyn_addf(&ctx->data_out, "PROXY %s %s %s %i %i\r\n",
- is_ipv6 ? "TCP6" : "TCP4",
- client_ip, ipquad.remote_ip,
- ipquad.local_port, ipquad.remote_port);
+ result = curlx_dyn_addf(&ctx->data_out, "PROXY %s %s %s %i %i\r\n",
+ is_ipv6 ? "TCP6" : "TCP4",
+ client_ip, ipquad.remote_ip,
+ ipquad.local_port, ipquad.remote_port);
#ifdef USE_UNIX_SOCKETS
}
ctx->state = HAPROXY_SEND;
FALLTHROUGH();
case HAPROXY_SEND:
- len = Curl_dyn_len(&ctx->data_out);
+ len = curlx_dyn_len(&ctx->data_out);
if(len > 0) {
ssize_t nwritten;
nwritten = Curl_conn_cf_send(cf->next, data,
- Curl_dyn_ptr(&ctx->data_out), len, FALSE,
+ curlx_dyn_ptr(&ctx->data_out), len, FALSE,
&result);
if(nwritten < 0) {
if(result != CURLE_AGAIN)
result = CURLE_OK;
nwritten = 0;
}
- Curl_dyn_tail(&ctx->data_out, len - (size_t)nwritten);
- if(Curl_dyn_len(&ctx->data_out) > 0) {
+ curlx_dyn_tail(&ctx->data_out, len - (size_t)nwritten);
+ if(curlx_dyn_len(&ctx->data_out) > 0) {
result = CURLE_OK;
goto out;
}
ctx->state = HAPROXY_DONE;
FALLTHROUGH();
default:
- Curl_dyn_free(&ctx->data_out);
+ curlx_dyn_free(&ctx->data_out);
break;
}
goto out;
}
ctx->state = HAPROXY_INIT;
- Curl_dyn_init(&ctx->data_out, DYN_HAXPROXY);
+ curlx_dyn_init(&ctx->data_out, DYN_HAXPROXY);
result = Curl_cf_create(&cf, &Curl_cft_haproxy, ctx);
if(result)
struct Curl_cfilter *save = cf->next;
cf->next = NULL;
- b->started = Curl_now();
+ b->started = curlx_now();
switch(b->alpn_id) {
case ALPN_h3:
transport = TRNSPRT_QUIC;
reply_ms = cf_hc_baller_reply_ms(winner, data);
if(reply_ms >= 0)
CURL_TRC_CF(data, cf, "connect+handshake %s: %dms, 1st data: %dms",
- winner->name, (int)Curl_timediff(Curl_now(), winner->started),
- reply_ms);
+ winner->name, (int)curlx_timediff(curlx_now(),
+ winner->started), reply_ms);
else
CURL_TRC_CF(data, cf, "deferred handshake %s: %dms",
- winner->name, (int)Curl_timediff(Curl_now(), winner->started));
+ winner->name, (int)curlx_timediff(curlx_now(),
+ winner->started));
cf->next = winner->cf;
winner->cf = NULL;
ctx->ballers[idx].name);
return TRUE;
}
- elapsed_ms = Curl_timediff(now, ctx->started);
+ elapsed_ms = curlx_timediff(now, ctx->started);
if(elapsed_ms >= ctx->hard_eyeballs_timeout_ms) {
CURL_TRC_CF(data, cf, "hard timeout of %dms reached, starting %s",
ctx->hard_eyeballs_timeout_ms, ctx->ballers[idx].name);
}
*done = FALSE;
- now = Curl_now();
+ now = curlx_now();
switch(ctx->state) {
case CF_HC_INIT:
DEBUGASSERT(!cf->next);
struct Curl_cfilter *cfb = ctx->ballers[i].cf;
memset(&t, 0, sizeof(t));
if(cfb && !cfb->cft->query(cfb, data, query, NULL, &t)) {
- if((t.tv_sec || t.tv_usec) && Curl_timediff_us(t, tmax) > 0)
+ if((t.tv_sec || t.tv_usec) && curlx_timediff_us(t, tmax) > 0)
tmax = t;
}
}
#include "inet_ntop.h"
#include "inet_pton.h"
#include "progress.h"
-#include "warnless.h"
+#include "curlx/warnless.h"
#include "conncache.h"
#include "multihandle.h"
#include "rand.h"
#include "strdup.h"
#include "system_win32.h"
#include "version_win32.h"
-#include "strparse.h"
+#include "curlx/strparse.h"
/* The last 3 #include files should be in this order */
#include "curl_printf.h"
IDs and the former returns none at all. So the scope ID, if
present, is known to be numeric */
curl_off_t scope_id;
- if(Curl_str_number((const char **)CURL_UNCONST(&scope_ptr),
+ if(curlx_str_number((const char **)CURL_UNCONST(&scope_ptr),
&scope_id, UINT_MAX))
return CURLE_UNSUPPORTED_PROTOCOL;
si6->sin6_scope_id = (unsigned int)scope_id;
const char *p = getenv("CURL_DBG_SOCK_WBLOCK");
if(p) {
curl_off_t l;
- if(!Curl_str_number(&p, &l, 100))
+ if(!curlx_str_number(&p, &l, 100))
ctx->wblock_percent = (int)l;
}
p = getenv("CURL_DBG_SOCK_WPARTIAL");
if(p) {
curl_off_t l;
- if(!Curl_str_number(&p, &l, 100))
+ if(!curlx_str_number(&p, &l, 100))
ctx->wpartial_percent = (int)l;
}
p = getenv("CURL_DBG_SOCK_RBLOCK");
if(p) {
curl_off_t l;
- if(!Curl_str_number(&p, &l, 100))
+ if(!curlx_str_number(&p, &l, 100))
ctx->rblock_percent = (int)l;
}
p = getenv("CURL_DBG_SOCK_RMAX");
if(p) {
curl_off_t l;
- if(!Curl_str_number(&p, &l, CURL_OFF_T_MAX))
+ if(!curlx_str_number(&p, &l, CURL_OFF_T_MAX))
ctx->recv_max = (size_t)l;
}
}
(void)data;
DEBUGASSERT(ctx->sock == CURL_SOCKET_BAD);
- ctx->started_at = Curl_now();
+ ctx->started_at = curlx_now();
#ifdef SOCK_NONBLOCK
/* Do not tuck SOCK_NONBLOCK into socktype when opensocket callback is set
* because we would not know how socketype is about to be used in the
}
else if(isconnected) {
set_local_ip(cf, data);
- ctx->connected_at = Curl_now();
+ ctx->connected_at = curlx_now();
cf->connected = TRUE;
}
CURL_TRC_CF(data, cf, "cf_socket_open() -> %d, fd=%" FMT_SOCKET_T,
else if(rc == CURL_CSELECT_OUT || cf->conn->bits.tcp_fastopen) {
if(verifyconnect(ctx->sock, &ctx->error)) {
/* we are connected with TCP, awesome! */
- ctx->connected_at = Curl_now();
+ ctx->connected_at = curlx_now();
set_local_ip(cf, data);
*done = TRUE;
cf->connected = TRUE;
{
ULONG ideal;
DWORD ideallen;
- struct curltime n = Curl_now();
+ struct curltime n = curlx_now();
- if(Curl_timediff(n, ctx->last_sndbuf_query_at) > 1000) {
+ if(curlx_timediff(n, ctx->last_sndbuf_query_at) > 1000) {
if(!WSAIoctl(ctx->sock, SIO_IDEAL_SEND_BACKLOG_QUERY, 0, 0,
&ideal, sizeof(ideal), &ideallen, 0, 0) &&
ideal != ctx->sndbuf_size &&
CURL_TRC_CF(data, cf, "recv(len=%zu) -> %d, err=%d", len, (int)nread,
*err);
if(nread > 0 && !ctx->got_first_byte) {
- ctx->first_byte_at = Curl_now();
+ ctx->first_byte_at = curlx_now();
ctx->got_first_byte = TRUE;
}
return nread;
return CURLE_OK;
case CF_QUERY_CONNECT_REPLY_MS:
if(ctx->got_first_byte) {
- timediff_t ms = Curl_timediff(ctx->first_byte_at, ctx->started_at);
+ timediff_t ms = curlx_timediff(ctx->first_byte_at, ctx->started_at);
*pres1 = (ms < INT_MAX) ? (int)ms : INT_MAX;
}
else
timeout_ms = data->set.accepttimeout;
#endif
- now = Curl_now();
+ now = curlx_now();
/* check if the generic timeout possibly is set shorter */
other = Curl_timeleft(data, &now, FALSE);
if(other && (other < timeout_ms))
timeout_ms = other;
else {
/* subtract elapsed time */
- timeout_ms -= Curl_timediff(now, ctx->started_at);
+ timeout_ms -= curlx_timediff(now, ctx->started_at);
if(!timeout_ms)
/* avoid returning 0 as that means no timeout! */
timeout_ms = -1;
cf_tcp_set_accepted_remote_ip(cf, data);
set_local_ip(cf, data);
ctx->active = TRUE;
- ctx->connected_at = Curl_now();
+ ctx->connected_at = curlx_now();
cf->connected = TRUE;
CURL_TRC_CF(data, cf, "accepted_set(sock=%" FMT_SOCKET_T
", remote=%s port=%d)",
goto out;
Curl_conn_cf_add(data, conn, sockindex, cf);
- ctx->started_at = Curl_now();
+ ctx->started_at = curlx_now();
conn->sock[sockindex] = ctx->sock;
set_local_ip(cf, data);
CURL_TRC_CF(data, cf, "set filter for listen socket fd=%" FMT_SOCKET_T
#include "multiif.h"
#include "progress.h"
#include "select.h"
-#include "warnless.h"
-#include "strparse.h"
+#include "curlx/warnless.h"
+#include "curlx/strparse.h"
/* The last 3 #include files should be in this order */
#include "curl_printf.h"
}
*done = FALSE;
- now = Curl_now();
+ now = curlx_now();
if(!Curl_shutdown_started(data, sockindex)) {
CURL_TRC_M(data, "shutdown start on%s connection",
sockindex ? " secondary" : "");
* socket and ip related information. */
cf_cntrl_update_info(data, data->conn);
conn_report_connect_stats(data, data->conn);
- data->conn->keepalive = Curl_now();
+ data->conn->keepalive = curlx_now();
Curl_verboseconnect(data, data->conn, sockindex);
goto out;
}
const char *p = getenv("CURL_SMALLSENDS");
if(p) {
curl_off_t altsize;
- if(!Curl_str_number(&p, &altsize, write_len))
+ if(!curlx_str_number(&p, &altsize, write_len))
write_len = (size_t)altsize;
}
}
*
***************************************************************************/
-#include "timediff.h"
+#include "curlx/timediff.h"
struct Curl_cfilter;
struct Curl_easy;
#include "connect.h"
#include "select.h"
#include "strcase.h"
-#include "strparse.h"
+#include "curlx/strparse.h"
#include "uint-table.h"
/* The last 3 #include files should be in this order */
size_t size)
{
Curl_hash_init(&cpool->dest2bundle, size, Curl_hash_str,
- Curl_str_key_compare, cpool_bundle_free_entry);
+ curlx_str_key_compare, cpool_bundle_free_entry);
DEBUGASSERT(idata);
struct connectdata *oldest_idle = NULL;
struct connectdata *conn;
- now = Curl_now();
+ now = curlx_now();
curr = Curl_llist_head(&bundle->conns);
while(curr) {
conn = Curl_node_elem(curr);
if(!CONN_INUSE(conn)) {
/* Set higher score for the age passed since the connection was used */
- score = Curl_timediff(now, conn->lastused);
+ score = curlx_timediff(now, conn->lastused);
if(score > highscore) {
highscore = score;
timediff_t highscore =- 1;
timediff_t score;
- now = Curl_now();
+ now = curlx_now();
Curl_hash_start_iterate(&cpool->dest2bundle, &iter);
for(he = Curl_hash_next_element(&iter); he;
if(CONN_INUSE(conn) || conn->bits.close || conn->connect_only)
continue;
/* Set higher score for the age passed since the connection was used */
- score = Curl_timediff(now, conn->lastused);
+ score = curlx_timediff(now, conn->lastused);
if(score > highscore) {
highscore = score;
oldest_idle = conn;
struct cpool *cpool = cpool_get_instance(data);
bool kept = TRUE;
- conn->lastused = Curl_now(); /* it was used up until now */
+ conn->lastused = curlx_now(); /* it was used up until now */
if(cpool && maxconnects) {
/* may be called form a callback already under lock */
bool do_lock = !CPOOL_IS_LOCKED(cpool);
if(!cpool)
return;
- rctx.now = Curl_now();
+ rctx.now = curlx_now();
CPOOL_LOCK(cpool, data);
- elapsed = Curl_timediff(rctx.now, cpool->last_cleanup);
+ elapsed = curlx_timediff(rctx.now, cpool->last_cleanup);
if(elapsed >= 1000L) {
while(cpool_foreach(data, cpool, &rctx, cpool_reap_dead_cb))
CURLcode Curl_cpool_upkeep(void *data)
{
struct cpool *cpool = cpool_get_instance(data);
- struct curltime now = Curl_now();
+ struct curltime now = curlx_now();
if(!cpool)
return CURLE_OK;
***************************************************************************/
#include <curl/curl.h>
-#include "timeval.h"
+#include "curlx/timeval.h"
struct connectdata;
struct Curl_easy;
#include "inet_pton.h"
#include "vtls/vtls.h" /* for vtsl cfilters */
#include "progress.h"
-#include "warnless.h"
+#include "curlx/warnless.h"
#include "conncache.h"
#include "multihandle.h"
#include "share.h"
* infinite time left). If the value is negative, the timeout time has already
* elapsed.
* @param data the transfer to check on
- * @param nowp timestamp to use for calculation, NULL to use Curl_now()
+ * @param nowp timestamp to use for calculation, NULL to use curlx_now()
* @param duringconnect TRUE iff connect timeout is also taken into account.
* @unittest: 1303
*/
return 0; /* no timeout in place or checked, return "no limit" */
if(!nowp) {
- now = Curl_now();
+ now = curlx_now();
nowp = &now;
}
if(data->set.timeout > 0) {
timeleft_ms = data->set.timeout -
- Curl_timediff(*nowp, data->progress.t_startop);
+ curlx_timediff(*nowp, data->progress.t_startop);
if(!timeleft_ms)
timeleft_ms = -1; /* 0 is "no limit", fake 1 ms expiry */
if(!duringconnect)
timediff_t ctimeout_ms = (data->set.connecttimeout > 0) ?
data->set.connecttimeout : DEFAULT_CONNECT_TIMEOUT;
ctimeleft_ms = ctimeout_ms -
- Curl_timediff(*nowp, data->progress.t_startsingle);
+ curlx_timediff(*nowp, data->progress.t_startsingle);
if(!ctimeleft_ms)
ctimeleft_ms = -1; /* 0 is "no limit", fake 1 ms expiry */
if(!timeleft_ms)
DEBUGASSERT(data->conn);
if(!nowp) {
- now = Curl_now();
+ now = curlx_now();
nowp = &now;
}
data->conn->shutdown.start[sockindex] = *nowp;
return 0; /* not started or no limits */
if(!nowp) {
- now = Curl_now();
+ now = curlx_now();
nowp = &now;
}
left_ms = conn->shutdown.timeout_ms -
- Curl_timediff(*nowp, conn->shutdown.start[sockindex]);
+ curlx_timediff(*nowp, conn->shutdown.start[sockindex]);
return left_ms ? left_ms : -1;
}
if(!conn->shutdown.start[i].tv_sec)
continue;
if(!nowp) {
- now = Curl_now();
+ now = curlx_now();
nowp = &now;
}
ms = Curl_shutdown_timeleft(conn, i, nowp);
baller->has_started = TRUE;
while(baller->addr) {
- baller->started = Curl_now();
+ baller->started = curlx_now();
baller->timeoutms = addr_next_match(baller->addr, baller->ai_family) ?
USETIME(timeoutms) : timeoutms;
baller_initiate(cf, data, baller);
baller->connected = TRUE;
baller->is_done = TRUE;
}
- else if(Curl_timediff(*now, baller->started) >= baller->timeoutms) {
+ else if(curlx_timediff(*now, baller->started) >= baller->timeoutms) {
infof(data, "%s connect timeout after %" FMT_TIMEDIFF_T
"ms, move on!", baller->name, baller->timeoutms);
#ifdef SOCKETIMEDOUT
* cot ballers in a QUIC appropriate way. */
evaluate:
*connected = FALSE; /* a negative world view is best */
- now = Curl_now();
+ now = curlx_now();
ongoing = not_started = 0;
for(i = 0; i < CURL_ARRAYSIZE(ctx->baller); i++) {
struct eyeballer *baller = ctx->baller[i];
* start new ballers or return ok. */
if((ongoing || not_started) && Curl_timeleft(data, &now, TRUE) < 0) {
failf(data, "Connection timeout after %" FMT_OFF_T " ms",
- Curl_timediff(now, data->progress.t_startsingle));
+ curlx_timediff(now, data->progress.t_startsingle));
return CURLE_OPERATION_TIMEDOUT;
}
/* We start its primary baller has failed to connect or if
* its start delay_ms have expired */
if((baller->primary && baller->primary->is_done) ||
- Curl_timediff(now, ctx->started) >= baller->delay_ms) {
+ curlx_timediff(now, ctx->started) >= baller->delay_ms) {
baller_start(cf, data, baller, Curl_timeleft(data, &now, TRUE));
if(baller->is_done) {
CURL_TRC_CF(data, cf, "%s done", baller->name);
failf(data, "Failed to connect to %s port %u after "
"%" FMT_TIMEDIFF_T " ms: %s",
hostname, conn->primary.remote_port,
- Curl_timediff(now, data->progress.t_startsingle),
+ curlx_timediff(now, data->progress.t_startsingle),
curl_easy_strerror(result));
#ifdef SOCKETIMEDOUT
return CURLE_OPERATION_TIMEDOUT;
}
- ctx->started = Curl_now();
+ ctx->started = curlx_now();
/* remotehost->addr is the list of addresses from the resolver, each
* with an address family. The list has at least one entry, possibly
memset(&t, 0, sizeof(t));
if(baller && baller->cf &&
!baller->cf->cft->query(baller->cf, data, query, NULL, &t)) {
- if((t.tv_sec || t.tv_usec) && Curl_timediff_us(t, tmax) > 0)
+ if((t.tv_sec || t.tv_usec) && curlx_timediff_us(t, tmax) > 0)
tmax = t;
}
}
#include "nonblock.h" /* for curlx_nonblock(), formerly Curl_nonblock() */
#include "sockaddr.h"
-#include "timeval.h"
+#include "curlx/timeval.h"
struct Curl_dns_entry;
struct ip_quadruple;
#include "fopen.h"
#include "strdup.h"
#include "llist.h"
-#include "strparse.h"
+#include "curlx/strparse.h"
/* The last 3 #include files should be in this order */
#include "curl_printf.h"
struct Curl_str val;
/* we have a <name>=<value> pair or a stand-alone word here */
- if(!Curl_str_cspn(&ptr, &name, ";\t\r\n=")) {
+ if(!curlx_str_cspn(&ptr, &name, ";\t\r\n=")) {
bool done = FALSE;
bool sep = FALSE;
- Curl_str_trimblanks(&name);
+ curlx_str_trimblanks(&name);
- if(!Curl_str_single(&ptr, '=')) {
+ if(!curlx_str_single(&ptr, '=')) {
sep = TRUE; /* a '=' was used */
- if(!Curl_str_cspn(&ptr, &val, ";\r\n")) {
- Curl_str_trimblanks(&val);
+ if(!curlx_str_cspn(&ptr, &val, ";\r\n")) {
+ curlx_str_trimblanks(&val);
/* Reject cookies with a TAB inside the value */
- if(memchr(Curl_str(&val), '\t', Curl_strlen(&val))) {
+ if(memchr(curlx_str(&val), '\t', curlx_strlen(&val))) {
infof(data, "cookie contains TAB, dropping");
return CERR_TAB;
}
}
}
else {
- Curl_str_init(&val);
+ curlx_str_init(&val);
}
/*
* combination of name + contents. Chrome and Firefox support 4095 or
* 4096 bytes combo
*/
- if(Curl_strlen(&name) >= (MAX_NAME-1) ||
- Curl_strlen(&val) >= (MAX_NAME-1) ||
- ((Curl_strlen(&name) + Curl_strlen(&val)) > MAX_NAME)) {
+ if(curlx_strlen(&name) >= (MAX_NAME-1) ||
+ curlx_strlen(&val) >= (MAX_NAME-1) ||
+ ((curlx_strlen(&name) + curlx_strlen(&val)) > MAX_NAME)) {
infof(data, "oversized cookie dropped, name/val %zu + %zu bytes",
- Curl_strlen(&name), Curl_strlen(&val));
+ curlx_strlen(&name), curlx_strlen(&val));
return CERR_TOO_BIG;
}
* "the rest". Prefixes must start with '__' and end with a '-', so
* only test for names where that can possibly be true.
*/
- if(!strncmp("__Secure-", Curl_str(&name), 9))
+ if(!strncmp("__Secure-", curlx_str(&name), 9))
co->prefix_secure = TRUE;
- else if(!strncmp("__Host-", Curl_str(&name), 7))
+ else if(!strncmp("__Host-", curlx_str(&name), 7))
co->prefix_host = TRUE;
/*
/* Bad name/value pair. */
return CERR_NO_SEP;
- strstore(&co->name, Curl_str(&name), Curl_strlen(&name));
- strstore(&co->value, Curl_str(&val), Curl_strlen(&val));
+ strstore(&co->name, curlx_str(&name), curlx_strlen(&name));
+ strstore(&co->value, curlx_str(&val), curlx_strlen(&val));
done = TRUE;
if(!co->name || !co->value)
return CERR_NO_NAME_VALUE;
return CERR_INVALID_OCTET;
}
}
- else if(!Curl_strlen(&val)) {
+ else if(!curlx_strlen(&val)) {
/*
* this was a "<name>=" with no content, and we must allow
* 'secure' and 'httponly' specified this weirdly
* using a secure protocol, or when the cookie is being set by
* reading from file
*/
- if(Curl_str_casecompare(&name, "secure")) {
+ if(curlx_str_casecompare(&name, "secure")) {
if(secure || !ci->running) {
co->secure = TRUE;
}
return CERR_BAD_SECURE;
}
}
- else if(Curl_str_casecompare(&name, "httponly"))
+ else if(curlx_str_casecompare(&name, "httponly"))
co->httponly = TRUE;
else if(sep)
/* there was a '=' so we are not done parsing this field */
}
if(done)
;
- else if(Curl_str_casecompare(&name, "path")) {
- strstore(&co->path, Curl_str(&val), Curl_strlen(&val));
+ else if(curlx_str_casecompare(&name, "path")) {
+ strstore(&co->path, curlx_str(&val), curlx_strlen(&val));
if(!co->path)
return CERR_OUT_OF_MEMORY;
free(co->spath); /* if this is set again */
if(!co->spath)
return CERR_OUT_OF_MEMORY;
}
- else if(Curl_str_casecompare(&name, "domain") && Curl_strlen(&val)) {
+ else if(curlx_str_casecompare(&name, "domain") && curlx_strlen(&val)) {
bool is_ip;
- const char *v = Curl_str(&val);
+ const char *v = curlx_str(&val);
/*
* Now, we make sure that our host is within the given domain, or
* the given domain is not valid and thus cannot be set.
*/
if('.' == *v)
- Curl_str_nudge(&val, 1);
+ curlx_str_nudge(&val, 1);
#ifndef USE_LIBPSL
/*
* TLD or otherwise "protected" suffix. To reduce risk, we require a
* dot OR the exact hostname being "localhost".
*/
- if(bad_domain(Curl_str(&val), Curl_strlen(&val)))
+ if(bad_domain(curlx_str(&val), curlx_strlen(&val)))
domain = ":";
#endif
- is_ip = Curl_host_is_ipnum(domain ? domain : Curl_str(&val));
+ is_ip = Curl_host_is_ipnum(domain ? domain : curlx_str(&val));
if(!domain
- || (is_ip && !strncmp(Curl_str(&val), domain, Curl_strlen(&val)) &&
- (Curl_strlen(&val) == strlen(domain)))
- || (!is_ip && cookie_tailmatch(Curl_str(&val),
- Curl_strlen(&val), domain))) {
- strstore(&co->domain, Curl_str(&val), Curl_strlen(&val));
+ || (is_ip && !strncmp(curlx_str(&val), domain,
+ curlx_strlen(&val)) &&
+ (curlx_strlen(&val) == strlen(domain)))
+ || (!is_ip && cookie_tailmatch(curlx_str(&val),
+ curlx_strlen(&val), domain))) {
+ strstore(&co->domain, curlx_str(&val), curlx_strlen(&val));
if(!co->domain)
return CERR_OUT_OF_MEMORY;
* not a domain to which the current host belongs. Mark as bad.
*/
infof(data, "skipped cookie with bad tailmatch domain: %s",
- Curl_str(&val));
+ curlx_str(&val));
return CERR_NO_TAILMATCH;
}
}
- else if(Curl_str_casecompare(&name, "version")) {
+ else if(curlx_str_casecompare(&name, "version")) {
/* just ignore */
}
- else if(Curl_str_casecompare(&name, "max-age") && Curl_strlen(&val)) {
+ else if(curlx_str_casecompare(&name, "max-age") && curlx_strlen(&val)) {
/*
* Defined in RFC2109:
*
* cookie should be discarded immediately.
*/
int rc;
- const char *maxage = Curl_str(&val);
+ const char *maxage = curlx_str(&val);
if(*maxage == '\"')
maxage++;
- rc = Curl_str_number(&maxage, &co->expires, CURL_OFF_T_MAX);
+ rc = curlx_str_number(&maxage, &co->expires, CURL_OFF_T_MAX);
switch(rc) {
case STRE_OVERFLOW:
}
cap_expires(now, co);
}
- else if(Curl_str_casecompare(&name, "expires") && Curl_strlen(&val)) {
- if(!co->expires && (Curl_strlen(&val) < MAX_DATE_LENGTH)) {
+ else if(curlx_str_casecompare(&name, "expires") && curlx_strlen(&val)) {
+ if(!co->expires && (curlx_strlen(&val) < MAX_DATE_LENGTH)) {
/*
* Let max-age have priority.
*
* will be treated as a session cookie
*/
char dbuf[MAX_DATE_LENGTH + 1];
- memcpy(dbuf, Curl_str(&val), Curl_strlen(&val));
- dbuf[Curl_strlen(&val)] = 0;
+ memcpy(dbuf, curlx_str(&val), curlx_strlen(&val));
+ dbuf[curlx_strlen(&val)] = 0;
co->expires = Curl_getdate_capped(dbuf);
/*
*/
}
- if(Curl_str_single(&ptr, ';'))
+ if(curlx_str_single(&ptr, ';'))
break;
} while(1);
}
break;
case 4:
- if(Curl_str_number(&ptr, &co->expires, CURL_OFF_T_MAX))
+ if(curlx_str_number(&ptr, &co->expires, CURL_OFF_T_MAX))
return CERR_RANGE;
break;
case 5:
ci->running = FALSE; /* this is not running, this is init */
if(fp) {
struct dynbuf buf;
- Curl_dyn_init(&buf, MAX_COOKIE_LINE);
+ curlx_dyn_init(&buf, MAX_COOKIE_LINE);
while(Curl_get_line(&buf, fp)) {
- const char *lineptr = Curl_dyn_ptr(&buf);
+ const char *lineptr = curlx_dyn_ptr(&buf);
bool headerline = FALSE;
if(checkprefix("Set-Cookie:", lineptr)) {
/* This is a cookie line, get it! */
lineptr += 11;
headerline = TRUE;
- Curl_str_passblanks(&lineptr);
+ curlx_str_passblanks(&lineptr);
}
Curl_cookie_add(data, ci, headerline, TRUE, lineptr, NULL, NULL, TRUE);
}
- Curl_dyn_free(&buf); /* free the line buffer */
+ curlx_dyn_free(&buf); /* free the line buffer */
/*
* Remove expired cookies from the hash. We must make sure to run this
#include "connect.h"
#include "select.h"
#include "strcase.h"
-#include "strparse.h"
+#include "curlx/strparse.h"
/* The last 3 #include files should be in this order */
#include "curl_printf.h"
/* idata has one timer list, but maybe more than one connection.
* Set EXPIRE_SHUTDOWN to the smallest time left for all. */
if(!nowp) {
- now = Curl_now();
+ now = curlx_now();
nowp = &now;
}
ms = Curl_conn_shutdown_timeleft(conn, nowp);
struct Curl_easy *data,
int timeout_ms)
{
- struct curltime started = Curl_now();
+ struct curltime started = curlx_now();
struct Curl_llist_node *e;
SIGPIPE_VARIABLE(pipe_st);
}
/* wait for activity, timeout or "nothing" */
- timespent = Curl_timediff(Curl_now(), started);
+ timespent = curlx_timediff(curlx_now(), started);
if(timespent >= (timediff_t)timeout_ms) {
CURL_TRC_M(data, "[SHUTDOWN] shutdown finished, %s",
(timeout_ms > 0) ? "timeout" : "best effort done");
const char *p = getenv("CURL_GRACEFUL_SHUTDOWN");
if(p) {
curl_off_t l;
- if(!Curl_str_number(&p, &l, INT_MAX))
+ if(!curlx_str_number(&p, &l, INT_MAX))
timeout_ms = (int)l;
}
}
***************************************************************************/
#include <curl/curl.h>
-#include "timeval.h"
+#include "curlx/timeval.h"
struct connectdata;
struct Curl_easy;
#include "curl_addrinfo.h"
#include "fake_addrinfo.h"
#include "inet_pton.h"
-#include "warnless.h"
+#include "curlx/warnless.h"
/* The last 3 #include files should be in this order */
#include "curl_printf.h"
#include "curl_memory.h"
!defined(CURL_DISABLE_HSTS) || !defined(CURL_DISABLE_NETRC)
#include "curl_get_line.h"
-#ifdef BUILDING_LIBCURL
#include "curl_memory.h"
-#endif
/* The last #include file should be: */
#include "memdebug.h"
{
CURLcode result;
char buffer[128];
- Curl_dyn_reset(buf);
+ curlx_dyn_reset(buf);
while(1) {
char *b = fgets(buffer, sizeof(buffer), input);
if(!rlen)
break;
- result = Curl_dyn_addn(buf, b, rlen);
+ result = curlx_dyn_addn(buf, b, rlen);
if(result)
/* too long line or out of memory */
return 0; /* error */
else if(feof(input)) {
/* append a newline */
- result = Curl_dyn_addn(buf, "\n", 1);
+ result = curlx_dyn_addn(buf, "\n", 1);
if(result)
/* too long line or out of memory */
return 0; /* error */
return 1; /* all good */
}
}
- else if(Curl_dyn_len(buf))
+ else if(curlx_dyn_len(buf))
return 1; /* all good */
else
break;
*
***************************************************************************/
-#include "dynbuf.h"
-
-#ifndef BUILDING_LIBCURL
-/* this renames functions so that the tool code can use the same code
- without getting symbol collisions */
-#define Curl_get_line(a,b) curlx_get_line(a,b)
-#endif
+#include "curlx/dynbuf.h"
/* Curl_get_line() returns complete lines that end with a newline. */
int Curl_get_line(struct dynbuf *buf, FILE *input);
#include "curl_ntlm_core.h"
#include "curl_md5.h"
#include "curl_hmac.h"
-#include "warnless.h"
+#include "curlx/warnless.h"
#include "curl_endian.h"
#include "curl_des.h"
#include "curl_md4.h"
*
***************************************************************************/
-/*
- * This header should be included by ALL code in libcurl that uses any
- * *rintf() functions.
- */
-
-#ifndef CURL_TEMP_PRINTF
-#error "CURL_TEMP_PRINTF must be set before including curl/mprintf.h"
-#endif
-
#include <curl/mprintf.h>
#define MERR_OK 0
#define MERR_MEM 1
#define MERR_TOO_LARGE 2
+#ifdef BUILDING_LIBCURL
+
+/*
+ * This header should be included by ALL code in libcurl that uses any
+ * *rintf() functions.
+ */
+
# undef printf
# undef fprintf
# undef msnprintf
# define mvsnprintf curl_mvsnprintf
# define aprintf curl_maprintf
# define vaprintf curl_mvaprintf
+
+#endif /* BUILDING_LIBCURL */
#endif /* HEADER_CURL_PRINTF_H */
#include <curl/curl.h>
#include "curl_range.h"
#include "sendf.h"
-#include "strparse.h"
+#include "curlx/strparse.h"
/* Only include this function if one or more of FTP, FILE are enabled. */
#if !defined(CURL_DISABLE_FTP) || !defined(CURL_DISABLE_FILE)
curl_off_t from, to;
bool first_num = TRUE;
const char *p = data->state.range;
- if(Curl_str_number(&p, &from, CURL_OFF_T_MAX))
+ if(curlx_str_number(&p, &from, CURL_OFF_T_MAX))
first_num = FALSE;
- if(Curl_str_single(&p, '-'))
+ if(curlx_str_single(&p, '-'))
/* no leading dash or after the first number is an error */
return CURLE_RANGE_ERROR;
- if(Curl_str_number(&p, &to, CURL_OFF_T_MAX)) {
+ if(curlx_str_number(&p, &to, CURL_OFF_T_MAX)) {
/* no second number */
/* X - */
data->state.resume_from = from;
#include "nonblock.h" /* for curlx_nonblock */
#include "progress.h" /* for Curl_pgrsSetUploadSize */
#include "transfer.h"
-#include "warnless.h"
+#include "curlx/warnless.h"
#include <curl/curl.h>
#include <librtmp/rtmp.h>
#include <curl/curl.h>
#include "urldata.h"
-#include "curl_base64.h"
+#include "curlx/base64.h"
#include "curl_md5.h"
#include "vauth/vauth.h"
#include "cfilters.h"
#include "vtls/vtls.h"
#include "curl_hmac.h"
#include "curl_sasl.h"
-#include "warnless.h"
+#include "curlx/warnless.h"
#include "sendf.h"
/* The last 3 #include files should be in this order */
#include "curl_printf.h"
if(!*serverdata || *serverdata == '=')
Curl_bufref_set(out, NULL, 0, NULL);
else {
- result = Curl_base64_decode(serverdata, &msg, &msglen);
+ result = curlx_base64_decode(serverdata, &msg, &msglen);
if(!result)
Curl_bufref_set(out, msg, msglen, curl_free);
}
char *base64;
size_t base64len;
- result = Curl_base64_encode((const char *) Curl_bufref_ptr(msg),
- Curl_bufref_len(msg), &base64, &base64len);
+ result = curlx_base64_encode((const char *) Curl_bufref_ptr(msg),
+ Curl_bufref_len(msg), &base64, &base64len);
if(!result)
Curl_bufref_set(msg, base64, base64len, curl_free);
}
#define CURL_NO_OLDIES
#endif
-/* Tell "curl/curl.h" not to include "curl/mprintf.h" */
-#define CURL_SKIP_INCLUDE_MPRINTF
-
/* Set default _WIN32_WINNT */
#ifdef __MINGW32__
#include <_mingw.h>
#if !defined(CURL_DISABLE_DIGEST_AUTH) && !defined(CURL_DISABLE_SHA512_256)
#include "curl_sha512_256.h"
-#include "warnless.h"
+#include "curlx/warnless.h"
/* The recommended order of the TLS backends:
* * OpenSSL
#include "curl_multibyte.h"
#include "system_win32.h"
#include "version_win32.h"
-#include "warnless.h"
+#include "curlx/warnless.h"
/* The last #include files should be: */
#include "curl_memory.h"
#endif
#include "curl_threads.h"
-#ifdef BUILDING_LIBCURL
#include "curl_memory.h"
-#endif
/* The last #include file should be: */
#include "memdebug.h"
#include "cf-haproxy.h"
#include "cf-https-connect.h"
#include "socks.h"
-#include "strparse.h"
+#include "curlx/strparse.h"
#include "vtls/vtls.h"
#include "vquic/vquic.h"
size_t i;
for(i = 0; i < CURL_ARRAYSIZE(trc_cfts); ++i) {
- if(Curl_str_casecompare(token, trc_cfts[i].cft->name)) {
+ if(curlx_str_casecompare(token, trc_cfts[i].cft->name)) {
trc_cfts[i].cft->log_level = lvl;
break;
}
}
for(i = 0; i < CURL_ARRAYSIZE(trc_feats); ++i) {
- if(Curl_str_casecompare(token, trc_feats[i].feat->name)) {
+ if(curlx_str_casecompare(token, trc_feats[i].feat->name)) {
trc_feats[i].feat->log_level = lvl;
break;
}
static CURLcode trc_opt(const char *config)
{
struct Curl_str out;
- while(!Curl_str_until(&config, &out, 32, ',')) {
+ while(!curlx_str_until(&config, &out, 32, ',')) {
int lvl = CURL_LOG_LVL_INFO;
- const char *token = Curl_str(&out);
+ const char *token = curlx_str(&out);
if(*token == '-') {
lvl = CURL_LOG_LVL_NONE;
- Curl_str_nudge(&out, 1);
+ curlx_str_nudge(&out, 1);
}
else if(*token == '+')
- Curl_str_nudge(&out, 1);
+ curlx_str_nudge(&out, 1);
- if(Curl_str_casecompare(&out, "all"))
+ if(curlx_str_casecompare(&out, "all"))
trc_apply_level_by_category(TRC_CT_NONE, lvl);
- else if(Curl_str_casecompare(&out, "protocol"))
+ else if(curlx_str_casecompare(&out, "protocol"))
trc_apply_level_by_category(TRC_CT_PROTOCOL, lvl);
- else if(Curl_str_casecompare(&out, "network"))
+ else if(curlx_str_casecompare(&out, "network"))
trc_apply_level_by_category(TRC_CT_NETWORK, lvl);
- else if(Curl_str_casecompare(&out, "proxy"))
+ else if(curlx_str_casecompare(&out, "proxy"))
trc_apply_level_by_category(TRC_CT_PROXY, lvl);
- else if(Curl_str_casecompare(&out, "doh")) {
+ else if(curlx_str_casecompare(&out, "doh")) {
struct Curl_str dns = { "dns", 3 };
trc_apply_level_by_name(&dns, lvl);
}
else
trc_apply_level_by_name(&out, lvl);
- if(Curl_str_single(&config, ','))
+ if(curlx_str_single(&config, ','))
break;
}
return CURLE_OK;
--- /dev/null
+<!--
+Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al.
+
+SPDX-License-Identifier: curl
+-->
+
+# `curlx`
+
+Functions that are prefixed with `curlx_` are internal global functions that
+are written in a way to allow them to be "borrowed" and used outside of the
+library: in the curl tool and in the curl test suite.
+
+The `curlx` functions are not part of the libcurl API, but are stand-alone
+functions whose sources can be built and used outside of libcurl. There are
+not API or ABI guarantees. The functions are not written or meant to be used
+outside of the curl project.
+
+Only functions actually used by the library are provided here.
+
+## Ways to success
+
+- Do not use `struct Curl_easy` in these files
+- Do not use the printf defines in these files
+- Make them as stand-alone as possible
/* Base64 encoding/decoding */
-#include "curl_setup.h"
+#include "../curl_setup.h"
#if !defined(CURL_DISABLE_HTTP_AUTH) || defined(USE_SSH) || \
!defined(CURL_DISABLE_LDAP) || \
!defined(CURL_DISABLE_IMAP) || \
!defined(CURL_DISABLE_DIGEST_AUTH) || \
!defined(CURL_DISABLE_DOH) || defined(USE_SSL) || !defined(BUILDING_LIBCURL)
-#include "curl/curl.h"
+#include <curl/curl.h>
#include "warnless.h"
-#include "curl_base64.h"
+#include "base64.h"
/* The last 2 #include files should be in this order */
#ifdef BUILDING_LIBCURL
-#include "curl_memory.h"
+#include "../curl_memory.h"
#endif
-#include "memdebug.h"
+#include "../memdebug.h"
/* ---- Base64 Encoding/Decoding Table --- */
/* Padding character string starts at offset 64. */
29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
48, 49, 50, 51 };
/*
- * Curl_base64_decode()
+ * curlx_base64_decode()
*
* Given a base64 NUL-terminated string at src, decode it and return a
* pointer in *outptr to a newly allocated memory area holding decoded
*
* @unittest: 1302
*/
-CURLcode Curl_base64_decode(const char *src,
- unsigned char **outptr, size_t *outlen)
+CURLcode curlx_base64_decode(const char *src,
+ unsigned char **outptr, size_t *outlen)
{
size_t srclen = 0;
size_t padding = 0;
}
/*
- * Curl_base64_encode()
+ * curlx_base64_encode()
*
* Given a pointer to an input buffer and an input size, encode it and
* return a pointer in *outptr to a newly allocated memory area holding
*
* @unittest: 1302
*/
-CURLcode Curl_base64_encode(const char *inputbuff, size_t insize,
- char **outptr, size_t *outlen)
+CURLcode curlx_base64_encode(const char *inputbuff, size_t insize,
+ char **outptr, size_t *outlen)
{
return base64_encode(base64encdec, inputbuff, insize, outptr, outlen);
}
/*
- * Curl_base64url_encode()
+ * curlx_base64url_encode()
*
* Given a pointer to an input buffer and an input size, encode it and
* return a pointer in *outptr to a newly allocated memory area holding
*
* @unittest: 1302
*/
-CURLcode Curl_base64url_encode(const char *inputbuff, size_t insize,
- char **outptr, size_t *outlen)
+CURLcode curlx_base64url_encode(const char *inputbuff, size_t insize,
+ char **outptr, size_t *outlen)
{
return base64_encode(base64url, inputbuff, insize, outptr, outlen);
}
*
***************************************************************************/
-#ifndef BUILDING_LIBCURL
-/* this renames functions so that the tool code can use the same code
- without getting symbol collisions */
-#define Curl_base64_encode(a,b,c,d) curlx_base64_encode(a,b,c,d)
-#define Curl_base64url_encode(a,b,c,d) curlx_base64url_encode(a,b,c,d)
-#define Curl_base64_decode(a,b,c) curlx_base64_decode(a,b,c)
-#endif
-
-CURLcode Curl_base64_encode(const char *inputbuff, size_t insize,
- char **outptr, size_t *outlen);
-CURLcode Curl_base64url_encode(const char *inputbuff, size_t insize,
- char **outptr, size_t *outlen);
-CURLcode Curl_base64_decode(const char *src,
- unsigned char **outptr, size_t *outlen);
+CURLcode curlx_base64_encode(const char *inputbuff, size_t insize,
+ char **outptr, size_t *outlen);
+CURLcode curlx_base64url_encode(const char *inputbuff, size_t insize,
+ char **outptr, size_t *outlen);
+CURLcode curlx_base64_decode(const char *src,
+ unsigned char **outptr, size_t *outlen);
#endif /* HEADER_CURL_BASE64_H */
* be.
*/
-/* map standard printf functions to curl implementations */
-#include "curl_printf.h"
-
-#include "strcase.h"
-/* "strcase.h" provides the strcasecompare protos */
-
-#include "nonblock.h"
+#include "../nonblock.h"
/* "nonblock.h" provides curlx_nonblock() */
#include "warnless.h"
curlx_uztosi()
*/
-#include "curl_multibyte.h"
+#include "../curl_multibyte.h"
/* "curl_multibyte.h" provides these functions and macros:
curlx_convert_UTF8_to_wchar()
curlx_unicodefree()
*/
-#include "version_win32.h"
+#include "../version_win32.h"
/* "version_win32.h" provides curlx_verify_windows_version() */
#include "strparse.h"
/* The curlx_str_* parsing functions */
+#include "dynbuf.h"
+/* The curlx_dyn_* functions */
+
+#include "base64.h"
+#include "timeval.h"
+#include "timediff.h"
+
+#include "../curl_get_line.h"
+
#define curlx_safefree(x) Curl_safefree(x)
#endif /* HEADER_CURL_CURLX_H */
*
***************************************************************************/
-#include "curl_setup.h"
+#include "../curl_setup.h"
#include "dynbuf.h"
-#include "curl_printf.h"
+#include "../curl_printf.h"
#ifdef BUILDING_LIBCURL
-#include "curl_memory.h"
+#include "../curl_memory.h"
#endif
-#include "memdebug.h"
+#include "../memdebug.h"
#define MIN_FIRST_ALLOC 32
/*
* Init a dynbuf struct.
*/
-void Curl_dyn_init(struct dynbuf *s, size_t toobig)
+void curlx_dyn_init(struct dynbuf *s, size_t toobig)
{
DEBUGASSERT(s);
DEBUGASSERT(toobig);
* free the buffer and re-init the necessary fields. It does not touch the
* 'init' field and thus this buffer can be reused to add data to again.
*/
-void Curl_dyn_free(struct dynbuf *s)
+void curlx_dyn_free(struct dynbuf *s)
{
DEBUGASSERT(s);
DEBUGASSERT(s->init == DYNINIT);
DEBUGASSERT(!len || mem);
if(fit > s->toobig) {
- Curl_dyn_free(s);
+ curlx_dyn_free(s);
return CURLE_TOO_LARGE;
}
else if(!a) {
include that as well when it uses this code */
void *p = realloc(s->bufr, a);
if(!p) {
- Curl_dyn_free(s);
+ curlx_dyn_free(s);
return CURLE_OUT_OF_MEMORY;
}
s->bufr = p;
* Clears the string, keeps the allocation. This can also be called on a
* buffer that already was freed.
*/
-void Curl_dyn_reset(struct dynbuf *s)
+void curlx_dyn_reset(struct dynbuf *s)
{
DEBUGASSERT(s);
DEBUGASSERT(s->init == DYNINIT);
* Specify the size of the tail to keep (number of bytes from the end of the
* buffer). The rest will be dropped.
*/
-CURLcode Curl_dyn_tail(struct dynbuf *s, size_t trail)
+CURLcode curlx_dyn_tail(struct dynbuf *s, size_t trail)
{
DEBUGASSERT(s);
DEBUGASSERT(s->init == DYNINIT);
else if(trail == s->leng)
return CURLE_OK;
else if(!trail) {
- Curl_dyn_reset(s);
+ curlx_dyn_reset(s);
}
else {
memmove(&s->bufr[0], &s->bufr[s->leng - trail], trail);
/*
* Appends a buffer with length.
*/
-CURLcode Curl_dyn_addn(struct dynbuf *s, const void *mem, size_t len)
+CURLcode curlx_dyn_addn(struct dynbuf *s, const void *mem, size_t len)
{
DEBUGASSERT(s);
DEBUGASSERT(s->init == DYNINIT);
/*
* Append a null-terminated string at the end.
*/
-CURLcode Curl_dyn_add(struct dynbuf *s, const char *str)
+CURLcode curlx_dyn_add(struct dynbuf *s, const char *str)
{
size_t n;
DEBUGASSERT(str);
/*
* Append a string vprintf()-style
*/
-CURLcode Curl_dyn_vaddf(struct dynbuf *s, const char *fmt, va_list ap)
+CURLcode curlx_dyn_vaddf(struct dynbuf *s, const char *fmt, va_list ap)
{
#ifdef BUILDING_LIBCURL
int rc;
DEBUGASSERT(s->init == DYNINIT);
DEBUGASSERT(!s->leng || s->bufr);
DEBUGASSERT(fmt);
- rc = Curl_dyn_vprintf(s, fmt, ap);
+ rc = curlx_dyn_vprintf(s, fmt, ap);
if(!rc)
return CURLE_OK;
return CURLE_OUT_OF_MEMORY;
#else
char *str;
- str = vaprintf(fmt, ap); /* this allocs a new string to append */
+ str = curl_mvaprintf(fmt, ap); /* this allocs a new string to append */
if(str) {
CURLcode result = dyn_nappend(s, (const unsigned char *)str, strlen(str));
return result;
}
/* If we failed, we cleanup the whole buffer and return error */
- Curl_dyn_free(s);
+ curlx_dyn_free(s);
return CURLE_OUT_OF_MEMORY;
#endif
}
/*
* Append a string printf()-style
*/
-CURLcode Curl_dyn_addf(struct dynbuf *s, const char *fmt, ...)
+CURLcode curlx_dyn_addf(struct dynbuf *s, const char *fmt, ...)
{
CURLcode result;
va_list ap;
DEBUGASSERT(s->init == DYNINIT);
DEBUGASSERT(!s->leng || s->bufr);
va_start(ap, fmt);
- result = Curl_dyn_vaddf(s, fmt, ap);
+ result = curlx_dyn_vaddf(s, fmt, ap);
va_end(ap);
return result;
}
/*
* Returns a pointer to the buffer.
*/
-char *Curl_dyn_ptr(const struct dynbuf *s)
+char *curlx_dyn_ptr(const struct dynbuf *s)
{
DEBUGASSERT(s);
DEBUGASSERT(s->init == DYNINIT);
return s->bufr;
}
-char *Curl_dyn_take(struct dynbuf *s, size_t *plen)
+char *curlx_dyn_take(struct dynbuf *s, size_t *plen)
{
char *ptr = s->bufr;
DEBUGASSERT(s);
/*
* Returns an unsigned pointer to the buffer.
*/
-unsigned char *Curl_dyn_uptr(const struct dynbuf *s)
+unsigned char *curlx_dyn_uptr(const struct dynbuf *s)
{
DEBUGASSERT(s);
DEBUGASSERT(s->init == DYNINIT);
/*
* Returns the length of the buffer.
*/
-size_t Curl_dyn_len(const struct dynbuf *s)
+size_t curlx_dyn_len(const struct dynbuf *s)
{
DEBUGASSERT(s);
DEBUGASSERT(s->init == DYNINIT);
/*
* Set a new (smaller) length.
*/
-CURLcode Curl_dyn_setlen(struct dynbuf *s, size_t set)
+CURLcode curlx_dyn_setlen(struct dynbuf *s, size_t set)
{
DEBUGASSERT(s);
DEBUGASSERT(s->init == DYNINIT);
#include <curl/curl.h>
-#ifndef BUILDING_LIBCURL
-/* this renames the functions so that the tool code can use the same code
- without getting symbol collisions */
-#define Curl_dyn_init(a,b) curlx_dyn_init(a,b)
-#define Curl_dyn_add(a,b) curlx_dyn_add(a,b)
-#define Curl_dyn_addn(a,b,c) curlx_dyn_addn(a,b,c)
-#define Curl_dyn_addf curlx_dyn_addf
-#define Curl_dyn_vaddf curlx_dyn_vaddf
-#define Curl_dyn_free(a) curlx_dyn_free(a)
-#define Curl_dyn_ptr(a) curlx_dyn_ptr(a)
-#define Curl_dyn_uptr(a) curlx_dyn_uptr(a)
-#define Curl_dyn_len(a) curlx_dyn_len(a)
-#define Curl_dyn_reset(a) curlx_dyn_reset(a)
-#define Curl_dyn_take(a,b) curlx_dyn_take(a,b)
-#define Curl_dyn_tail(a,b) curlx_dyn_tail(a,b)
-#define Curl_dyn_setlen(a,b) curlx_dyn_setlen(a,b)
-#define curlx_dynbuf dynbuf /* for the struct name */
-#endif
-
struct dynbuf {
char *bufr; /* point to a null-terminated allocated buffer */
size_t leng; /* number of bytes *EXCLUDING* the null-terminator */
#endif
};
-void Curl_dyn_init(struct dynbuf *s, size_t toobig);
-void Curl_dyn_free(struct dynbuf *s);
-CURLcode Curl_dyn_addn(struct dynbuf *s, const void *mem, size_t len)
+void curlx_dyn_init(struct dynbuf *s, size_t toobig);
+void curlx_dyn_free(struct dynbuf *s);
+CURLcode curlx_dyn_addn(struct dynbuf *s, const void *mem, size_t len)
WARN_UNUSED_RESULT;
-CURLcode Curl_dyn_add(struct dynbuf *s, const char *str)
+CURLcode curlx_dyn_add(struct dynbuf *s, const char *str)
WARN_UNUSED_RESULT;
-CURLcode Curl_dyn_addf(struct dynbuf *s, const char *fmt, ...)
+CURLcode curlx_dyn_addf(struct dynbuf *s, const char *fmt, ...)
WARN_UNUSED_RESULT CURL_PRINTF(2, 3);
-CURLcode Curl_dyn_vaddf(struct dynbuf *s, const char *fmt, va_list ap)
+CURLcode curlx_dyn_vaddf(struct dynbuf *s, const char *fmt, va_list ap)
WARN_UNUSED_RESULT CURL_PRINTF(2, 0);
-void Curl_dyn_reset(struct dynbuf *s);
-CURLcode Curl_dyn_tail(struct dynbuf *s, size_t trail);
-CURLcode Curl_dyn_setlen(struct dynbuf *s, size_t set);
-char *Curl_dyn_ptr(const struct dynbuf *s);
-unsigned char *Curl_dyn_uptr(const struct dynbuf *s);
-size_t Curl_dyn_len(const struct dynbuf *s);
+void curlx_dyn_reset(struct dynbuf *s);
+CURLcode curlx_dyn_tail(struct dynbuf *s, size_t trail);
+CURLcode curlx_dyn_setlen(struct dynbuf *s, size_t set);
+char *curlx_dyn_ptr(const struct dynbuf *s);
+unsigned char *curlx_dyn_uptr(const struct dynbuf *s);
+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 Curl_dyn_vprintf(struct dynbuf *dyn, const char *format, va_list ap_save);
+int curlx_dyn_vprintf(struct dynbuf *dyn, const char *format, va_list ap_save);
/* Take the buffer out of the dynbuf. Caller has ownership and
* dynbuf resets to initial state. */
-char *Curl_dyn_take(struct dynbuf *s, size_t *plen);
+char *curlx_dyn_take(struct dynbuf *s, size_t *plen);
/* Dynamic buffer max sizes */
#define MAX_DYNBUF_SIZE (SIZE_T_MAX/2)
***************************************************************************/
#include "strparse.h"
-#include "strcase.h"
+#include "../strcase.h"
-void Curl_str_init(struct Curl_str *out)
+void curlx_str_init(struct Curl_str *out)
{
out->str = NULL;
out->len = 0;
}
-void Curl_str_assign(struct Curl_str *out, const char *str, size_t len)
+void curlx_str_assign(struct Curl_str *out, const char *str, size_t len)
{
out->str = str;
out->len = len;
/* Get a word until the first DELIM or end of string. At least one byte long.
return non-zero on error */
-int Curl_str_until(const char **linep, struct Curl_str *out,
+int curlx_str_until(const char **linep, struct Curl_str *out,
const size_t max, char delim)
{
const char *s = *linep;
size_t len = 0;
DEBUGASSERT(linep && *linep && out && max && delim);
- Curl_str_init(out);
+ curlx_str_init(out);
while(*s && (*s != delim)) {
s++;
if(++len > max) {
/* Get a word until the first space or end of string. At least one byte long.
return non-zero on error */
-int Curl_str_word(const char **linep, struct Curl_str *out,
+int curlx_str_word(const char **linep, struct Curl_str *out,
const size_t max)
{
- return Curl_str_until(linep, out, max, ' ');
+ return curlx_str_until(linep, out, max, ' ');
}
/* Get a word until a newline byte or end of string. At least one byte long.
return non-zero on error */
-int Curl_str_untilnl(const char **linep, struct Curl_str *out,
+int curlx_str_untilnl(const char **linep, struct Curl_str *out,
const size_t max)
{
const char *s = *linep;
size_t len = 0;
DEBUGASSERT(linep && *linep && out && max);
- Curl_str_init(out);
+ curlx_str_init(out);
while(*s && !ISNEWLINE(*s)) {
s++;
if(++len > max)
/* Get a "quoted" word. No escaping possible.
return non-zero on error */
-int Curl_str_quotedword(const char **linep, struct Curl_str *out,
+int curlx_str_quotedword(const char **linep, struct Curl_str *out,
const size_t max)
{
const char *s = *linep;
size_t len = 0;
DEBUGASSERT(linep && *linep && out && max);
- Curl_str_init(out);
+ curlx_str_init(out);
if(*s != '\"')
return STRE_BEGQUOTE;
s++;
/* Advance over a single character.
return non-zero on error */
-int Curl_str_single(const char **linep, char byte)
+int curlx_str_single(const char **linep, char byte)
{
DEBUGASSERT(linep && *linep);
if(**linep != byte)
/* Advance over a single space.
return non-zero on error */
-int Curl_str_singlespace(const char **linep)
+int curlx_str_singlespace(const char **linep)
{
- return Curl_str_single(linep, ' ');
+ return curlx_str_single(linep, ' ');
}
/* given an ASCII character and max ascii, return TRUE if valid */
/* Get an unsigned decimal number with no leading space or minus. Leading
zeroes are accepted. return non-zero on error */
-int Curl_str_number(const char **linep, curl_off_t *nump, curl_off_t max)
+int curlx_str_number(const char **linep, curl_off_t *nump, curl_off_t max)
{
return str_num_base(linep, nump, max, 10);
}
/* Get an unsigned hexadecimal number with no leading space or minus and no
"0x" support. Leading zeroes are accepted. return non-zero on error */
-int Curl_str_hex(const char **linep, curl_off_t *nump, curl_off_t max)
+int curlx_str_hex(const char **linep, curl_off_t *nump, curl_off_t max)
{
return str_num_base(linep, nump, max, 16);
}
/* Get an unsigned octal number with no leading space or minus and no "0"
prefix support. Leading zeroes are accepted. return non-zero on error */
-int Curl_str_octal(const char **linep, curl_off_t *nump, curl_off_t max)
+int curlx_str_octal(const char **linep, curl_off_t *nump, curl_off_t max)
{
return str_num_base(linep, nump, max, 8);
}
* Parse a positive number up to 63-bit number written in ASCII. Skip leading
* blanks. No support for prefixes.
*/
-int Curl_str_numblanks(const char **str, curl_off_t *num)
+int curlx_str_numblanks(const char **str, curl_off_t *num)
{
- Curl_str_passblanks(str);
- return Curl_str_number(str, num, CURL_OFF_T_MAX);
+ curlx_str_passblanks(str);
+ return curlx_str_number(str, num, CURL_OFF_T_MAX);
}
/* CR or LF
return non-zero on error */
-int Curl_str_newline(const char **linep)
+int curlx_str_newline(const char **linep)
{
DEBUGASSERT(linep && *linep);
if(ISNEWLINE(**linep)) {
/* case insensitive compare that the parsed string matches the
given string. Returns non-zero on match. */
-int Curl_str_casecompare(struct Curl_str *str, const char *check)
+int curlx_str_casecompare(struct Curl_str *str, const char *check)
{
size_t clen = check ? strlen(check) : 0;
return ((str->len == clen) && strncasecompare(str->str, check, clen));
}
/* case sensitive string compare. Returns non-zero on match. */
-int Curl_str_cmp(struct Curl_str *str, const char *check)
+int curlx_str_cmp(struct Curl_str *str, const char *check)
{
if(check) {
size_t clen = strlen(check);
/* Trim off 'num' number of bytes from the beginning (left side) of the
string. If 'num' is larger than the string, return error. */
-int Curl_str_nudge(struct Curl_str *str, size_t num)
+int curlx_str_nudge(struct Curl_str *str, size_t num)
{
if(num <= str->len) {
str->str += num;
/* Get the following character sequence that consists only of bytes not
present in the 'reject' string. Like strcspn(). */
-int Curl_str_cspn(const char **linep, struct Curl_str *out, const char *reject)
+int curlx_str_cspn(const char **linep, struct Curl_str *out,
+ const char *reject)
{
const char *s = *linep;
size_t len;
*linep = &s[len];
return STRE_OK;
}
- Curl_str_init(out);
+ curlx_str_init(out);
return STRE_SHORT;
}
/* remove ISBLANK()s from both ends of the string */
-void Curl_str_trimblanks(struct Curl_str *out)
+void curlx_str_trimblanks(struct Curl_str *out)
{
while(out->len && ISBLANK(*out->str))
- Curl_str_nudge(out, 1);
+ curlx_str_nudge(out, 1);
/* trim trailing spaces and tabs */
while(out->len && ISBLANK(out->str[out->len - 1]))
}
/* increase the pointer until it has moved over all blanks */
-void Curl_str_passblanks(const char **linep)
+void curlx_str_passblanks(const char **linep)
{
while(ISBLANK(**linep))
(*linep)++; /* move over it */
* SPDX-License-Identifier: curl
*
***************************************************************************/
-#include "curl_setup.h"
+#include "../curl_setup.h"
#define STRE_OK 0
#define STRE_BIG 1
size_t len;
};
-void Curl_str_init(struct Curl_str *out);
-void Curl_str_assign(struct Curl_str *out, const char *str, size_t len);
+void curlx_str_init(struct Curl_str *out);
+void curlx_str_assign(struct Curl_str *out, const char *str, size_t len);
-#define Curl_str(x) ((x)->str)
-#define Curl_strlen(x) ((x)->len)
+#define curlx_str(x) ((x)->str)
+#define curlx_strlen(x) ((x)->len)
/* Get a word until the first space
return non-zero on error */
-int Curl_str_word(const char **linep, struct Curl_str *out, const size_t max);
+int curlx_str_word(const char **linep, struct Curl_str *out, const size_t max);
/* Get a word until the first DELIM or end of string
return non-zero on error */
-int Curl_str_until(const char **linep, struct Curl_str *out, const size_t max,
+int curlx_str_until(const char **linep, struct Curl_str *out, const size_t max,
char delim);
/* Get a word until a newline byte or end of string. At least one byte long.
return non-zero on error */
-int Curl_str_untilnl(const char **linep, struct Curl_str *out,
+int curlx_str_untilnl(const char **linep, struct Curl_str *out,
const size_t max);
/* Get a "quoted" word. No escaping possible.
return non-zero on error */
-int Curl_str_quotedword(const char **linep, struct Curl_str *out,
+int curlx_str_quotedword(const char **linep, struct Curl_str *out,
const size_t max);
/* Advance over a single character.
return non-zero on error */
-int Curl_str_single(const char **linep, char byte);
+int curlx_str_single(const char **linep, char byte);
/* Advance over a single space.
return non-zero on error */
-int Curl_str_singlespace(const char **linep);
+int curlx_str_singlespace(const char **linep);
/* Get an unsigned decimal number. Return non-zero on error */
-int Curl_str_number(const char **linep, curl_off_t *nump, curl_off_t max);
+int curlx_str_number(const char **linep, curl_off_t *nump, curl_off_t max);
/* As above with CURL_OFF_T_MAX but also pass leading blanks */
-int Curl_str_numblanks(const char **str, curl_off_t *num);
+int curlx_str_numblanks(const char **str, curl_off_t *num);
/* Get an unsigned hexadecimal number. Return non-zero on error */
-int Curl_str_hex(const char **linep, curl_off_t *nump, curl_off_t max);
+int curlx_str_hex(const char **linep, curl_off_t *nump, curl_off_t max);
/* Get an unsigned octal number. Return non-zero on error */
-int Curl_str_octal(const char **linep, curl_off_t *nump, curl_off_t max);
+int curlx_str_octal(const char **linep, curl_off_t *nump, curl_off_t max);
/* Check for CR or LF
return non-zero on error */
-int Curl_str_newline(const char **linep);
+int curlx_str_newline(const char **linep);
/* case insensitive compare that the parsed string matches the
given string. */
-int Curl_str_casecompare(struct Curl_str *str, const char *check);
-int Curl_str_cmp(struct Curl_str *str, const char *check);
+int curlx_str_casecompare(struct Curl_str *str, const char *check);
+int curlx_str_cmp(struct Curl_str *str, const char *check);
-int Curl_str_nudge(struct Curl_str *str, size_t num);
+int curlx_str_nudge(struct Curl_str *str, size_t num);
-int Curl_str_cspn(const char **linep, struct Curl_str *out, const char *cspn);
-void Curl_str_trimblanks(struct Curl_str *out);
-void Curl_str_passblanks(const char **linep);
+int curlx_str_cspn(const char **linep, struct Curl_str *out, const char *cspn);
+void curlx_str_trimblanks(struct Curl_str *out);
+void curlx_str_passblanks(const char **linep);
/* given a hexadecimal letter, return the binary value. '0' returns 0, 'a'
returns 10. THIS ONLY WORKS ON VALID HEXADECIMAL LETTER INPUT. Verify
extern const unsigned char Curl_hexasciitable[];
#define Curl_hexval(x) (unsigned char)(Curl_hexasciitable[(x) - '0'] & 0x0f)
-#define curlx_str_number(x,y,z) Curl_str_number(x,y,z)
-#define curlx_str_octal(x,y,z) Curl_str_octal(x,y,z)
-#define curlx_str_single(x,y) Curl_str_single(x,y)
-#define curlx_str_passblanks(x) Curl_str_passblanks(x)
-#define curlx_str_numblanks(x,y) Curl_str_numblanks(x,y)
-
#endif /* HEADER_CURL_STRPARSE_H */
*
***************************************************************************/
-#include "curl_setup.h"
+#include "../curl_setup.h"
/* Use a larger type even for 32-bit time_t systems so that we can keep
microsecond accuracy in it */
#ifdef _WIN32
#include <curl/curl.h>
-#ifdef BUILDING_LIBCURL
-#include "system_win32.h"
-#else
-#include "version_win32.h"
+#include "../version_win32.h"
+#include "../system_win32.h"
-static LARGE_INTEGER s_freq;
-static bool s_isVistaOrGreater;
+LARGE_INTEGER Curl_freq;
+bool Curl_isVistaOrGreater;
-/* For tool or tests, we must initialize before calling Curl_now() */
+/* For tool or tests, we must initialize before calling curlx_now().
+ Providing this function here is wrong. */
void curlx_now_init(void)
{
if(curlx_verify_windows_version(6, 0, 0, PLATFORM_WINNT,
VERSION_GREATER_THAN_EQUAL))
- s_isVistaOrGreater = true;
+ Curl_isVistaOrGreater = true;
else
- s_isVistaOrGreater = false;
+ Curl_isVistaOrGreater = false;
- QueryPerformanceFrequency(&s_freq);
+ QueryPerformanceFrequency(&Curl_freq);
}
-#endif
/* In case of bug fix this function has a counterpart in tool_util.c */
-struct curltime Curl_now(void)
+struct curltime curlx_now(void)
{
struct curltime now;
bool isVistaOrGreater;
-#ifdef BUILDING_LIBCURL
isVistaOrGreater = Curl_isVistaOrGreater;
-#else
- isVistaOrGreater = s_isVistaOrGreater;
-#endif
if(isVistaOrGreater) { /* QPC timer might have issues pre-Vista */
LARGE_INTEGER count;
LARGE_INTEGER freq;
-#ifdef BUILDING_LIBCURL
freq = Curl_freq;
-#else
- freq = s_freq;
-#endif
DEBUGASSERT(freq.QuadPart);
QueryPerformanceCounter(&count);
now.tv_sec = (time_t)(count.QuadPart / freq.QuadPart);
#elif defined(HAVE_CLOCK_GETTIME_MONOTONIC) || \
defined(HAVE_CLOCK_GETTIME_MONOTONIC_RAW)
-struct curltime Curl_now(void)
+struct curltime curlx_now(void)
{
/*
** clock_gettime() is granted to be increased monotonically when the
#include <stdint.h>
#include <mach/mach_time.h>
-struct curltime Curl_now(void)
+struct curltime curlx_now(void)
{
/*
** Monotonic timer on macOS is provided by mach_absolute_time(), which
#elif defined(HAVE_GETTIMEOFDAY)
-struct curltime Curl_now(void)
+struct curltime curlx_now(void)
{
/*
** gettimeofday() is not granted to be increased monotonically, due to
#else
-struct curltime Curl_now(void)
+struct curltime curlx_now(void)
{
/*
** time() returns the value of time in seconds since the Epoch.
*
* @unittest: 1323
*/
-timediff_t Curl_timediff(struct curltime newer, struct curltime older)
+timediff_t curlx_timediff(struct curltime newer, struct curltime older)
{
timediff_t diff = (timediff_t)newer.tv_sec-older.tv_sec;
if(diff >= (TIMEDIFF_T_MAX/1000))
* Returns: time difference in number of milliseconds, rounded up.
* For too large diffs it returns max value.
*/
-timediff_t Curl_timediff_ceil(struct curltime newer, struct curltime older)
+timediff_t curlx_timediff_ceil(struct curltime newer, struct curltime older)
{
timediff_t diff = (timediff_t)newer.tv_sec-older.tv_sec;
if(diff >= (TIMEDIFF_T_MAX/1000))
* Returns: time difference in number of microseconds. For too large diffs it
* returns max value.
*/
-timediff_t Curl_timediff_us(struct curltime newer, struct curltime older)
+timediff_t curlx_timediff_us(struct curltime newer, struct curltime older)
{
timediff_t diff = (timediff_t)newer.tv_sec-older.tv_sec;
if(diff >= (TIMEDIFF_T_MAX/1000000))
*
***************************************************************************/
-#include "curl_setup.h"
+#include "../curl_setup.h"
#include "timediff.h"
-#ifndef BUILDING_LIBCURL
-/* this renames the functions so that the tool code can use the same code
- without getting symbol collisions */
-#define Curl_now curlx_now
-#define Curl_timediff(a,b) curlx_timediff(a,b)
-#define Curl_timediff_ceil(a,b) curlx_timediff_ceil(a,b)
-#define Curl_timediff_us(a,b) curlx_timediff_us(a,b)
-
-/* For tool or tests, we must initialize before calling Curl_now() */
-void curlx_now_init(void);
-#endif
-
struct curltime {
time_t tv_sec; /* seconds */
int tv_usec; /* microseconds */
};
-struct curltime Curl_now(void);
+#ifdef _WIN32
+/* For tool or tests, we must initialize before calling curlx_now() */
+void curlx_now_init(void);
+#endif
+
+struct curltime curlx_now(void);
/*
* Make sure that the first argument (newer) is the more recent time and older
*
* Returns: the time difference in number of milliseconds.
*/
-timediff_t Curl_timediff(struct curltime newer, struct curltime older);
+timediff_t curlx_timediff(struct curltime newer, struct curltime older);
/*
* Make sure that the first argument (newer) is the more recent time and older
*
* Returns: the time difference in number of milliseconds, rounded up.
*/
-timediff_t Curl_timediff_ceil(struct curltime newer, struct curltime older);
+timediff_t curlx_timediff_ceil(struct curltime newer, struct curltime older);
/*
* Make sure that the first argument (newer) is the more recent time and older
*
* Returns: the time difference in number of microseconds.
*/
-timediff_t Curl_timediff_us(struct curltime newer, struct curltime older);
+timediff_t curlx_timediff_us(struct curltime newer, struct curltime older);
#endif /* HEADER_CURL_TIMEVAL_H */
*
***************************************************************************/
-#include "curl_setup.h"
+#include "warnless.h"
#if defined(__INTEL_COMPILER) && defined(__unix__)
#endif /* __INTEL_COMPILER && __unix__ */
-#include "warnless.h"
-
#ifdef _WIN32
#undef read
#undef write
*
***************************************************************************/
-#include "curl_setup.h"
+#include "../curl_setup.h"
#ifdef USE_WINSOCK
#include <curl/curl.h> /* for curl_socket_t */
struct cw_out_buf *cwbuf = calloc(1, sizeof(*cwbuf));
if(cwbuf) {
cwbuf->type = otype;
- Curl_dyn_init(&cwbuf->b, DYN_PAUSE_BUFFER);
+ curlx_dyn_init(&cwbuf->b, DYN_PAUSE_BUFFER);
}
return cwbuf;
}
static void cw_out_buf_free(struct cw_out_buf *cwbuf)
{
if(cwbuf) {
- Curl_dyn_free(&cwbuf->b);
+ curlx_dyn_free(&cwbuf->b);
free(cwbuf);
}
}
struct cw_out_buf *cwbuf = ctx->buf;
size_t len = 0;
while(cwbuf) {
- len += Curl_dyn_len(&cwbuf->b);
+ len += curlx_dyn_len(&cwbuf->b);
cwbuf = cwbuf->next;
}
return len;
{
CURLcode result = CURLE_OK;
- if(Curl_dyn_len(&cwbuf->b)) {
+ if(curlx_dyn_len(&cwbuf->b)) {
size_t consumed;
result = cw_out_ptr_flush(ctx, data, cwbuf->type, flush_all,
- Curl_dyn_ptr(&cwbuf->b),
- Curl_dyn_len(&cwbuf->b),
+ curlx_dyn_ptr(&cwbuf->b),
+ curlx_dyn_len(&cwbuf->b),
&consumed);
if(result)
return result;
if(consumed) {
- if(consumed == Curl_dyn_len(&cwbuf->b)) {
- Curl_dyn_free(&cwbuf->b);
+ if(consumed == curlx_dyn_len(&cwbuf->b)) {
+ curlx_dyn_free(&cwbuf->b);
}
else {
- DEBUGASSERT(consumed < Curl_dyn_len(&cwbuf->b));
- result = Curl_dyn_tail(&cwbuf->b, Curl_dyn_len(&cwbuf->b) - consumed);
+ DEBUGASSERT(consumed < curlx_dyn_len(&cwbuf->b));
+ result = curlx_dyn_tail(&cwbuf->b,
+ curlx_dyn_len(&cwbuf->b) - consumed);
if(result)
return result;
}
result = cw_out_buf_flush(ctx, data, cwbuf, flush_all);
if(result)
return result;
- if(!Curl_dyn_len(&cwbuf->b)) {
+ if(!curlx_dyn_len(&cwbuf->b)) {
cw_out_buf_free(cwbuf);
*pcwbuf = NULL;
}
ctx->buf = cwbuf;
}
DEBUGASSERT(ctx->buf && (ctx->buf->type == otype));
- return Curl_dyn_addn(&ctx->buf->b, buf, blen);
+ return curlx_dyn_addn(&ctx->buf->b, buf, blen);
}
static CURLcode cw_out_do_write(struct cw_out_ctx *ctx,
struct dynbuf out;
const char *ptr;
CURLcode result = CURLE_OK;
- Curl_dyn_init(&out, DYN_DICT_WORD);
+ curlx_dyn_init(&out, DYN_DICT_WORD);
/* According to RFC2229 section 2.2, these letters need to be escaped with
\[letter] */
char ch = *ptr;
if((ch <= 32) || (ch == 127) ||
(ch == '\'') || (ch == '\"') || (ch == '\\'))
- result = Curl_dyn_addn(&out, "\\", 1);
+ result = curlx_dyn_addn(&out, "\\", 1);
if(!result)
- result = Curl_dyn_addn(&out, ptr, 1);
+ result = curlx_dyn_addn(&out, ptr, 1);
if(result)
return NULL;
}
- return Curl_dyn_ptr(&out);
+ return curlx_dyn_ptr(&out);
}
/* sendf() sends formatted data to the server */
#include "multiif.h"
#include "url.h"
#include "share.h"
-#include "curl_base64.h"
+#include "curlx/base64.h"
#include "connect.h"
#include "strdup.h"
-#include "dynbuf.h"
+#include "curlx/dynbuf.h"
#include "escape.h"
#include "urlapi-int.h"
if(!doh_req)
return CURL_WRITEFUNC_ERROR;
- if(Curl_dyn_addn(&doh_req->resp_body, contents, realsize))
+ if(curlx_dyn_addn(&doh_req->resp_body, contents, realsize))
return 0;
return realsize;
if(doh_req) {
if(!result) {
dohp->probe_resp[i].dnstype = doh_req->dnstype;
- result = Curl_dyn_addn(&dohp->probe_resp[i].body,
- Curl_dyn_ptr(&doh_req->resp_body),
- Curl_dyn_len(&doh_req->resp_body));
- Curl_dyn_free(&doh_req->resp_body);
+ result = curlx_dyn_addn(&dohp->probe_resp[i].body,
+ curlx_dyn_ptr(&doh_req->resp_body),
+ curlx_dyn_len(&doh_req->resp_body));
+ curlx_dyn_free(&doh_req->resp_body);
}
Curl_meta_remove(doh, CURL_EZM_DOH_PROBE);
}
if(e) {
struct doh_request *doh_req = e;
curl_slist_free_all(doh_req->req_hds);
- Curl_dyn_free(&doh_req->resp_body);
+ curlx_dyn_free(&doh_req->resp_body);
free(e);
}
}
if(!doh_req)
return CURLE_OUT_OF_MEMORY;
doh_req->dnstype = dnstype;
- Curl_dyn_init(&doh_req->resp_body, DYN_DOH_RESPONSE);
+ curlx_dyn_init(&doh_req->resp_body, DYN_DOH_RESPONSE);
d = doh_req_encode(host, dnstype, doh_req->req_body,
sizeof(doh_req->req_body),
for(i = 0; i < DOH_SLOT_COUNT; ++i) {
dohp->probe_resp[i].probe_mid = UINT_MAX;
- Curl_dyn_init(&dohp->probe_resp[i].body, DYN_DOH_RESPONSE);
+ curlx_dyn_init(&dohp->probe_resp[i].body, DYN_DOH_RESPONSE);
}
conn->bits.doh = TRUE;
index++;
if(length) {
- if(Curl_dyn_len(c)) {
- if(Curl_dyn_addn(c, STRCONST(".")))
+ if(curlx_dyn_len(c)) {
+ if(curlx_dyn_addn(c, STRCONST(".")))
return DOH_OUT_OF_MEM;
}
if((index + length) > dohlen)
return DOH_DNS_BAD_LABEL;
- if(Curl_dyn_addn(c, &doh[index], length))
+ if(curlx_dyn_addn(c, &doh[index], length))
return DOH_OUT_OF_MEM;
index += length;
}
memset(de, 0, sizeof(*de));
de->ttl = INT_MAX;
for(i = 0; i < DOH_MAX_CNAME; i++)
- Curl_dyn_init(&de->cname[i], DYN_DOH_CNAME);
+ curlx_dyn_init(&de->cname[i], DYN_DOH_CNAME);
}
}
#endif
for(i = 0; i < d->numcname; i++) {
- infof(data, "CNAME: %s", Curl_dyn_ptr(&d->cname[i]));
+ infof(data, "CNAME: %s", curlx_dyn_ptr(&d->cname[i]));
}
}
#else
{
int i = 0;
for(i = 0; i < d->numcname; i++) {
- Curl_dyn_free(&d->cname[i]);
+ curlx_dyn_free(&d->cname[i]);
}
#ifdef USE_HTTPSRR
for(i = 0; i < d->numhttps_rrs; i++)
DEBUGASSERT(buf && remaining && dnsname);
if(!buf || !remaining || !dnsname || !*remaining)
return CURLE_OUT_OF_MEMORY;
- Curl_dyn_init(&thename, CURL_MAXLEN_host_name);
+ curlx_dyn_init(&thename, CURL_MAXLEN_host_name);
rem = *remaining;
cp = *buf;
clen = *cp++;
if(clen == 0) {
/* special case - return "." as name */
- if(Curl_dyn_addn(&thename, ".", 1))
+ if(curlx_dyn_addn(&thename, ".", 1))
return CURLE_OUT_OF_MEMORY;
}
while(clen) {
if(clen >= rem) {
- Curl_dyn_free(&thename);
+ curlx_dyn_free(&thename);
return CURLE_OUT_OF_MEMORY;
}
- if(Curl_dyn_addn(&thename, cp, clen) ||
- Curl_dyn_addn(&thename, ".", 1))
+ if(curlx_dyn_addn(&thename, cp, clen) ||
+ curlx_dyn_addn(&thename, ".", 1))
return CURLE_TOO_LARGE;
cp += clen;
rem -= (clen + 1);
if(rem <= 0) {
- Curl_dyn_free(&thename);
+ curlx_dyn_free(&thename);
return CURLE_OUT_OF_MEMORY;
}
clen = *cp++;
}
*buf = cp;
*remaining = rem - 1;
- *dnsname = Curl_dyn_ptr(&thename);
+ *dnsname = curlx_dyn_ptr(&thename);
return CURLE_OK;
}
struct doh_response *p = &dohp->probe_resp[slot];
if(!p->dnstype)
continue;
- rc[slot] = doh_resp_decode(Curl_dyn_uptr(&p->body),
- Curl_dyn_len(&p->body),
+ rc[slot] = doh_resp_decode(curlx_dyn_uptr(&p->body),
+ curlx_dyn_len(&p->body),
p->dnstype, &de);
#ifndef CURL_DISABLE_VERBOSE_STRINGS
if(rc[slot]) {
int i;
Curl_doh_close(data);
for(i = 0; i < DOH_SLOT_COUNT; ++i) {
- Curl_dyn_free(&dohp->probe_resp[i].body);
+ curlx_dyn_free(&dohp->probe_resp[i].body);
}
Curl_safefree(data->state.async.doh);
}
return result;
for(i = 0; i < dynhds->hds_len; ++i) {
- result = Curl_dyn_addf(dbuf, "%.*s: %.*s\r\n",
- (int)dynhds->hds[i]->namelen, dynhds->hds[i]->name,
- (int)dynhds->hds[i]->valuelen, dynhds->hds[i]->value);
+ result = curlx_dyn_addf(dbuf, "%.*s: %.*s\r\n",
+ (int)dynhds->hds[i]->namelen, dynhds->hds[i]->name,
+ (int)dynhds->hds[i]->valuelen,
+ dynhds->hds[i]->value);
if(result)
break;
}
#include "curl_setup.h"
#include <curl/curl.h>
-#include "dynbuf.h"
+#include "curlx/dynbuf.h"
struct dynbuf;
#include "mime.h"
#include "amigaos.h"
#include "macos.h"
-#include "warnless.h"
+#include "curlx/warnless.h"
#include "sigpipe.h"
#include "vssh/ssh.h"
#include "setopt.h"
#include "http_digest.h"
#include "system_win32.h"
#include "http2.h"
-#include "dynbuf.h"
+#include "curlx/dynbuf.h"
#include "altsvc.h"
#include "hsts.h"
const unsigned int numfds = populate_fds(fds, ev);
/* get the time stamp to use to figure out how long poll takes */
- before = Curl_now();
+ before = curlx_now();
if(numfds) {
/* wait for activity or timeout */
/* If nothing updated the timeout, we decrease it by the spent time.
* If it was updated, it has the new timeout time stored already.
*/
- timediff_t timediff = Curl_timediff(Curl_now(), before);
+ timediff_t timediff = curlx_timediff(curlx_now(), before);
if(timediff > 0) {
#if DEBUG_EV_POLL
fprintf(stderr, "poll timeout %ldms not updated, decrease by "
outcurl->set.buffer_size = data->set.buffer_size;
Curl_hash_init(&outcurl->meta_hash, 23,
- Curl_hash_str, Curl_str_key_compare, dupeasy_meta_freeentry);
- Curl_dyn_init(&outcurl->state.headerb, CURL_MAX_HTTP_HEADER);
+ Curl_hash_str, curlx_str_key_compare, dupeasy_meta_freeentry);
+ curlx_dyn_init(&outcurl->state.headerb, CURL_MAX_HTTP_HEADER);
Curl_netrc_init(&outcurl->state.netrc);
/* the connection pool is setup on demand */
#ifndef CURL_DISABLE_COOKIES
free(outcurl->cookies);
#endif
- Curl_dyn_free(&outcurl->state.headerb);
+ curlx_dyn_free(&outcurl->state.headerb);
Curl_altsvc_cleanup(&outcurl->asi);
Curl_hsts_cleanup(&outcurl->hsts);
Curl_freeset(outcurl);
struct Curl_easy;
#include "urldata.h"
-#include "warnless.h"
+#include "curlx/warnless.h"
#include "escape.h"
#include "strdup.h"
-#include "strparse.h"
+#include "curlx/strparse.h"
/* The last 3 #include files should be in this order */
#include "curl_printf.h"
if(!length)
return strdup("");
- Curl_dyn_init(&d, length * 3 + 1);
+ curlx_dyn_init(&d, length * 3 + 1);
while(length--) {
/* treat the characters unsigned */
if(ISUNRESERVED(in)) {
/* append this */
- if(Curl_dyn_addn(&d, &in, 1))
+ if(curlx_dyn_addn(&d, &in, 1))
return NULL;
}
else {
/* encode it */
unsigned char out[3]={'%'};
Curl_hexbyte(&out[1], in, FALSE);
- if(Curl_dyn_addn(&d, out, 3))
+ if(curlx_dyn_addn(&d, out, 3))
return NULL;
}
}
- return Curl_dyn_ptr(&d);
+ return curlx_dyn_ptr(&d);
}
/*
#include "transfer.h"
#include "url.h"
#include "parsedate.h" /* for the week day and month names */
-#include "warnless.h"
+#include "curlx/warnless.h"
#include "curl_range.h"
/* The last 3 #include files should be in this order */
#include "curl_printf.h"
if(Curl_pgrsUpdate(data))
result = CURLE_ABORTED_BY_CALLBACK;
else
- result = Curl_speedcheck(data, Curl_now());
+ result = Curl_speedcheck(data, curlx_now());
}
if(!result && Curl_pgrsUpdate(data))
result = CURLE_ABORTED_BY_CALLBACK;
if(Curl_pgrsUpdate(data))
result = CURLE_ABORTED_BY_CALLBACK;
else
- result = Curl_speedcheck(data, Curl_now());
+ result = Curl_speedcheck(data, curlx_now());
if(result)
goto out;
}
if(!finfo)
return;
- Curl_dyn_free(&finfo->buf);
+ curlx_dyn_free(&finfo->buf);
free(finfo);
}
#endif
#include <curl/curl.h>
#include "llist.h"
-#include "dynbuf.h"
+#include "curlx/dynbuf.h"
struct fileinfo {
struct curl_fileinfo info;
size_t n;
struct dynbuf out;
DEBUGASSERT(path);
- Curl_dyn_init(&out, CURL_MAX_INPUT_LENGTH);
+ curlx_dyn_init(&out, CURL_MAX_INPUT_LENGTH);
n = strlen(path);
if(n) {
/* find the rightmost path separator, if any */
while(n && IS_SEP(path[n-1]))
--n;
}
- if(Curl_dyn_addn(&out, path, n))
+ if(curlx_dyn_addn(&out, path, n))
return NULL;
/* if there was a directory, append a single trailing slash */
- if(n && Curl_dyn_addn(&out, PATHSEP, 1))
+ if(n && curlx_dyn_addn(&out, PATHSEP, 1))
return NULL;
- return Curl_dyn_ptr(&out);
+ return curlx_dyn_ptr(&out);
}
/*
#include "sendf.h"
#include "strdup.h"
#include "rand.h"
-#include "warnless.h"
+#include "curlx/warnless.h"
/* The last 3 #include files should be in this order */
#include "curl_printf.h"
#include "curl_memory.h"
#include "multiif.h"
#include "url.h"
#include "speedcheck.h"
-#include "warnless.h"
+#include "curlx/warnless.h"
#include "http_proxy.h"
#include "socks.h"
#include "strdup.h"
-#include "strparse.h"
+#include "curlx/strparse.h"
/* The last 3 #include files should be in this order */
#include "curl_printf.h"
#include "curl_memory.h"
bool response = FALSE;
/* First check whether there is a cached response from server */
- if(Curl_dyn_len(&pp->recvbuf) && (*Curl_dyn_ptr(&pp->recvbuf) > '3')) {
+ if(curlx_dyn_len(&pp->recvbuf) && (*curlx_dyn_ptr(&pp->recvbuf) > '3')) {
/* Data connection could not be established, let's return */
infof(data, "There is negative response in cache while serv connect");
(void)Curl_GetFTPResponse(data, &nread, &ftpcode);
if(response) {
infof(data, "Ctrl conn has data while waiting for data conn");
if(pp->overflow > 3) {
- const char *r = Curl_dyn_ptr(&pp->recvbuf);
+ const char *r = curlx_dyn_ptr(&pp->recvbuf);
DEBUGASSERT((pp->overflow + pp->nfinal) <=
- Curl_dyn_len(&pp->recvbuf));
+ curlx_dyn_len(&pp->recvbuf));
/* move over the most recently handled response line */
r += pp->nfinal;
if(LASTLINE(r)) {
curl_off_t status;
- if(!Curl_str_number(&r, &status, 999) && (status == 226)) {
+ if(!curlx_str_number(&r, &status, 999) && (status == 226)) {
/* funny timing situation where we get the final message on the
control connection before traffic on the data connection has been
noticed. Leave the 226 in there and use this as a trigger to read
(void)data;
(void)conn;
- if((len > 3) && LASTLINE(line) && !Curl_str_number(&line, &status, 999)) {
+ if((len > 3) && LASTLINE(line) && !curlx_str_number(&line, &status, 999)) {
*code = (int)status;
return TRUE;
}
#ifdef HAVE_GSSAPI
{
struct connectdata *conn = data->conn;
- char * const buf = Curl_dyn_ptr(&ftpc->pp.recvbuf);
+ char * const buf = curlx_dyn_ptr(&ftpc->pp.recvbuf);
/* handle the security-oriented responses 6xx ***/
switch(code) {
*
*/
- if(Curl_dyn_len(&pp->recvbuf) && (cache_skip < 2)) {
+ if(curlx_dyn_len(&pp->recvbuf) && (cache_skip < 2)) {
/*
* There is a cache left since before. We then skipping the wait for
* socket action, unless this is the same cache like the previous round
if(result)
break;
- if(!nread && Curl_dyn_len(&pp->recvbuf))
+ if(!nread && curlx_dyn_len(&pp->recvbuf))
/* bump cache skip counter as on repeated skips we must wait for more
data */
cache_skip++;
curl_off_t start;
curl_off_t end;
portp++;
- if(!Curl_str_number(&portp, &start, 0xffff)) {
+ if(!curlx_str_number(&portp, &start, 0xffff)) {
/* got the first number */
port_min = (unsigned short)start;
- if(!Curl_str_single(&portp, '-')) {
+ if(!curlx_str_single(&portp, '-')) {
/* got the dash */
- if(!Curl_str_number(&portp, &end, 0xffff))
+ if(!curlx_str_number(&portp, &end, 0xffff))
/* got the second number */
port_max = (unsigned short)end;
}
return FALSE;
p++;
}
- if(Curl_str_number(&p, &num, 0xff))
+ if(curlx_str_number(&p, &num, 0xff))
return FALSE;
array[i] = (unsigned int)num;
}
unsigned short connectport; /* the local port connect() should use! */
struct pingpong *pp = &ftpc->pp;
char *str =
- Curl_dyn_ptr(&pp->recvbuf) + 4; /* start on the first letter */
+ curlx_dyn_ptr(&pp->recvbuf) + 4; /* start on the first letter */
/* if we come here again, make sure the former name is cleared */
Curl_safefree(ftpc->newhost);
if((ptr[1] == sep) && (ptr[2] == sep) && ISDIGIT(ptr[3])) {
const char *p = &ptr[3];
curl_off_t num;
- if(Curl_str_number(&p, &num, 0xffff) || (*p != sep)) {
+ if(curlx_str_number(&p, &num, 0xffff) || (*p != sep)) {
failf(data, "Illegal port number in EPSV reply");
return CURLE_FTP_WEIRD_PASV_REPLY;
}
last .sss part is optional and means fractions of a second */
int year, month, day, hour, minute, second;
struct pingpong *pp = &ftpc->pp;
- char *resp = Curl_dyn_ptr(&pp->recvbuf) + 4;
+ char *resp = curlx_dyn_ptr(&pp->recvbuf) + 4;
if(ftp_213_date(resp, &year, &month, &day, &hour, &minute, &second)) {
/* we have a time, reformat it */
char timebuf[24];
{
CURLcode result = CURLE_OK;
curl_off_t filesize = -1;
- char *buf = Curl_dyn_ptr(&ftpc->pp.recvbuf);
+ char *buf = curlx_dyn_ptr(&ftpc->pp.recvbuf);
size_t len = ftpc->pp.nfinal;
/* get the size from the ascii string: */
}
else
fdigit = start;
- if(Curl_str_number(&fdigit, &filesize, CURL_OFF_T_MAX))
+ if(curlx_str_number(&fdigit, &filesize, CURL_OFF_T_MAX))
filesize = -1; /* size remain unknown */
}
else if(ftpcode == 550) { /* "No such file or directory" */
*
* Example D above makes this parsing a little tricky */
const char *bytes;
- char *buf = Curl_dyn_ptr(&ftpc->pp.recvbuf);
+ char *buf = curlx_dyn_ptr(&ftpc->pp.recvbuf);
bytes = strstr(buf, " bytes");
if(bytes) {
long in = (long)(--bytes-buf);
if(bytes) {
++bytes;
/* get the number! */
- if(Curl_str_number(&bytes, &size, CURL_OFF_T_MAX))
+ if(curlx_str_number(&bytes, &size, CURL_OFF_T_MAX))
size = 1;
}
}
case FTP_PWD:
if(ftpcode == 257) {
- char *ptr = Curl_dyn_ptr(&pp->recvbuf) + 4; /* start on the first
- letter */
+ char *ptr = curlx_dyn_ptr(&pp->recvbuf) + 4; /* start on the first
+ letter */
bool entry_extracted = FALSE;
struct dynbuf out;
- Curl_dyn_init(&out, 1000);
+ curlx_dyn_init(&out, 1000);
/* Reply format is like
257<space>[rubbish]"<directory-name>"<space><commentary> and the
if('\"' == *ptr) {
if('\"' == ptr[1]) {
/* "quote-doubling" */
- result = Curl_dyn_addn(&out, &ptr[1], 1);
+ result = curlx_dyn_addn(&out, &ptr[1], 1);
ptr++;
}
else {
/* end of path */
- if(Curl_dyn_len(&out))
+ if(curlx_dyn_len(&out))
entry_extracted = TRUE;
break; /* get out of this loop */
}
}
else
- result = Curl_dyn_addn(&out, ptr, 1);
+ result = curlx_dyn_addn(&out, ptr, 1);
if(result)
return result;
}
The method used here is to check the server OS: we do it only
if the path name looks strange to minimize overhead on other
systems. */
- char *dir = Curl_dyn_ptr(&out);
+ char *dir = curlx_dyn_ptr(&out);
if(!ftpc->server_os && dir[0] != '/') {
result = Curl_pp_sendf(data, &ftpc->pp, "%s", "SYST");
}
else {
/* could not get the path */
- Curl_dyn_free(&out);
+ curlx_dyn_free(&out);
infof(data, "Failed to figure out path");
}
}
case FTP_SYST:
if(ftpcode == 215) {
- char *ptr = Curl_dyn_ptr(&pp->recvbuf) + 4; /* start on the first
+ char *ptr = curlx_dyn_ptr(&pp->recvbuf) + 4; /* start on the first
letter */
char *os;
char *start;
timediff_t old_time = pp->response_time;
pp->response_time = 60*1000; /* give it only a minute for now */
- pp->response = Curl_now(); /* timeout relative now */
+ pp->response = curlx_now(); /* timeout relative now */
result = Curl_GetFTPResponse(data, &nread, &ftpcode);
result = Curl_pp_sendf(data, &ftpc->pp, "%s", cmd);
if(!result) {
- pp->response = Curl_now(); /* timeout relative now */
+ pp->response = curlx_now(); /* timeout relative now */
result = Curl_GetFTPResponse(data, &nread, &ftpcode);
}
if(result)
#include "ftplistparser.h"
#include "curl_fnmatch.h"
#include "multiif.h"
-#include "strparse.h"
+#include "curlx/strparse.h"
/* The last 3 #include files should be in this order */
#include "curl_printf.h"
struct curl_fileinfo *finfo = &infop->info;
/* set the finfo pointers */
- char *str = Curl_dyn_ptr(&infop->buf);
+ char *str = curlx_dyn_ptr(&infop->buf);
finfo->filename = str + parser->offsets.filename;
finfo->strings.group = parser->offsets.group ?
str + parser->offsets.group : NULL;
}
parser->item_offset = 0;
parser->item_length = 0;
- Curl_dyn_init(&parser->file_data->buf, MAX_FTPLIST_BUFFER);
+ curlx_dyn_init(&parser->file_data->buf, MAX_FTPLIST_BUFFER);
}
infop = parser->file_data;
finfo = &infop->info;
- if(Curl_dyn_addn(&infop->buf, &c, 1)) {
+ if(curlx_dyn_addn(&infop->buf, &c, 1)) {
parser->error = CURLE_OUT_OF_MEMORY;
goto fail;
}
- len = Curl_dyn_len(&infop->buf);
- mem = Curl_dyn_ptr(&infop->buf);
+ len = curlx_dyn_len(&infop->buf);
+ mem = curlx_dyn_ptr(&infop->buf);
switch(parser->os_type) {
case OS_TYPE_UNIX:
else {
parser->state.UNIX.main = PL_UNIX_FILETYPE;
/* start FSM again not considering size of directory */
- Curl_dyn_reset(&infop->buf);
+ curlx_dyn_reset(&infop->buf);
continue;
}
break;
parser->item_length++;
if(c == '\r') {
parser->item_length--;
- Curl_dyn_setlen(&infop->buf, --len);
+ curlx_dyn_setlen(&infop->buf, --len);
}
else if(c == '\n') {
mem[parser->item_length - 1] = 0;
const char *endptr = mem + 6;
/* here we can deal with directory size, pass the leading
whitespace and then the digits */
- Curl_str_passblanks(&endptr);
+ curlx_str_passblanks(&endptr);
while(ISDIGIT(*endptr))
endptr++;
if(*endptr) {
goto fail;
}
parser->state.UNIX.main = PL_UNIX_FILETYPE;
- Curl_dyn_reset(&infop->buf);
+ curlx_dyn_reset(&infop->buf);
}
else {
parser->error = CURLE_FTP_BAD_FILE_LIST;
curl_off_t hlinks;
mem[parser->item_offset + parser->item_length - 1] = 0;
- if(!Curl_str_number(&p, &hlinks, LONG_MAX)) {
+ if(!curlx_str_number(&p, &hlinks, LONG_MAX)) {
parser->file_data->info.flags |= CURLFINFOFLAG_KNOWN_HLINKCOUNT;
parser->file_data->info.hardlinks = (long)hlinks;
}
const char *p = mem + parser->item_offset;
curl_off_t fsize;
mem[parser->item_offset + parser->item_length - 1] = 0;
- if(!Curl_str_numblanks(&p, &fsize)) {
+ if(!curlx_str_numblanks(&p, &fsize)) {
if(p[0] == '\0' && fsize != CURL_OFF_T_MAX) {
parser->file_data->info.flags |= CURLFINFOFLAG_KNOWN_SIZE;
parser->file_data->info.size = fsize;
}
else {
const char *p = mem + parser->item_offset;
- if(Curl_str_numblanks(&p, &finfo->size)) {
+ if(curlx_str_numblanks(&p, &finfo->size)) {
parser->error = CURLE_FTP_BAD_FILE_LIST;
goto fail;
}
#include "vtls/vtls.h"
#include "connect.h" /* Curl_getconnectinfo() */
#include "progress.h"
-#include "strparse.h"
+#include "curlx/strparse.h"
/* The last #include files should be: */
#include "curl_memory.h"
const char *timestr = getenv("CURL_TIME");
if(timestr) {
curl_off_t val;
- Curl_str_number(×tr, &val, TIME_T_MAX);
+ curlx_str_number(×tr, &val, TIME_T_MAX);
switch(info) {
case CURLINFO_LOCAL_PORT:
*param_longp = (long)val;
timestr = getenv("CURL_DEBUG_SIZE");
if(timestr) {
curl_off_t val;
- Curl_str_number(×tr, &val, LONG_MAX);
+ curlx_str_number(×tr, &val, LONG_MAX);
switch(info) {
case CURLINFO_HEADER_SIZE:
case CURLINFO_REQUEST_SIZE:
const char *timestr = getenv("CURL_TIME");
if(timestr) {
curl_off_t val;
- Curl_str_number(×tr, &val, CURL_OFF_T_MAX);
+ curlx_str_number(×tr, &val, CURL_OFF_T_MAX);
switch(info) {
case CURLINFO_TOTAL_TIME_T:
const char *timestr = getenv("CURL_TIME");
if(timestr) {
curl_off_t val;
- Curl_str_number(×tr, &val, CURL_OFF_T_MAX);
+ curlx_str_number(×tr, &val, CURL_OFF_T_MAX);
switch(info) {
case CURLINFO_TOTAL_TIME:
#include "vtls/vtls.h"
#include "url.h"
#include "escape.h"
-#include "warnless.h"
+#include "curlx/warnless.h"
#include "curl_printf.h"
#include "curl_memory.h"
/* The last #include file should be: */
return (h % slots_num);
}
-size_t Curl_str_key_compare(void *k1, size_t key1_len,
+size_t curlx_str_key_compare(void *k1, size_t key1_len,
void *k2, size_t key2_len)
{
if((key1_len == key2_len) && !memcmp(k1, k2, key1_len))
void Curl_hash_clean_with_criterium(struct Curl_hash *h, void *user,
int (*comp)(void *, void *));
size_t Curl_hash_str(void *key, size_t key_length, size_t slots_num);
-size_t Curl_str_key_compare(void *k1, size_t key1_len, void *k2,
+size_t curlx_str_key_compare(void *k1, size_t key1_len, void *k2,
size_t key2_len);
void Curl_hash_start_iterate(struct Curl_hash *hash,
struct Curl_hash_iterator *iter);
#include "strcase.h"
#include "sendf.h"
#include "headers.h"
-#include "strparse.h"
+#include "curlx/strparse.h"
/* The last 3 #include files should be in this order */
#include "curl_printf.h"
#include "curl_hmac.h"
#include "curl_memory.h"
-#include "warnless.h"
+#include "curlx/warnless.h"
/* The last #include file should be: */
#include "memdebug.h"
#include "inet_pton.h"
#include "multiif.h"
#include "doh.h"
-#include "warnless.h"
+#include "curlx/warnless.h"
#include "select.h"
#include "strcase.h"
#include "easy_lock.h"
-#include "strparse.h"
+#include "curlx/strparse.h"
/* The last 3 #include files should be in this order */
#include "curl_printf.h"
the time we spent until now! */
if(prev_alarm) {
/* there was an alarm() set before us, now put it back */
- timediff_t elapsed_secs = Curl_timediff(Curl_now(),
+ timediff_t elapsed_secs = curlx_timediff(curlx_now(),
data->conn->created) / 1000;
/* the alarm period is counted in even number of seconds */
*/
void Curl_dnscache_init(struct Curl_dnscache *dns, size_t size)
{
- Curl_hash_init(&dns->entries, size, Curl_hash_str, Curl_str_key_compare,
+ Curl_hash_init(&dns->entries, size, Curl_hash_str, curlx_str_key_compare,
dnscache_entry_dtor);
}
curl_off_t num = 0;
size_t entry_len;
host++;
- if(!Curl_str_single(&host, '[')) {
- if(Curl_str_until(&host, &source, MAX_IPADR_LEN, ']') ||
- Curl_str_single(&host, ']') ||
- Curl_str_single(&host, ':'))
+ if(!curlx_str_single(&host, '[')) {
+ if(curlx_str_until(&host, &source, MAX_IPADR_LEN, ']') ||
+ curlx_str_single(&host, ']') ||
+ curlx_str_single(&host, ':'))
continue;
}
else {
- if(Curl_str_until(&host, &source, 4096, ':') ||
- Curl_str_single(&host, ':')) {
+ if(curlx_str_until(&host, &source, 4096, ':') ||
+ curlx_str_single(&host, ':')) {
continue;
}
}
- if(!Curl_str_number(&host, &num, 0xffff)) {
+ if(!curlx_str_number(&host, &num, 0xffff)) {
/* Create an entry id, based upon the hostname and port */
- entry_len = create_dnscache_id(Curl_str(&source),
- Curl_strlen(&source), (int)num,
+ entry_len = create_dnscache_id(curlx_str(&source),
+ curlx_strlen(&source), (int)num,
entry_id, sizeof(entry_id));
dnscache_lock(data, dnscache);
/* delete entry, ignore if it did not exist */
host++;
permanent = FALSE;
}
- if(!Curl_str_single(&host, '[')) {
- if(Curl_str_until(&host, &source, MAX_IPADR_LEN, ']') ||
- Curl_str_single(&host, ']'))
+ if(!curlx_str_single(&host, '[')) {
+ if(curlx_str_until(&host, &source, MAX_IPADR_LEN, ']') ||
+ curlx_str_single(&host, ']'))
continue;
}
else {
- if(Curl_str_until(&host, &source, 4096, ':'))
+ if(curlx_str_until(&host, &source, 4096, ':'))
continue;
}
- if(Curl_str_single(&host, ':') ||
- Curl_str_number(&host, &port, 0xffff) ||
- Curl_str_single(&host, ':'))
+ if(curlx_str_single(&host, ':') ||
+ curlx_str_number(&host, &port, 0xffff) ||
+ curlx_str_single(&host, ':'))
goto err;
#if !defined(CURL_DISABLE_VERBOSE_STRINGS)
struct Curl_str target;
struct Curl_addrinfo *ai;
- if(!Curl_str_single(&host, '[')) {
- if(Curl_str_until(&host, &target, MAX_IPADR_LEN, ']') ||
- Curl_str_single(&host, ']'))
+ if(!curlx_str_single(&host, '[')) {
+ if(curlx_str_until(&host, &target, MAX_IPADR_LEN, ']') ||
+ curlx_str_single(&host, ']'))
goto err;
}
else {
- if(Curl_str_until(&host, &target, 4096, ',')) {
- if(Curl_str_single(&host, ','))
+ if(curlx_str_until(&host, &target, 4096, ',')) {
+ if(curlx_str_single(&host, ','))
goto err;
/* survive nothing but just a comma */
continue;
if(memchr(target.str, ':', target.len)) {
infof(data, "Ignoring resolve address '%s', missing IPv6 support.",
address);
- if(Curl_str_single(&host, ','))
+ if(curlx_str_single(&host, ','))
goto err;
continue;
}
#endif
- if(Curl_strlen(&target) >= sizeof(address))
+ if(curlx_strlen(&target) >= sizeof(address))
goto err;
- memcpy(address, Curl_str(&target), Curl_strlen(&target));
- address[Curl_strlen(&target)] = '\0';
+ memcpy(address, curlx_str(&target), curlx_strlen(&target));
+ address[curlx_strlen(&target)] = '\0';
ai = Curl_str2addr(address, (int)port);
if(!ai) {
else {
head = tail = ai;
}
- if(Curl_str_single(&host, ','))
+ if(curlx_str_single(&host, ','))
break;
}
}
/* Create an entry id, based upon the hostname and port */
- entry_len = create_dnscache_id(Curl_str(&source), Curl_strlen(&source),
+ entry_len = create_dnscache_id(curlx_str(&source), curlx_strlen(&source),
(int)port,
entry_id, sizeof(entry_id));
if(dns) {
infof(data, "RESOLVE %.*s:%" CURL_FORMAT_CURL_OFF_T
- " - old addresses discarded", (int)Curl_strlen(&source),
- Curl_str(&source), port);
+ " - old addresses discarded", (int)curlx_strlen(&source),
+ curlx_str(&source), port);
/* delete old entry, there are two reasons for this
1. old entry may have different addresses.
2. even if entry with correct addresses is already in the cache,
}
/* put this new host in the cache */
- dns = dnscache_add_addr(data, dnscache, head, Curl_str(&source),
- Curl_strlen(&source), (int)port, permanent);
+ dns = dnscache_add_addr(data, dnscache, head, curlx_str(&source),
+ curlx_strlen(&source), (int)port, permanent);
if(dns) {
/* release the returned reference; the cache itself will keep the
* entry alive: */
#ifndef CURL_DISABLE_VERBOSE_STRINGS
infof(data, "Added %.*s:%" CURL_FORMAT_CURL_OFF_T ":%s to DNS cache%s",
- (int)Curl_strlen(&source), Curl_str(&source), port, addresses,
+ (int)curlx_strlen(&source), curlx_str(&source), port, addresses,
permanent ? "" : " (non-permanent)");
#endif
/* Wildcard hostname */
- if(Curl_str_casecompare(&source, "*")) {
+ if(curlx_str_casecompare(&source, "*")) {
infof(data, "RESOLVE *:%" CURL_FORMAT_CURL_OFF_T " using wildcard",
port);
data->state.wildcard_resolve = TRUE;
infof(data, "Host %s:%d was resolved.",
(dns->hostname[0] ? dns->hostname : "(none)"), dns->hostport);
- Curl_dyn_init(&out[0], 1024);
+ curlx_dyn_init(&out[0], 1024);
#ifdef CURLRES_IPV6
- Curl_dyn_init(&out[1], 1024);
+ curlx_dyn_init(&out[1], 1024);
#endif
while(a) {
char buf[MAX_IPADR_LEN];
struct dynbuf *d = &out[(a->ai_family != PF_INET)];
Curl_printable_address(a, buf, sizeof(buf));
- if(Curl_dyn_len(d))
- result = Curl_dyn_addn(d, ", ", 2);
+ if(curlx_dyn_len(d))
+ result = curlx_dyn_addn(d, ", ", 2);
if(!result)
- result = Curl_dyn_add(d, buf);
+ result = curlx_dyn_add(d, buf);
if(result) {
infof(data, "too many IP, cannot show");
goto fail;
#ifdef CURLRES_IPV6
infof(data, "IPv6: %s",
- (Curl_dyn_len(&out[1]) ? Curl_dyn_ptr(&out[1]) : "(none)"));
+ (curlx_dyn_len(&out[1]) ? curlx_dyn_ptr(&out[1]) : "(none)"));
#endif
infof(data, "IPv4: %s",
- (Curl_dyn_len(&out[0]) ? Curl_dyn_ptr(&out[0]) : "(none)"));
+ (curlx_dyn_len(&out[0]) ? curlx_dyn_ptr(&out[0]) : "(none)"));
fail:
- Curl_dyn_free(&out[0]);
+ curlx_dyn_free(&out[0]);
#ifdef CURLRES_IPV6
- Curl_dyn_free(&out[1]);
+ curlx_dyn_free(&out[1]);
#endif
}
#endif
#include "curl_setup.h"
#include "hash.h"
#include "curl_addrinfo.h"
-#include "timeval.h" /* for timediff_t */
+#include "curlx/timeval.h" /* for timediff_t */
#include "asyn.h"
#include "httpsrr.h"
#include "rename.h"
#include "share.h"
#include "strdup.h"
-#include "strparse.h"
+#include "curlx/strparse.h"
/* The last 3 #include files should be in this order */
#include "curl_printf.h"
(void)unused;
if(timestr) {
curl_off_t val;
- if(!Curl_str_number(×tr, &val, TIME_T_MAX))
+ if(!curlx_str_number(×tr, &val, TIME_T_MAX))
val += (curl_off_t)deltatime;
return (time_t)val;
}
return CURLE_OK;
do {
- Curl_str_passblanks(&p);
+ curlx_str_passblanks(&p);
if(strncasecompare("max-age", p, 7)) {
bool quoted = FALSE;
int rc;
return CURLE_BAD_FUNCTION_ARGUMENT;
p += 7;
- Curl_str_passblanks(&p);
- if(Curl_str_single(&p, '='))
+ curlx_str_passblanks(&p);
+ if(curlx_str_single(&p, '='))
return CURLE_BAD_FUNCTION_ARGUMENT;
- Curl_str_passblanks(&p);
+ curlx_str_passblanks(&p);
- if(!Curl_str_single(&p, '\"'))
+ if(!curlx_str_single(&p, '\"'))
quoted = TRUE;
- rc = Curl_str_number(&p, &expires, TIME_T_MAX);
+ rc = curlx_str_number(&p, &expires, TIME_T_MAX);
if(rc == STRE_OVERFLOW)
expires = CURL_OFF_T_MAX;
else if(rc)
p++;
}
- Curl_str_passblanks(&p);
+ curlx_str_passblanks(&p);
if(*p == ';')
p++;
} while(*p);
struct Curl_str host;
struct Curl_str date;
- if(Curl_str_word(&line, &host, MAX_HSTS_HOSTLEN) ||
- Curl_str_singlespace(&line) ||
- Curl_str_quotedword(&line, &date, MAX_HSTS_DATELEN) ||
- Curl_str_newline(&line))
+ if(curlx_str_word(&line, &host, MAX_HSTS_HOSTLEN) ||
+ curlx_str_singlespace(&line) ||
+ curlx_str_quotedword(&line, &date, MAX_HSTS_DATELEN) ||
+ curlx_str_newline(&line))
;
else {
CURLcode result = CURLE_OK;
struct stsentry *e;
char dbuf[MAX_HSTS_DATELEN + 1];
time_t expires;
- const char *hp = Curl_str(&host);
+ const char *hp = curlx_str(&host);
/* The date parser works on a null terminated string. The maximum length
- is upheld by Curl_str_quotedword(). */
- memcpy(dbuf, Curl_str(&date), Curl_strlen(&date));
- dbuf[Curl_strlen(&date)] = 0;
+ is upheld by curlx_str_quotedword(). */
+ memcpy(dbuf, curlx_str(&date), curlx_strlen(&date));
+ dbuf[curlx_strlen(&date)] = 0;
expires = strcmp(dbuf, UNLIMITED) ? Curl_getdate_capped(dbuf) :
TIME_T_MAX;
if(hp[0] == '.') {
- Curl_str_nudge(&host, 1);
+ curlx_str_nudge(&host, 1);
subdomain = TRUE;
}
/* only add it if not already present */
- e = Curl_hsts(h, Curl_str(&host), Curl_strlen(&host), subdomain);
+ e = Curl_hsts(h, curlx_str(&host), curlx_strlen(&host), subdomain);
if(!e)
- result = hsts_create(h, Curl_str(&host), Curl_strlen(&host),
+ result = hsts_create(h, curlx_str(&host), curlx_strlen(&host),
subdomain, expires);
- else if(Curl_str_casecompare(&host, e->host)) {
+ else if(curlx_str_casecompare(&host, e->host)) {
/* the same hostname, use the largest expire time */
if(expires > e->expires)
e->expires = expires;
fp = fopen(file, FOPEN_READTEXT);
if(fp) {
struct dynbuf buf;
- Curl_dyn_init(&buf, MAX_HSTS_LINE);
+ curlx_dyn_init(&buf, MAX_HSTS_LINE);
while(Curl_get_line(&buf, fp)) {
- const char *lineptr = Curl_dyn_ptr(&buf);
- Curl_str_passblanks(&lineptr);
+ const char *lineptr = curlx_dyn_ptr(&buf);
+ curlx_str_passblanks(&lineptr);
/*
* Skip empty or commented lines, since we know the line will have a
hsts_add(h, lineptr);
}
- Curl_dyn_free(&buf); /* free the line buffer */
+ curlx_dyn_free(&buf); /* free the line buffer */
fclose(fp);
}
return result;
#include "formdata.h"
#include "mime.h"
#include "progress.h"
-#include "curl_base64.h"
+#include "curlx/base64.h"
#include "cookie.h"
#include "vauth/vauth.h"
#include "vtls/vtls.h"
#include "strcase.h"
#include "content_encoding.h"
#include "http_proxy.h"
-#include "warnless.h"
+#include "curlx/warnless.h"
#include "http2.h"
#include "cfilters.h"
#include "connect.h"
#include "hsts.h"
#include "ws.h"
#include "curl_ctype.h"
-#include "strparse.h"
+#include "curlx/strparse.h"
/* The last 3 #include files should be in this order */
#include "curl_printf.h"
const char **tep);
static CURLcode http_size(struct Curl_easy *data);
static CURLcode http_statusline(struct Curl_easy *data,
- struct connectdata *conn);
+ struct connectdata *conn);
static CURLcode http_target(struct Curl_easy *data, struct connectdata *conn,
struct dynbuf *req);
static CURLcode http_useragent(struct Curl_easy *data);
struct Curl_str out;
/* find the end of the header name */
- if(!Curl_str_cspn(&header, &out, ";:") &&
- (!Curl_str_single(&header, ':') || !Curl_str_single(&header, ';'))) {
- Curl_str_untilnl(&header, &out, MAX_HTTP_RESP_HEADER_SIZE);
- Curl_str_trimblanks(&out);
+ if(!curlx_str_cspn(&header, &out, ";:") &&
+ (!curlx_str_single(&header, ':') || !curlx_str_single(&header, ';'))) {
+ curlx_str_untilnl(&header, &out, MAX_HTTP_RESP_HEADER_SIZE);
+ curlx_str_trimblanks(&out);
- return Curl_memdup0(Curl_str(&out), Curl_strlen(&out));
+ return Curl_memdup0(curlx_str(&out), curlx_strlen(&out));
}
/* bad input */
return NULL;
if(!out)
return CURLE_OUT_OF_MEMORY;
- result = Curl_base64_encode(out, strlen(out), &authorization, &size);
+ result = curlx_base64_encode(out, strlen(out), &authorization, &size);
if(result)
goto fail;
#ifndef CURL_DISABLE_PROXY
(conn->bits.httpproxy && conn->bits.proxy_user_passwd) ||
#endif
- data->state.aptr.user ||
+ data->state.aptr.user ||
#ifdef USE_SPNEGO
- authhost->want & CURLAUTH_NEGOTIATE ||
- authproxy->want & CURLAUTH_NEGOTIATE ||
+ authhost->want & CURLAUTH_NEGOTIATE ||
+ authproxy->want & CURLAUTH_NEGOTIATE ||
#endif
- data->set.str[STRING_BEARER])
+ data->set.str[STRING_BEARER])
/* continue please */;
else {
authhost->done = TRUE;
auth++;
else
break;
- Curl_str_passblanks(&auth);
+ curlx_str_passblanks(&auth);
}
return result;
#else
/* pass the header */
p = &headerline[hlen];
- if(Curl_str_untilnl(&p, &val, MAX_HTTP_RESP_HEADER_SIZE))
+ if(curlx_str_untilnl(&p, &val, MAX_HTTP_RESP_HEADER_SIZE))
return FALSE;
- Curl_str_trimblanks(&val);
+ curlx_str_trimblanks(&val);
/* find the content string in the rest of the line */
- if(Curl_strlen(&val) >= clen) {
+ if(curlx_strlen(&val) >= clen) {
size_t len;
- p = Curl_str(&val);
- for(len = Curl_strlen(&val); len >= Curl_strlen(&val); len--, p++) {
+ p = curlx_str(&val);
+ for(len = curlx_strlen(&val); len >= curlx_strlen(&val); len--, p++) {
if(strncasecompare(p, content, clen))
return TRUE; /* match! */
}
data->state.authhost.multipass = FALSE;
data->state.authproxy.multipass = FALSE;
- Curl_dyn_reset(&data->state.headerb);
+ curlx_dyn_reset(&data->state.headerb);
if(status)
return status;
/* explicitly asked to send header without content is done by a header
that ends with a semicolon, but there must be no colon present in the
name */
- if(!Curl_str_until(&p, &name, MAX_HTTP_RESP_HEADER_SIZE, ';') &&
- !Curl_str_single(&p, ';') &&
- !Curl_str_single(&p, '\0') &&
- !memchr(Curl_str(&name), ':', Curl_strlen(&name)))
+ if(!curlx_str_until(&p, &name, MAX_HTTP_RESP_HEADER_SIZE, ';') &&
+ !curlx_str_single(&p, ';') &&
+ !curlx_str_single(&p, '\0') &&
+ !memchr(curlx_str(&name), ':', curlx_strlen(&name)))
blankheader = TRUE;
else {
p = origp;
- if(!Curl_str_until(&p, &name, MAX_HTTP_RESP_HEADER_SIZE, ':') &&
- !Curl_str_single(&p, ':')) {
+ if(!curlx_str_until(&p, &name, MAX_HTTP_RESP_HEADER_SIZE, ':') &&
+ !curlx_str_single(&p, ':')) {
struct Curl_str val;
- Curl_str_untilnl(&p, &val, MAX_HTTP_RESP_HEADER_SIZE);
- Curl_str_trimblanks(&val);
- if(!Curl_strlen(&val))
+ curlx_str_untilnl(&p, &val, MAX_HTTP_RESP_HEADER_SIZE);
+ curlx_str_trimblanks(&val);
+ if(!curlx_strlen(&val))
/* no content, don't send this */
continue;
}
/* a Host: header was sent already, do not pass on any custom
Host: header as that will produce *two* in the same
request! */
- Curl_str_casecompare(&name, "Host"))
+ curlx_str_casecompare(&name, "Host"))
;
else if(data->state.httpreq == HTTPREQ_POST_FORM &&
/* this header (extended by formdata.c) is sent later */
- Curl_str_casecompare(&name, "Content-Type"))
+ curlx_str_casecompare(&name, "Content-Type"))
;
else if(data->state.httpreq == HTTPREQ_POST_MIME &&
/* this header is sent later */
- Curl_str_casecompare(&name, "Content-Type"))
+ curlx_str_casecompare(&name, "Content-Type"))
;
else if(data->req.authneg &&
/* while doing auth neg, do not allow the custom length since
we will force length zero then */
- Curl_str_casecompare(&name, "Content-Length"))
+ curlx_str_casecompare(&name, "Content-Length"))
;
else if(data->state.aptr.te &&
/* when asking for Transfer-Encoding, do not pass on a custom
Connection: */
- Curl_str_casecompare(&name, "Connection"))
+ curlx_str_casecompare(&name, "Connection"))
;
else if((httpversion >= 20) &&
- Curl_str_casecompare(&name, "Transfer-Encoding"))
+ curlx_str_casecompare(&name, "Transfer-Encoding"))
/* HTTP/2 does not support chunked requests */
;
- else if((Curl_str_casecompare(&name, "Authorization") ||
- Curl_str_casecompare(&name, "Cookie")) &&
+ else if((curlx_str_casecompare(&name, "Authorization") ||
+ curlx_str_casecompare(&name, "Cookie")) &&
/* be careful of sending this potentially sensitive header to
other hosts */
!Curl_auth_allowed_to_host(data))
;
else if(blankheader)
- result = Curl_dyn_addf(req, "%.*s:\r\n", (int)Curl_strlen(&name),
- Curl_str(&name));
+ result = curlx_dyn_addf(req, "%.*s:\r\n", (int)curlx_strlen(&name),
+ curlx_str(&name));
else
- result = Curl_dyn_addf(req, "%s\r\n", origp);
+ result = curlx_dyn_addf(req, "%s\r\n", origp);
if(result)
return result;
tm->tm_min,
tm->tm_sec);
- result = Curl_dyn_add(req, datestr);
+ result = curlx_dyn_add(req, datestr);
return result;
}
#else
curl_url_cleanup(h);
/* target or URL */
- result = Curl_dyn_add(r, data->set.str[STRING_TARGET] ?
+ result = curlx_dyn_add(r, data->set.str[STRING_TARGET] ?
data->set.str[STRING_TARGET] : url);
free(url);
if(result)
}
}
if(!type) {
- result = Curl_dyn_addf(r, ";type=%c",
- data->state.prefer_ascii ? 'a' : 'i');
+ result = curlx_dyn_addf(r, ";type=%c",
+ data->state.prefer_ascii ? 'a' : 'i');
if(result)
return result;
}
(void)conn; /* not used in disabled-proxy builds */
#endif
{
- result = Curl_dyn_add(r, path);
+ result = curlx_dyn_add(r, path);
if(result)
return result;
if(query)
- result = Curl_dyn_addf(r, "?%s", query);
+ result = curlx_dyn_addf(r, "?%s", query);
}
return result;
operations (as there is one packet coming back from the web server) */
curl_off_t client_len = Curl_creader_client_length(data);
if(client_len > EXPECT_100_THRESHOLD || client_len < 0) {
- result = Curl_dyn_addn(r, STRCONST("Expect: 100-continue\r\n"));
+ result = curlx_dyn_addn(r, STRCONST("Expect: 100-continue\r\n"));
if(result)
return result;
*announced_exp100 = TRUE;
!Curl_checkheaders(data, STRCONST("Content-Length")))) {
/* we allow replacing this header if not during auth negotiation,
although it is not very wise to actually set your own */
- result = Curl_dyn_addf(r, "Content-Length: %" FMT_OFF_T "\r\n",
- req_clen);
+ result = curlx_dyn_addf(r, "Content-Length: %" FMT_OFF_T "\r\n",
+ req_clen);
}
if(result)
goto out;
struct curl_slist *hdr;
for(hdr = data->state.mimepost->curlheaders; hdr; hdr = hdr->next) {
- result = Curl_dyn_addf(r, "%s\r\n", hdr->data);
+ result = curlx_dyn_addf(r, "%s\r\n", hdr->data);
if(result)
goto out;
}
#endif
if(httpreq == HTTPREQ_POST) {
if(!Curl_checkheaders(data, STRCONST("Content-Type"))) {
- result = Curl_dyn_addn(r, STRCONST("Content-Type: application/"
- "x-www-form-urlencoded\r\n"));
+ result = curlx_dyn_addn(r, STRCONST("Content-Type: application/"
+ "x-www-form-urlencoded\r\n"));
if(result)
goto out;
}
}
/* end of headers */
- result = Curl_dyn_addn(r, STRCONST("\r\n"));
+ result = curlx_dyn_addn(r, STRCONST("\r\n"));
if(!result) {
Curl_pgrsSetUploadSize(data, req_clen);
if(announced_exp100)
if(co->value) {
size_t add;
if(!count) {
- result = Curl_dyn_addn(r, STRCONST("Cookie: "));
+ result = curlx_dyn_addn(r, STRCONST("Cookie: "));
if(result)
break;
}
linecap = TRUE;
break;
}
- result = Curl_dyn_addf(r, "%s%s=%s", count ? "; " : "",
- co->name, co->value);
+ result = curlx_dyn_addf(r, "%s%s=%s", count ? "; " : "",
+ co->name, co->value);
if(result)
break;
clen += add + (count ? 2 : 0);
}
if(addcookies && !result && !linecap) {
if(!count)
- result = Curl_dyn_addn(r, STRCONST("Cookie: "));
+ result = curlx_dyn_addn(r, STRCONST("Cookie: "));
if(!result) {
- result = Curl_dyn_addf(r, "%s%s", count ? "; " : "", addcookies);
+ result = curlx_dyn_addf(r, "%s%s", count ? "; " : "", addcookies);
count++;
}
}
if(count && !result)
- result = Curl_dyn_addn(r, STRCONST("\r\n"));
+ result = curlx_dyn_addn(r, STRCONST("\r\n"));
if(result)
return result;
goto fail;
/* initialize a dynamic send-buffer */
- Curl_dyn_init(&req, DYN_HTTP_REQUEST);
+ curlx_dyn_init(&req, DYN_HTTP_REQUEST);
/* make sure the header buffer is reset - if there are leftovers from a
previous transfer */
- Curl_dyn_reset(&data->state.headerb);
+ curlx_dyn_reset(&data->state.headerb);
/* add the main request stuff */
/* GET/HEAD/POST/PUT */
- result = Curl_dyn_addf(&req, "%s ", request);
+ result = curlx_dyn_addf(&req, "%s ", request);
if(!result)
result = http_target(data, conn, &req);
if(result) {
- Curl_dyn_free(&req);
+ curlx_dyn_free(&req);
goto fail;
}
altused = aprintf("Alt-Used: %s:%d\r\n",
conn->conn_to_host.name, conn->conn_to_port);
if(!altused) {
- Curl_dyn_free(&req);
+ curlx_dyn_free(&req);
return CURLE_OUT_OF_MEMORY;
}
}
#endif
result =
- Curl_dyn_addf(&req,
- " HTTP/%s\r\n" /* HTTP version */
- "%s" /* host */
- "%s" /* proxyuserpwd */
- "%s" /* userpwd */
- "%s" /* range */
- "%s" /* user agent */
- "%s" /* accept */
- "%s" /* TE: */
- "%s" /* accept-encoding */
- "%s" /* referer */
- "%s" /* Proxy-Connection */
- "%s" /* transfer-encoding */
- "%s",/* Alt-Used */
-
- httpstring,
- (data->state.aptr.host ? data->state.aptr.host : ""),
+ curlx_dyn_addf(&req,
+ " HTTP/%s\r\n" /* HTTP version */
+ "%s" /* host */
+ "%s" /* proxyuserpwd */
+ "%s" /* userpwd */
+ "%s" /* range */
+ "%s" /* user agent */
+ "%s" /* accept */
+ "%s" /* TE: */
+ "%s" /* accept-encoding */
+ "%s" /* referer */
+ "%s" /* Proxy-Connection */
+ "%s" /* transfer-encoding */
+ "%s",/* Alt-Used */
+
+ httpstring,
+ (data->state.aptr.host ? data->state.aptr.host : ""),
#ifndef CURL_DISABLE_PROXY
- data->state.aptr.proxyuserpwd ?
- data->state.aptr.proxyuserpwd : "",
+ data->state.aptr.proxyuserpwd ?
+ data->state.aptr.proxyuserpwd : "",
#else
- "",
+ "",
#endif
- data->state.aptr.userpwd ? data->state.aptr.userpwd : "",
- (data->state.use_range && data->state.aptr.rangeline) ?
- data->state.aptr.rangeline : "",
- (data->set.str[STRING_USERAGENT] &&
- *data->set.str[STRING_USERAGENT] &&
- data->state.aptr.uagent) ?
- data->state.aptr.uagent : "",
- p_accept ? p_accept : "",
- data->state.aptr.te ? data->state.aptr.te : "",
- (data->set.str[STRING_ENCODING] &&
- *data->set.str[STRING_ENCODING] &&
- data->state.aptr.accept_encoding) ?
- data->state.aptr.accept_encoding : "",
- (data->state.referer && data->state.aptr.ref) ?
- data->state.aptr.ref : "" /* Referer: <data> */,
+ data->state.aptr.userpwd ? data->state.aptr.userpwd : "",
+ (data->state.use_range && data->state.aptr.rangeline) ?
+ data->state.aptr.rangeline : "",
+ (data->set.str[STRING_USERAGENT] &&
+ *data->set.str[STRING_USERAGENT] &&
+ data->state.aptr.uagent) ?
+ data->state.aptr.uagent : "",
+ p_accept ? p_accept : "",
+ data->state.aptr.te ? data->state.aptr.te : "",
+ (data->set.str[STRING_ENCODING] &&
+ *data->set.str[STRING_ENCODING] &&
+ data->state.aptr.accept_encoding) ?
+ data->state.aptr.accept_encoding : "",
+ (data->state.referer && data->state.aptr.ref) ?
+ data->state.aptr.ref : "" /* Referer: <data> */,
#ifndef CURL_DISABLE_PROXY
- (conn->bits.httpproxy &&
- !conn->bits.tunnel_proxy &&
- !Curl_checkheaders(data, STRCONST("Proxy-Connection")) &&
- !Curl_checkProxyheaders(data, conn,
- STRCONST("Proxy-Connection"))) ?
- "Proxy-Connection: Keep-Alive\r\n":"",
+ (conn->bits.httpproxy &&
+ !conn->bits.tunnel_proxy &&
+ !Curl_checkheaders(data, STRCONST("Proxy-Connection")) &&
+ !Curl_checkProxyheaders(data, conn,
+ STRCONST("Proxy-Connection"))) ?
+ "Proxy-Connection: Keep-Alive\r\n":"",
#else
- "",
+ "",
#endif
- te,
- altused ? altused : ""
+ te,
+ altused ? altused : ""
);
/* clear userpwd and proxyuserpwd to avoid reusing old credentials
free(altused);
if(result) {
- Curl_dyn_free(&req);
+ curlx_dyn_free(&req);
goto fail;
}
over SSL */
result = Curl_http2_request_upgrade(&req, data);
if(result) {
- Curl_dyn_free(&req);
+ curlx_dyn_free(&req);
return result;
}
}
if(!result)
result = Curl_req_send(data, &req, httpversion);
}
- Curl_dyn_free(&req);
+ curlx_dyn_free(&req);
if(result)
goto fail;
HD_VAL(hd, hdlen, "Content-Length:") : NULL;
if(v) {
curl_off_t contentlength;
- int offt = Curl_str_numblanks(&v, &contentlength);
+ int offt = curlx_str_numblanks(&v, &contentlength);
if(offt == STRE_OK) {
k->size = contentlength;
/* if it truly stopped on a digit */
if(ISDIGIT(*ptr)) {
- if(!Curl_str_number(&ptr, &k->offset, CURL_OFF_T_MAX) &&
+ if(!curlx_str_number(&ptr, &k->offset, CURL_OFF_T_MAX) &&
(data->state.resume_from == k->offset))
/* we asked for a resume and we got it */
k->content_range = TRUE;
/* Retry-After = HTTP-date / delay-seconds */
curl_off_t retry_after = 0; /* zero for unknown or "now" */
time_t date;
- Curl_str_passblanks(&v);
+ curlx_str_passblanks(&v);
/* try it as a date first, because a date can otherwise start with and
get treated as a number */
}
else
/* Try it as a decimal number */
- Curl_str_number(&v, &retry_after, CURL_OFF_T_MAX);
+ curlx_str_number(&v, &retry_after, CURL_OFF_T_MAX);
/* limit to 6 hours max. this is not documented so that it can be changed
in the future if necessary. */
if(retry_after > 21600)
struct dynbuf last_header;
size_t consumed;
- Curl_dyn_init(&last_header, hdlen + 1);
- result = Curl_dyn_addn(&last_header, hd, hdlen);
+ curlx_dyn_init(&last_header, hdlen + 1);
+ result = curlx_dyn_addn(&last_header, hd, hdlen);
if(result)
return result;
/* Caveat: we clear anything in the header brigade, because a
* response might switch HTTP version which may call use recursively.
* Not nice, but that is currently the way of things. */
- Curl_dyn_reset(&data->state.headerb);
- result = http_on_response(data, Curl_dyn_ptr(&last_header),
- Curl_dyn_len(&last_header),
+ curlx_dyn_reset(&data->state.headerb);
+ result = http_on_response(data, curlx_dyn_ptr(&last_header),
+ curlx_dyn_len(&last_header),
buf_remain, blen, &consumed);
*pconsumed += consumed;
- Curl_dyn_free(&last_header);
+ curlx_dyn_free(&last_header);
return result;
}
*/
const char *p = hd;
- Curl_str_passblanks(&p);
+ curlx_str_passblanks(&p);
if(!strncmp(p, "HTTP/", 5)) {
p += 5;
switch(*p) {
curl_off_t status;
/* we set the max string a little excessive to forgive some leading
spaces */
- if(!Curl_str_until(&p, &ver, 32, ' ') &&
- !Curl_str_single(&p, ' ') &&
- !Curl_str_number(&p, &status, 999)) {
- Curl_str_trimblanks(&ver);
- if(Curl_str_cmp(&ver, "RTSP/1.0")) {
+ if(!curlx_str_until(&p, &ver, 32, ' ') &&
+ !curlx_str_single(&p, ' ') &&
+ !curlx_str_number(&p, &status, 999)) {
+ curlx_str_trimblanks(&ver);
+ if(curlx_str_cmp(&ver, "RTSP/1.0")) {
k->httpcode = (int)status;
fine_statusline = TRUE;
k->httpversion = 11; /* RTSP acts like HTTP 1.1 */
if(!end_ptr) {
/* Not a complete header line within buffer, append the data to
the end of the headerbuff. */
- result = Curl_dyn_addn(&data->state.headerb, buf, blen);
+ result = curlx_dyn_addn(&data->state.headerb, buf, blen);
if(result)
return result;
*pconsumed += blen;
/* check if this looks like a protocol header */
statusline st =
checkprotoprefix(data, conn,
- Curl_dyn_ptr(&data->state.headerb),
- Curl_dyn_len(&data->state.headerb));
+ curlx_dyn_ptr(&data->state.headerb),
+ curlx_dyn_len(&data->state.headerb));
if(st == STATUS_BAD) {
/* this is not the beginning of a protocol first header line.
/* decrease the size of the remaining (supposed) header line */
consumed = (end_ptr - buf) + 1;
- result = Curl_dyn_addn(&data->state.headerb, buf, consumed);
+ result = curlx_dyn_addn(&data->state.headerb, buf, consumed);
if(result)
return result;
blen -= consumed;
if(!k->headerline) {
/* the first read header */
statusline st = checkprotoprefix(data, conn,
- Curl_dyn_ptr(&data->state.headerb),
- Curl_dyn_len(&data->state.headerb));
+ curlx_dyn_ptr(&data->state.headerb),
+ curlx_dyn_len(&data->state.headerb));
if(st == STATUS_BAD) {
streamclose(conn, "bad HTTP: No end-of-message indicator");
/* this is not the beginning of a protocol first header line.
}
}
- result = http_rw_hd(data, Curl_dyn_ptr(&data->state.headerb),
- Curl_dyn_len(&data->state.headerb),
+ result = http_rw_hd(data, curlx_dyn_ptr(&data->state.headerb),
+ curlx_dyn_len(&data->state.headerb),
buf, blen, &consumed);
/* We are done with this line. We reset because response
* processing might switch to HTTP/2 and that might call us
* directly again. */
- Curl_dyn_reset(&data->state.headerb);
+ curlx_dyn_reset(&data->state.headerb);
if(consumed) {
blen -= consumed;
buf += consumed;
buffer. */
out:
if(!k->header && !leftover_body) {
- Curl_dyn_free(&data->state.headerb);
+ curlx_dyn_free(&data->state.headerb);
}
return CURLE_OK;
}
result = http_parse_headers(data, buf, blen, pconsumed);
if(!result && !data->req.header) {
- if(!data->req.no_body && Curl_dyn_len(&data->state.headerb)) {
+ if(!data->req.no_body && curlx_dyn_len(&data->state.headerb)) {
/* leftover from parsing something that turned out not
* to be a header, only happens if we allow for
* HTTP/0.9 like responses */
result = Curl_client_write(data, CLIENTWRITE_BODY,
- Curl_dyn_ptr(&data->state.headerb),
- Curl_dyn_len(&data->state.headerb));
+ curlx_dyn_ptr(&data->state.headerb),
+ curlx_dyn_len(&data->state.headerb));
}
- Curl_dyn_free(&data->state.headerb);
+ curlx_dyn_free(&data->state.headerb);
}
return result;
}
CURLcode result = CURLE_URL_MALFORMAT;
user = pass = host = port = NULL;
- Curl_dyn_init(&buf, DYN_HTTP_REQUEST);
+ curlx_dyn_init(&buf, DYN_HTTP_REQUEST);
uc = curl_url_get(url, CURLUPART_HOST, &host, 0);
if(uc && uc != CURLUE_NO_HOST)
}
if(user) {
- result = Curl_dyn_add(&buf, user);
+ result = curlx_dyn_add(&buf, user);
if(result)
goto out;
if(pass) {
- result = Curl_dyn_addf(&buf, ":%s", pass);
+ result = curlx_dyn_addf(&buf, ":%s", pass);
if(result)
goto out;
}
- result = Curl_dyn_add(&buf, "@");
+ result = curlx_dyn_add(&buf, "@");
if(result)
goto out;
}
- result = Curl_dyn_add(&buf, host);
+ result = curlx_dyn_add(&buf, host);
if(result)
goto out;
if(port) {
- result = Curl_dyn_addf(&buf, ":%s", port);
+ result = curlx_dyn_addf(&buf, ":%s", port);
if(result)
goto out;
}
- req->authority = strdup(Curl_dyn_ptr(&buf));
+ req->authority = strdup(curlx_dyn_ptr(&buf));
if(!req->authority)
goto out;
result = CURLE_OK;
free(pass);
free(host);
free(port);
- Curl_dyn_free(&buf);
+ curlx_dyn_free(&buf);
return result;
}
CURLcode result = CURLE_URL_MALFORMAT;
path = query = NULL;
- Curl_dyn_init(&buf, DYN_HTTP_REQUEST);
+ curlx_dyn_init(&buf, DYN_HTTP_REQUEST);
uc = curl_url_get(url, CURLUPART_PATH, &path, CURLU_PATH_AS_IS);
if(uc)
}
else {
if(path) {
- result = Curl_dyn_add(&buf, path);
+ result = curlx_dyn_add(&buf, path);
if(result)
goto out;
}
if(query) {
- result = Curl_dyn_addf(&buf, "?%s", query);
+ result = curlx_dyn_addf(&buf, "?%s", query);
if(result)
goto out;
}
- req->path = strdup(Curl_dyn_ptr(&buf));
+ req->path = strdup(curlx_dyn_ptr(&buf));
if(!req->path)
goto out;
}
out:
free(path);
free(query);
- Curl_dyn_free(&buf);
+ curlx_dyn_free(&buf);
return result;
}
/* skip to first token */
while(ISBLANK(*fvalue) || *fvalue == ',')
fvalue++;
- if(Curl_str_cspn(&fvalue, &name, " \t\r;,"))
+ if(curlx_str_cspn(&fvalue, &name, " \t\r;,"))
return FALSE;
- if(Curl_str_casecompare(&name, token))
+ if(curlx_str_casecompare(&name, token))
return TRUE;
/* skip any remainder after token, e.g. parameters with quoted strings */
struct Curl_str qw;
/* if we do not cleanly find a quoted word here, the header value
* does not follow HTTP syntax and we reject */
- if(Curl_str_quotedword(&fvalue, &qw, CURL_MAX_HTTP_HEADER))
+ if(curlx_str_quotedword(&fvalue, &qw, CURL_MAX_HTTP_HEADER))
return FALSE;
}
else
scheme = Curl_checkheaders(data, STRCONST(HTTP_PSEUDO_SCHEME));
if(scheme) {
scheme += sizeof(HTTP_PSEUDO_SCHEME);
- Curl_str_passblanks(&scheme);
+ curlx_str_passblanks(&scheme);
infof(data, "set pseudo header %s to %s", HTTP_PSEUDO_SCHEME, scheme);
}
else {
DEBUGF(infof(data, "cr_exp100_read, start AWAITING_CONTINUE, "
"timeout %ldms", data->set.expect_100_timeout));
ctx->state = EXP100_AWAITING_CONTINUE;
- ctx->start = Curl_now();
+ ctx->start = curlx_now();
Curl_expire(data, data->set.expect_100_timeout, EXPIRE_100_TIMEOUT);
data->req.keepon &= ~KEEP_SEND;
data->req.keepon |= KEEP_SEND_TIMED;
*eos = FALSE;
return CURLE_READ_ERROR;
case EXP100_AWAITING_CONTINUE:
- ms = Curl_timediff(Curl_now(), ctx->start);
+ ms = curlx_timediff(curlx_now(), ctx->start);
if(ms < data->set.expect_100_timeout) {
DEBUGF(infof(data, "cr_exp100_read, AWAITING_CONTINUE, not expired"));
data->req.keepon &= ~KEEP_SEND;
{
memset(parser, 0, sizeof(*parser));
parser->max_line_len = max_line_len;
- Curl_dyn_init(&parser->scratch, max_line_len);
+ curlx_dyn_init(&parser->scratch, max_line_len);
}
void Curl_h1_req_parse_free(struct h1_req_parser *parser)
{
if(parser) {
Curl_http_req_free(parser->req);
- Curl_dyn_free(&parser->scratch);
+ curlx_dyn_free(&parser->scratch);
parser->req = NULL;
parser->done = FALSE;
}
if(parser->line) {
parser->line = NULL;
parser->line_len = 0;
- Curl_dyn_reset(&parser->scratch);
+ curlx_dyn_reset(&parser->scratch);
}
nread = detect_line(parser, buf, buflen, err);
if(nread >= 0) {
- if(Curl_dyn_len(&parser->scratch)) {
+ if(curlx_dyn_len(&parser->scratch)) {
/* append detected line to scratch to have the complete line */
- *err = Curl_dyn_addn(&parser->scratch, parser->line, parser->line_len);
+ *err = curlx_dyn_addn(&parser->scratch, parser->line, parser->line_len);
if(*err)
return -1;
- parser->line = Curl_dyn_ptr(&parser->scratch);
- parser->line_len = Curl_dyn_len(&parser->scratch);
+ parser->line = curlx_dyn_ptr(&parser->scratch);
+ parser->line_len = curlx_dyn_len(&parser->scratch);
}
*err = trim_line(parser, options);
if(*err)
}
else if(*err == CURLE_AGAIN) {
/* no line end in `buf`, add it to our scratch */
- *err = Curl_dyn_addn(&parser->scratch, (const unsigned char *)buf, buflen);
+ *err = curlx_dyn_addn(&parser->scratch, (const unsigned char *)buf,
+ buflen);
nread = (*err) ? -1 : (ssize_t)buflen;
}
return nread;
goto out;
}
parser->done = TRUE;
- Curl_dyn_reset(&parser->scratch);
+ curlx_dyn_reset(&parser->scratch);
/* last chance adjustments */
}
else {
{
CURLcode result;
- result = Curl_dyn_addf(dbuf, "%s %s%s%s%s HTTP/1.%d\r\n",
- req->method,
- req->scheme ? req->scheme : "",
- req->scheme ? "://" : "",
- req->authority ? req->authority : "",
- req->path ? req->path : "",
- http_minor);
+ result = curlx_dyn_addf(dbuf, "%s %s%s%s%s HTTP/1.%d\r\n",
+ req->method,
+ req->scheme ? req->scheme : "",
+ req->scheme ? "://" : "",
+ req->authority ? req->authority : "",
+ req->path ? req->path : "",
+ http_minor);
if(result)
goto out;
if(result)
goto out;
- result = Curl_dyn_addn(dbuf, STRCONST("\r\n"));
+ result = curlx_dyn_addn(dbuf, STRCONST("\r\n"));
out:
return result;
#include "http.h"
#include "sendf.h"
#include "select.h"
-#include "curl_base64.h"
+#include "curlx/base64.h"
#include "strcase.h"
#include "multiif.h"
#include "url.h"
#include "connect.h"
#include "rand.h"
#include "strdup.h"
-#include "strparse.h"
+#include "curlx/strparse.h"
#include "transfer.h"
-#include "dynbuf.h"
+#include "curlx/dynbuf.h"
#include "headers.h"
/* The last 3 #include files should be in this order */
#include "curl_printf.h"
Curl_bufcp_init(&ctx->stream_bufcp, H2_CHUNK_SIZE, H2_STREAM_POOL_SPARES);
Curl_bufq_initp(&ctx->inbufq, &ctx->stream_bufcp, H2_NW_RECV_CHUNKS, 0);
Curl_bufq_initp(&ctx->outbufq, &ctx->stream_bufcp, H2_NW_SEND_CHUNKS, 0);
- Curl_dyn_init(&ctx->scratch, CURL_MAX_HTTP_HEADER);
+ curlx_dyn_init(&ctx->scratch, CURL_MAX_HTTP_HEADER);
Curl_uint_hash_init(&ctx->streams, 63, h2_stream_hash_free);
ctx->remote_max_sid = 2147483647;
ctx->via_h1_upgrade = via_h1_upgrade;
ctx->stream_win_max = H2_STREAM_WINDOW_SIZE_MAX;
if(p) {
curl_off_t l;
- if(!Curl_str_number(&p, &l, INT_MAX))
+ if(!curlx_str_number(&p, &l, INT_MAX))
ctx->stream_win_max = (int32_t)l;
}
}
Curl_bufq_free(&ctx->inbufq);
Curl_bufq_free(&ctx->outbufq);
Curl_bufcp_free(&ctx->stream_bufcp);
- Curl_dyn_free(&ctx->scratch);
+ curlx_dyn_free(&ctx->scratch);
Curl_uint_hash_destroy(&ctx->streams);
memset(ctx, 0, sizeof(*ctx));
}
}
static CURLcode h2_progress_egress(struct Curl_cfilter *cf,
- struct Curl_easy *data);
+ struct Curl_easy *data);
/**
* All about the H2 internals of a stream
BIT(write_paused); /* stream write is paused */
};
-#define H2_STREAM_CTX(ctx,data) ((struct h2_stream_ctx *)(\
- data? Curl_uint_hash_get(&(ctx)->streams, (data)->mid) : NULL))
+#define H2_STREAM_CTX(ctx,data) \
+ ((struct h2_stream_ctx *)( \
+ data? Curl_uint_hash_get(&(ctx)->streams, (data)->mid) : NULL))
static struct h2_stream_ctx *h2_stream_ctx_create(struct cf_h2_ctx *ctx)
{
struct cf_h2_ctx *ctx = cf->ctx;
nghttp2_option *o;
nghttp2_mem mem = {NULL, Curl_nghttp2_malloc, Curl_nghttp2_free,
- Curl_nghttp2_calloc, Curl_nghttp2_realloc};
+ Curl_nghttp2_calloc, Curl_nghttp2_realloc};
int rc = nghttp2_option_new(&o);
if(rc)
cf_h2_header_error(cf, data_s, stream, result);
return NGHTTP2_ERR_CALLBACK_FAILURE;
}
- Curl_dyn_reset(&ctx->scratch);
- result = Curl_dyn_addn(&ctx->scratch, STRCONST("HTTP/2 "));
+ curlx_dyn_reset(&ctx->scratch);
+ result = curlx_dyn_addn(&ctx->scratch, STRCONST("HTTP/2 "));
if(!result)
- result = Curl_dyn_addn(&ctx->scratch, value, valuelen);
+ result = curlx_dyn_addn(&ctx->scratch, value, valuelen);
if(!result)
- result = Curl_dyn_addn(&ctx->scratch, STRCONST(" \r\n"));
+ result = curlx_dyn_addn(&ctx->scratch, STRCONST(" \r\n"));
if(!result)
- h2_xfer_write_resp_hd(cf, data_s, stream, Curl_dyn_ptr(&ctx->scratch),
- Curl_dyn_len(&ctx->scratch), FALSE);
+ h2_xfer_write_resp_hd(cf, data_s, stream, curlx_dyn_ptr(&ctx->scratch),
+ curlx_dyn_len(&ctx->scratch), FALSE);
if(result) {
cf_h2_header_error(cf, data_s, stream, result);
return NGHTTP2_ERR_CALLBACK_FAILURE;
/* nghttp2 guarantees that namelen > 0, and :status was already
received, and this is not pseudo-header field . */
/* convert to an HTTP1-style header */
- Curl_dyn_reset(&ctx->scratch);
- result = Curl_dyn_addn(&ctx->scratch, (const char *)name, namelen);
+ curlx_dyn_reset(&ctx->scratch);
+ result = curlx_dyn_addn(&ctx->scratch, (const char *)name, namelen);
if(!result)
- result = Curl_dyn_addn(&ctx->scratch, STRCONST(": "));
+ result = curlx_dyn_addn(&ctx->scratch, STRCONST(": "));
if(!result)
- result = Curl_dyn_addn(&ctx->scratch, (const char *)value, valuelen);
+ result = curlx_dyn_addn(&ctx->scratch, (const char *)value, valuelen);
if(!result)
- result = Curl_dyn_addn(&ctx->scratch, STRCONST("\r\n"));
+ result = curlx_dyn_addn(&ctx->scratch, STRCONST("\r\n"));
if(!result)
- h2_xfer_write_resp_hd(cf, data_s, stream, Curl_dyn_ptr(&ctx->scratch),
- Curl_dyn_len(&ctx->scratch), FALSE);
+ h2_xfer_write_resp_hd(cf, data_s, stream, curlx_dyn_ptr(&ctx->scratch),
+ curlx_dyn_len(&ctx->scratch), FALSE);
if(result) {
cf_h2_header_error(cf, data_s, stream, result);
return NGHTTP2_ERR_CALLBACK_FAILURE;
binlen = populate_binsettings(binsettings, data);
if(binlen <= 0) {
failf(data, "nghttp2 unexpectedly failed on pack_settings_payload");
- Curl_dyn_free(req);
+ curlx_dyn_free(req);
return CURLE_FAILED_INIT;
}
- result = Curl_base64url_encode((const char *)binsettings, (size_t)binlen,
- &base64, &blen);
+ result = curlx_base64url_encode((const char *)binsettings, (size_t)binlen,
+ &base64, &blen);
if(result) {
- Curl_dyn_free(req);
+ curlx_dyn_free(req);
return result;
}
- result = Curl_dyn_addf(req,
- "Connection: Upgrade, HTTP2-Settings\r\n"
- "Upgrade: %s\r\n"
- "HTTP2-Settings: %s\r\n",
- NGHTTP2_CLEARTEXT_PROTO_VERSION_ID, base64);
+ result = curlx_dyn_addf(req,
+ "Connection: Upgrade, HTTP2-Settings\r\n"
+ "Upgrade: %s\r\n"
+ "HTTP2-Settings: %s\r\n",
+ NGHTTP2_CLEARTEXT_PROTO_VERSION_ID, base64);
free(base64);
k->upgr101 = UPGR101_H2;
size_t i;
*err = CURLE_OK;
- Curl_dyn_init(&dbuf, DYN_TRAILERS);
+ curlx_dyn_init(&dbuf, DYN_TRAILERS);
for(i = 0; i < Curl_dynhds_count(&stream->resp_trailers); ++i) {
e = Curl_dynhds_getn(&stream->resp_trailers, i);
if(!e)
break;
- Curl_dyn_reset(&dbuf);
- *err = Curl_dyn_addf(&dbuf, "%.*s: %.*s\x0d\x0a",
- (int)e->namelen, e->name,
- (int)e->valuelen, e->value);
+ curlx_dyn_reset(&dbuf);
+ *err = curlx_dyn_addf(&dbuf, "%.*s: %.*s\x0d\x0a",
+ (int)e->namelen, e->name,
+ (int)e->valuelen, e->value);
if(*err)
break;
- Curl_debug(data, CURLINFO_HEADER_IN, Curl_dyn_ptr(&dbuf),
- Curl_dyn_len(&dbuf));
+ Curl_debug(data, CURLINFO_HEADER_IN, curlx_dyn_ptr(&dbuf),
+ curlx_dyn_len(&dbuf));
*err = Curl_client_write(data, CLIENTWRITE_HEADER|CLIENTWRITE_TRAILER,
- Curl_dyn_ptr(&dbuf), Curl_dyn_len(&dbuf));
+ curlx_dyn_ptr(&dbuf), curlx_dyn_len(&dbuf));
if(*err)
break;
}
- Curl_dyn_free(&dbuf);
+ curlx_dyn_free(&dbuf);
if(*err)
goto out;
}
#include "parsedate.h"
#include "sendf.h"
#include "escape.h"
-#include "strparse.h"
+#include "curlx/strparse.h"
#include <time.h>
store = (char *)CURL_UNCONST(value);
/* skip leading whitespace */
- Curl_str_passblanks(&value);
+ curlx_str_passblanks(&value);
while(*value) {
int space = 0;
char *colon_next;
char *val_next;
- Curl_dyn_init(&buf, CURL_MAX_HTTP_HEADER);
+ curlx_dyn_init(&buf, CURL_MAX_HTTP_HEADER);
- result = Curl_dyn_add(&buf, curr->data);
+ result = curlx_dyn_add(&buf, curr->data);
if(result)
return result;
DEBUGASSERT(colon_next);
val_next = colon_next + 1;
- result = Curl_dyn_addn(&buf, ",", 1);
+ result = curlx_dyn_addn(&buf, ",", 1);
if(result)
return result;
- result = Curl_dyn_add(&buf, val_next);
+ result = curlx_dyn_add(&buf, val_next);
if(result)
return result;
free(curr->data);
- curr->data = Curl_dyn_ptr(&buf);
+ curr->data = curlx_dyn_ptr(&buf);
curr->next = next->next;
free(next->data);
goto fail;
}
++value;
- Curl_str_passblanks(&value);
+ curlx_str_passblanks(&value);
endp = value;
while(*endp && ISALNUM(*endp))
++endp;
for(l = head; l; l = l->next) {
char *tmp;
- if(Curl_dyn_add(canonical_headers, l->data))
+ if(curlx_dyn_add(canonical_headers, l->data))
goto fail;
- if(Curl_dyn_add(canonical_headers, "\n"))
+ if(curlx_dyn_add(canonical_headers, "\n"))
goto fail;
tmp = strchr(l->data, ':');
*tmp = 0;
if(l != head) {
- if(Curl_dyn_add(signed_headers, ";"))
+ if(curlx_dyn_add(signed_headers, ";"))
goto fail;
}
- if(Curl_dyn_add(signed_headers, l->data))
+ if(curlx_dyn_add(signed_headers, l->data))
goto fail;
}
return NULL;
++value;
- Curl_str_passblanks(&value);
+ curlx_str_passblanks(&value);
len = strlen(value);
while(len > 0 && ISBLANK(value[len-1]))
for(; len && !result; q++, len--) {
if(ISALNUM(*q))
- result = Curl_dyn_addn(dq, q, 1);
+ result = curlx_dyn_addn(dq, q, 1);
else {
switch(*q) {
case '-':
case '_':
case '~':
/* allowed as-is */
- result = Curl_dyn_addn(dq, q, 1);
+ result = curlx_dyn_addn(dq, q, 1);
break;
case '%':
/* uppercase the following if hexadecimal */
char tmp[3]="%";
tmp[1] = Curl_raw_toupper(q[1]);
tmp[2] = Curl_raw_toupper(q[2]);
- result = Curl_dyn_addn(dq, tmp, 3);
+ result = curlx_dyn_addn(dq, tmp, 3);
q += 2;
len -= 2;
}
else
/* '%' without a following two-digit hex, encode it */
- result = Curl_dyn_addn(dq, "%25", 3);
+ result = curlx_dyn_addn(dq, "%25", 3);
break;
default: {
unsigned char out[3]={'%'};
/* if found_equals is NULL assuming, been in path */
if(*q == '/') {
/* allowed as if */
- result = Curl_dyn_addn(dq, q, 1);
+ result = curlx_dyn_addn(dq, q, 1);
break;
}
}
else {
/* allowed as-is */
if(*q == '=') {
- result = Curl_dyn_addn(dq, q, 1);
+ result = curlx_dyn_addn(dq, q, 1);
*found_equals = TRUE;
break;
}
}
/* URL encode */
Curl_hexbyte(&out[1], *q, FALSE);
- result = Curl_dyn_addn(dq, out, 3);
+ result = curlx_dyn_addn(dq, out, 3);
break;
}
}
result = canon_string(q, ap->len, dq, &found_equals);
if(!result && !found_equals) {
/* queries without value still need an equals */
- result = Curl_dyn_addn(dq, "=", 1);
+ result = curlx_dyn_addn(dq, "=", 1);
}
if(!result && i < entry - 1) {
/* insert ampersands between query pairs */
- result = Curl_dyn_addn(dq, "&", 1);
+ result = curlx_dyn_addn(dq, "&", 1);
}
}
return result;
}
/* we init those buffers here, so goto fail will free initialized dynbuf */
- Curl_dyn_init(&canonical_headers, CURL_MAX_HTTP_HEADER);
- Curl_dyn_init(&canonical_query, CURL_MAX_HTTP_HEADER);
- Curl_dyn_init(&signed_headers, CURL_MAX_HTTP_HEADER);
- Curl_dyn_init(&canonical_path, CURL_MAX_HTTP_HEADER);
+ curlx_dyn_init(&canonical_headers, CURL_MAX_HTTP_HEADER);
+ curlx_dyn_init(&canonical_query, CURL_MAX_HTTP_HEADER);
+ curlx_dyn_init(&signed_headers, CURL_MAX_HTTP_HEADER);
+ curlx_dyn_init(&canonical_path, CURL_MAX_HTTP_HEADER);
/*
* Parameters parsing
No string can be longer than N bytes of non-whitespace
*/
- if(Curl_str_until(&line, &provider0, MAX_SIGV4_LEN, ':')) {
+ if(curlx_str_until(&line, &provider0, MAX_SIGV4_LEN, ':')) {
failf(data, "first aws-sigv4 provider cannot be empty");
result = CURLE_BAD_FUNCTION_ARGUMENT;
goto fail;
}
- if(Curl_str_single(&line, ':') ||
- Curl_str_until(&line, &provider1, MAX_SIGV4_LEN, ':')) {
+ if(curlx_str_single(&line, ':') ||
+ curlx_str_until(&line, &provider1, MAX_SIGV4_LEN, ':')) {
provider1 = provider0;
}
- else if(Curl_str_single(&line, ':') ||
- Curl_str_until(&line, ®ion, MAX_SIGV4_LEN, ':') ||
- Curl_str_single(&line, ':') ||
- Curl_str_until(&line, &service, MAX_SIGV4_LEN, ':')) {
+ else if(curlx_str_single(&line, ':') ||
+ curlx_str_until(&line, ®ion, MAX_SIGV4_LEN, ':') ||
+ curlx_str_single(&line, ':') ||
+ curlx_str_until(&line, &service, MAX_SIGV4_LEN, ':')) {
/* nothing to do */
}
- if(!Curl_strlen(&service)) {
+ if(!curlx_strlen(&service)) {
const char *p = hostname;
- if(Curl_str_until(&p, &service, MAX_SIGV4_LEN, '.') ||
- Curl_str_single(&p, '.')) {
+ if(curlx_str_until(&p, &service, MAX_SIGV4_LEN, '.') ||
+ curlx_str_single(&p, '.')) {
failf(data, "aws-sigv4: service missing in parameters and hostname");
result = CURLE_URL_MALFORMAT;
goto fail;
}
infof(data, "aws_sigv4: picked service %.*s from host",
- (int)Curl_strlen(&service), Curl_str(&service));
+ (int)curlx_strlen(&service), curlx_str(&service));
- if(!Curl_strlen(®ion)) {
- if(Curl_str_until(&p, ®ion, MAX_SIGV4_LEN, '.') ||
- Curl_str_single(&p, '.')) {
+ if(!curlx_strlen(®ion)) {
+ if(curlx_str_until(&p, ®ion, MAX_SIGV4_LEN, '.') ||
+ curlx_str_single(&p, '.')) {
failf(data, "aws-sigv4: region missing in parameters and hostname");
result = CURLE_URL_MALFORMAT;
goto fail;
}
infof(data, "aws_sigv4: picked region %.*s from host",
- (int)Curl_strlen(®ion), Curl_str(®ion));
+ (int)curlx_strlen(®ion), curlx_str(®ion));
}
}
Curl_http_method(data, conn, &method, &httpreq);
payload_hash =
- parse_content_sha_hdr(data, Curl_str(&provider1), Curl_strlen(&provider1),
- &payload_hash_len);
+ parse_content_sha_hdr(data, curlx_str(&provider1),
+ curlx_strlen(&provider1), &payload_hash_len);
if(!payload_hash) {
/* AWS S3 requires a x-amz-content-sha256 header, and supports special
* values like UNSIGNED-PAYLOAD */
- bool sign_as_s3 = Curl_str_casecompare(&provider0, "aws") &&
- Curl_str_casecompare(&service, "s3");
+ bool sign_as_s3 = curlx_str_casecompare(&provider0, "aws") &&
+ curlx_str_casecompare(&service, "s3");
if(sign_as_s3)
- result = calc_s3_payload_hash(data, httpreq, Curl_str(&provider1),
- Curl_strlen(&provider1), sha_hash, sha_hex,
- content_sha256_hdr);
+ result = calc_s3_payload_hash(data, httpreq, curlx_str(&provider1),
+ curlx_strlen(&provider1), sha_hash,
+ sha_hex, content_sha256_hdr);
else
result = calc_payload_hash(data, sha_hash, sha_hex);
if(result)
}
result = make_headers(data, hostname, timestamp,
- Curl_str(&provider1), Curl_strlen(&provider1),
+ curlx_str(&provider1), curlx_strlen(&provider1),
&date_header, content_sha256_hdr,
&canonical_headers, &signed_headers);
if(result)
"%s\n" /* SignedHeaders */
"%.*s", /* HashedRequestPayload in hex */
method,
- Curl_dyn_ptr(&canonical_path),
- Curl_dyn_ptr(&canonical_query) ?
- Curl_dyn_ptr(&canonical_query) : "",
- Curl_dyn_ptr(&canonical_headers),
- Curl_dyn_ptr(&signed_headers),
+ curlx_dyn_ptr(&canonical_path),
+ curlx_dyn_ptr(&canonical_query) ?
+ curlx_dyn_ptr(&canonical_query) : "",
+ curlx_dyn_ptr(&canonical_headers),
+ curlx_dyn_ptr(&signed_headers),
(int)payload_hash_len, payload_hash);
if(!canonical_request)
goto fail;
canonical_request);
request_type = aprintf("%.*s4_request",
- (int)Curl_strlen(&provider0), Curl_str(&provider0));
+ (int)curlx_strlen(&provider0), curlx_str(&provider0));
if(!request_type)
goto fail;
/* provider0 is lowercased *after* aprintf() so that the buffer can be
written to */
- Curl_strntolower(request_type, request_type, Curl_strlen(&provider0));
+ Curl_strntolower(request_type, request_type, curlx_strlen(&provider0));
credential_scope = aprintf("%s/%.*s/%.*s/%s", date,
- (int)Curl_strlen(®ion), Curl_str(®ion),
- (int)Curl_strlen(&service), Curl_str(&service),
+ (int)curlx_strlen(®ion), curlx_str(®ion),
+ (int)curlx_strlen(&service), curlx_str(&service),
request_type);
if(!credential_scope)
goto fail;
"%s\n" /* RequestDateTime */
"%s\n" /* CredentialScope */
"%s", /* HashedCanonicalRequest in hex */
- (int)Curl_strlen(&provider0), Curl_str(&provider0),
+ (int)curlx_strlen(&provider0), curlx_str(&provider0),
timestamp,
credential_scope,
sha_hex);
goto fail;
/* make provider0 part done uppercase */
- Curl_strntoupper(str_to_sign, Curl_str(&provider0), Curl_strlen(&provider0));
+ Curl_strntoupper(str_to_sign, curlx_str(&provider0),
+ curlx_strlen(&provider0));
infof(data, "aws_sigv4: String to sign (enclosed in []) - [%s]",
str_to_sign);
- secret = aprintf("%.*s4%s", (int)Curl_strlen(&provider0),
- Curl_str(&provider0), data->state.aptr.passwd ?
+ secret = aprintf("%.*s4%s", (int)curlx_strlen(&provider0),
+ curlx_str(&provider0), data->state.aptr.passwd ?
data->state.aptr.passwd : "");
if(!secret)
goto fail;
/* make provider0 part done uppercase */
- Curl_strntoupper(secret, Curl_str(&provider0), Curl_strlen(&provider0));
+ Curl_strntoupper(secret, curlx_str(&provider0), curlx_strlen(&provider0));
HMAC_SHA256(secret, strlen(secret), date, strlen(date), sign0);
HMAC_SHA256(sign0, sizeof(sign0),
- Curl_str(®ion), Curl_strlen(®ion), sign1);
+ curlx_str(®ion), curlx_strlen(®ion), sign1);
HMAC_SHA256(sign1, sizeof(sign1),
- Curl_str(&service), Curl_strlen(&service), sign0);
+ curlx_str(&service), curlx_strlen(&service), sign0);
HMAC_SHA256(sign0, sizeof(sign0), request_type, strlen(request_type), sign1);
HMAC_SHA256(sign1, sizeof(sign1), str_to_sign, strlen(str_to_sign), sign0);
*/
"%s"
"%s", /* optional sha256 header includes \r\n */
- (int)Curl_strlen(&provider0), Curl_str(&provider0),
+ (int)curlx_strlen(&provider0), curlx_str(&provider0),
user,
credential_scope,
- Curl_dyn_ptr(&signed_headers),
+ curlx_dyn_ptr(&signed_headers),
sha_hex,
date_header ? date_header : "",
content_sha256_hdr);
}
/* provider 0 uppercase */
Curl_strntoupper(&auth_headers[sizeof("Authorization: ") - 1],
- Curl_str(&provider0), Curl_strlen(&provider0));
+ curlx_str(&provider0), curlx_strlen(&provider0));
free(data->state.aptr.userpwd);
data->state.aptr.userpwd = auth_headers;
result = CURLE_OK;
fail:
- Curl_dyn_free(&canonical_query);
- Curl_dyn_free(&canonical_path);
- Curl_dyn_free(&canonical_headers);
- Curl_dyn_free(&signed_headers);
+ curlx_dyn_free(&canonical_query);
+ curlx_dyn_free(&canonical_path);
+ curlx_dyn_free(&canonical_headers);
+ curlx_dyn_free(&signed_headers);
free(canonical_request);
free(request_type);
free(credential_scope);
#include "curl_printf.h"
#include "curl_trc.h"
#include "sendf.h" /* for the client write stuff */
-#include "dynbuf.h"
+#include "curlx/dynbuf.h"
#include "content_encoding.h"
#include "http.h"
#include "multiif.h"
-#include "strparse.h"
-#include "warnless.h"
+#include "curlx/strparse.h"
+#include "curlx/warnless.h"
/* The last #include files should be: */
#include "curl_memory.h"
ch->hexindex = 0; /* start at 0 */
ch->state = CHUNK_HEX; /* we get hex first! */
ch->last_code = CHUNKE_OK;
- Curl_dyn_init(&ch->trailer, DYN_H1_TRAILER);
+ curlx_dyn_init(&ch->trailer, DYN_H1_TRAILER);
ch->ignore_body = ignore_body;
}
ch->hexindex = 0; /* start at 0 */
ch->state = CHUNK_HEX; /* we get hex first! */
ch->last_code = CHUNKE_OK;
- Curl_dyn_reset(&ch->trailer);
+ curlx_dyn_reset(&ch->trailer);
ch->ignore_body = ignore_body;
}
void Curl_httpchunk_free(struct Curl_easy *data, struct Curl_chunker *ch)
{
(void)data;
- Curl_dyn_free(&ch->trailer);
+ curlx_dyn_free(&ch->trailer);
}
bool Curl_httpchunk_is_done(struct Curl_easy *data, struct Curl_chunker *ch)
/* blen and buf are unmodified */
ch->hexbuffer[ch->hexindex] = 0;
p = &ch->hexbuffer[0];
- if(Curl_str_hex(&p, &ch->datasize, CURL_OFF_T_MAX)) {
+ if(curlx_str_hex(&p, &ch->datasize, CURL_OFF_T_MAX)) {
failf(data, "invalid chunk size: '%s'", ch->hexbuffer);
ch->state = CHUNK_FAILED;
ch->last_code = CHUNKE_ILLEGAL_HEX;
case CHUNK_TRAILER:
if((*buf == 0x0d) || (*buf == 0x0a)) {
- char *tr = Curl_dyn_ptr(&ch->trailer);
+ char *tr = curlx_dyn_ptr(&ch->trailer);
/* this is the end of a trailer, but if the trailer was zero bytes
there was no trailer and we move on */
if(tr) {
size_t trlen;
- result = Curl_dyn_addn(&ch->trailer, STRCONST("\x0d\x0a"));
+ result = curlx_dyn_addn(&ch->trailer, STRCONST("\x0d\x0a"));
if(result) {
ch->state = CHUNK_FAILED;
ch->last_code = CHUNKE_OUT_OF_MEMORY;
return result;
}
- tr = Curl_dyn_ptr(&ch->trailer);
- trlen = Curl_dyn_len(&ch->trailer);
+ tr = curlx_dyn_ptr(&ch->trailer);
+ trlen = curlx_dyn_len(&ch->trailer);
if(!data->set.http_te_skip) {
if(cw_next)
result = Curl_cwriter_write(data, cw_next,
return result;
}
}
- Curl_dyn_reset(&ch->trailer);
+ curlx_dyn_reset(&ch->trailer);
ch->state = CHUNK_TRAILER_CR;
if(*buf == 0x0a)
/* already on the LF */
}
}
else {
- result = Curl_dyn_addn(&ch->trailer, buf, 1);
+ result = curlx_dyn_addn(&ch->trailer, buf, 1);
if(result) {
ch->state = CHUNK_FAILED;
ch->last_code = CHUNKE_OUT_OF_MEMORY;
#ifndef CURL_DISABLE_HTTP
-#include "dynbuf.h"
+#include "curlx/dynbuf.h"
struct connectdata;
#include "strcase.h"
#include "vauth/vauth.h"
#include "http_digest.h"
-#include "strparse.h"
+#include "curlx/strparse.h"
/* The last 3 #include files should be in this order */
#include "curl_printf.h"
return CURLE_BAD_CONTENT_ENCODING;
header += strlen("Digest");
- Curl_str_passblanks(&header);
+ curlx_str_passblanks(&header);
return Curl_auth_decode_digest_http_message(header, digest);
}
#include "http_negotiate.h"
#include "vauth/vauth.h"
#include "vtls/vtls.h"
-#include "strparse.h"
+#include "curlx/strparse.h"
/* The last 3 #include files should be in this order */
#include "curl_printf.h"
/* Obtain the input token, if any */
header += strlen("Negotiate");
- Curl_str_passblanks(&header);
+ curlx_str_passblanks(&header);
len = strlen(header);
neg_ctx->havenegdata = len != 0;
/* Check if the connection is using SSL and get the channel binding data */
#ifdef HAVE_GSSAPI
#ifdef USE_SSL
- Curl_dyn_init(&neg_ctx->channel_binding_data, SSL_CB_MAX_SIZE + 1);
+ curlx_dyn_init(&neg_ctx->channel_binding_data, SSL_CB_MAX_SIZE + 1);
if(Curl_conn_is_ssl(conn, FIRSTSOCKET)) {
result = Curl_ssl_get_channel_binding(
data, FIRSTSOCKET, &neg_ctx->channel_binding_data);
}
}
#else
- Curl_dyn_init(&neg_ctx->channel_binding_data, 1);
+ curlx_dyn_init(&neg_ctx->channel_binding_data, 1);
#endif /* USE_SSL */
#endif /* HAVE_GSSAPI */
host, header, neg_ctx);
#ifdef HAVE_GSSAPI
- Curl_dyn_free(&neg_ctx->channel_binding_data);
+ curlx_dyn_free(&neg_ctx->channel_binding_data);
#endif
if(result)
#include "strcase.h"
#include "http_ntlm.h"
#include "curl_ntlm_core.h"
-#include "curl_base64.h"
+#include "curlx/base64.h"
#include "vauth/vauth.h"
#include "url.h"
-#include "strparse.h"
+#include "curlx/strparse.h"
/* SSL backend-specific #if branches in this file must be kept in the order
documented in curl_ntlm_core. */
if(checkprefix("NTLM", header)) {
header += strlen("NTLM");
- Curl_str_passblanks(&header);
+ curlx_str_passblanks(&header);
if(*header) {
unsigned char *hdr;
size_t hdrlen;
- result = Curl_base64_decode(header, &hdr, &hdrlen);
+ result = curlx_base64_decode(header, &hdr, &hdrlen);
if(!result) {
struct bufref hdrbuf;
ntlm, &ntlmmsg);
if(!result) {
DEBUGASSERT(Curl_bufref_len(&ntlmmsg) != 0);
- result = Curl_base64_encode((const char *) Curl_bufref_ptr(&ntlmmsg),
+ result = curlx_base64_encode((const char *) Curl_bufref_ptr(&ntlmmsg),
Curl_bufref_len(&ntlmmsg), &base64, &len);
if(!result) {
free(*allocuserpwd);
result = Curl_auth_create_ntlm_type3_message(data, userp, passwdp,
ntlm, &ntlmmsg);
if(!result && Curl_bufref_len(&ntlmmsg)) {
- result = Curl_base64_encode((const char *) Curl_bufref_ptr(&ntlmmsg),
- Curl_bufref_len(&ntlmmsg), &base64, &len);
+ result = curlx_base64_encode((const char *) Curl_bufref_ptr(&ntlmmsg),
+ Curl_bufref_len(&ntlmmsg), &base64, &len);
if(!result) {
free(*allocuserpwd);
*allocuserpwd = aprintf("%sAuthorization: NTLM %s\r\n",
#include "cf-h1-proxy.h"
#include "cf-h2-proxy.h"
#include "connect.h"
-#include "curlx.h"
+#include "strcase.h"
#include "vtls/vtls.h"
#include "transfer.h"
#include "multiif.h"
#include "vauth/vauth.h"
-#include "strparse.h"
+#include "curlx/strparse.h"
/* The last 3 #include files should be in this order */
#include "curl_printf.h"
name = headers->data;
namelen = ptr - headers->data;
ptr++; /* pass the colon */
- Curl_str_passblanks(&ptr);
+ curlx_str_passblanks(&ptr);
if(*ptr) {
value = ptr;
valuelen = strlen(value);
name = headers->data;
namelen = ptr - headers->data;
ptr++; /* pass the semicolon */
- Curl_str_passblanks(&ptr);
+ curlx_str_passblanks(&ptr);
if(!*ptr) {
/* quirk #2, send an empty header */
value = "";
#include "idn.h"
#include "sendf.h"
#include "curl_multibyte.h"
-#include "warnless.h"
+#include "curlx/warnless.h"
#ifdef USE_LIBIDN2
#include <idn2.h>
***************************************************************************/
#include "curl_setup.h"
-#include "dynbuf.h"
+#include "curlx/dynbuf.h"
#ifndef CURL_DISABLE_IMAP
#include "socks.h"
#include "imap.h"
#include "mime.h"
-#include "strparse.h"
+#include "curlx/strparse.h"
#include "strcase.h"
#include "vtls/vtls.h"
#include "cfilters.h"
#include "url.h"
#include "bufref.h"
#include "curl_sasl.h"
-#include "warnless.h"
+#include "curlx/warnless.h"
#include "curl_ctype.h"
/* The last 3 #include files should be in this order */
if(!imapc)
return CURLE_FAILED_INIT;
- message = Curl_dyn_ptr(&imapc->pp.recvbuf);
+ message = curlx_dyn_ptr(&imapc->pp.recvbuf);
len = imapc->pp.nfinal;
if(len > 2) {
/* Find the start of the message */
return CURLE_OUT_OF_MEMORY;
/* Generate flags string and send the APPEND command */
- Curl_dyn_init(&flags, 100);
+ curlx_dyn_init(&flags, 100);
if(data->set.upload_flags) {
int i;
struct ulbits ulflag[] = {
};
result = CURLE_OUT_OF_MEMORY;
- if(Curl_dyn_add(&flags, " (")) {
+ if(curlx_dyn_add(&flags, " (")) {
goto cleanup;
}
for(i = 0; ulflag[i].bit; i++) {
if(data->set.upload_flags & ulflag[i].bit) {
- if((Curl_dyn_len(&flags) > 2 && Curl_dyn_add(&flags, " ")) ||
- Curl_dyn_add(&flags, "\\") || Curl_dyn_add(&flags, ulflag[i].flag))
- goto cleanup;
+ if((curlx_dyn_len(&flags) > 2 && curlx_dyn_add(&flags, " ")) ||
+ curlx_dyn_add(&flags, "\\") ||
+ curlx_dyn_add(&flags, ulflag[i].flag))
+ goto cleanup;
}
}
- if(Curl_dyn_add(&flags, ")"))
+ if(curlx_dyn_add(&flags, ")"))
goto cleanup;
}
- else if(Curl_dyn_add(&flags, ""))
+ else if(curlx_dyn_add(&flags, ""))
goto cleanup;
result = imap_sendf(data, imapc, "APPEND %s%s {%" FMT_OFF_T "}",
- mailbox, Curl_dyn_ptr(&flags), data->state.infilesize);
+ mailbox, curlx_dyn_ptr(&flags), data->state.infilesize);
cleanup:
- Curl_dyn_free(&flags);
+ curlx_dyn_free(&flags);
free(mailbox);
if(!result)
{
CURLcode result = CURLE_OK;
struct connectdata *conn = data->conn;
- const char *line = Curl_dyn_ptr(&imapc->pp.recvbuf);
+ const char *line = curlx_dyn_ptr(&imapc->pp.recvbuf);
(void)instate; /* no use for this yet */
imapstate instate)
{
CURLcode result = CURLE_OK;
- char *line = Curl_dyn_ptr(&imapc->pp.recvbuf);
+ char *line = curlx_dyn_ptr(&imapc->pp.recvbuf);
size_t len = imapc->pp.nfinal;
(void)instate; /* No use for this yet */
imapstate instate)
{
CURLcode result = CURLE_OK;
- const char *line = Curl_dyn_ptr(&imapc->pp.recvbuf);
+ const char *line = curlx_dyn_ptr(&imapc->pp.recvbuf);
(void)instate; /* no use for this yet */
len++;
if(len && (p[len] == ']')) {
struct dynbuf uid;
- Curl_dyn_init(&uid, 20);
- if(Curl_dyn_addn(&uid, p, len))
+ curlx_dyn_init(&uid, 20);
+ if(curlx_dyn_addn(&uid, p, len))
return CURLE_OUT_OF_MEMORY;
free(imapc->mailbox_uidvalidity);
- imapc->mailbox_uidvalidity = Curl_dyn_ptr(&uid);
+ imapc->mailbox_uidvalidity = curlx_dyn_ptr(&uid);
}
}
}
{
CURLcode result = CURLE_OK;
struct pingpong *pp = &imapc->pp;
- const char *ptr = Curl_dyn_ptr(&imapc->pp.recvbuf);
+ const char *ptr = curlx_dyn_ptr(&imapc->pp.recvbuf);
size_t len = imapc->pp.nfinal;
bool parsed = FALSE;
curl_off_t size = 0;
ptr = memchr(ptr, '{', len);
if(ptr) {
ptr++;
- if(!Curl_str_number(&ptr, &size, CURL_OFF_T_MAX) &&
- !Curl_str_single(&ptr, '}'))
+ if(!curlx_str_number(&ptr, &size, CURL_OFF_T_MAX) &&
+ !curlx_str_single(&ptr, '}'))
parsed = TRUE;
}
size_t chunk = pp->overflow;
/* keep only the overflow */
- Curl_dyn_tail(&pp->recvbuf, chunk);
+ curlx_dyn_tail(&pp->recvbuf, chunk);
pp->nfinal = 0; /* done */
if(chunk > (size_t)size)
return CURLE_OK;
}
result = Curl_client_write(data, CLIENTWRITE_BODY,
- Curl_dyn_ptr(&pp->recvbuf), chunk);
+ curlx_dyn_ptr(&pp->recvbuf), chunk);
if(result)
return result;
if(pp->overflow > chunk) {
/* remember the remaining trailing overflow data */
pp->overflow -= chunk;
- Curl_dyn_tail(&pp->recvbuf, pp->overflow);
+ curlx_dyn_tail(&pp->recvbuf, pp->overflow);
}
else {
pp->overflow = 0; /* handled */
/* Free the cache */
- Curl_dyn_reset(&pp->recvbuf);
+ curlx_dyn_reset(&pp->recvbuf);
}
}
(void)key;
(void)klen;
Curl_pp_disconnect(&imapc->pp);
- Curl_dyn_free(&imapc->dyn);
+ curlx_dyn_free(&imapc->dyn);
Curl_safefree(imapc->mailbox);
Curl_safefree(imapc->mailbox_uidvalidity);
free(imapc);
imapc->preftype = IMAP_TYPE_ANY;
Curl_sasl_init(&imapc->sasl, data, &saslimap);
- Curl_dyn_init(&imapc->dyn, DYN_IMAP_CMD);
+ curlx_dyn_init(&imapc->dyn, DYN_IMAP_CMD);
Curl_pp_init(pp);
if(Curl_conn_meta_set(conn, CURL_META_IMAP_CONN, imapc, imap_conn_dtor))
++imapc->cmdid);
/* start with a blank buffer */
- Curl_dyn_reset(&imapc->dyn);
+ curlx_dyn_reset(&imapc->dyn);
/* append tag + space + fmt */
- result = Curl_dyn_addf(&imapc->dyn, "%s %s", imapc->resptag, fmt);
+ result = curlx_dyn_addf(&imapc->dyn, "%s %s", imapc->resptag, fmt);
if(!result) {
va_list ap;
va_start(ap, fmt);
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wformat-nonliteral"
#endif
- result = Curl_pp_vsendf(data, &imapc->pp, Curl_dyn_ptr(&imapc->dyn), ap);
+ result = Curl_pp_vsendf(data, &imapc->pp, curlx_dyn_ptr(&imapc->dyn), ap);
#ifdef __clang__
#pragma clang diagnostic pop
#endif
/* nothing to escape, return a strdup */
return strdup(str);
- Curl_dyn_init(&line, 2000);
+ curlx_dyn_init(&line, 2000);
- if(!escape_only && Curl_dyn_addn(&line, "\"", 1))
+ if(!escape_only && curlx_dyn_addn(&line, "\"", 1))
return NULL;
while(*str) {
if((*str == '\\' || *str == '"') &&
- Curl_dyn_addn(&line, "\\", 1))
+ curlx_dyn_addn(&line, "\\", 1))
return NULL;
- if(Curl_dyn_addn(&line, str, 1))
+ if(curlx_dyn_addn(&line, str, 1))
return NULL;
str++;
}
- if(!escape_only && Curl_dyn_addn(&line, "\"", 1))
+ if(!escape_only && curlx_dyn_addn(&line, "\"", 1))
return NULL;
- return Curl_dyn_ptr(&line);
+ return curlx_dyn_ptr(&line);
}
/***********************************************************************
#include "curl_setup.h"
#include "curl_ctype.h"
-#include "strparse.h"
+#include "curlx/strparse.h"
#ifndef HAVE_INET_PTON
#include "url.h"
#include "cfilters.h"
#include "cf-socket.h"
-#include "curl_base64.h"
+#include "curlx/base64.h"
#include "ftp.h"
#include "curl_gssapi.h"
#include "sendf.h"
#include "transfer.h"
#include "curl_krb5.h"
-#include "warnless.h"
+#include "curlx/warnless.h"
#include "strcase.h"
#include "strdup.h"
if(Curl_GetFTPResponse(data, &nread, NULL))
return -1;
else {
- char *line = Curl_dyn_ptr(&ftpc->pp.recvbuf);
+ char *line = curlx_dyn_ptr(&ftpc->pp.recvbuf);
if(line[0] != '3')
return -1;
}
if(output_buffer.length) {
char *cmd;
- result = Curl_base64_encode((char *)output_buffer.value,
+ result = curlx_base64_encode((char *)output_buffer.value,
output_buffer.length, &p, &base64_sz);
if(result) {
infof(data, "base64-encoding: %s", curl_easy_strerror(result));
break;
}
else {
- size_t len = Curl_dyn_len(&ftpc->pp.recvbuf);
- p = Curl_dyn_ptr(&ftpc->pp.recvbuf);
+ size_t len = curlx_dyn_len(&ftpc->pp.recvbuf);
+ p = curlx_dyn_ptr(&ftpc->pp.recvbuf);
if((len < 4) || (p[0] != '2' && p[0] != '3')) {
infof(data, "Server did not accept auth data");
ret = AUTH_ERROR;
if(p) {
unsigned char *outptr;
size_t outlen;
- result = Curl_base64_decode(p + 5, &outptr, &outlen);
+ result = curlx_base64_decode(p + 5, &outptr, &outlen);
if(result) {
failf(data, "base64-decoding: %s", curl_easy_strerror(result));
ret = AUTH_CONTINUE;
if(len > CURL_MAX_INPUT_LENGTH)
return CURLE_TOO_LARGE;
- Curl_dyn_reset(&buf->buf);
+ curlx_dyn_reset(&buf->buf);
}
else
return CURLE_RECV_ERROR;
result = socket_read(data, sockindex, buffer, (size_t)nread);
if(result)
return result;
- result = Curl_dyn_addn(&buf->buf, buffer, nread);
+ result = curlx_dyn_addn(&buf->buf, buffer, nread);
if(result)
return result;
len -= nread;
} while(len);
/* this decodes the dynbuf *in place* */
nread = conn->mech->decode(conn->app_data,
- Curl_dyn_ptr(&buf->buf),
+ curlx_dyn_ptr(&buf->buf),
len, conn->data_prot, conn);
if(nread < 0)
return CURLE_RECV_ERROR;
- Curl_dyn_setlen(&buf->buf, nread);
+ curlx_dyn_setlen(&buf->buf, nread);
buf->index = 0;
return CURLE_OK;
}
static size_t
buffer_read(struct krb5buffer *buf, void *data, size_t len)
{
- size_t size = Curl_dyn_len(&buf->buf);
+ size_t size = curlx_dyn_len(&buf->buf);
if(size - buf->index < len)
len = size - buf->index;
- memcpy(data, Curl_dyn_ptr(&buf->buf) + buf->index, len);
+ memcpy(data, curlx_dyn_ptr(&buf->buf) + buf->index, len);
buf->index += len;
return len;
}
while(len > 0) {
if(read_data(data, sockindex, &conn->in_buffer))
return -1;
- if(Curl_dyn_len(&conn->in_buffer.buf) == 0) {
+ if(curlx_dyn_len(&conn->in_buffer.buf) == 0) {
if(bytes_read > 0)
conn->in_buffer.eof_flag = 1;
return bytes_read;
return; /* error */
if(iscmd) {
- error = Curl_base64_encode(buffer, curlx_sitouz(bytes),
+ error = curlx_base64_encode(buffer, curlx_sitouz(bytes),
&cmd_buffer, &cmd_size);
if(error) {
free(buffer);
DEBUGASSERT(level > PROT_NONE && level < PROT_LAST);
- error = Curl_base64_decode(buffer + 4, (unsigned char **)&buf, &decoded_sz);
+ error = curlx_base64_decode(buffer + 4, (unsigned char **)&buf, &decoded_sz);
if(error || decoded_sz == 0)
return -1;
}
conn->buffer_size = buffer_size;
- line = Curl_dyn_ptr(&ftpc->pp.recvbuf);
+ line = curlx_dyn_ptr(&ftpc->pp.recvbuf);
pbsz = strstr(line, "PBSZ=");
if(pbsz) {
/* stick to default value if the check fails */
void
Curl_sec_conn_init(struct connectdata *conn)
{
- Curl_dyn_init(&conn->in_buffer.buf, CURL_MAX_INPUT_LENGTH);
+ curlx_dyn_init(&conn->in_buffer.buf, CURL_MAX_INPUT_LENGTH);
conn->in_buffer.index = 0;
conn->in_buffer.eof_flag = 0;
}
if(conn->mech && conn->mech->end)
conn->mech->end(conn->app_data);
Curl_safefree(conn->app_data);
- Curl_dyn_free(&conn->in_buffer.buf);
+ curlx_dyn_free(&conn->in_buffer.buf);
conn->in_buffer.index = 0;
conn->in_buffer.eof_flag = 0;
conn->sec_complete = 0;
#include "progress.h"
#include "transfer.h"
#include "strcase.h"
-#include "strparse.h"
+#include "curlx/strparse.h"
#include "curl_ldap.h"
#include "curl_multibyte.h"
-#include "curl_base64.h"
+#include "curlx/base64.h"
#include "connect.h"
/* The last 3 #include files should be in this order */
#include "curl_printf.h"
if((attr_len > 7) &&
(strcmp(";binary", attr + (attr_len - 7)) == 0)) {
/* Binary attribute, encode to base64. */
- result = Curl_base64_encode(vals[i]->bv_val, vals[i]->bv_len,
- &val_b64, &val_b64_sz);
+ result = curlx_base64_encode(vals[i]->bv_val, vals[i]->bv_len,
+ &val_b64, &val_b64_sz);
if(result) {
ldap_value_free_len(vals);
FREE_ON_WINLDAP(attr);
if(do_trace == -1) {
const char *env = getenv("CURL_TRACE");
curl_off_t e = 0;
- if(!Curl_str_number(&env, &e, INT_MAX))
+ if(!curlx_str_number(&env, &e, INT_MAX))
do_trace = e > 0;
}
if(!do_trace)
CURLcode result;
struct Curl_str out;
- if(Curl_str_until(&atp, &out, 1024, ','))
+ if(curlx_str_until(&atp, &out, 1024, ','))
break;
LDAP_TRACE(("attr[%zu] '%.*s'\n", i, (int)out.len, out.str));
#endif
ludp->lud_attrs_dups++;
- if(Curl_str_single(&atp, ','))
+ if(curlx_str_single(&atp, ','))
break;
}
}
#include "strdup.h"
#include "curl_md4.h"
-#include "warnless.h"
+#include "curlx/warnless.h"
#ifdef USE_OPENSSL
#include <openssl/opensslv.h>
#include "curl_md5.h"
#include "curl_hmac.h"
-#include "warnless.h"
+#include "curlx/warnless.h"
#ifdef USE_MBEDTLS
#include <mbedtls/version.h>
struct Curl_easy;
#include "mime.h"
-#include "warnless.h"
+#include "curlx/warnless.h"
#include "urldata.h"
#include "sendf.h"
#include "strdup.h"
#include "rand.h"
#include "slist.h"
#include "strcase.h"
-#include "dynbuf.h"
+#include "curlx/dynbuf.h"
/* The last 3 #include files should be in this order */
#include "curl_printf.h"
#include "curl_memory.h"
if(strategy == MIMESTRATEGY_MAIL || (data && (data->set.mime_formescape)))
table = mimetable;
- Curl_dyn_init(&db, CURL_MAX_INPUT_LENGTH);
+ curlx_dyn_init(&db, CURL_MAX_INPUT_LENGTH);
- for(result = Curl_dyn_addn(&db, STRCONST("")); !result && *src; src++) {
+ for(result = curlx_dyn_addn(&db, STRCONST("")); !result && *src; src++) {
for(p = table; *p && **p != *src; p++)
;
if(*p)
- result = Curl_dyn_add(&db, *p + 1);
+ result = curlx_dyn_add(&db, *p + 1);
else
- result = Curl_dyn_addn(&db, src, 1);
+ result = curlx_dyn_addn(&db, src, 1);
}
- return Curl_dyn_ptr(&db);
+ return curlx_dyn_ptr(&db);
}
/* Check if header matches. */
*/
#include "curl_setup.h"
-#include "dynbuf.h"
+#include "curlx/dynbuf.h"
#include "curl_printf.h"
-#include "strparse.h"
+#include "curlx/strparse.h"
#include "curl_memory.h"
/* The last #include file should be: */
static int dollarstring(const char *p, const char **end)
{
curl_off_t num;
- if(Curl_str_number(&p, &num, MAX_PARAMETERS) ||
- Curl_str_single(&p, '$') || !num)
+ if(curlx_str_number(&p, &num, MAX_PARAMETERS) ||
+ curlx_str_single(&p, '$') || !num)
return -1;
*end = p;
return (int)num - 1;
is_neg = ('-' == *fmt);
if(is_neg)
fmt++;
- if(Curl_str_number(&fmt, &num, INT_MAX))
+ if(curlx_str_number(&fmt, &num, INT_MAX))
return PFMT_PREC;
precision = (int)num;
if(is_neg)
curl_off_t num;
flags |= FLAGS_WIDTH;
fmt--;
- if(Curl_str_number(&fmt, &num, INT_MAX))
+ if(curlx_str_number(&fmt, &num, INT_MAX))
return PFMT_WIDTH;
width = (int)num;
break;
static int alloc_addbyter(unsigned char outc, void *f)
{
struct asprintf *infop = f;
- CURLcode result = Curl_dyn_addn(infop->b, &outc, 1);
+ CURLcode result = curlx_dyn_addn(infop->b, &outc, 1);
if(result) {
infop->merr = result == CURLE_TOO_LARGE ? MERR_TOO_LARGE : MERR_MEM;
return 1 ; /* fail */
}
/* appends the formatted string, returns MERR error code */
-int Curl_dyn_vprintf(struct dynbuf *dyn, const char *format, va_list ap_save)
+int curlx_dyn_vprintf(struct dynbuf *dyn, const char *format, va_list ap_save)
{
struct asprintf info;
info.b = dyn;
(void)formatf(&info, alloc_addbyter, format, ap_save);
if(info.merr) {
- Curl_dyn_free(info.b);
+ curlx_dyn_free(info.b);
return info.merr;
}
return 0;
struct asprintf info;
struct dynbuf dyn;
info.b = &dyn;
- Curl_dyn_init(info.b, DYN_APRINTF);
+ curlx_dyn_init(info.b, DYN_APRINTF);
info.merr = MERR_OK;
(void)formatf(&info, alloc_addbyter, format, ap_save);
if(info.merr) {
- Curl_dyn_free(info.b);
+ curlx_dyn_free(info.b);
return NULL;
}
- if(Curl_dyn_len(info.b))
- return Curl_dyn_ptr(info.b);
+ if(curlx_dyn_len(info.b))
+ return curlx_dyn_ptr(info.b);
return strdup("");
}
#include "strdup.h"
#include "url.h"
#include "escape.h"
-#include "warnless.h"
+#include "curlx/warnless.h"
#include "curl_printf.h"
#include "curl_memory.h"
#include "multiif.h"
struct MQTT *mq = entry;
(void)key;
(void)klen;
- Curl_dyn_free(&mq->sendbuf);
- Curl_dyn_free(&mq->recvbuf);
+ curlx_dyn_free(&mq->sendbuf);
+ curlx_dyn_free(&mq->recvbuf);
free(mq);
}
mq = calloc(1, sizeof(struct MQTT));
if(!mq)
return CURLE_OUT_OF_MEMORY;
- Curl_dyn_init(&mq->recvbuf, DYN_MQTT_RECV);
- Curl_dyn_init(&mq->sendbuf, DYN_MQTT_SEND);
+ curlx_dyn_init(&mq->recvbuf, DYN_MQTT_RECV);
+ curlx_dyn_init(&mq->sendbuf, DYN_MQTT_SEND);
if(Curl_meta_set(data, CURL_META_MQTT_EASY, mq, mqtt_easy_dtor))
return CURLE_OUT_OF_MEMORY;
return CURLE_OK;
result = Curl_xfer_send(data, buf, len, FALSE, &n);
if(result)
return result;
- mq->lastTime = Curl_now();
+ mq->lastTime = curlx_now();
Curl_debug(data, CURLINFO_HEADER_OUT, buf, (size_t)n);
if(len != n) {
size_t nsend = len - n;
- if(Curl_dyn_len(&mq->sendbuf)) {
- DEBUGASSERT(Curl_dyn_len(&mq->sendbuf) >= nsend);
- result = Curl_dyn_tail(&mq->sendbuf, nsend); /* keep this much */
+ if(curlx_dyn_len(&mq->sendbuf)) {
+ DEBUGASSERT(curlx_dyn_len(&mq->sendbuf) >= nsend);
+ result = curlx_dyn_tail(&mq->sendbuf, nsend); /* keep this much */
}
else {
- result = Curl_dyn_addn(&mq->sendbuf, &buf[n], nsend);
+ result = curlx_dyn_addn(&mq->sendbuf, &buf[n], nsend);
}
}
else
- Curl_dyn_reset(&mq->sendbuf);
+ curlx_dyn_reset(&mq->sendbuf);
return result;
}
if(!mq)
return CURLE_FAILED_INIT;
- rlen = Curl_dyn_len(&mq->recvbuf);
+ rlen = curlx_dyn_len(&mq->recvbuf);
if(rlen < nbytes) {
unsigned char readbuf[1024];
if(result)
return result;
DEBUGASSERT(nread >= 0);
- if(Curl_dyn_addn(&mq->recvbuf, readbuf, (size_t)nread))
+ if(curlx_dyn_addn(&mq->recvbuf, readbuf, (size_t)nread))
return CURLE_OUT_OF_MEMORY;
- rlen = Curl_dyn_len(&mq->recvbuf);
+ rlen = curlx_dyn_len(&mq->recvbuf);
}
return (rlen >= nbytes) ? CURLE_OK : CURLE_AGAIN;
}
struct MQTT *mq = Curl_meta_get(data, CURL_META_MQTT_EASY);
DEBUGASSERT(mq);
if(mq) {
- size_t rlen = Curl_dyn_len(&mq->recvbuf);
+ size_t rlen = curlx_dyn_len(&mq->recvbuf);
if(rlen <= nbytes)
- Curl_dyn_reset(&mq->recvbuf);
+ curlx_dyn_reset(&mq->recvbuf);
else
- Curl_dyn_tail(&mq->recvbuf, rlen - nbytes);
+ curlx_dyn_tail(&mq->recvbuf, rlen - nbytes);
}
}
goto fail;
/* verify CONNACK */
- DEBUGASSERT(Curl_dyn_len(&mq->recvbuf) >= MQTT_CONNACK_LEN);
- ptr = Curl_dyn_ptr(&mq->recvbuf);
+ DEBUGASSERT(curlx_dyn_len(&mq->recvbuf) >= MQTT_CONNACK_LEN);
+ ptr = curlx_dyn_ptr(&mq->recvbuf);
Curl_debug(data, CURLINFO_HEADER_IN, ptr, MQTT_CONNACK_LEN);
if(ptr[0] != 0x00 || ptr[1] != 0x00) {
failf(data, "Expected %02x%02x but got %02x%02x",
0x00, 0x00, ptr[0], ptr[1]);
- Curl_dyn_reset(&mq->recvbuf);
+ curlx_dyn_reset(&mq->recvbuf);
result = CURLE_WEIRD_SERVER_REPLY;
goto fail;
}
goto fail;
/* verify SUBACK */
- DEBUGASSERT(Curl_dyn_len(&mq->recvbuf) >= MQTT_SUBACK_LEN);
- ptr = Curl_dyn_ptr(&mq->recvbuf);
+ DEBUGASSERT(curlx_dyn_len(&mq->recvbuf) >= MQTT_SUBACK_LEN);
+ ptr = curlx_dyn_ptr(&mq->recvbuf);
Curl_debug(data, CURLINFO_HEADER_IN, ptr, MQTT_SUBACK_LEN);
if(((unsigned char)ptr[0]) != ((mqtt->packetid >> 8) & 0xff) ||
((unsigned char)ptr[1]) != (mqtt->packetid & 0xff) ||
ptr[2] != 0x00) {
- Curl_dyn_reset(&mq->recvbuf);
+ curlx_dyn_reset(&mq->recvbuf);
result = CURLE_WEIRD_SERVER_REPLY;
goto fail;
}
}
/* we received something */
- mq->lastTime = Curl_now();
+ mq->lastTime = curlx_now();
/* if QoS is set, message contains packet id */
result = Curl_client_write(data, CLIENTWRITE_BODY, buffer, nread);
if(!mq)
return CURLE_FAILED_INIT;
- mq->lastTime = Curl_now();
+ mq->lastTime = curlx_now();
mq->pingsent = FALSE;
result = mqtt_connect(data);
(void)status;
(void)premature;
if(mq) {
- Curl_dyn_free(&mq->sendbuf);
- Curl_dyn_free(&mq->recvbuf);
+ curlx_dyn_free(&mq->sendbuf);
+ curlx_dyn_free(&mq->recvbuf);
}
return CURLE_OK;
}
if(mqtt->state == MQTT_FIRST &&
!mq->pingsent &&
data->set.upkeep_interval_ms > 0) {
- struct curltime t = Curl_now();
- timediff_t diff = Curl_timediff(t, mq->lastTime);
+ struct curltime t = curlx_now();
+ timediff_t diff = curlx_timediff(t, mq->lastTime);
if(diff > data->set.upkeep_interval_ms) {
/* 0xC0 is PINGREQ, and 0x00 is remaining length */
*done = FALSE;
- if(Curl_dyn_len(&mq->sendbuf)) {
+ if(curlx_dyn_len(&mq->sendbuf)) {
/* send the remainder of an outgoing packet */
- result = mqtt_send(data, Curl_dyn_ptr(&mq->sendbuf),
- Curl_dyn_len(&mq->sendbuf));
+ result = mqtt_send(data, curlx_dyn_ptr(&mq->sendbuf),
+ curlx_dyn_len(&mq->sendbuf));
if(result)
return result;
}
Curl_debug(data, CURLINFO_HEADER_IN, (const char *)&mq->firstbyte, 1);
/* we received something */
- mq->lastTime = Curl_now();
+ mq->lastTime = curlx_now();
/* remember the first byte */
mq->npacket = 0;
#include "multiif.h"
#include "multi_ev.h"
#include "sendf.h"
-#include "timeval.h"
+#include "curlx/timeval.h"
#include "http.h"
#include "select.h"
-#include "warnless.h"
+#include "curlx/warnless.h"
#include "speedcheck.h"
#include "conncache.h"
#include "multihandle.h"
Curl_uint_bset_init(&multi->pending);
Curl_uint_bset_init(&multi->msgsent);
Curl_hash_init(&multi->proto_hash, 23,
- Curl_hash_str, Curl_str_key_compare, ph_freeentry);
+ Curl_hash_str, curlx_str_key_compare, ph_freeentry);
Curl_llist_init(&multi->msglist, NULL);
multi->multiplexing = TRUE;
since = data->progress.t_startop;
if(data->mstate == MSTATE_RESOLVING)
failf(data, "Resolving timed out after %" FMT_TIMEDIFF_T
- " milliseconds", Curl_timediff(*now, since));
+ " milliseconds", curlx_timediff(*now, since));
else if(data->mstate == MSTATE_CONNECTING)
failf(data, "Connection timed out after %" FMT_TIMEDIFF_T
- " milliseconds", Curl_timediff(*now, since));
+ " milliseconds", curlx_timediff(*now, since));
else {
struct SingleRequest *k = &data->req;
if(k->size != -1) {
failf(data, "Operation timed out after %" FMT_TIMEDIFF_T
" milliseconds with %" FMT_OFF_T " out of %"
FMT_OFF_T " bytes received",
- Curl_timediff(*now, since), k->bytecount, k->size);
+ curlx_timediff(*now, since), k->bytecount, k->size);
}
else {
failf(data, "Operation timed out after %" FMT_TIMEDIFF_T
" milliseconds with %" FMT_OFF_T " bytes received",
- Curl_timediff(*now, since), k->bytecount);
+ curlx_timediff(*now, since), k->bytecount);
}
}
*result = CURLE_OPERATION_TIMEDOUT;
{
CURLMcode returncode = CURLM_OK;
struct Curl_tree *t = NULL;
- struct curltime now = Curl_now();
+ struct curltime now = curlx_now();
struct Curl_multi *multi = m;
unsigned int mid;
SIGPIPE_VARIABLE(pipe_st);
for(e = Curl_llist_head(list); e;) {
struct Curl_llist_node *n = Curl_node_next(e);
struct time_node *node = Curl_node_elem(e);
- timediff_t diff = Curl_timediff_us(node->time, now);
+ timediff_t diff = curlx_timediff_us(node->time, now);
if(diff <= 0)
/* remove outdated entry */
Curl_node_remove(e);
(void)ev_bitmask;
memset(&mrc, 0, sizeof(mrc));
mrc.multi = multi;
- mrc.now = Curl_now();
+ mrc.now = curlx_now();
sigpipe_init(&mrc.pipe_st);
if(checkall) {
* to set a 0 timeout and call us again, we run them here.
* Do that only once or it might be unfair to transfers on other
* sockets. */
- mrc.now = Curl_now();
+ mrc.now = curlx_now();
result = multi_run_expired(&mrc);
}
if(multi->timetree) {
/* we have a tree of expire times */
- struct curltime now = Curl_now();
+ struct curltime now = curlx_now();
/* splay the lowest to the bottom */
multi->timetree = Curl_splay(tv_zero, multi->timetree);
/* 'multi->timetree' will be non-NULL here but the compilers sometimes
yell at us if we assume so */
if(multi->timetree &&
- Curl_timediff_us(multi->timetree->key, now) > 0) {
+ curlx_timediff_us(multi->timetree->key, now) > 0) {
/* some time left before expiration */
- timediff_t diff = Curl_timediff_ceil(multi->timetree->key, now);
+ timediff_t diff = curlx_timediff_ceil(multi->timetree->key, now);
/* this should be safe even on 32-bit archs, as we do not use that
overly long timeouts */
*timeout_ms = (long)diff;
#endif
set_value = TRUE;
}
- else if(Curl_timediff_us(multi->last_expire_ts, expire_ts)) {
+ else if(curlx_timediff_us(multi->last_expire_ts, expire_ts)) {
/* We had a timeout before and have one now, the absolute timestamp
* differs. The relative timeout_ms may be the same, but the starting
* point differs. Let the application restart its timer. */
/* find the correct spot in the list */
for(e = Curl_llist_head(timeoutlist); e; e = Curl_node_next(e)) {
struct time_node *check = Curl_node_elem(e);
- timediff_t diff = Curl_timediff(check->time, node->time);
+ timediff_t diff = curlx_timediff(check->time, node->time);
if(diff > 0)
break;
prev = e;
/* This means that the struct is added as a node in the splay tree.
Compare if the new time is earlier, and only remove-old/add-new if it
is. */
- timediff_t diff = Curl_timediff(set, *curr_expire);
+ timediff_t diff = curlx_timediff(set, *curr_expire);
int rc;
if(diff > 0) {
*/
void Curl_expire(struct Curl_easy *data, timediff_t milli, expire_id id)
{
- struct curltime now = Curl_now();
+ struct curltime now = curlx_now();
Curl_expire_ex(data, &now, milli, id);
}
#include "cfilters.h"
#include "curl_trc.h"
#include "multiif.h"
-#include "timeval.h"
+#include "curlx/timeval.h"
#include "multi_ev.h"
#include "select.h"
#include "uint-bset.h"
#include "uint-spbset.h"
#include "uint-table.h"
-#include "warnless.h"
+#include "curlx/warnless.h"
#include "multihandle.h"
#include "socks.h"
/* The last 3 #include files should be in this order */
#include "netrc.h"
#include "strcase.h"
#include "curl_get_line.h"
-#include "strparse.h"
+#include "curlx/strparse.h"
/* The last 3 #include files should be in this order */
#include "curl_printf.h"
NETRCcode ret = NETRC_FILE_MISSING; /* if it cannot open the file */
FILE *file = fopen(filename, FOPEN_READTEXT);
struct dynbuf linebuf;
- Curl_dyn_init(&linebuf, MAX_NETRC_LINE);
+ curlx_dyn_init(&linebuf, MAX_NETRC_LINE);
if(file) {
ret = NETRC_OK;
while(Curl_get_line(&linebuf, file)) {
CURLcode result;
- const char *line = Curl_dyn_ptr(&linebuf);
+ const char *line = curlx_dyn_ptr(&linebuf);
/* skip comments on load */
- Curl_str_passblanks(&line);
+ curlx_str_passblanks(&line);
if(*line == '#')
continue;
- result = Curl_dyn_add(filebuf, line);
+ result = curlx_dyn_add(filebuf, line);
if(result) {
ret = curl2netrc(result);
goto done;
}
}
done:
- Curl_dyn_free(&linebuf);
+ curlx_dyn_free(&linebuf);
if(file)
fclose(file);
return ret;
struct dynbuf token;
struct dynbuf *filebuf = &store->filebuf;
DEBUGASSERT(!*passwordp);
- Curl_dyn_init(&token, MAX_NETRC_TOKEN);
+ curlx_dyn_init(&token, MAX_NETRC_TOKEN);
if(!store->loaded) {
NETRCcode ret = file2memory(netrcfile, filebuf);
store->loaded = TRUE;
}
- netrcbuffer = Curl_dyn_ptr(filebuf);
+ netrcbuffer = curlx_dyn_ptr(filebuf);
while(!done) {
const char *tok = netrcbuffer;
while(tok && !done) {
const char *tok_end;
bool quoted;
- Curl_dyn_reset(&token);
- Curl_str_passblanks(&tok);
+ curlx_dyn_reset(&token);
+ curlx_str_passblanks(&tok);
/* tok is first non-space letter */
if(state == MACDEF) {
if((*tok == '\n') || (*tok == '\r'))
retcode = NETRC_SYNTAX_ERROR;
goto out;
}
- result = Curl_dyn_addn(&token, tok, len);
+ result = curlx_dyn_addn(&token, tok, len);
if(result) {
retcode = curl2netrc(result);
goto out;
endquote = TRUE;
break;
}
- result = Curl_dyn_addn(&token, &s, 1);
+ result = curlx_dyn_addn(&token, &s, 1);
if(result) {
retcode = curl2netrc(result);
goto out;
}
}
- tok = Curl_dyn_ptr(&token);
+ tok = curlx_dyn_ptr(&token);
switch(state) {
case NOTHING:
} /* while !done */
out:
- Curl_dyn_free(&token);
+ curlx_dyn_free(&token);
if(!retcode) {
if(!password && our_login) {
/* success without a password, set a blank one */
*passwordp = password;
}
else {
- Curl_dyn_free(filebuf);
+ curlx_dyn_free(filebuf);
if(!specific_login)
free(login);
free(password);
void Curl_netrc_init(struct store_netrc *s)
{
- Curl_dyn_init(&s->filebuf, MAX_NETRC_FILE);
+ curlx_dyn_init(&s->filebuf, MAX_NETRC_FILE);
s->loaded = FALSE;
}
void Curl_netrc_cleanup(struct store_netrc *s)
{
- Curl_dyn_free(&s->filebuf);
+ curlx_dyn_free(&s->filebuf);
s->loaded = FALSE;
}
#endif
#include "curl_setup.h"
#ifndef CURL_DISABLE_NETRC
-#include "dynbuf.h"
+#include "curlx/dynbuf.h"
struct store_netrc {
struct dynbuf filebuf;
#include "inet_pton.h"
#include "strcase.h"
#include "noproxy.h"
-#include "strparse.h"
+#include "curlx/strparse.h"
#ifdef HAVE_NETINET_IN_H
#include <netinet/in.h>
bool match = FALSE;
/* pass blanks */
- Curl_str_passblanks(&p);
+ curlx_str_passblanks(&p);
token = p;
/* pass over the pattern */
return TRUE;
} /* if(tokenlen) */
/* pass blanks after pattern */
- Curl_str_passblanks(&p);
+ curlx_str_passblanks(&p);
/* if not a comma, this ends the loop */
if(*p != ',')
break;
#include "vtls/vtls.h"
#include "transfer.h"
#include "curl_ldap.h"
-#include "curl_base64.h"
+#include "curlx/base64.h"
#include "cfilters.h"
#include "connect.h"
#include "curl_sasl.h"
if(do_trace < 0) {
const char *env = getenv("CURL_OPENLDAP_TRACE");
curl_off_t e = 0;
- if(!Curl_str_number(&env, &e, INT_MAX))
+ if(!curlx_str_number(&env, &e, INT_MAX))
do_trace = e > 0;
}
if(do_trace)
/* Binary value, encode to base64. */
if(bvals[i].bv_len)
- result = Curl_base64_encode(bvals[i].bv_val, bvals[i].bv_len,
- &val_b64, &val_b64_sz);
+ result = curlx_base64_encode(bvals[i].bv_val, bvals[i].bv_len,
+ &val_b64, &val_b64_sz);
if(!result)
result = client_write(data, STRCONST(": "), val_b64, val_b64_sz,
STRCONST("\n"));
#include <curl/curl.h>
#include "strcase.h"
-#include "warnless.h"
+#include "curlx/warnless.h"
#include "parsedate.h"
-#include "strparse.h"
+#include "curlx/strparse.h"
/*
* parsedate()
curl_off_t lval;
int num_digits = 0;
const char *p = date;
- if(Curl_str_number(&p, &lval, 99999999))
+ if(curlx_str_number(&p, &lval, 99999999))
return PARSEDATE_FAIL;
/* we know num_digits cannot be larger than 8 */
timediff_t timeout_ms; /* in milliseconds */
timediff_t response_time = (data->set.server_response_timeout) ?
data->set.server_response_timeout : pp->response_time;
- struct curltime now = Curl_now();
+ struct curltime now = curlx_now();
/* if CURLOPT_SERVER_RESPONSE_TIMEOUT is set, use that to determine
remaining time, or use pp->response because SERVER_RESPONSE_TIMEOUT is
/* Without a requested timeout, we only wait 'response_time' seconds for the
full response to arrive before we bail out */
- timeout_ms = response_time - Curl_timediff(now, pp->response);
+ timeout_ms = response_time - curlx_timediff(now, pp->response);
if(data->set.timeout && !disconnecting) {
/* if timeout is requested, find out how much overall remains */
if(Curl_pgrsUpdate(data))
result = CURLE_ABORTED_BY_CALLBACK;
else
- result = Curl_speedcheck(data, Curl_now());
+ result = Curl_speedcheck(data, curlx_now());
if(result)
return result;
{
DEBUGASSERT(!pp->initialised);
pp->nread_resp = 0;
- pp->response = Curl_now(); /* start response time-out now! */
+ pp->response = curlx_now(); /* start response time-out now! */
pp->pending_resp = TRUE;
- Curl_dyn_init(&pp->sendbuf, DYN_PINGPPONG_CMD);
- Curl_dyn_init(&pp->recvbuf, DYN_PINGPPONG_CMD);
+ curlx_dyn_init(&pp->sendbuf, DYN_PINGPPONG_CMD);
+ curlx_dyn_init(&pp->recvbuf, DYN_PINGPPONG_CMD);
pp->initialised = TRUE;
}
/* cannot send without a connection! */
return CURLE_SEND_ERROR;
- Curl_dyn_reset(&pp->sendbuf);
- result = Curl_dyn_vaddf(&pp->sendbuf, fmt, args);
+ curlx_dyn_reset(&pp->sendbuf);
+ result = curlx_dyn_vaddf(&pp->sendbuf, fmt, args);
if(result)
return result;
/* append CRLF */
- result = Curl_dyn_addn(&pp->sendbuf, "\r\n", 2);
+ result = curlx_dyn_addn(&pp->sendbuf, "\r\n", 2);
if(result)
return result;
pp->pending_resp = TRUE;
- write_len = Curl_dyn_len(&pp->sendbuf);
- s = Curl_dyn_ptr(&pp->sendbuf);
+ write_len = curlx_dyn_len(&pp->sendbuf);
+ s = curlx_dyn_ptr(&pp->sendbuf);
#ifdef HAVE_GSSAPI
conn->data_prot = PROT_CMD;
else {
pp->sendthis = NULL;
pp->sendleft = pp->sendsize = 0;
- pp->response = Curl_now();
+ pp->response = curlx_now();
}
return CURLE_OK;
if(pp->nfinal) {
/* a previous call left this many bytes in the beginning of the buffer as
that was the final line; now ditch that */
- size_t full = Curl_dyn_len(&pp->recvbuf);
+ size_t full = curlx_dyn_len(&pp->recvbuf);
/* trim off the "final" leading part */
- Curl_dyn_tail(&pp->recvbuf, full - pp->nfinal);
+ curlx_dyn_tail(&pp->recvbuf, full - pp->nfinal);
pp->nfinal = 0; /* now gone */
}
return CURLE_RECV_ERROR;
}
- result = Curl_dyn_addn(&pp->recvbuf, buffer, gotbytes);
+ result = curlx_dyn_addn(&pp->recvbuf, buffer, gotbytes);
if(result)
return result;
}
do {
- char *line = Curl_dyn_ptr(&pp->recvbuf);
- char *nl = memchr(line, '\n', Curl_dyn_len(&pp->recvbuf));
+ char *line = curlx_dyn_ptr(&pp->recvbuf);
+ char *nl = memchr(line, '\n', curlx_dyn_len(&pp->recvbuf));
if(nl) {
/* a newline is CRLF in pp-talk, so the CR is ignored as
the line is not really terminated until the LF comes */
parsers). Store the overflow counter to inform about additional
data in this buffer after the endofresp line. */
pp->nfinal = length;
- if(Curl_dyn_len(&pp->recvbuf) > length)
- pp->overflow = Curl_dyn_len(&pp->recvbuf) - length;
+ if(curlx_dyn_len(&pp->recvbuf) > length)
+ pp->overflow = curlx_dyn_len(&pp->recvbuf) - length;
else
pp->overflow = 0;
*size = pp->nread_resp; /* size of the response */
gotbytes = 0; /* force break out of outer loop */
break;
}
- if(Curl_dyn_len(&pp->recvbuf) > length)
+ if(curlx_dyn_len(&pp->recvbuf) > length)
/* keep the remaining piece */
- Curl_dyn_tail((&pp->recvbuf), Curl_dyn_len(&pp->recvbuf) - length);
+ curlx_dyn_tail((&pp->recvbuf), curlx_dyn_len(&pp->recvbuf) - length);
else
- Curl_dyn_reset(&pp->recvbuf);
+ curlx_dyn_reset(&pp->recvbuf);
}
else {
/* without a newline, there is no overflow */
else {
pp->sendthis = NULL;
pp->sendleft = pp->sendsize = 0;
- pp->response = Curl_now();
+ pp->response = curlx_now();
}
return CURLE_OK;
}
CURLcode Curl_pp_disconnect(struct pingpong *pp)
{
if(pp->initialised) {
- Curl_dyn_free(&pp->sendbuf);
- Curl_dyn_free(&pp->recvbuf);
+ curlx_dyn_free(&pp->sendbuf);
+ curlx_dyn_free(&pp->recvbuf);
memset(pp, 0, sizeof(*pp));
}
return CURLE_OK;
bool Curl_pp_moredata(struct pingpong *pp)
{
- return !pp->sendleft && Curl_dyn_len(&pp->recvbuf) > pp->nfinal;
+ return !pp->sendleft && curlx_dyn_len(&pp->recvbuf) > pp->nfinal;
}
#endif
#include "bufref.h"
#include "curl_sasl.h"
#include "curl_md5.h"
-#include "warnless.h"
+#include "curlx/warnless.h"
#include "strdup.h"
/* The last 3 #include files should be in this order */
#include "curl_printf.h"
if(!pop3c)
return CURLE_FAILED_INIT;
- message = Curl_dyn_ptr(&pop3c->pp.recvbuf);
+ message = curlx_dyn_ptr(&pop3c->pp.recvbuf);
len = pop3c->pp.nfinal;
if(len > 2) {
/* Find the start of the message */
if(!pop3c)
return CURLE_FAILED_INIT;
- line = Curl_dyn_ptr(&pop3c->pp.recvbuf);
+ line = curlx_dyn_ptr(&pop3c->pp.recvbuf);
len = pop3c->pp.nfinal;
if(pop3code != '+') {
if(!pop3c)
return CURLE_FAILED_INIT;
- line = Curl_dyn_ptr(&pop3c->pp.recvbuf);
+ line = curlx_dyn_ptr(&pop3c->pp.recvbuf);
len = pop3c->pp.nfinal;
/* Do we have a untagged continuation response? */
the body */
/* keep only the overflow */
- Curl_dyn_tail(&pp->recvbuf, pp->overflow);
+ curlx_dyn_tail(&pp->recvbuf, pp->overflow);
pp->nfinal = 0; /* done */
if(!data->req.no_body) {
- result = pop3_write(data, Curl_dyn_ptr(&pp->recvbuf),
- Curl_dyn_len(&pp->recvbuf), FALSE);
+ result = pop3_write(data, curlx_dyn_ptr(&pp->recvbuf),
+ curlx_dyn_len(&pp->recvbuf), FALSE);
if(result)
return result;
}
/* reset the buffer */
- Curl_dyn_reset(&pp->recvbuf);
+ curlx_dyn_reset(&pp->recvbuf);
pp->overflow = 0;
}
}
#include "sendf.h"
#include "multiif.h"
#include "progress.h"
-#include "timeval.h"
+#include "curlx/timeval.h"
#include "curl_printf.h"
/* check rate limits within this many recent milliseconds, at minimum. */
case TIMER_POSTQUEUE:
/* Queue time is accumulative from all involved redirects */
data->progress.t_postqueue +=
- Curl_timediff_us(timestamp, data->progress.t_startqueue);
+ curlx_timediff_us(timestamp, data->progress.t_startqueue);
break;
case TIMER_STARTACCEPT:
data->progress.t_acceptdata = timestamp;
delta = &data->progress.t_posttransfer;
break;
case TIMER_REDIRECT:
- data->progress.t_redirect = Curl_timediff_us(timestamp,
+ data->progress.t_redirect = curlx_timediff_us(timestamp,
data->progress.start);
data->progress.t_startqueue = timestamp;
break;
}
if(delta) {
- timediff_t us = Curl_timediff_us(timestamp, data->progress.t_startsingle);
+ timediff_t us = curlx_timediff_us(timestamp, data->progress.t_startsingle);
if(us < 1)
us = 1; /* make sure at least one microsecond passed */
*delta += us;
*/
struct curltime Curl_pgrsTime(struct Curl_easy *data, timerid timer)
{
- struct curltime now = Curl_now();
+ struct curltime now = curlx_now();
Curl_pgrsTimeWas(data, timer, now);
return now;
void Curl_pgrsStartNow(struct Curl_easy *data)
{
data->progress.speeder_c = 0; /* reset the progress meter display */
- data->progress.start = Curl_now();
+ data->progress.start = curlx_now();
data->progress.is_t_startransfer_set = FALSE;
data->progress.ul.limit.start = data->progress.start;
data->progress.dl.limit.start = data->progress.start;
* 'actual' is the time in milliseconds it took to actually download the
* last 'size' bytes.
*/
- actual = Curl_timediff_ceil(now, d->limit.start);
+ actual = curlx_timediff_ceil(now, d->limit.start);
if(actual < minimum) {
/* if it downloaded the data faster than the limit, make it wait the
difference */
{
/* do not set a new stamp unless the time since last update is long enough */
if(data->set.max_recv_speed) {
- if(Curl_timediff(now, data->progress.dl.limit.start) >=
+ if(curlx_timediff(now, data->progress.dl.limit.start) >=
MIN_RATE_LIMIT_PERIOD) {
data->progress.dl.limit.start = now;
data->progress.dl.limit.start_size = data->progress.dl.cur_size;
}
}
if(data->set.max_send_speed) {
- if(Curl_timediff(now, data->progress.ul.limit.start) >=
+ if(curlx_timediff(now, data->progress.ul.limit.start) >=
MIN_RATE_LIMIT_PERIOD) {
data->progress.ul.limit.start = now;
data->progress.ul.limit.start_size = data->progress.ul.cur_size;
struct Progress * const p = &data->progress;
/* The time spent so far (from the start) in microseconds */
- p->timespent = Curl_timediff_us(now, p->start);
+ p->timespent = curlx_timediff_us(now, p->start);
p->dl.speed = trspeed(p->dl.cur_size, p->timespent);
p->ul.speed = trspeed(p->ul.cur_size, p->timespent);
checkindex = (p->speeder_c >= CURR_TIME) ? p->speeder_c%CURR_TIME : 0;
/* Figure out the exact time for the time span */
- span_ms = Curl_timediff(now, p->speeder_time[checkindex]);
+ span_ms = curlx_timediff(now, p->speeder_time[checkindex]);
if(0 == span_ms)
span_ms = 1; /* at least one millisecond MUST have passed */
int Curl_pgrsUpdate(struct Curl_easy *data)
{
- struct curltime now = Curl_now(); /* what time is it */
+ struct curltime now = curlx_now(); /* what time is it */
bool showprogress = progress_calc(data, now);
return pgrsupdate(data, showprogress);
}
*/
void Curl_pgrsUpdate_nometer(struct Curl_easy *data)
{
- struct curltime now = Curl_now(); /* what time is it */
+ struct curltime now = curlx_now(); /* what time is it */
(void)progress_calc(data, now);
}
*
***************************************************************************/
-#include "timeval.h"
+#include "curlx/timeval.h"
typedef enum {
static time_t now_seconds(void)
{
- struct curltime now = Curl_now();
+ struct curltime now = curlx_now();
return now.tv_sec;
}
#include "urldata.h"
#include "vtls/vtls.h"
#include "sendf.h"
-#include "timeval.h"
+#include "curlx/timeval.h"
#include "rand.h"
#include "escape.h"
static bool seeded = FALSE;
unsigned int rnd;
if(!seeded) {
- struct curltime now = Curl_now();
+ struct curltime now = curlx_now();
randseed += (unsigned int)now.tv_usec + (unsigned int)now.tv_sec;
randseed = randseed * 1103515245 + 12345;
randseed = randseed * 1103515245 + 12345;
!defined(CURL_DISABLE_ALTSVC)
#include "curl_multibyte.h"
-#include "timeval.h"
+#include "curlx/timeval.h"
/* The last 3 #include files should be in this order */
#include "curl_printf.h"
MoveFileEx() will overwrite and is usually atomic, however it fails
when there are open handles to the file. */
const int max_wait_ms = 1000;
- struct curltime start = Curl_now();
+ struct curltime start = curlx_now();
TCHAR *tchar_oldpath = curlx_convert_UTF8_to_tchar(oldpath);
TCHAR *tchar_newpath = curlx_convert_UTF8_to_tchar(newpath);
for(;;) {
curlx_unicodefree(tchar_newpath);
break;
}
- diff = Curl_timediff(Curl_now(), start);
+ diff = curlx_timediff(curlx_now(), start);
if(diff < 0 || diff > max_wait_ms) {
curlx_unicodefree(tchar_oldpath);
curlx_unicodefree(tchar_newpath);
#include "urldata.h"
#include "cfilters.h"
-#include "dynbuf.h"
+#include "curlx/dynbuf.h"
#include "doh.h"
#include "multiif.h"
#include "progress.h"
#include "sendf.h"
#include "transfer.h"
#include "url.h"
-#include "strparse.h"
+#include "curlx/strparse.h"
/* The last 3 #include files should be in this order */
#include "curl_printf.h"
CURLcode Curl_req_start(struct SingleRequest *req,
struct Curl_easy *data)
{
- req->start = Curl_now();
+ req->start = curlx_now();
return Curl_req_soft_reset(req, data);
}
const char *p = getenv("CURL_SMALLREQSEND");
if(p) {
curl_off_t body_small;
- if(!Curl_str_number(&p, &body_small, body_len))
+ if(!curlx_str_number(&p, &body_small, body_len))
blen = hds_len + (size_t)body_small;
}
}
return CURLE_FAILED_INIT;
data->req.httpversion_sent = httpversion;
- buf = Curl_dyn_ptr(req);
- blen = Curl_dyn_len(req);
+ buf = curlx_dyn_ptr(req);
+ blen = curlx_dyn_len(req);
if(!Curl_creader_total_length(data)) {
/* Request without body. Try to send directly from the buf given. */
data->req.eos_read = TRUE;
#include "connect.h"
#include "cfilters.h"
#include "strdup.h"
-#include "strparse.h"
+#include "curlx/strparse.h"
/* The last 3 #include files should be in this order */
#include "curl_printf.h"
#include "curl_memory.h"
struct rtsp_conn *rtspc = entry;
(void)key;
(void)klen;
- Curl_dyn_free(&rtspc->buf);
+ curlx_dyn_free(&rtspc->buf);
free(rtspc);
}
rtspc = calloc(1, sizeof(*rtspc));
if(!rtspc)
return CURLE_OUT_OF_MEMORY;
- Curl_dyn_init(&rtspc->buf, MAX_RTP_BUFFERSIZE);
+ curlx_dyn_init(&rtspc->buf, MAX_RTP_BUFFERSIZE);
if(Curl_conn_meta_set(conn, CURL_META_RTSP_CONN, rtspc, rtsp_conn_dtor))
return CURLE_OUT_OF_MEMORY;
return CURLE_FAILED_INIT;
/* Initialize a dynamic send buffer */
- Curl_dyn_init(&req_buffer, DYN_RTSP_REQ_HEADER);
+ curlx_dyn_init(&req_buffer, DYN_RTSP_REQ_HEADER);
rtsp->CSeq_sent = data->state.rtsp_next_client_CSeq;
rtsp->CSeq_recv = 0;
}
result =
- Curl_dyn_addf(&req_buffer,
- "%s %s RTSP/1.0\r\n" /* Request Stream-URI RTSP/1.0 */
- "CSeq: %ld\r\n", /* CSeq */
- p_request, p_stream_uri, rtsp->CSeq_sent);
+ curlx_dyn_addf(&req_buffer,
+ "%s %s RTSP/1.0\r\n" /* Request Stream-URI RTSP/1.0 */
+ "CSeq: %ld\r\n", /* CSeq */
+ p_request, p_stream_uri, rtsp->CSeq_sent);
if(result)
goto out;
* to make comparison easier
*/
if(p_session_id) {
- result = Curl_dyn_addf(&req_buffer, "Session: %s\r\n", p_session_id);
+ result = curlx_dyn_addf(&req_buffer, "Session: %s\r\n", p_session_id);
if(result)
goto out;
}
/*
* Shared HTTP-like options
*/
- result = Curl_dyn_addf(&req_buffer,
- "%s" /* transport */
- "%s" /* accept */
- "%s" /* accept-encoding */
- "%s" /* range */
- "%s" /* referrer */
- "%s" /* user-agent */
- "%s" /* proxyuserpwd */
- "%s" /* userpwd */
- ,
- p_transport ? p_transport : "",
- p_accept ? p_accept : "",
- p_accept_encoding ? p_accept_encoding : "",
- p_range ? p_range : "",
- p_referrer ? p_referrer : "",
- p_uagent ? p_uagent : "",
- p_proxyuserpwd ? p_proxyuserpwd : "",
- p_userpwd ? p_userpwd : "");
+ result = curlx_dyn_addf(&req_buffer,
+ "%s" /* transport */
+ "%s" /* accept */
+ "%s" /* accept-encoding */
+ "%s" /* range */
+ "%s" /* referrer */
+ "%s" /* user-agent */
+ "%s" /* proxyuserpwd */
+ "%s" /* userpwd */
+ ,
+ p_transport ? p_transport : "",
+ p_accept ? p_accept : "",
+ p_accept_encoding ? p_accept_encoding : "",
+ p_range ? p_range : "",
+ p_referrer ? p_referrer : "",
+ p_uagent ? p_uagent : "",
+ p_proxyuserpwd ? p_proxyuserpwd : "",
+ p_userpwd ? p_userpwd : "");
/*
* Free userpwd now --- cannot reuse this for Negotiate and possibly NTLM
* actually set a custom Content-Length in the headers */
if(!Curl_checkheaders(data, STRCONST("Content-Length"))) {
result =
- Curl_dyn_addf(&req_buffer, "Content-Length: %" FMT_OFF_T"\r\n",
- req_clen);
+ curlx_dyn_addf(&req_buffer, "Content-Length: %" FMT_OFF_T"\r\n",
+ req_clen);
if(result)
goto out;
}
if(rtspreq == RTSPREQ_SET_PARAMETER ||
rtspreq == RTSPREQ_GET_PARAMETER) {
if(!Curl_checkheaders(data, STRCONST("Content-Type"))) {
- result = Curl_dyn_addn(&req_buffer,
- STRCONST("Content-Type: "
- "text/parameters\r\n"));
+ result = curlx_dyn_addn(&req_buffer,
+ STRCONST("Content-Type: "
+ "text/parameters\r\n"));
if(result)
goto out;
}
if(rtspreq == RTSPREQ_ANNOUNCE) {
if(!Curl_checkheaders(data, STRCONST("Content-Type"))) {
- result = Curl_dyn_addn(&req_buffer,
- STRCONST("Content-Type: "
- "application/sdp\r\n"));
+ result = curlx_dyn_addn(&req_buffer,
+ STRCONST("Content-Type: "
+ "application/sdp\r\n"));
if(result)
goto out;
}
}
/* Finish the request buffer */
- result = Curl_dyn_addn(&req_buffer, STRCONST("\r\n"));
+ result = curlx_dyn_addn(&req_buffer, STRCONST("\r\n"));
if(result)
goto out;
result = CURLE_ABORTED_BY_CALLBACK;
}
out:
- Curl_dyn_free(&req_buffer);
+ curlx_dyn_free(&req_buffer);
return result;
}
switch(rtspc->state) {
case RTP_PARSE_SKIP: {
- DEBUGASSERT(Curl_dyn_len(&rtspc->buf) == 0);
+ DEBUGASSERT(curlx_dyn_len(&rtspc->buf) == 0);
while(blen && buf[0] != '$') {
if(!in_body && buf[0] == 'R' &&
data->set.rtspreq != RTSPREQ_RECEIVE) {
if(result)
goto out;
}
- if(Curl_dyn_addn(&rtspc->buf, buf, 1)) {
+ if(curlx_dyn_addn(&rtspc->buf, buf, 1)) {
result = CURLE_OUT_OF_MEMORY;
goto out;
}
case RTP_PARSE_CHANNEL: {
int idx = ((unsigned char)buf[0]) / 8;
int off = ((unsigned char)buf[0]) % 8;
- DEBUGASSERT(Curl_dyn_len(&rtspc->buf) == 1);
+ DEBUGASSERT(curlx_dyn_len(&rtspc->buf) == 1);
if(!(data->state.rtp_channel_mask[idx] & (1 << off))) {
/* invalid channel number, junk or BODY data */
rtspc->state = RTP_PARSE_SKIP;
* it from an earlier call. We cannot un-consume it and have
* to write it directly as BODY data */
result = rtp_write_body_junk(data, rtspc,
- Curl_dyn_ptr(&rtspc->buf), 1);
+ curlx_dyn_ptr(&rtspc->buf), 1);
if(result)
goto out;
}
/* count the '$' as skip and continue */
skip_len = 1;
}
- Curl_dyn_free(&rtspc->buf);
+ curlx_dyn_free(&rtspc->buf);
break;
}
/* a valid channel, so we expect this to be a real RTP message */
rtspc->rtp_channel = (unsigned char)buf[0];
- if(Curl_dyn_addn(&rtspc->buf, buf, 1)) {
+ if(curlx_dyn_addn(&rtspc->buf, buf, 1)) {
result = CURLE_OUT_OF_MEMORY;
goto out;
}
}
case RTP_PARSE_LEN: {
- size_t rtp_len = Curl_dyn_len(&rtspc->buf);
+ size_t rtp_len = curlx_dyn_len(&rtspc->buf);
const char *rtp_buf;
DEBUGASSERT(rtp_len >= 2 && rtp_len < 4);
- if(Curl_dyn_addn(&rtspc->buf, buf, 1)) {
+ if(curlx_dyn_addn(&rtspc->buf, buf, 1)) {
result = CURLE_OUT_OF_MEMORY;
goto out;
}
--blen;
if(rtp_len == 2)
break;
- rtp_buf = Curl_dyn_ptr(&rtspc->buf);
+ rtp_buf = curlx_dyn_ptr(&rtspc->buf);
rtspc->rtp_len = RTP_PKT_LENGTH(rtp_buf) + 4;
rtspc->state = RTP_PARSE_DATA;
break;
}
case RTP_PARSE_DATA: {
- size_t rtp_len = Curl_dyn_len(&rtspc->buf);
+ size_t rtp_len = curlx_dyn_len(&rtspc->buf);
size_t needed;
DEBUGASSERT(rtp_len < rtspc->rtp_len);
needed = rtspc->rtp_len - rtp_len;
if(needed <= blen) {
- if(Curl_dyn_addn(&rtspc->buf, buf, needed)) {
+ if(curlx_dyn_addn(&rtspc->buf, buf, needed)) {
result = CURLE_OUT_OF_MEMORY;
goto out;
}
/* complete RTP message in buffer */
DEBUGF(infof(data, "RTP write channel %d rtp_len %zu",
rtspc->rtp_channel, rtspc->rtp_len));
- result = rtp_client_write(data, Curl_dyn_ptr(&rtspc->buf),
+ result = rtp_client_write(data, curlx_dyn_ptr(&rtspc->buf),
rtspc->rtp_len);
- Curl_dyn_free(&rtspc->buf);
+ curlx_dyn_free(&rtspc->buf);
rtspc->state = RTP_PARSE_SKIP;
if(result)
goto out;
}
else {
- if(Curl_dyn_addn(&rtspc->buf, buf, blen)) {
+ if(curlx_dyn_addn(&rtspc->buf, buf, blen)) {
result = CURLE_OUT_OF_MEMORY;
goto out;
}
const char *p = &header[5];
if(!rtsp)
return CURLE_FAILED_INIT;
- Curl_str_passblanks(&p);
- if(Curl_str_number(&p, &CSeq, LONG_MAX)) {
+ curlx_str_passblanks(&p);
+ if(curlx_str_number(&p, &CSeq, LONG_MAX)) {
failf(data, "Unable to read the CSeq header: [%s]", header);
return CURLE_RTSP_CSEQ_ERROR;
}
/* Find the first non-space letter */
start = header + 8;
- Curl_str_passblanks(&start);
+ curlx_str_passblanks(&start);
if(!*start) {
failf(data, "Got a blank Session ID");
const char *start, *end;
start = transport;
while(start && *start) {
- Curl_str_passblanks(&start);
+ curlx_str_passblanks(&start);
end = strchr(start, ';');
if(checkprefix("interleaved=", start)) {
curl_off_t chan1, chan2, chan;
const char *p = start + 12;
- if(!Curl_str_number(&p, &chan1, 255)) {
+ if(!curlx_str_number(&p, &chan1, 255)) {
unsigned char *rtp_channel_mask = data->state.rtp_channel_mask;
chan2 = chan1;
- if(!Curl_str_single(&p, '-')) {
- if(Curl_str_number(&p, &chan2, 255)) {
+ if(!curlx_str_single(&p, '-')) {
+ if(curlx_str_number(&p, &chan2, 255)) {
infof(data, "Unable to read the interleaved parameter from "
"Transport header: [%s]", transport);
chan2 = chan1;
#include "urldata.h"
#include "connect.h"
#include "select.h"
-#include "timediff.h"
-#include "warnless.h"
+#include "curlx/timediff.h"
+#include "curlx/warnless.h"
/* The last 3 #include files should be in this order */
#include "curl_printf.h"
#include "curl_memory.h"
return Curl_wait_ms(timeout_ms);
}
- /* Avoid initial timestamp, avoid Curl_now() call, when elapsed
+ /* Avoid initial timestamp, avoid curlx_now() call, when elapsed
time in this function does not need to be measured. This happens
when function is called with a zero timeout or a negative timeout
value indicating a blocking call should be performed. */
return Curl_wait_ms(timeout_ms);
}
- /* Avoid initial timestamp, avoid Curl_now() call, when elapsed
+ /* Avoid initial timestamp, avoid curlx_now() call, when elapsed
time in this function does not need to be measured. This happens
when function is called with a zero timeout or a negative timeout
value indicating a blocking call should be performed. */
#include "strdup.h"
#include "http2.h"
#include "progress.h"
-#include "warnless.h"
+#include "curlx/warnless.h"
#include "ws.h"
/* The last 3 #include files should be in this order */
#include "strcase.h"
#include "share.h"
#include "vtls/vtls.h"
-#include "warnless.h"
+#include "curlx/warnless.h"
#include "sendf.h"
#include "http2.h"
#include "setopt.h"
#if !defined(CURL_DISABLE_AWS) || !defined(CURL_DISABLE_DIGEST_AUTH) \
|| defined(USE_LIBSSH2) || defined(USE_SSL)
-#include "warnless.h"
+#include "curlx/warnless.h"
#include "curl_sha256.h"
#include "curl_hmac.h"
#include "curl_gethostname.h"
#include "bufref.h"
#include "curl_sasl.h"
-#include "warnless.h"
+#include "curlx/warnless.h"
#include "idn.h"
-#include "strparse.h"
+#include "curlx/strparse.h"
/* The last 3 #include files should be in this order */
#include "curl_printf.h"
result = TRUE;
memcpy(tmpline, line, (len == 5 ? 5 : 3));
tmpline[len == 5 ? 5 : 3 ] = 0;
- if(Curl_str_number(&p, &code, len == 5 ? 99999 : 999))
+ if(curlx_str_number(&p, &code, len == 5 ? 99999 : 999))
return FALSE;
*resp = (int) code;
*/
static CURLcode smtp_get_message(struct Curl_easy *data, struct bufref *out)
{
- char *message = Curl_dyn_ptr(&data->conn->proto.smtpc.pp.recvbuf);
+ char *message = curlx_dyn_ptr(&data->conn->proto.smtpc.pp.recvbuf);
size_t len = data->conn->proto.smtpc.pp.nfinal;
if(len > 4) {
{
CURLcode result = CURLE_OK;
struct smtp_conn *smtpc = &conn->proto.smtpc;
- const char *line = Curl_dyn_ptr(&smtpc->pp.recvbuf);
+ const char *line = curlx_dyn_ptr(&smtpc->pp.recvbuf);
size_t len = smtpc->pp.nfinal;
(void)instate; /* no use for this yet */
{
CURLcode result = CURLE_OK;
struct SMTP *smtp = data->req.p.smtp;
- char *line = Curl_dyn_ptr(&data->conn->proto.smtpc.pp.recvbuf);
+ char *line = curlx_dyn_ptr(&data->conn->proto.smtpc.pp.recvbuf);
size_t len = data->conn->proto.smtpc.pp.nfinal;
(void)instate; /* no use for this yet */
#endif /* !_WIN32 */
#include "nonblock.h" /* for curlx_nonblock */
-#include "timeval.h" /* needed before select.h */
+#include "curlx/timeval.h" /* needed before select.h */
#include "select.h" /* for Curl_poll */
/* The last 3 #include files should be in this order */
if(socks[1] == CURL_SOCKET_BAD)
goto error;
else {
- struct curltime start = Curl_now();
+ struct curltime start = curlx_now();
char rnd[9];
char check[sizeof(rnd)];
char *p = &check[0];
if(nread == -1) {
int sockerr = SOCKERRNO;
/* Do not block forever */
- if(Curl_timediff(Curl_now(), start) > (60 * 1000))
+ if(curlx_timediff(curlx_now(), start) > (60 * 1000))
goto error;
if(
#ifdef USE_WINSOCK
#include "select.h"
#include "cfilters.h"
#include "connect.h"
-#include "timeval.h"
+#include "curlx/timeval.h"
#include "socks.h"
#include "multiif.h" /* for getsock macros */
#include "inet_pton.h"
#include "sendf.h"
#include "cfilters.h"
#include "connect.h"
-#include "timeval.h"
+#include "curlx/timeval.h"
#include "socks.h"
-#include "warnless.h"
+#include "curlx/warnless.h"
#include "strdup.h"
/* The last 3 #include files should be in this order */
gss_buffer_desc status_string = GSS_C_EMPTY_BUFFER;
struct dynbuf dbuf;
- Curl_dyn_init(&dbuf, MAX_GSS_LEN);
+ curlx_dyn_init(&dbuf, MAX_GSS_LEN);
msg_ctx = 0;
while(!msg_ctx) {
/* convert major status code (GSS-API error) to text */
GSS_C_NULL_OID,
&msg_ctx, &status_string);
if(maj_stat == GSS_S_COMPLETE) {
- if(Curl_dyn_addn(&dbuf, status_string.value,
+ if(curlx_dyn_addn(&dbuf, status_string.value,
status_string.length))
return 1; /* error */
gss_release_buffer(&min_stat, &status_string);
}
gss_release_buffer(&min_stat, &status_string);
}
- if(Curl_dyn_addn(&dbuf, ".\n", 2))
+ if(curlx_dyn_addn(&dbuf, ".\n", 2))
return 1; /* error */
msg_ctx = 0;
while(!msg_ctx) {
GSS_C_NULL_OID,
&msg_ctx, &status_string);
if(maj_stat == GSS_S_COMPLETE) {
- if(Curl_dyn_addn(&dbuf, status_string.value,
+ if(curlx_dyn_addn(&dbuf, status_string.value,
status_string.length))
return 1; /* error */
gss_release_buffer(&min_stat, &status_string);
}
gss_release_buffer(&min_stat, &status_string);
}
- failf(data, "GSS-API error: %s failed: %s", function, Curl_dyn_ptr(&dbuf));
- Curl_dyn_free(&dbuf);
+ failf(data, "GSS-API error: %s failed: %s", function,
+ curlx_dyn_ptr(&dbuf));
+ curlx_dyn_free(&dbuf);
return 1;
}
#include "cfilters.h"
#include "connect.h"
#include "strerror.h"
-#include "timeval.h"
+#include "curlx/timeval.h"
#include "socks.h"
#include "curl_sspi.h"
#include "curl_multibyte.h"
-#include "warnless.h"
+#include "curlx/warnless.h"
#include "strdup.h"
/* The last 3 #include files should be in this order */
#include "curl_printf.h"
data->state.keeps_speed = now;
else {
/* how long has it been under the limit */
- timediff_t howlong = Curl_timediff(now, data->state.keeps_speed);
+ timediff_t howlong = curlx_timediff(now, data->state.keeps_speed);
if(howlong >= data->set.low_speed_time * 1000) {
/* too long */
#include "curl_setup.h"
-#include "timeval.h"
+#include "curlx/timeval.h"
struct Curl_easy;
void Curl_speedinit(struct Curl_easy *data);
CURLcode Curl_speedcheck(struct Curl_easy *data,
#include "curl_setup.h"
-#include "timeval.h"
+#include "curlx/timeval.h"
#include "splay.h"
/*
* zero : when i is equal to j
* positive when : when i is larger than j
*/
-#define compare(i,j) Curl_timediff_us(i,j)
+#define compare(i,j) curlx_timediff_us(i,j)
/*
* Splay using the key i (which may or may not be in the tree.) The starting
*
***************************************************************************/
#include "curl_setup.h"
-#include "timeval.h"
+#include "curlx/timeval.h"
/* only use function calls to access this struct */
struct Curl_tree {
#ifndef UNDER_CE
/* 'sys_nerr' is the maximum errno number, it is not widely portable */
if(err >= 0 && err < sys_nerr)
- msnprintf(buf, buflen, "%s", sys_errlist[err]);
+ curl_msnprintf(buf, buflen, "%s", sys_errlist[err]);
else
#endif
{
!get_winsock_error(err, buf, buflen) &&
#endif
!get_winapi_error(err, buf, buflen))
- msnprintf(buf, buflen, "Unknown error %d (%#x)", err, err);
+ curl_msnprintf(buf, buflen, "Unknown error %d (%#x)", err, err);
}
#else /* not Windows coming up */
*/
if(0 != strerror_r(err, buf, buflen)) {
if('\0' == buf[0])
- msnprintf(buf, buflen, "Unknown error %d", err);
+ curl_msnprintf(buf, buflen, "Unknown error %d", err);
}
#elif defined(HAVE_STRERROR_R) && defined(HAVE_GLIBC_STRERROR_R)
/*
char buffer[256];
char *msg = strerror_r(err, buffer, sizeof(buffer));
if(msg)
- msnprintf(buf, buflen, "%s", msg);
+ curl_msnprintf(buf, buflen, "%s", msg);
else
- msnprintf(buf, buflen, "Unknown error %d", err);
+ curl_msnprintf(buf, buflen, "Unknown error %d", err);
}
#else
{
/* !checksrc! disable BANNEDFUNC 1 */
const char *msg = strerror(err);
if(msg)
- msnprintf(buf, buflen, "%s", msg);
+ curl_msnprintf(buf, buflen, "%s", msg);
else
- msnprintf(buf, buflen, "Unknown error %d", err);
+ curl_msnprintf(buf, buflen, "Unknown error %d", err);
}
#endif
#ifndef CURL_DISABLE_VERBOSE_STRINGS
if(!get_winapi_error((int)err, buf, buflen)) {
- msnprintf(buf, buflen, "Unknown error %lu (0x%08lX)", err, err);
+ curl_msnprintf(buf, buflen, "Unknown error %lu (0x%08lX)", err, err);
}
#else
{
}
if(err == SEC_E_ILLEGAL_MESSAGE) {
- msnprintf(buf, buflen,
- "SEC_E_ILLEGAL_MESSAGE (0x%08X) - This error usually occurs "
- "when a fatal SSL/TLS alert is received (e.g. handshake failed)."
- " More detail may be available in the Windows System event log.",
- err);
+ curl_msnprintf(buf, buflen,
+ "SEC_E_ILLEGAL_MESSAGE (0x%08X) - This error usually "
+ "occurs when a fatal SSL/TLS alert is received (e.g. "
+ "handshake failed). More detail may be available in "
+ "the Windows System event log.", err);
}
else {
char msgbuf[256];
if(get_winapi_error(err, msgbuf, sizeof(msgbuf)))
- msnprintf(buf, buflen, "%s (0x%08X) - %s", txt, err, msgbuf);
+ curl_msnprintf(buf, buflen, "%s (0x%08X) - %s", txt, err, msgbuf);
else
- msnprintf(buf, buflen, "%s (0x%08X)", txt, err);
+ curl_msnprintf(buf, buflen, "%s (0x%08X)", txt, err);
}
#else
#include "system_win32.h"
#include "version_win32.h"
#include "curl_sspi.h"
-#include "warnless.h"
+#include "curlx/warnless.h"
/* The last #include files should be: */
#include "curl_memory.h"
#include "memdebug.h"
-LARGE_INTEGER Curl_freq;
-bool Curl_isVistaOrGreater;
-
/* Handle of iphlpapp.dll */
static HMODULE s_hIpHlpApiDll = NULL;
#include "arpa_telnet.h"
#include "select.h"
#include "strcase.h"
-#include "warnless.h"
-#include "strparse.h"
+#include "curlx/warnless.h"
+#include "curlx/strparse.h"
/* The last 3 #include files should be in this order */
#include "curl_printf.h"
if(!tn)
return CURLE_OUT_OF_MEMORY;
- Curl_dyn_init(&tn->out, 0xffff);
+ curlx_dyn_init(&tn->out, 0xffff);
data->req.p.telnet = tn; /* make us known */
tn->telrcv_state = CURL_TS_DATA;
const char *p = arg;
curl_off_t x = 0;
curl_off_t y = 0;
- if(Curl_str_number(&p, &x, 0xffff) ||
- Curl_str_single(&p, 'x') ||
- Curl_str_number(&p, &y, 0xffff)) {
+ if(curlx_str_number(&p, &x, 0xffff) ||
+ curlx_str_single(&p, 'x') ||
+ curlx_str_number(&p, &y, 0xffff)) {
failf(data, "Syntax error in telnet option: %s", head->data);
result = CURLE_SETOPT_OPTION_SYNTAX;
}
if(memchr(buffer, CURL_IAC, nread)) {
/* only use the escape buffer when necessary */
- Curl_dyn_reset(&tn->out);
+ curlx_dyn_reset(&tn->out);
for(i = 0; i < (size_t)nread && !result; i++) {
- result = Curl_dyn_addn(&tn->out, &buffer[i], 1);
+ result = curlx_dyn_addn(&tn->out, &buffer[i], 1);
if(!result && ((unsigned char)buffer[i] == CURL_IAC))
/* IAC is FF in hex */
- result = Curl_dyn_addn(&tn->out, "\xff", 1);
+ result = curlx_dyn_addn(&tn->out, "\xff", 1);
}
- outlen = Curl_dyn_len(&tn->out);
- outbuf = Curl_dyn_uptr(&tn->out);
+ outlen = curlx_dyn_len(&tn->out);
+ outbuf = curlx_dyn_uptr(&tn->out);
}
else {
outlen = (size_t)nread;
curl_slist_free_all(tn->telnet_vars);
tn->telnet_vars = NULL;
- Curl_dyn_free(&tn->out);
+ curlx_dyn_free(&tn->out);
return CURLE_OK;
}
}
if(data->set.timeout) {
- now = Curl_now();
- if(Curl_timediff(now, conn->created) >= data->set.timeout) {
+ now = curlx_now();
+ if(curlx_timediff(now, conn->created) >= data->set.timeout) {
failf(data, "Time-out");
result = CURLE_OPERATION_TIMEDOUT;
keepon = FALSE;
} /* poll switch statement */
if(data->set.timeout) {
- now = Curl_now();
- if(Curl_timediff(now, conn->created) >= data->set.timeout) {
+ now = curlx_now();
+ if(curlx_timediff(now, conn->created) >= data->set.timeout) {
failf(data, "Time-out");
result = CURLE_OPERATION_TIMEDOUT;
keepon = FALSE;
#include "speedcheck.h"
#include "select.h"
#include "escape.h"
-#include "strparse.h"
+#include "curlx/strparse.h"
/* The last 3 #include files should be in this order */
#include "curl_printf.h"
if(checkprefix(TFTP_OPTION_BLKSIZE, option)) {
curl_off_t blksize;
- if(Curl_str_number(&value, &blksize, TFTP_BLKSIZE_MAX)) {
+ if(curlx_str_number(&value, &blksize, TFTP_BLKSIZE_MAX)) {
failf(data, "%s (%d)", "blksize is larger than max supported",
TFTP_BLKSIZE_MAX);
return CURLE_TFTP_ILLEGAL;
/* tsize should be ignored on upload: Who cares about the size of the
remote file? */
if(!data->state.upload &&
- !Curl_str_number(&value, &tsize, CURL_OFF_T_MAX)) {
+ !curlx_str_number(&value, &tsize, CURL_OFF_T_MAX)) {
if(!tsize) {
failf(data, "invalid tsize -:%s:- value in OACK packet", value);
return CURLE_TFTP_ILLEGAL;
if(Curl_pgrsUpdate(data))
result = CURLE_ABORTED_BY_CALLBACK;
else
- result = Curl_speedcheck(data, Curl_now());
+ result = Curl_speedcheck(data, curlx_now());
}
return result;
}
failf(data, "Operation timed out after %" FMT_TIMEDIFF_T
" milliseconds with %" FMT_OFF_T " out of %"
FMT_OFF_T " bytes received",
- Curl_timediff(*nowp, data->progress.t_startsingle),
+ curlx_timediff(*nowp, data->progress.t_startsingle),
k->bytecount, k->size);
}
else {
failf(data, "Operation timed out after %" FMT_TIMEDIFF_T
" milliseconds with %" FMT_OFF_T " bytes received",
- Curl_timediff(*nowp, data->progress.t_startsingle),
+ curlx_timediff(*nowp, data->progress.t_startsingle),
k->bytecount);
}
result = CURLE_OPERATION_TIMEDOUT;
#include "multiif.h"
#include "easyif.h"
#include "speedcheck.h"
-#include "warnless.h"
+#include "curlx/warnless.h"
#include "getinfo.h"
#include "pop3.h"
#include "urlapi-int.h"
#include "strdup.h"
#include "setopt.h"
#include "altsvc.h"
-#include "dynbuf.h"
+#include "curlx/dynbuf.h"
#include "headers.h"
-#include "strparse.h"
+#include "curlx/strparse.h"
/* The last 3 #include files should be in this order */
#include "curl_printf.h"
#include "curl_memory.h"
data->state.referer = NULL;
up_free(data);
- Curl_dyn_free(&data->state.headerb);
+ curlx_dyn_free(&data->state.headerb);
Curl_flush_cookies(data, TRUE);
#ifndef CURL_DISABLE_ALTSVC
Curl_altsvc_save(data, data->asi, data->set.str[STRING_ALTSVC]);
data->state.current_speed = -1; /* init to negative == impossible */
Curl_hash_init(&data->meta_hash, 23,
- Curl_hash_str, Curl_str_key_compare, easy_meta_freeentry);
- Curl_dyn_init(&data->state.headerb, CURL_MAX_HTTP_HEADER);
+ Curl_hash_str, curlx_str_key_compare, easy_meta_freeentry);
+ curlx_dyn_init(&data->state.headerb, CURL_MAX_HTTP_HEADER);
Curl_req_init(&data->req);
Curl_initinfo(data);
#ifndef CURL_DISABLE_HTTP
result = Curl_init_userdefined(data);
if(result) {
- Curl_dyn_free(&data->state.headerb);
+ curlx_dyn_free(&data->state.headerb);
Curl_freeset(data);
Curl_req_free(&data->req, data);
Curl_hash_destroy(&data->meta_hash);
{
timediff_t idletime, lifetime;
- idletime = Curl_timediff(now, conn->lastused);
+ idletime = curlx_timediff(now, conn->lastused);
idletime /= 1000; /* integer seconds is fine */
if(idletime > data->set.maxage_conn) {
return TRUE;
}
- lifetime = Curl_timediff(now, conn->created);
+ lifetime = curlx_timediff(now, conn->created);
lifetime /= 1000; /* integer seconds is fine */
if(data->set.maxlifetime_conn && lifetime > data->set.maxlifetime_conn) {
bool dead;
struct curltime now;
if(!pnow) {
- now = Curl_now();
+ now = curlx_now();
pnow = &now;
}
struct curltime *now)
{
CURLcode result = CURLE_OK;
- if(Curl_timediff(*now, conn->keepalive) <= data->set.upkeep_interval_ms)
+ if(curlx_timediff(*now, conn->keepalive) <= data->set.upkeep_interval_ms)
return result;
/* briefly attach for action */
connclose(conn, "Default to force-close");
/* Store creation time to help future close decision making */
- conn->created = Curl_now();
+ conn->created = curlx_now();
/* Store current time to give a baseline to keepalive connection times. */
conn->keepalive = conn->created;
if(!uc && zoneid) {
const char *p = zoneid;
curl_off_t scope;
- if(!Curl_str_number(&p, &scope, UINT_MAX))
+ if(!curlx_str_number(&p, &scope, UINT_MAX))
/* A plain number, use it directly as a scope id. */
conn->scope_id = (unsigned int)scope;
#ifdef HAVE_IF_NAMETOINDEX
port = data->set.use_port;
else {
const char *p = data->state.up.port;
- if(Curl_str_number(&p, &port, 0xffff))
+ if(curlx_str_number(&p, &port, 0xffff))
valid = FALSE;
}
if(valid)
if(portptr) {
curl_off_t num;
const char *p = portptr;
- if(!Curl_str_number(&p, &num, 0xffff))
+ if(!curlx_str_number(&p, &num, 0xffff))
port = (int)num;
free(portptr);
}
if(*host_portno) {
curl_off_t portparse;
const char *p = host_portno;
- if(Curl_str_number(&p, &portparse, 0xffff)) {
+ if(curlx_str_number(&p, &portparse, 0xffff)) {
failf(data, "No valid port number in connect to host string (%s)",
host_portno);
result = CURLE_SETOPT_OPTION_SYNTAX;
char *ptr_next = strchr(ptr, ':');
if(ptr_next) {
curl_off_t port_to_match;
- if(!Curl_str_number(&ptr, &port_to_match, 0xffff) &&
+ if(!curlx_str_number(&ptr, &port_to_match, 0xffff) &&
(port_to_match == (curl_off_t)conn->remote_port))
port_match = TRUE;
ptr = ptr_next + 1;
else if(result == CURLE_OPERATION_TIMEDOUT) {
failf(data, "Failed to resolve %s '%s' with timeout after %"
FMT_TIMEDIFF_T " ms", peertype, ehost->dispname,
- Curl_timediff(Curl_now(), data->progress.t_startsingle));
+ curlx_timediff(curlx_now(), data->progress.t_startsingle));
return CURLE_OPERATION_TIMEDOUT;
}
else if(result) {
/* Do the unfailable inits first, before checks that may early return */
Curl_hash_init(&conn->meta_hash, 23,
- Curl_hash_str, Curl_str_key_compare, conn_meta_freeentry);
+ Curl_hash_str, curlx_str_key_compare, conn_meta_freeentry);
/* GSSAPI related inits */
Curl_sec_conn_init(conn);
#include "inet_ntop.h"
#include "strdup.h"
#include "idn.h"
-#include "strparse.h"
+#include "curlx/strparse.h"
#include "curl_memrchr.h"
/* The last 3 #include files should be in this order */
/* output the first piece as-is */
n = (const char *)host_sep - url;
- result = Curl_dyn_addn(o, url, n);
+ result = curlx_dyn_addn(o, url, n);
len -= n;
}
for(iptr = host_sep; len && !result; iptr++, len--) {
if(*iptr == ' ') {
if(left)
- result = Curl_dyn_addn(o, "%20", 3);
+ result = curlx_dyn_addn(o, "%20", 3);
else
- result = Curl_dyn_addn(o, "+", 1);
+ result = curlx_dyn_addn(o, "+", 1);
}
else if((*iptr < ' ') || (*iptr >= 0x7f)) {
unsigned char out[3]={'%'};
Curl_hexbyte(&out[1], *iptr, TRUE);
- result = Curl_dyn_addn(o, out, 3);
+ result = curlx_dyn_addn(o, out, 3);
}
else {
- result = Curl_dyn_addn(o, iptr, 1);
+ result = curlx_dyn_addn(o, iptr, 1);
if(*iptr == '?')
left = FALSE;
}
prelen = cutoff ? (size_t)(cutoff - base) : strlen(base);
/* build new URL */
- Curl_dyn_init(&urlbuf, CURL_MAX_INPUT_LENGTH);
+ curlx_dyn_init(&urlbuf, CURL_MAX_INPUT_LENGTH);
- if(!Curl_dyn_addn(&urlbuf, base, prelen) &&
+ if(!curlx_dyn_addn(&urlbuf, base, prelen) &&
!urlencode_str(&urlbuf, useurl, strlen(useurl), !host_changed, FALSE)) {
- uc = parseurl_and_replace(Curl_dyn_ptr(&urlbuf), u,
+ uc = parseurl_and_replace(curlx_dyn_ptr(&urlbuf), u,
flags & ~CURLU_PATH_AS_IS);
}
else
uc = CURLUE_OUT_OF_MEMORY;
- Curl_dyn_free(&urlbuf);
+ curlx_dyn_free(&urlbuf);
return uc;
}
bool has_scheme)
{
const char *portptr;
- char *hostname = Curl_dyn_ptr(host);
+ char *hostname = curlx_dyn_ptr(host);
/*
* Find the end of an IPv6 address on the ']' ending bracket.
*/
Do not do it if the URL has no scheme, to make something that looks like
a scheme not work!
*/
- Curl_dyn_setlen(host, keep);
+ curlx_dyn_setlen(host, keep);
portptr++;
if(!*portptr)
return has_scheme ? CURLUE_OK : CURLUE_BAD_PORT_NUMBER;
- if(Curl_str_number(&portptr, &port, 0xffff) || *portptr)
+ if(curlx_str_number(&portptr, &port, 0xffff) || *portptr)
return CURLUE_BAD_PORT_NUMBER;
u->portnum = (unsigned short) port;
{
bool done = FALSE;
int n = 0;
- const char *c = Curl_dyn_ptr(host);
+ const char *c = curlx_dyn_ptr(host);
unsigned int parts[4] = {0, 0, 0, 0};
CURLcode result = CURLE_OK;
if(*c == '0') {
if(c[1] == 'x') {
c += 2; /* skip the prefix */
- rc = Curl_str_hex(&c, &l, UINT_MAX);
+ rc = curlx_str_hex(&c, &l, UINT_MAX);
}
else
- rc = Curl_str_octal(&c, &l, UINT_MAX);
+ rc = curlx_str_octal(&c, &l, UINT_MAX);
}
else
- rc = Curl_str_number(&c, &l, UINT_MAX);
+ rc = curlx_str_number(&c, &l, UINT_MAX);
if(rc)
return HOST_NAME;
switch(n) {
case 0: /* a -- 32 bits */
- Curl_dyn_reset(host);
+ curlx_dyn_reset(host);
- result = Curl_dyn_addf(host, "%u.%u.%u.%u",
- (parts[0] >> 24),
- ((parts[0] >> 16) & 0xff),
- ((parts[0] >> 8) & 0xff),
- (parts[0] & 0xff));
+ result = curlx_dyn_addf(host, "%u.%u.%u.%u",
+ (parts[0] >> 24),
+ ((parts[0] >> 16) & 0xff),
+ ((parts[0] >> 8) & 0xff),
+ (parts[0] & 0xff));
break;
case 1: /* a.b -- 8.24 bits */
if((parts[0] > 0xff) || (parts[1] > 0xffffff))
return HOST_NAME;
- Curl_dyn_reset(host);
- result = Curl_dyn_addf(host, "%u.%u.%u.%u",
- (parts[0]),
- ((parts[1] >> 16) & 0xff),
- ((parts[1] >> 8) & 0xff),
- (parts[1] & 0xff));
+ curlx_dyn_reset(host);
+ result = curlx_dyn_addf(host, "%u.%u.%u.%u",
+ (parts[0]),
+ ((parts[1] >> 16) & 0xff),
+ ((parts[1] >> 8) & 0xff),
+ (parts[1] & 0xff));
break;
case 2: /* a.b.c -- 8.8.16 bits */
if((parts[0] > 0xff) || (parts[1] > 0xff) || (parts[2] > 0xffff))
return HOST_NAME;
- Curl_dyn_reset(host);
- result = Curl_dyn_addf(host, "%u.%u.%u.%u",
- (parts[0]),
- (parts[1]),
- ((parts[2] >> 8) & 0xff),
- (parts[2] & 0xff));
+ curlx_dyn_reset(host);
+ result = curlx_dyn_addf(host, "%u.%u.%u.%u",
+ (parts[0]),
+ (parts[1]),
+ ((parts[2] >> 8) & 0xff),
+ (parts[2] & 0xff));
break;
case 3: /* a.b.c.d -- 8.8.8.8 bits */
if((parts[0] > 0xff) || (parts[1] > 0xff) || (parts[2] > 0xff) ||
(parts[3] > 0xff))
return HOST_NAME;
- Curl_dyn_reset(host);
- result = Curl_dyn_addf(host, "%u.%u.%u.%u",
- (parts[0]),
- (parts[1]),
- (parts[2]),
- (parts[3]));
+ curlx_dyn_reset(host);
+ result = curlx_dyn_addf(host, "%u.%u.%u.%u",
+ (parts[0]),
+ (parts[1]),
+ (parts[2]),
+ (parts[3]));
break;
}
if(result)
static CURLUcode urldecode_host(struct dynbuf *host)
{
char *per = NULL;
- const char *hostname = Curl_dyn_ptr(host);
+ const char *hostname = curlx_dyn_ptr(host);
per = strchr(hostname, '%');
if(!per)
/* nothing to decode */
REJECT_CTRL);
if(result)
return CURLUE_BAD_HOSTNAME;
- Curl_dyn_reset(host);
- result = Curl_dyn_addn(host, decoded, dlen);
+ curlx_dyn_reset(host);
+ result = curlx_dyn_addn(host, decoded, dlen);
free(decoded);
if(result)
return cc2cu(result);
if(uc)
goto out;
- result = Curl_dyn_addn(host, auth + offset, authlen - offset);
+ result = curlx_dyn_addn(host, auth + offset, authlen - offset);
if(result) {
uc = cc2cu(result);
goto out;
if(uc)
goto out;
- if(!Curl_dyn_len(host))
+ if(!curlx_dyn_len(host))
return CURLUE_NO_HOST;
switch(ipv4_normalize(host)) {
case HOST_IPV4:
break;
case HOST_IPV6:
- uc = ipv6_parse(u, Curl_dyn_ptr(host), Curl_dyn_len(host));
+ uc = ipv6_parse(u, curlx_dyn_ptr(host), curlx_dyn_len(host));
break;
case HOST_NAME:
uc = urldecode_host(host);
if(!uc)
- uc = hostname_check(u, Curl_dyn_ptr(host), Curl_dyn_len(host));
+ uc = hostname_check(u, curlx_dyn_ptr(host), curlx_dyn_len(host));
break;
case HOST_ERROR:
uc = CURLUE_OUT_OF_MEMORY;
struct dynbuf host;
DEBUGASSERT(authority);
- Curl_dyn_init(&host, CURL_MAX_INPUT_LENGTH);
+ curlx_dyn_init(&host, CURL_MAX_INPUT_LENGTH);
result = parse_authority(u, authority, strlen(authority),
CURLU_DISALLOW_USER, &host, !!u->scheme);
if(result)
- Curl_dyn_free(&host);
+ curlx_dyn_free(&host);
else {
free(u->host);
- u->host = Curl_dyn_ptr(&host);
+ u->host = curlx_dyn_ptr(&host);
}
return result;
}
if(clen < 2)
return 0;
- Curl_dyn_init(&out, clen + 1);
+ curlx_dyn_init(&out, clen + 1);
/* A. If the input buffer begins with a prefix of "../" or "./", then
remove that prefix from the input buffer; otherwise, */
the input buffer; otherwise, */
if(is_dot(&p, &blen)) {
if(!blen) { /* /. */
- result = Curl_dyn_addn(&out, "/", 1);
+ result = curlx_dyn_addn(&out, "/", 1);
break;
}
else if(ISSLASH(*p)) { /* /./ */
preceding "/" (if any) from the output buffer; otherwise, */
else if(is_dot(&p, &blen) && (ISSLASH(*p) || !blen)) {
/* remove the last segment from the output buffer */
- size_t len = Curl_dyn_len(&out);
+ size_t len = curlx_dyn_len(&out);
if(len) {
- char *ptr = Curl_dyn_ptr(&out);
+ char *ptr = curlx_dyn_ptr(&out);
char *last = memrchr(ptr, '/', len);
if(last)
/* trim the output at the slash */
- Curl_dyn_setlen(&out, last - ptr);
+ curlx_dyn_setlen(&out, last - ptr);
}
if(blen) { /* /../ */
clen = blen;
continue;
}
- result = Curl_dyn_addn(&out, "/", 1);
+ result = curlx_dyn_addn(&out, "/", 1);
break;
}
}
any subsequent characters up to, but not including, the next "/"
character or the end of the input buffer. */
- result = Curl_dyn_addn(&out, input, 1);
+ result = curlx_dyn_addn(&out, input, 1);
input++;
clen--;
}
end:
if(!result) {
- if(Curl_dyn_len(&out))
- *outp = Curl_dyn_ptr(&out);
+ if(curlx_dyn_len(&out))
+ *outp = curlx_dyn_ptr(&out);
else {
*outp = strdup("");
if(!*outp)
DEBUGASSERT(url);
- Curl_dyn_init(&host, CURL_MAX_INPUT_LENGTH);
+ curlx_dyn_init(&host, CURL_MAX_INPUT_LENGTH);
result = Curl_junkscan(url, &urllen, !!(flags & CURLU_ALLOW_SPACE));
if(result)
len = path - ptr;
if(len) {
- CURLcode code = Curl_dyn_addn(&host, ptr, len);
+ CURLcode code = curlx_dyn_addn(&host, ptr, len);
if(code) {
result = cc2cu(code);
goto fail;
if(!uncpath)
/* no host for file: URLs by default */
- Curl_dyn_reset(&host);
+ curlx_dyn_reset(&host);
#if !defined(_WIN32) && !defined(MSDOS) && !defined(__CYGWIN__)
/* Do not allow Windows drive letters when not in Windows.
goto fail;
if((flags & CURLU_GUESS_SCHEME) && !schemep) {
- const char *hostname = Curl_dyn_ptr(&host);
+ const char *hostname = curlx_dyn_ptr(&host);
/* legacy curl-style guess based on hostname */
if(checkprefix("ftp.", hostname))
schemep = "ftp";
}
else if(flags & CURLU_NO_AUTHORITY) {
/* allowed to be empty. */
- if(Curl_dyn_add(&host, "")) {
+ if(curlx_dyn_add(&host, "")) {
result = CURLUE_OUT_OF_MEMORY;
goto fail;
}
/* skip the leading '#' in the copy but include the terminating null */
if(flags & CURLU_URLENCODE) {
struct dynbuf enc;
- Curl_dyn_init(&enc, CURL_MAX_INPUT_LENGTH);
+ curlx_dyn_init(&enc, CURL_MAX_INPUT_LENGTH);
result = urlencode_str(&enc, fragment + 1, fraglen - 1, TRUE, FALSE);
if(result)
goto fail;
- u->fragment = Curl_dyn_ptr(&enc);
+ u->fragment = curlx_dyn_ptr(&enc);
}
else {
u->fragment = Curl_memdup0(fragment + 1, fraglen - 1);
if(qlen > 1) {
if(flags & CURLU_URLENCODE) {
struct dynbuf enc;
- Curl_dyn_init(&enc, CURL_MAX_INPUT_LENGTH);
+ curlx_dyn_init(&enc, CURL_MAX_INPUT_LENGTH);
/* skip the leading question mark */
result = urlencode_str(&enc, query + 1, qlen - 1, TRUE, TRUE);
if(result)
goto fail;
- u->query = Curl_dyn_ptr(&enc);
+ u->query = curlx_dyn_ptr(&enc);
}
else {
u->query = Curl_memdup0(query + 1, qlen - 1);
if(pathlen && (flags & CURLU_URLENCODE)) {
struct dynbuf enc;
- Curl_dyn_init(&enc, CURL_MAX_INPUT_LENGTH);
+ curlx_dyn_init(&enc, CURL_MAX_INPUT_LENGTH);
result = urlencode_str(&enc, path, pathlen, TRUE, FALSE);
if(result)
goto fail;
- pathlen = Curl_dyn_len(&enc);
- path = u->path = Curl_dyn_ptr(&enc);
+ pathlen = curlx_dyn_len(&enc);
+ path = u->path = curlx_dyn_ptr(&enc);
}
if(pathlen <= 1) {
}
}
- u->host = Curl_dyn_ptr(&host);
+ u->host = curlx_dyn_ptr(&host);
return result;
fail:
- Curl_dyn_free(&host);
+ curlx_dyn_free(&host);
free_urlhandle(u);
return result;
}
/* make it '[ host %25 zoneid ]' */
struct dynbuf enc;
size_t hostlen = strlen(u->host);
- Curl_dyn_init(&enc, CURL_MAX_INPUT_LENGTH);
- if(Curl_dyn_addf(&enc, "%.*s%%25%s]", (int)hostlen - 1, u->host,
- u->zoneid))
+ curlx_dyn_init(&enc, CURL_MAX_INPUT_LENGTH);
+ if(curlx_dyn_addf(&enc, "%.*s%%25%s]", (int)hostlen - 1, u->host,
+ u->zoneid))
return CURLUE_OUT_OF_MEMORY;
- allochost = Curl_dyn_ptr(&enc);
+ allochost = curlx_dyn_ptr(&enc);
}
}
else if(urlencode) {
if(urlencode) {
struct dynbuf enc;
CURLUcode uc;
- Curl_dyn_init(&enc, CURL_MAX_INPUT_LENGTH);
+ curlx_dyn_init(&enc, CURL_MAX_INPUT_LENGTH);
uc = urlencode_str(&enc, *part, partlen, TRUE, what == CURLUPART_QUERY);
if(uc)
return uc;
free(*part);
- *part = Curl_dyn_ptr(&enc);
+ *part = curlx_dyn_ptr(&enc);
}
else if(punycode) {
if(!Curl_is_ASCII_name(u->host)) {
else {
char *tmp;
curl_off_t port;
- if(Curl_str_number(&part, &port, 0xffff) || *part)
+ if(curlx_str_number(&part, &port, 0xffff) || *part)
/* weirdly provided number, not good! */
return CURLUE_BAD_PORT_NUMBER;
tmp = aprintf("%" CURL_FORMAT_CURL_OFF_T, port);
{
const char *newp;
struct dynbuf enc;
- Curl_dyn_init(&enc, nalloc * 3 + 1 + leadingslash);
+ curlx_dyn_init(&enc, nalloc * 3 + 1 + leadingslash);
if(leadingslash && (part[0] != '/')) {
- CURLcode result = Curl_dyn_addn(&enc, "/", 1);
+ CURLcode result = curlx_dyn_addn(&enc, "/", 1);
if(result)
return cc2cu(result);
}
for(i = (const unsigned char *)part; *i; i++) {
CURLcode result;
if((*i == ' ') && plusencode) {
- result = Curl_dyn_addn(&enc, "+", 1);
+ result = curlx_dyn_addn(&enc, "+", 1);
if(result)
return CURLUE_OUT_OF_MEMORY;
}
if((*i == '=') && equalsencode)
/* only skip the first equals sign */
equalsencode = FALSE;
- result = Curl_dyn_addn(&enc, i, 1);
+ result = curlx_dyn_addn(&enc, i, 1);
if(result)
return cc2cu(result);
}
else {
unsigned char out[3]={'%'};
Curl_hexbyte(&out[1], *i, TRUE);
- result = Curl_dyn_addn(&enc, out, 3);
+ result = curlx_dyn_addn(&enc, out, 3);
if(result)
return cc2cu(result);
}
}
else {
char *p;
- CURLcode result = Curl_dyn_add(&enc, part);
+ CURLcode result = curlx_dyn_add(&enc, part);
if(result)
return cc2cu(result);
- p = Curl_dyn_ptr(&enc);
+ p = curlx_dyn_ptr(&enc);
while(*p) {
/* make sure percent encoded are lower case */
if((*p == '%') && ISXDIGIT(p[1]) && ISXDIGIT(p[2]) &&
p++;
}
}
- newp = Curl_dyn_ptr(&enc);
+ newp = curlx_dyn_ptr(&enc);
if(appendquery && newp) {
/* Append the 'newp' string onto the old query. Add a '&' separator if
bool addamperand = querylen && (u->query[querylen -1] != '&');
if(querylen) {
struct dynbuf qbuf;
- Curl_dyn_init(&qbuf, CURL_MAX_INPUT_LENGTH);
+ curlx_dyn_init(&qbuf, CURL_MAX_INPUT_LENGTH);
- if(Curl_dyn_addn(&qbuf, u->query, querylen)) /* add original query */
+ if(curlx_dyn_addn(&qbuf, u->query, querylen)) /* add original query */
goto nomem;
if(addamperand) {
- if(Curl_dyn_addn(&qbuf, "&", 1))
+ if(curlx_dyn_addn(&qbuf, "&", 1))
goto nomem;
}
- if(Curl_dyn_add(&qbuf, newp))
+ if(curlx_dyn_add(&qbuf, newp))
goto nomem;
- Curl_dyn_free(&enc);
+ curlx_dyn_free(&enc);
free(*storep);
- *storep = Curl_dyn_ptr(&qbuf);
+ *storep = curlx_dyn_ptr(&qbuf);
return CURLUE_OK;
nomem:
- Curl_dyn_free(&enc);
+ curlx_dyn_free(&enc);
return CURLUE_OUT_OF_MEMORY;
}
}
else if(what == CURLUPART_HOST) {
- size_t n = Curl_dyn_len(&enc);
+ size_t n = curlx_dyn_len(&enc);
if(!n && (flags & CURLU_NO_AUTHORITY)) {
/* Skip hostname check, it is allowed to be empty. */
}
else if(hostname_check(u, (char *)CURL_UNCONST(newp), n))
bad = TRUE;
if(bad) {
- Curl_dyn_free(&enc);
+ curlx_dyn_free(&enc);
return CURLUE_BAD_HOSTNAME;
}
}
#include <netinet/in6.h>
#endif
-#include "timeval.h"
+#include "curlx/timeval.h"
#include <curl/curl.h>
#include "hostip.h"
#include "hash.h"
#include "splay.h"
-#include "dynbuf.h"
+#include "curlx/dynbuf.h"
#include "dynhds.h"
#include "request.h"
#include "netrc.h"
#include "../urldata.h"
#include "vauth.h"
-#include "../warnless.h"
+#include "../curlx/warnless.h"
#include "../sendf.h"
#include "../curl_printf.h"
#include "vauth.h"
#include "../curl_hmac.h"
#include "../curl_md5.h"
-#include "../warnless.h"
+#include "../curlx/warnless.h"
#include "../curl_printf.h"
/* The last #include files should be: */
#include "vauth.h"
#include "digest.h"
#include "../urldata.h"
-#include "../curl_base64.h"
+#include "../curlx/base64.h"
#include "../curl_hmac.h"
#include "../curl_md5.h"
#include "../curl_sha256.h"
#include "../curl_sha512_256.h"
#include "../vtls/vtls.h"
-#include "../warnless.h"
-#include "../strparse.h"
+#include "../curlx/warnless.h"
+#include "../curlx/strparse.h"
#include "../strcase.h"
#include "../curl_printf.h"
#include "../rand.h"
/* Initialise the output */
*value = 0;
- while(!Curl_str_until(&options, &out, 32, ',')) {
- if(Curl_str_casecompare(&out, DIGEST_QOP_VALUE_STRING_AUTH))
+ while(!curlx_str_until(&options, &out, 32, ',')) {
+ if(curlx_str_casecompare(&out, DIGEST_QOP_VALUE_STRING_AUTH))
*value |= DIGEST_QOP_VALUE_AUTH;
- else if(Curl_str_casecompare(&out, DIGEST_QOP_VALUE_STRING_AUTH_INT))
+ else if(curlx_str_casecompare(&out, DIGEST_QOP_VALUE_STRING_AUTH_INT))
*value |= DIGEST_QOP_VALUE_AUTH_INT;
- else if(Curl_str_casecompare(&out, DIGEST_QOP_VALUE_STRING_AUTH_CONF))
+ else if(curlx_str_casecompare(&out, DIGEST_QOP_VALUE_STRING_AUTH_CONF))
*value |= DIGEST_QOP_VALUE_AUTH_CONF;
- if(Curl_str_single(&options, ','))
+ if(curlx_str_single(&options, ','))
break;
}
/* Pass leading spaces */
while(*token && ISBLANK(*token))
token++;
- while(!Curl_str_until(&token, &out, 32, ',')) {
- if(Curl_str_casecompare(&out, DIGEST_QOP_VALUE_STRING_AUTH))
+ while(!curlx_str_until(&token, &out, 32, ',')) {
+ if(curlx_str_casecompare(&out, DIGEST_QOP_VALUE_STRING_AUTH))
foundAuth = TRUE;
- else if(Curl_str_casecompare(&out,
+ else if(curlx_str_casecompare(&out,
DIGEST_QOP_VALUE_STRING_AUTH_INT))
foundAuthInt = TRUE;
- if(Curl_str_single(&token, ','))
+ if(curlx_str_single(&token, ','))
break;
while(*token && ISBLANK(*token))
token++;
if(result)
return result;
- result = Curl_base64_encode(cnoncebuf, sizeof(cnoncebuf),
- &cnonce, &cnonce_sz);
+ result = curlx_base64_encode(cnoncebuf, sizeof(cnoncebuf),
+ &cnonce, &cnonce_sz);
if(result)
return result;
#include "vauth.h"
#include "digest.h"
#include "../urldata.h"
-#include "../warnless.h"
+#include "../curlx/warnless.h"
#include "../curl_multibyte.h"
#include "../sendf.h"
#include "../strdup.h"
#include "vauth.h"
#include "../urldata.h"
-#include "../warnless.h"
+#include "../curlx/warnless.h"
#include "../curl_multibyte.h"
#include "../sendf.h"
#include "../curl_gethostname.h"
#include "../curl_multibyte.h"
#include "../curl_md5.h"
-#include "../warnless.h"
+#include "../curlx/warnless.h"
#include "../rand.h"
#include "../vtls/vtls.h"
#include "../strdup.h"
#include "vauth.h"
#include "../urldata.h"
#include "../curl_ntlm_core.h"
-#include "../warnless.h"
+#include "../curlx/warnless.h"
#include "../curl_multibyte.h"
#include "../sendf.h"
#include "../strdup.h"
#include "../urldata.h"
#include "vauth.h"
-#include "../warnless.h"
+#include "../curlx/warnless.h"
#include "../curl_printf.h"
/* The last #include files should be: */
#include "vauth.h"
#include "../urldata.h"
-#include "../curl_base64.h"
+#include "../curlx/base64.h"
#include "../curl_gssapi.h"
-#include "../warnless.h"
+#include "../curlx/warnless.h"
#include "../curl_multibyte.h"
#include "../sendf.h"
if(chlg64 && *chlg64) {
/* Decode the base-64 encoded challenge message */
if(*chlg64 != '=') {
- result = Curl_base64_decode(chlg64, &chlg, &chlglen);
+ result = curlx_base64_decode(chlg64, &chlg, &chlglen);
if(result)
return result;
}
}
/* Set channel binding data if available */
- if(Curl_dyn_len(&nego->channel_binding_data)) {
+ if(curlx_dyn_len(&nego->channel_binding_data)) {
memset(&chan, 0, sizeof(struct gss_channel_bindings_struct));
- chan.application_data.length = Curl_dyn_len(&nego->channel_binding_data);
- chan.application_data.value = Curl_dyn_ptr(&nego->channel_binding_data);
+ chan.application_data.length = curlx_dyn_len(&nego->channel_binding_data);
+ chan.application_data.value = curlx_dyn_ptr(&nego->channel_binding_data);
chan_bindings = &chan;
}
OM_uint32 minor_status;
/* Base64 encode the already generated response */
- result = Curl_base64_encode(nego->output_token.value,
- nego->output_token.length,
- outptr, outlen);
+ result = curlx_base64_encode(nego->output_token.value,
+ nego->output_token.length,
+ outptr, outlen);
if(result) {
gss_release_buffer(&minor_status, &nego->output_token);
#include "vauth.h"
#include "../urldata.h"
-#include "../curl_base64.h"
-#include "../warnless.h"
+#include "../curlx/base64.h"
+#include "../curlx/warnless.h"
#include "../curl_multibyte.h"
#include "../sendf.h"
#include "../strerror.h"
if(chlg64 && *chlg64) {
/* Decode the base-64 encoded challenge message */
if(*chlg64 != '=') {
- result = Curl_base64_decode(chlg64, &chlg, &chlglen);
+ result = curlx_base64_decode(chlg64, &chlg, &chlglen);
if(result)
return result;
}
char **outptr, size_t *outlen)
{
/* Base64 encode the already generated response */
- CURLcode result = Curl_base64_encode((const char *) nego->output_token,
- nego->output_token_length, outptr,
- outlen);
+ CURLcode result = curlx_base64_encode((const char *) nego->output_token,
+ nego->output_token_length, outptr,
+ outlen);
if(!result && (!*outptr || !*outlen)) {
free(*outptr);
result = CURLE_REMOTE_ACCESS_DENIED;
#include <curl/curl.h>
#include "version_win32.h"
-#include "warnless.h"
+#include "curlx/warnless.h"
/* The last 2 #include files should be in this order */
-#ifdef BUILDING_LIBCURL
#include "curl_memory.h"
-#endif
#include "memdebug.h"
/* This Unicode version struct works for VerifyVersionInfoW (OSVERSIONINFOEXW)
#include "../urldata.h"
#include "../hash.h"
#include "../uint-hash.h"
-#include "../timeval.h"
+#include "../curlx/timeval.h"
#include "../multiif.h"
#include "../sendf.h"
#include "../curl_trc.h"
*done = FALSE;
if(!ctx->qconn) {
- ctx->connect_started = Curl_now();
+ ctx->connect_started = curlx_now();
result = cf_connect_start(cf, data);
if(result)
goto out;
}
if(ctx->handshake_complete) {
- ctx->handshake_at = Curl_now();
+ ctx->handshake_at = curlx_now();
if(ctx->handshake_succeeded) {
CURL_TRC_CF(data, cf, "handshake succeeded");
cf->conn->bits.multiplex = TRUE; /* at least potentially multiplexed */
#include "../connect.h"
#include "../progress.h"
#include "../strerror.h"
-#include "../dynbuf.h"
+#include "../curlx/dynbuf.h"
#include "../http1.h"
#include "../select.h"
#include "../inet_pton.h"
#include "../vtls/vtls_scache.h"
#include "curl_ngtcp2.h"
-#include "../warnless.h"
+#include "../curlx/warnless.h"
/* The last 3 #include files should be in this order */
#include "../curl_printf.h"
ctx->max_stream_window = H3_STREAM_WINDOW_SIZE;
Curl_bufcp_init(&ctx->stream_bufcp, H3_STREAM_CHUNK_SIZE,
H3_STREAM_POOL_SPARES);
- Curl_dyn_init(&ctx->scratch, CURL_MAX_HTTP_HEADER);
+ curlx_dyn_init(&ctx->scratch, CURL_MAX_HTTP_HEADER);
Curl_uint_hash_init(&ctx->streams, 63, h3_stream_hash_free);
ctx->initialized = TRUE;
}
Curl_vquic_tls_cleanup(&ctx->tls);
vquic_ctx_free(&ctx->q);
Curl_bufcp_free(&ctx->stream_bufcp);
- Curl_dyn_free(&ctx->scratch);
+ curlx_dyn_free(&ctx->scratch);
Curl_uint_hash_destroy(&ctx->streams);
Curl_ssl_peer_cleanup(&ctx->peer);
}
if(!ctx || !data)
return NGHTTP3_ERR_CALLBACK_FAILURE;
- ctx->handshake_at = Curl_now();
+ ctx->handshake_at = curlx_now();
ctx->tls_handshake_complete = TRUE;
cf->conn->bits.multiplex = TRUE; /* at least potentially multiplexed */
ctx->tls_vrfy_result = Curl_vquic_tls_verify_peer(&ctx->tls, cf,
data, &ctx->peer);
CURL_TRC_CF(data, cf, "handshake complete after %dms",
- (int)Curl_timediff(ctx->handshake_at, ctx->started_at));
+ (int)curlx_timediff(ctx->handshake_at, ctx->started_at));
/* In case of earlydata, where we simulate being connected, update
* the handshake time when we really did connect */
if(ctx->use_earlydata)
(const char *)h3val.base, h3val.len);
if(result)
return -1;
- Curl_dyn_reset(&ctx->scratch);
- result = Curl_dyn_addn(&ctx->scratch, STRCONST("HTTP/3 "));
+ curlx_dyn_reset(&ctx->scratch);
+ result = curlx_dyn_addn(&ctx->scratch, STRCONST("HTTP/3 "));
if(!result)
- result = Curl_dyn_addn(&ctx->scratch,
- (const char *)h3val.base, h3val.len);
+ result = curlx_dyn_addn(&ctx->scratch,
+ (const char *)h3val.base, h3val.len);
if(!result)
- result = Curl_dyn_addn(&ctx->scratch, STRCONST(" \r\n"));
+ result = curlx_dyn_addn(&ctx->scratch, STRCONST(" \r\n"));
if(!result)
- h3_xfer_write_resp_hd(cf, data, stream, Curl_dyn_ptr(&ctx->scratch),
- Curl_dyn_len(&ctx->scratch), FALSE);
+ h3_xfer_write_resp_hd(cf, data, stream, curlx_dyn_ptr(&ctx->scratch),
+ curlx_dyn_len(&ctx->scratch), FALSE);
CURL_TRC_CF(data, cf, "[%" FMT_PRId64 "] status: %s",
- stream_id, Curl_dyn_ptr(&ctx->scratch));
+ stream_id, curlx_dyn_ptr(&ctx->scratch));
if(result) {
return -1;
}
CURL_TRC_CF(data, cf, "[%" FMT_PRId64 "] header: %.*s: %.*s",
stream_id, (int)h3name.len, h3name.base,
(int)h3val.len, h3val.base);
- Curl_dyn_reset(&ctx->scratch);
- result = Curl_dyn_addn(&ctx->scratch,
- (const char *)h3name.base, h3name.len);
+ curlx_dyn_reset(&ctx->scratch);
+ result = curlx_dyn_addn(&ctx->scratch,
+ (const char *)h3name.base, h3name.len);
if(!result)
- result = Curl_dyn_addn(&ctx->scratch, STRCONST(": "));
+ result = curlx_dyn_addn(&ctx->scratch, STRCONST(": "));
if(!result)
- result = Curl_dyn_addn(&ctx->scratch,
- (const char *)h3val.base, h3val.len);
+ result = curlx_dyn_addn(&ctx->scratch,
+ (const char *)h3val.base, h3val.len);
if(!result)
- result = Curl_dyn_addn(&ctx->scratch, STRCONST("\r\n"));
+ result = curlx_dyn_addn(&ctx->scratch, STRCONST("\r\n"));
if(!result)
- h3_xfer_write_resp_hd(cf, data, stream, Curl_dyn_ptr(&ctx->scratch),
- Curl_dyn_len(&ctx->scratch), FALSE);
+ h3_xfer_write_resp_hd(cf, data, stream, curlx_dyn_ptr(&ctx->scratch),
+ curlx_dyn_len(&ctx->scratch), FALSE);
}
return 0;
}
}
*done = FALSE;
- now = Curl_now();
+ now = curlx_now();
pktx_init(&pktx, cf, data);
CF_DATA_SAVE(save, cf, data);
}
case CF_QUERY_CONNECT_REPLY_MS:
if(ctx->q.got_first_byte) {
- timediff_t ms = Curl_timediff(ctx->q.first_byte_at, ctx->started_at);
+ timediff_t ms = curlx_timediff(ctx->q.first_byte_at, ctx->started_at);
*pres1 = (ms < INT_MAX) ? (int)ms : INT_MAX;
}
else
* it will close the connection when it expires. */
rp = ngtcp2_conn_get_remote_transport_params(ctx->qconn);
if(rp && rp->max_idle_timeout) {
- timediff_t idletime = Curl_timediff(Curl_now(), ctx->q.last_io);
+ timediff_t idletime = curlx_timediff(curlx_now(), ctx->q.last_io);
if(idletime > 0 && (uint64_t)idletime > rp->max_idle_timeout)
goto out;
}
#include "../connect.h"
#include "../progress.h"
#include "../strerror.h"
-#include "../dynbuf.h"
+#include "../curlx/dynbuf.h"
#include "../http1.h"
#include "../select.h"
#include "../inet_pton.h"
#include "../vtls/vtls.h"
#include "../vtls/openssl.h"
#include "curl_osslq.h"
-
-#include "../warnless.h"
+#include "../curlx/warnless.h"
/* The last 3 #include files should be in this order */
#include "../curl_printf.h"
if(acked_len > 0 || (eos && !s->send_blocked)) {
/* Since QUIC buffers the data written internally, we can tell
* nghttp3 that it can move forward on it */
- ctx->q.last_io = Curl_now();
+ ctx->q.last_io = curlx_now();
rv = nghttp3_conn_add_write_offset(ctx->h3.conn, s->id, acked_len);
if(rv && rv != NGHTTP3_ERR_STREAM_NOT_FOUND) {
failf(data, "nghttp3_conn_add_write_offset returned error: %s\n",
}
*done = FALSE;
- now = Curl_now();
+ now = curlx_now();
CF_DATA_SAVE(save, cf, data);
if(!ctx->tls.ossl.ssl) {
int readable = SOCKET_READABLE(ctx->q.sockfd, 0);
if(readable > 0 && (readable & CURL_CSELECT_IN)) {
ctx->got_first_byte = TRUE;
- ctx->first_byte_at = Curl_now();
+ ctx->first_byte_at = curlx_now();
}
}
ctx->handshake_at = now;
ctx->q.last_io = now;
CURL_TRC_CF(data, cf, "handshake complete after %dms",
- (int)Curl_timediff(now, ctx->started_at));
+ (int)curlx_timediff(now, ctx->started_at));
result = cf_osslq_verify_peer(cf, data);
if(!result) {
CURL_TRC_CF(data, cf, "peer verified");
goto out;
}
CURL_TRC_CF(data, cf, "negotiated idle timeout: %zums", (size_t)idle_ms);
- idletime = Curl_timediff(Curl_now(), ctx->q.last_io);
+ idletime = curlx_timediff(curlx_now(), ctx->q.last_io);
if(idletime > 0 && (uint64_t)idletime > idle_ms)
goto out;
}
}
case CF_QUERY_CONNECT_REPLY_MS:
if(ctx->got_first_byte) {
- timediff_t ms = Curl_timediff(ctx->first_byte_at, ctx->started_at);
+ timediff_t ms = curlx_timediff(ctx->first_byte_at, ctx->started_at);
*pres1 = (ms < INT_MAX) ? (int)ms : INT_MAX;
}
else
if(quiche_conn_is_established(ctx->qconn)) {
ctx->handshake_at = ctx->q.last_op;
CURL_TRC_CF(data, cf, "handshake complete after %dms",
- (int)Curl_timediff(ctx->handshake_at, ctx->started_at));
+ (int)curlx_timediff(ctx->handshake_at, ctx->started_at));
result = cf_quiche_verify_peer(cf, data);
if(!result) {
CURL_TRC_CF(data, cf, "peer verified");
}
case CF_QUERY_CONNECT_REPLY_MS:
if(ctx->q.got_first_byte) {
- timediff_t ms = Curl_timediff(ctx->q.first_byte_at, ctx->started_at);
+ timediff_t ms = curlx_timediff(ctx->q.first_byte_at, ctx->started_at);
*pres1 = (ms < INT_MAX) ? (int)ms : INT_MAX;
}
else
#endif
#include "../urldata.h"
#include "../bufq.h"
-#include "../dynbuf.h"
+#include "../curlx/dynbuf.h"
#include "../cfilters.h"
#include "../curl_trc.h"
#include "curl_msh3.h"
#include "vquic.h"
#include "vquic_int.h"
#include "../strerror.h"
-#include "../strparse.h"
+#include "../curlx/strparse.h"
/* The last 3 #include files should be in this order */
#include "../curl_printf.h"
const char *p = getenv("CURL_DBG_QUIC_WBLOCK");
if(p) {
curl_off_t l;
- if(!Curl_str_number(&p, &l, 100))
+ if(!curlx_str_number(&p, &l, 100))
qctx->wblock_percent = (int)l;
}
}
void vquic_ctx_update_time(struct cf_quic_ctx *qctx)
{
- qctx->last_op = Curl_now();
+ qctx->last_op = curlx_now();
}
static CURLcode send_packet_no_gso(struct Curl_cfilter *cf,
struct dynbuf fname;
CURLcode result;
unsigned int i;
- Curl_dyn_init(&fname, DYN_QLOG_NAME);
- result = Curl_dyn_add(&fname, qlog_dir);
+ curlx_dyn_init(&fname, DYN_QLOG_NAME);
+ result = curlx_dyn_add(&fname, qlog_dir);
if(!result)
- result = Curl_dyn_add(&fname, "/");
+ result = curlx_dyn_add(&fname, "/");
for(i = 0; (i < scidlen) && !result; i++) {
char hex[3];
msnprintf(hex, 3, "%02x", scid[i]);
- result = Curl_dyn_add(&fname, hex);
+ result = curlx_dyn_add(&fname, hex);
}
if(!result)
- result = Curl_dyn_add(&fname, ".sqlog");
+ result = curlx_dyn_add(&fname, ".sqlog");
if(!result) {
- int qlogfd = open(Curl_dyn_ptr(&fname), O_WRONLY|O_CREAT|CURL_O_BINARY,
+ int qlogfd = open(curlx_dyn_ptr(&fname), O_WRONLY|O_CREAT|CURL_O_BINARY,
data->set.new_file_perms);
if(qlogfd != -1)
*qlogfdp = qlogfd;
}
- Curl_dyn_free(&fname);
+ curlx_dyn_free(&fname);
if(result)
return result;
}
return result;
/* new path to switch to in case we need to */
- Curl_dyn_init(&npath, MAX_SSHPATH_LEN);
+ curlx_dyn_init(&npath, MAX_SSHPATH_LEN);
/* Check for /~/, indicating relative to the user's home directory */
if((data->conn->handler->protocol & CURLPROTO_SCP) &&
(working_path_len > 3) && (!memcmp(working_path, "/~/", 3))) {
/* It is referenced to the home directory, so strip the leading '/~/' */
- if(Curl_dyn_addn(&npath, &working_path[3], working_path_len - 3)) {
+ if(curlx_dyn_addn(&npath, &working_path[3], working_path_len - 3)) {
free(working_path);
return CURLE_OUT_OF_MEMORY;
}
else if((data->conn->handler->protocol & CURLPROTO_SFTP) &&
(!strcmp("/~", working_path) ||
((working_path_len > 2) && !memcmp(working_path, "/~/", 3)))) {
- if(Curl_dyn_add(&npath, homedir)) {
+ if(curlx_dyn_add(&npath, homedir)) {
free(working_path);
return CURLE_OUT_OF_MEMORY;
}
const char *p;
int copyfrom = 3;
/* Copy a separating '/' if homedir does not end with one */
- len = Curl_dyn_len(&npath);
- p = Curl_dyn_ptr(&npath);
+ len = curlx_dyn_len(&npath);
+ p = curlx_dyn_ptr(&npath);
if(len && (p[len-1] != '/'))
copyfrom = 2;
- if(Curl_dyn_addn(&npath,
- &working_path[copyfrom], working_path_len - copyfrom)) {
+ if(curlx_dyn_addn(&npath, &working_path[copyfrom],
+ working_path_len - copyfrom)) {
free(working_path);
return CURLE_OUT_OF_MEMORY;
}
}
}
- if(Curl_dyn_len(&npath)) {
+ if(curlx_dyn_len(&npath)) {
free(working_path);
/* store the pointer for the caller to receive */
- *path = Curl_dyn_ptr(&npath);
+ *path = curlx_dyn_ptr(&npath);
}
else
*path = working_path;
if(!*cp || !homedir)
return CURLE_QUOTE_ERROR;
- Curl_dyn_init(&out, MAX_PATHLENGTH);
+ curlx_dyn_init(&out, MAX_PATHLENGTH);
/* Ignore leading whitespace */
cp += strspn(cp, WHITESPACE);
goto fail;
}
}
- result = Curl_dyn_addn(&out, &cp[i], 1);
+ result = curlx_dyn_addn(&out, &cp[i], 1);
if(result)
return result;
}
- if(!Curl_dyn_len(&out))
+ if(!curlx_dyn_len(&out))
goto fail;
/* return pointer to second parameter if it exists */
/* Handling for relative path - prepend home directory */
if(cp[0] == '/' && cp[1] == '~' && cp[2] == '/') {
- result = Curl_dyn_add(&out, homedir);
+ result = curlx_dyn_add(&out, homedir);
if(!result)
- result = Curl_dyn_addn(&out, "/", 1);
+ result = curlx_dyn_addn(&out, "/", 1);
if(result)
return result;
cp += 3;
}
/* Copy path name up until first "whitespace" */
- result = Curl_dyn_addn(&out, cp, (end - cp));
+ result = curlx_dyn_addn(&out, cp, (end - cp));
if(result)
return result;
}
- *path = Curl_dyn_ptr(&out);
+ *path = curlx_dyn_ptr(&out);
return CURLE_OK;
fail:
- Curl_dyn_free(&out);
+ curlx_dyn_free(&out);
return CURLE_QUOTE_ERROR;
}
#include "../inet_ntop.h"
#include "../parsedate.h" /* for the week day and month names */
#include "../sockaddr.h" /* required for Curl_sockaddr_storage */
-#include "../strparse.h"
+#include "../curlx/strparse.h"
#include "../multiif.h"
#include "../select.h"
-#include "../warnless.h"
+#include "../curlx/warnless.h"
#include "curl_path.h"
#ifdef HAVE_SYS_STAT_H
break;
case SSH_SFTP_READDIR:
- Curl_dyn_reset(&sshc->readdir_buf);
+ curlx_dyn_reset(&sshc->readdir_buf);
if(sshc->readdir_attrs)
sftp_attributes_free(sshc->readdir_attrs);
}
else {
- if(Curl_dyn_add(&sshc->readdir_buf, sshc->readdir_longentry)) {
+ if(curlx_dyn_add(&sshc->readdir_buf, sshc->readdir_longentry)) {
sshc->actualcode = CURLE_OUT_OF_MEMORY;
state(data, SSH_STOP);
break;
Curl_safefree(sshc->readdir_linkPath);
- if(Curl_dyn_addf(&sshc->readdir_buf, " -> %s",
- sshc->readdir_filename)) {
+ if(curlx_dyn_addf(&sshc->readdir_buf, " -> %s",
+ sshc->readdir_filename)) {
sshc->actualcode = CURLE_OUT_OF_MEMORY;
break;
}
state(data, SSH_SFTP_READDIR_BOTTOM);
FALLTHROUGH();
case SSH_SFTP_READDIR_BOTTOM:
- if(Curl_dyn_addn(&sshc->readdir_buf, "\n", 1))
+ if(curlx_dyn_addn(&sshc->readdir_buf, "\n", 1))
result = CURLE_OUT_OF_MEMORY;
else
result = Curl_client_write(data, CLIENTWRITE_BODY,
- Curl_dyn_ptr(&sshc->readdir_buf),
- Curl_dyn_len(&sshc->readdir_buf));
+ curlx_dyn_ptr(&sshc->readdir_buf),
+ curlx_dyn_len(&sshc->readdir_buf));
ssh_string_free_char(sshc->readdir_tmp);
sshc->readdir_tmp = NULL;
const char *p = data->state.range;
int from_t, to_t;
- from_t = Curl_str_number(&p, &from, CURL_OFF_T_MAX);
+ from_t = curlx_str_number(&p, &from, CURL_OFF_T_MAX);
if(from_t == STRE_OVERFLOW)
return CURLE_RANGE_ERROR;
- Curl_str_passblanks(&p);
- (void)Curl_str_single(&p, '-');
+ curlx_str_passblanks(&p);
+ (void)curlx_str_single(&p, '-');
- to_t = Curl_str_numblanks(&p, &to);
+ to_t = curlx_str_numblanks(&p, &to);
if(to_t == STRE_OVERFLOW)
return CURLE_RANGE_ERROR;
while((sshc->state != SSH_STOP) && !result) {
bool block;
timediff_t left = 1000;
- struct curltime now = Curl_now();
+ struct curltime now = curlx_now();
result = myssh_statemach_act(data, &block);
if(result)
struct ssh_conn *sshc = &conn->proto.sshc;
if(!sshc->initialised) {
- Curl_dyn_init(&sshc->readdir_buf, CURL_PATH_MAX * 2);
+ curlx_dyn_init(&sshc->readdir_buf, CURL_PATH_MAX * 2);
sshc->initialised = TRUE;
}
Curl_safefree(sshc->rsa);
Curl_safefree(sshc->quote_path1);
Curl_safefree(sshc->quote_path2);
- Curl_dyn_free(&sshc->readdir_buf);
+ curlx_dyn_free(&sshc->readdir_buf);
Curl_safefree(sshc->readdir_linkPath);
SSH_STRING_FREE_CHAR(sshc->homedir);
sshc->initialised = FALSE;
if(!strncmp(cmd, "chgrp", 5)) {
const char *p = sshc->quote_path1;
curl_off_t gid;
- (void)Curl_str_number(&p, &gid, UINT_MAX);
+ (void)curlx_str_number(&p, &gid, UINT_MAX);
sshc->quote_attrs->gid = (uint32_t)gid;
if(sshc->quote_attrs->gid == 0 && !ISDIGIT(sshc->quote_path1[0]) &&
!sshc->acceptfail) {
else if(!strncmp(cmd, "chmod", 5)) {
curl_off_t perms;
const char *p = sshc->quote_path1;
- if(Curl_str_octal(&p, &perms, 07777)) {
+ if(curlx_str_octal(&p, &perms, 07777)) {
Curl_safefree(sshc->quote_path1);
Curl_safefree(sshc->quote_path2);
failf(data, "Syntax error: chmod permissions not a number");
else if(!strncmp(cmd, "chown", 5)) {
const char *p = sshc->quote_path1;
curl_off_t uid;
- (void)Curl_str_number(&p, &uid, UINT_MAX);
+ (void)curlx_str_number(&p, &uid, UINT_MAX);
if(sshc->quote_attrs->uid == 0 && !ISDIGIT(sshc->quote_path1[0]) &&
!sshc->acceptfail) {
Curl_safefree(sshc->quote_path1);
#include "../sockaddr.h" /* required for Curl_sockaddr_storage */
#include "../multiif.h"
#include "../select.h"
-#include "../warnless.h"
+#include "../curlx/warnless.h"
#include "curl_path.h"
-#include "../strparse.h"
-#include "../curl_base64.h" /* for base64 encoding/decoding */
+#include "../curlx/strparse.h"
+#include "../curlx/base64.h" /* for base64 encoding/decoding */
#include "../curl_sha256.h"
/* The last 3 #include files should be in this order */
/* The length of fingerprint is 32 bytes for SHA256.
* See libssh2_hostkey_hash documentation. */
- if(Curl_base64_encode(fingerprint, 32, &fingerprint_b64,
- &fingerprint_b64_len) != CURLE_OK) {
+ if(curlx_base64_encode(fingerprint, 32, &fingerprint_b64,
+ &fingerprint_b64_len) != CURLE_OK) {
state(data, SSH_SESSION_FREE);
sshc->actualcode = CURLE_PEER_FAILED_VERIFICATION;
return sshc->actualcode;
if(!strncmp(cmd, "chgrp", 5)) {
const char *p = sshc->quote_path1;
curl_off_t gid;
- (void)Curl_str_number(&p, &gid, ULONG_MAX);
+ (void)curlx_str_number(&p, &gid, ULONG_MAX);
sshp->quote_attrs.gid = (unsigned long)gid;
sshp->quote_attrs.flags = LIBSSH2_SFTP_ATTR_UIDGID;
if(sshp->quote_attrs.gid == 0 && !ISDIGIT(sshc->quote_path1[0]) &&
curl_off_t perms;
const char *p = sshc->quote_path1;
/* permissions are octal */
- if(Curl_str_octal(&p, &perms, 07777)) {
+ if(curlx_str_octal(&p, &perms, 07777)) {
failf(data, "Syntax error: chmod permissions not a number");
goto fail;
}
else if(!strncmp(cmd, "chown", 5)) {
const char *p = sshc->quote_path1;
curl_off_t uid;
- (void)Curl_str_number(&p, &uid, ULONG_MAX);
+ (void)curlx_str_number(&p, &uid, ULONG_MAX);
sshp->quote_attrs.uid = (unsigned long)uid;
sshp->quote_attrs.flags = LIBSSH2_SFTP_ATTR_UIDGID;
if(sshp->quote_attrs.uid == 0 && !ISDIGIT(sshc->quote_path1[0]) &&
const char *p = data->state.range;
int to_t, from_t;
- from_t = Curl_str_number(&p, &from, CURL_OFF_T_MAX);
+ from_t = curlx_str_number(&p, &from, CURL_OFF_T_MAX);
if(from_t == STRE_OVERFLOW)
return CURLE_RANGE_ERROR;
- Curl_str_passblanks(&p);
- (void)Curl_str_single(&p, '-');
+ curlx_str_passblanks(&p);
+ (void)curlx_str_single(&p, '-');
- to_t = Curl_str_numblanks(&p, &to);
+ to_t = curlx_str_numblanks(&p, &to);
if(to_t == STRE_OVERFLOW)
return CURLE_RANGE_ERROR;
if((to_t == STRE_NO_NUM) /* no "to" value given */
return result;
}
else {
- result = Curl_dyn_add(&sshp->readdir, sshp->readdir_longentry);
+ result = curlx_dyn_add(&sshp->readdir, sshp->readdir_longentry);
if(!result) {
if((sshp->readdir_attrs.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS) &&
((sshp->readdir_attrs.permissions & LIBSSH2_SFTP_S_IFMT) ==
LIBSSH2_SFTP_S_IFLNK)) {
- result = Curl_dyn_addf(&sshp->readdir_link, "%s%s", sshp->path,
- sshp->readdir_filename);
+ result = curlx_dyn_addf(&sshp->readdir_link, "%s%s", sshp->path,
+ sshp->readdir_filename);
state(data, SSH_SFTP_READDIR_LINK);
}
else {
case SSH_SFTP_READDIR_LINK:
rc =
libssh2_sftp_symlink_ex(sshc->sftp_session,
- Curl_dyn_ptr(&sshp->readdir_link),
+ curlx_dyn_ptr(&sshp->readdir_link),
(unsigned int)
- Curl_dyn_len(&sshp->readdir_link),
+ curlx_dyn_len(&sshp->readdir_link),
sshp->readdir_filename,
CURL_PATH_MAX, LIBSSH2_SFTP_READLINK);
if(rc == LIBSSH2_ERROR_EAGAIN) {
break;
}
- Curl_dyn_free(&sshp->readdir_link);
+ curlx_dyn_free(&sshp->readdir_link);
/* append filename and extra output */
- result = Curl_dyn_addf(&sshp->readdir, " -> %s", sshp->readdir_filename);
+ result = curlx_dyn_addf(&sshp->readdir, " -> %s",
+ sshp->readdir_filename);
if(result) {
state(data, SSH_SFTP_CLOSE);
break;
case SSH_SFTP_READDIR_BOTTOM:
- result = Curl_dyn_addn(&sshp->readdir, "\n", 1);
+ result = curlx_dyn_addn(&sshp->readdir, "\n", 1);
if(!result)
result = Curl_client_write(data, CLIENTWRITE_BODY,
- Curl_dyn_ptr(&sshp->readdir),
- Curl_dyn_len(&sshp->readdir));
+ curlx_dyn_ptr(&sshp->readdir),
+ curlx_dyn_len(&sshp->readdir));
if(result) {
- Curl_dyn_free(&sshp->readdir);
+ curlx_dyn_free(&sshp->readdir);
state(data, SSH_STOP);
}
else {
- Curl_dyn_reset(&sshp->readdir);
+ curlx_dyn_reset(&sshp->readdir);
state(data, SSH_SFTP_READDIR);
}
break;
{
struct ssh_conn *sshc = &conn->proto.sshc;
CURLcode result = CURLE_OK;
- struct curltime dis = Curl_now();
+ struct curltime dis = curlx_now();
while((sshc->state != SSH_STOP) && !result) {
bool block;
timediff_t left = 1000;
- struct curltime now = Curl_now();
+ struct curltime now = curlx_now();
result = ssh_statemachine(data, &block);
if(result)
return CURLE_OPERATION_TIMEDOUT;
}
}
- else if(Curl_timediff(now, dis) > 1000) {
+ else if(curlx_timediff(now, dis) > 1000) {
/* disconnect timeout */
failf(data, "Disconnect timed out");
result = CURLE_OK;
if(!ssh)
return CURLE_OUT_OF_MEMORY;
- Curl_dyn_init(&ssh->readdir, CURL_PATH_MAX * 2);
- Curl_dyn_init(&ssh->readdir_link, CURL_PATH_MAX);
+ curlx_dyn_init(&ssh->readdir, CURL_PATH_MAX * 2);
+ curlx_dyn_init(&ssh->readdir_link, CURL_PATH_MAX);
return CURLE_OK;
}
result = status;
Curl_safefree(sshp->path);
- Curl_dyn_free(&sshp->readdir);
- Curl_dyn_free(&sshp->readdir_link);
+ curlx_dyn_free(&sshp->readdir);
+ curlx_dyn_free(&sshp->readdir_link);
if(Curl_pgrsDone(data))
return CURLE_ABORTED_BY_CALLBACK;
#include "../speedcheck.h"
#include "../select.h"
#include "../multiif.h"
-#include "../warnless.h"
+#include "../curlx/warnless.h"
#include "../strdup.h"
/* The last 3 #include files should be in this order */
while((sshc->state != SSH_STOP) && !result) {
bool block;
timediff_t left = 1000;
- struct curltime now = Curl_now();
+ struct curltime now = curlx_now();
result = wssh_statemach_act(data, &block);
if(result)
#include "../select.h"
#include "../strcase.h"
#include "../strdup.h"
-#include "../warnless.h"
+#include "../curlx/warnless.h"
#include "x509asn1.h"
#include "../multiif.h"
#include "../curl_printf.h"
}
shared->refcount = 1;
- shared->time = Curl_now();
+ shared->time = curlx_now();
*pcreds = shared;
return CURLE_OK;
}
const struct gtls_shared_creds *sc)
{
const struct ssl_general_config *cfg = &data->set.general_ssl;
- struct curltime now = Curl_now();
- timediff_t elapsed_ms = Curl_timediff(now, sc->time);
+ struct curltime now = curlx_now();
+ timediff_t elapsed_ms = curlx_timediff(now, sc->time);
timediff_t timeout_ms = cfg->ca_cache_timeout * (timediff_t)1000;
if(timeout_ms < 0)
CURLcode result = CURLE_OK;
int rc;
- Curl_dyn_init(&buf, 4096);
+ curlx_dyn_init(&buf, 4096);
#ifdef USE_GNUTLS_SRP
if(conn_config->username) {
/* Only add SRP to the cipher list if SRP is requested. Otherwise
* GnuTLS will disable TLS 1.3 support. */
- result = Curl_dyn_add(&buf, priority);
+ result = curlx_dyn_add(&buf, priority);
if(!result)
- result = Curl_dyn_add(&buf, ":" GNUTLS_SRP);
+ result = curlx_dyn_add(&buf, ":" GNUTLS_SRP);
if(result)
goto out;
- priority = Curl_dyn_ptr(&buf);
+ priority = curlx_dyn_ptr(&buf);
}
#endif
(conn_config->cipher_list[0] == '-') ||
(conn_config->cipher_list[0] == '!')) {
/* add it to out own */
- if(!Curl_dyn_len(&buf)) { /* not added yet */
- result = Curl_dyn_add(&buf, priority);
+ if(!curlx_dyn_len(&buf)) { /* not added yet */
+ result = curlx_dyn_add(&buf, priority);
if(result)
goto out;
}
- result = Curl_dyn_addf(&buf, ":%s", conn_config->cipher_list);
+ result = curlx_dyn_addf(&buf, ":%s", conn_config->cipher_list);
if(result)
goto out;
- priority = Curl_dyn_ptr(&buf);
+ priority = curlx_dyn_ptr(&buf);
}
else /* replace our own completely */
priority = conn_config->cipher_list;
}
out:
- Curl_dyn_free(&buf);
+ curlx_dyn_free(&buf);
return result;
}
#ifdef USE_GNUTLS
#include <gnutls/gnutls.h>
-#include "../timeval.h"
+#include "../curlx/timeval.h"
#ifdef HAVE_GNUTLS_SRP
/* the function exists */
#include "../strcase.h"
#include "hostcheck.h"
#include "../multiif.h"
-#include "../strparse.h"
+#include "../curlx/strparse.h"
#include "../strdup.h"
#include "../strerror.h"
#include "../curl_printf.h"
static void ossl_provider_cleanup(struct Curl_easy *data);
#endif
-#include "../warnless.h"
+#include "../curlx/warnless.h"
/* The last #include files should be: */
#include "../curl_memory.h"
size_t len = sizeof(randb);
size_t i, i_max;
for(i = 0, i_max = len / sizeof(struct curltime); i < i_max; ++i) {
- struct curltime tv = Curl_now();
+ struct curltime tv = curlx_now();
Curl_wait_ms(1);
tv.tv_sec *= (time_t)i + 1;
tv.tv_usec *= (int)i + 2;
- tv.tv_sec ^= ((Curl_now().tv_sec + (time_t)Curl_now().tv_usec) *
+ tv.tv_sec ^= ((curlx_now().tv_sec + (time_t)curlx_now().tv_usec) *
(time_t)(i + 3)) << 8;
- tv.tv_usec ^= (int) ((Curl_now().tv_sec + (time_t)Curl_now().tv_usec) *
+ tv.tv_usec ^= (int) ((curlx_now().tv_sec + (time_t)curlx_now().tv_usec) *
(time_t)(i + 4)) << 16;
memcpy(&randb[i * sizeof(struct curltime)], &tv,
sizeof(struct curltime));
CURLcode result = CURLE_OUT_OF_MEMORY;
if(bio_out) {
- Curl_dyn_reset(d);
+ curlx_dyn_reset(d);
rc = X509_NAME_print_ex(bio_out, a, 0, XN_FLAG_SEP_SPLUS_SPC);
if(rc != -1) {
BIO_get_mem_ptr(bio_out, &biomem);
- result = Curl_dyn_addn(d, biomem->data, biomem->length);
+ result = curlx_dyn_addn(d, biomem->data, biomem->length);
BIO_free(bio_out);
}
}
ossl_provider_cleanup(data);
return CURLE_OK;
}
- if(Curl_str_until(&iname, &prov, MAX_PROVIDER_LEN, ':'))
+ if(curlx_str_until(&iname, &prov, MAX_PROVIDER_LEN, ':'))
return CURLE_BAD_FUNCTION_ARGUMENT;
- if(!Curl_str_single(&iname, ':'))
+ if(!curlx_str_single(&iname, ':'))
/* there was a colon, get the propq until the end of string */
propq = iname;
/* we need the name in a buffer, null-terminated */
- memcpy(name, Curl_str(&prov), Curl_strlen(&prov));
- name[Curl_strlen(&prov)] = 0;
+ memcpy(name, curlx_str(&prov), curlx_strlen(&prov));
+ name[curlx_strlen(&prov)] = 0;
if(!data->state.libctx) {
OSSL_LIB_CTX *libctx = OSSL_LIB_CTX_new();
if(cfg->ca_cache_timeout < 0)
return FALSE;
else {
- struct curltime now = Curl_now();
- timediff_t elapsed_ms = Curl_timediff(now, mb->time);
+ struct curltime now = curlx_now();
+ timediff_t elapsed_ms = curlx_timediff(now, mb->time);
timediff_t timeout_ms = cfg->ca_cache_timeout * (timediff_t)1000;
return elapsed_ms >= timeout_ms;
free(share->CAfile);
}
- share->time = Curl_now();
+ share->time = curlx_now();
share->store = store;
share->CAfile = CAfile;
}
return CURLE_SSL_CONNECT_ERROR;
}
ech_config_len = 2 * strlen(b64);
- result = Curl_base64_decode(b64, &ech_config, &ech_config_len);
+ result = curlx_base64_decode(b64, &ech_config, &ech_config_len);
if(result || !ech_config) {
infof(data, "ECH: cannot base64 decode ECHConfig from command line");
if(data->set.tls_ech & CURLECH_HARD)
char *b64str = NULL;
size_t blen = 0;
- result = Curl_base64_encode((const char *)rcs, rcl, &b64str, &blen);
+ result = curlx_base64_encode((const char *)rcs, rcl, &b64str, &blen);
if(!result && b64str) {
infof(data, "ECH: retry_configs %s", b64str);
free(b64str);
DEBUGASSERT(octx);
- Curl_dyn_init(&dname, MAX_CERT_NAME_LENGTH);
+ curlx_dyn_init(&dname, MAX_CERT_NAME_LENGTH);
if(!mem) {
failf(data,
result = x509_name_oneline(X509_get_subject_name(octx->server_cert),
&dname);
- infof(data, " subject: %s", result ? "[NONE]" : Curl_dyn_ptr(&dname));
+ infof(data, " subject: %s", result ? "[NONE]" : curlx_dyn_ptr(&dname));
#ifndef CURL_DISABLE_VERBOSE_STRINGS
{
if(result) {
X509_free(octx->server_cert);
octx->server_cert = NULL;
- Curl_dyn_free(&dname);
+ curlx_dyn_free(&dname);
return result;
}
}
result = CURLE_PEER_FAILED_VERIFICATION;
}
else {
- infof(data, " issuer: %s", Curl_dyn_ptr(&dname));
- Curl_dyn_free(&dname);
+ infof(data, " issuer: %s", curlx_dyn_ptr(&dname));
+ curlx_dyn_free(&dname);
/* We could do all sorts of certificate verification stuff here before
deallocating the certificate. */
}
/* Append "tls-server-end-point:" */
- if(Curl_dyn_addn(binding, prefix, sizeof(prefix) - 1) != CURLE_OK)
+ if(curlx_dyn_addn(binding, prefix, sizeof(prefix) - 1) != CURLE_OK)
return CURLE_OUT_OF_MEMORY;
/* Append digest */
- if(Curl_dyn_addn(binding, buf, length))
+ if(curlx_dyn_addn(binding, buf, length))
return CURLE_OUT_OF_MEMORY;
return CURLE_OK;
uint8_t buf[256];
const size_t rr = fread(buf, 1, sizeof(buf), f);
if(rr == 0 ||
- CURLE_OK != Curl_dyn_addn(out, buf, rr)) {
+ CURLE_OK != curlx_dyn_addn(out, buf, rr)) {
fclose(f);
return 0;
}
struct dynbuf crl_contents;
rustls_result rr;
- Curl_dyn_init(&crl_contents, DYN_CRLFILE_SIZE);
+ curlx_dyn_init(&crl_contents, DYN_CRLFILE_SIZE);
if(!read_file_into(conn_config->CRLfile, &crl_contents)) {
failf(data, "rustls: failed to read revocation list file");
result = CURLE_SSL_CRL_BADFILE;
rr = rustls_web_pki_server_cert_verifier_builder_add_crl(
builder,
- Curl_dyn_uptr(&crl_contents),
- Curl_dyn_len(&crl_contents));
+ curlx_dyn_uptr(&crl_contents),
+ curlx_dyn_len(&crl_contents));
if(rr != RUSTLS_RESULT_OK) {
rustls_failf(data, rr, "failed to parse revocation list");
result = CURLE_SSL_CRL_BADFILE;
}
cleanup:
- Curl_dyn_free(&crl_contents);
+ curlx_dyn_free(&crl_contents);
return result;
}
return CURLE_SSL_CERTPROBLEM;
}
- Curl_dyn_init(&cert_contents, DYN_CERTFILE_SIZE);
- Curl_dyn_init(&key_contents, DYN_KEYFILE_SIZE);
+ curlx_dyn_init(&cert_contents, DYN_CERTFILE_SIZE);
+ curlx_dyn_init(&key_contents, DYN_KEYFILE_SIZE);
if(!read_file_into(conn_config->clientcert, &cert_contents)) {
failf(data, "rustls: failed to read client certificate file: '%s'",
goto cleanup;
}
- rr = rustls_certified_key_build(Curl_dyn_uptr(&cert_contents),
- Curl_dyn_len(&cert_contents),
- Curl_dyn_uptr(&key_contents),
- Curl_dyn_len(&key_contents),
+ rr = rustls_certified_key_build(curlx_dyn_uptr(&cert_contents),
+ curlx_dyn_len(&cert_contents),
+ curlx_dyn_uptr(&key_contents),
+ curlx_dyn_len(&key_contents),
&certified_key);
if(rr != RUSTLS_RESULT_OK) {
rustls_failf(data, rr, "rustls: failed to build certified key");
}
cleanup:
- Curl_dyn_free(&cert_contents);
- Curl_dyn_free(&key_contents);
+ curlx_dyn_free(&cert_contents);
+ curlx_dyn_free(&key_contents);
if(certified_key) {
rustls_certified_key_free(certified_key);
}
goto cleanup;
}
/* rustls-ffi expects the raw TLS encoded ECHConfigList bytes */
- decode_result = Curl_base64_decode(b64, &ech_config, &ech_config_len);
+ decode_result = curlx_base64_decode(b64, &ech_config, &ech_config_len);
if(decode_result || !ech_config) {
infof(data, "rustls: cannot base64 decode ECHConfig from command line");
result = CURLE_SSL_CONNECT_ERROR;
#include "../select.h" /* for the socket readiness */
#include "../inet_pton.h" /* for IP addr SNI check */
#include "../curl_multibyte.h"
-#include "../warnless.h"
+#include "../curlx/warnless.h"
#include "x509asn1.h"
#include "../curl_printf.h"
#include "../multiif.h"
#include "../system_win32.h"
#include "../version_win32.h"
#include "../rand.h"
-#include "../strparse.h"
+#include "../curlx/strparse.h"
/* The last #include file should be: */
#include "../curl_memory.h"
int algCount = 0;
while(startCur && (0 != *startCur) && (algCount < NUM_CIPHERS)) {
curl_off_t alg;
- if(Curl_str_number(&startCur, &alg, INT_MAX) || !alg)
+ if(curlx_str_number(&startCur, &alg, INT_MAX) || !alg)
alg = get_alg_id_by_name(startCur);
if(alg)
negative timeout means retain forever. */
timeout_ms = cfg->ca_cache_timeout * (timediff_t)1000;
if(timeout_ms >= 0) {
- now = Curl_now();
- elapsed_ms = Curl_timediff(now, share->time);
+ now = curlx_now();
+ elapsed_ms = curlx_timediff(now, share->time);
if(elapsed_ms >= timeout_ms) {
return NULL;
}
}
free(share->CAfile);
- share->time = Curl_now();
+ share->time = curlx_now();
share->cert_store = cert_store;
share->CAinfo_blob_size = CAinfo_blob_size;
share->CAfile = CAfile;
#ifdef USE_SECTRANSP
#include "../urldata.h" /* for the Curl_easy definition */
-#include "../curl_base64.h"
-#include "../strparse.h"
+#include "../curlx/base64.h"
+#include "../curlx/strparse.h"
#include "../multiif.h"
#include "../strcase.h"
#include "x509asn1.h"
curl_off_t fnum;
curl_off_t snum;
/* Parse the version: */
- if(!Curl_str_number(&os, &fnum, INT_MAX) &&
- !Curl_str_single(&os, '.') &&
- !Curl_str_number(&os, &snum, INT_MAX)) {
+ if(!curlx_str_number(&os, &fnum, INT_MAX) &&
+ !curlx_str_single(&os, '.') &&
+ !curlx_str_number(&os, &snum, INT_MAX)) {
*major = (int)fnum;
*minor = (int)snum;
}
}
b64[j] = '\0';
- err = Curl_base64_decode((const char *)b64, out, outlen);
+ err = curlx_base64_decode((const char *)b64, out, outlen);
free(b64);
if(err) {
free(*out);
unsigned char buf[512];
struct dynbuf certs;
- Curl_dyn_init(&certs, MAX_CERTS_SIZE);
+ curlx_dyn_init(&certs, MAX_CERTS_SIZE);
fd = open(file, 0);
if(fd < 0)
break;
if(n < 0) {
close(fd);
- Curl_dyn_free(&certs);
+ curlx_dyn_free(&certs);
return -1;
}
- if(Curl_dyn_addn(&certs, buf, n)) {
+ if(curlx_dyn_addn(&certs, buf, n)) {
close(fd);
return -1;
}
}
close(fd);
- *out = Curl_dyn_uptr(&certs);
- *outlen = Curl_dyn_len(&certs);
+ *out = curlx_dyn_uptr(&certs);
+ *outlen = curlx_dyn_len(&certs);
return 0;
}
#include "../progress.h"
#include "../share.h"
#include "../multiif.h"
-#include "../timeval.h"
+#include "../curlx/timeval.h"
#include "../curl_md5.h"
#include "../curl_sha256.h"
-#include "../warnless.h"
-#include "../curl_base64.h"
+#include "../curlx/warnless.h"
+#include "../curlx/base64.h"
#include "../curl_printf.h"
#include "../inet_pton.h"
#include "../connect.h"
DEBUGASSERT(certnum < ci->num_of_certs);
- Curl_dyn_init(&build, CURL_X509_STR_MAX);
+ curlx_dyn_init(&build, CURL_X509_STR_MAX);
- if(Curl_dyn_add(&build, label) ||
- Curl_dyn_addn(&build, ":", 1) ||
- Curl_dyn_addn(&build, value, valuelen))
+ if(curlx_dyn_add(&build, label) ||
+ curlx_dyn_addn(&build, ":", 1) ||
+ curlx_dyn_addn(&build, value, valuelen))
return CURLE_OUT_OF_MEMORY;
nl = Curl_slist_append_nodup(ci->certinfo[certnum],
- Curl_dyn_ptr(&build));
+ curlx_dyn_ptr(&build));
if(!nl) {
- Curl_dyn_free(&build);
+ curlx_dyn_free(&build);
curl_slist_free_all(ci->certinfo[certnum]);
result = CURLE_OUT_OF_MEMORY;
}
if(!pem)
return CURLE_BAD_CONTENT_ENCODING;
- Curl_dyn_init(&pbuf, MAX_PINNED_PUBKEY_SIZE);
+ curlx_dyn_init(&pbuf, MAX_PINNED_PUBKEY_SIZE);
begin_pos = strstr(pem, "-----BEGIN PUBLIC KEY-----");
if(!begin_pos)
*/
while(pem_count < pem_len) {
if('\n' != pem[pem_count] && '\r' != pem[pem_count]) {
- result = Curl_dyn_addn(&pbuf, &pem[pem_count], 1);
+ result = curlx_dyn_addn(&pbuf, &pem[pem_count], 1);
if(result)
return result;
}
++pem_count;
}
- result = Curl_base64_decode(Curl_dyn_ptr(&pbuf), der, der_len);
+ result = curlx_base64_decode(curlx_dyn_ptr(&pbuf), der, der_len);
- Curl_dyn_free(&pbuf);
+ curlx_dyn_free(&pbuf);
return result;
}
sha256sumdigest, CURL_SHA256_DIGEST_LENGTH);
if(!encode)
- encode = Curl_base64_encode((char *)sha256sumdigest,
- CURL_SHA256_DIGEST_LENGTH, &encoded,
- &encodedlen);
+ encode = curlx_base64_encode((char *)sha256sumdigest,
+ CURL_SHA256_DIGEST_LENGTH, &encoded,
+ &encodedlen);
Curl_safefree(sha256sumdigest);
if(encode)
if(!fp)
return result;
- Curl_dyn_init(&buf, MAX_PINNED_PUBKEY_SIZE);
+ curlx_dyn_init(&buf, MAX_PINNED_PUBKEY_SIZE);
/* Determine the file's size */
if(fseek(fp, 0, SEEK_END))
size_t want = left > sizeof(buffer) ? sizeof(buffer) : left;
if(want != fread(buffer, 1, want, fp))
goto end;
- if(Curl_dyn_addn(&buf, buffer, want))
+ if(curlx_dyn_addn(&buf, buffer, want))
goto end;
left -= want;
} while(left);
/* If the sizes are the same, it cannot be base64 encoded, must be der */
if(pubkeylen == size) {
- if(!memcmp(pubkey, Curl_dyn_ptr(&buf), pubkeylen))
+ if(!memcmp(pubkey, curlx_dyn_ptr(&buf), pubkeylen))
result = CURLE_OK;
goto end;
}
* Otherwise we will assume it is PEM and try to decode it
* after placing null terminator
*/
- pem_read = pubkey_pem_to_der(Curl_dyn_ptr(&buf), &pem_ptr, &pem_len);
+ pem_read = pubkey_pem_to_der(curlx_dyn_ptr(&buf), &pem_ptr, &pem_len);
/* if it was not read successfully, exit */
if(pem_read)
goto end;
if(pubkeylen == pem_len && !memcmp(pubkey, pem_ptr, pubkeylen))
result = CURLE_OK;
end:
- Curl_dyn_free(&buf);
+ curlx_dyn_free(&buf);
Curl_safefree(pem_ptr);
fclose(fp);
}
if(!result && *done) {
cf->connected = TRUE;
if(connssl->state == ssl_connection_complete)
- connssl->handshake_done = Curl_now();
+ connssl->handshake_done = curlx_now();
/* Connection can be deferred when sending early data */
DEBUGASSERT(connssl->state == ssl_connection_complete ||
connssl->state == ssl_connection_deferred);
#define SSLSUPP_SIGNATURE_ALGORITHMS (1<<10) /* supports TLS sigalgs */
#ifdef USE_ECH
-# include "../curl_base64.h"
+# include "../curlx/base64.h"
# define ECH_ENABLED(__data__) \
(__data__->set.tls_ech && \
!(__data__->set.tls_ech & CURLECH_DISABLE)\
#include "../curl_trc.h"
#include "../curl_sha256.h"
#include "../rand.h"
-#include "../warnless.h"
+#include "../curlx/warnless.h"
#include "../curl_printf.h"
#include "../strdup.h"
* the path as is. */
#ifdef UNDER_CE
(void)is_local;
- return Curl_dyn_addf(buf, ":%s-%s", name, path);
+ return curlx_dyn_addf(buf, ":%s-%s", name, path);
#elif defined(_WIN32)
char abspath[_MAX_PATH];
if(_fullpath(abspath, path, _MAX_PATH))
- return Curl_dyn_addf(buf, ":%s-%s", name, abspath);
+ return curlx_dyn_addf(buf, ":%s-%s", name, abspath);
*is_local = TRUE;
#elif defined(HAVE_REALPATH)
if(path[0] != '/') {
char *abspath = realpath(path, NULL);
if(abspath) {
- CURLcode r = Curl_dyn_addf(buf, ":%s-%s", name, abspath);
+ CURLcode r = curlx_dyn_addf(buf, ":%s-%s", name, abspath);
(free)(abspath); /* allocated by libc, free without memdebug */
return r;
}
*is_local = TRUE;
}
#endif
- return Curl_dyn_addf(buf, ":%s-%s", name, path);
+ return curlx_dyn_addf(buf, ":%s-%s", name, path);
}
return CURLE_OK;
}
unsigned char hash[CURL_SHA256_DIGEST_LENGTH];
size_t i;
- r = Curl_dyn_addf(buf, ":%s-", name);
+ r = curlx_dyn_addf(buf, ":%s-", name);
if(r)
goto out;
r = Curl_sha256it(hash, blob->data, blob->len);
if(r)
goto out;
for(i = 0; i < CURL_SHA256_DIGEST_LENGTH; ++i) {
- r = Curl_dyn_addf(buf, "%02x", hash[i]);
+ r = curlx_dyn_addf(buf, "%02x", hash[i]);
if(r)
goto out;
}
CURLcode r;
*ppeer_key = NULL;
- Curl_dyn_init(&buf, 10 * 1024);
+ curlx_dyn_init(&buf, 10 * 1024);
- r = Curl_dyn_addf(&buf, "%s:%d", peer->hostname, peer->port);
+ r = curlx_dyn_addf(&buf, "%s:%d", peer->hostname, peer->port);
if(r)
goto out;
case TRNSPRT_TCP:
break;
case TRNSPRT_UDP:
- r = Curl_dyn_add(&buf, ":UDP");
+ r = curlx_dyn_add(&buf, ":UDP");
break;
case TRNSPRT_QUIC:
- r = Curl_dyn_add(&buf, ":QUIC");
+ r = curlx_dyn_add(&buf, ":QUIC");
break;
case TRNSPRT_UNIX:
- r = Curl_dyn_add(&buf, ":UNIX");
+ r = curlx_dyn_add(&buf, ":UNIX");
break;
default:
- r = Curl_dyn_addf(&buf, ":TRNSPRT-%d", peer->transport);
+ r = curlx_dyn_addf(&buf, ":TRNSPRT-%d", peer->transport);
break;
}
if(r)
goto out;
if(!ssl->verifypeer) {
- r = Curl_dyn_add(&buf, ":NO-VRFY-PEER");
+ r = curlx_dyn_add(&buf, ":NO-VRFY-PEER");
if(r)
goto out;
}
if(!ssl->verifyhost) {
- r = Curl_dyn_add(&buf, ":NO-VRFY-HOST");
+ r = curlx_dyn_add(&buf, ":NO-VRFY-HOST");
if(r)
goto out;
}
if(ssl->verifystatus) {
- r = Curl_dyn_add(&buf, ":VRFY-STATUS");
+ r = curlx_dyn_add(&buf, ":VRFY-STATUS");
if(r)
goto out;
}
if(!ssl->verifypeer || !ssl->verifyhost) {
if(cf->conn->bits.conn_to_host) {
- r = Curl_dyn_addf(&buf, ":CHOST-%s", cf->conn->conn_to_host.name);
+ r = curlx_dyn_addf(&buf, ":CHOST-%s", cf->conn->conn_to_host.name);
if(r)
goto out;
}
if(cf->conn->bits.conn_to_port) {
- r = Curl_dyn_addf(&buf, ":CPORT-%d", cf->conn->conn_to_port);
+ r = curlx_dyn_addf(&buf, ":CPORT-%d", cf->conn->conn_to_port);
if(r)
goto out;
}
}
if(ssl->version || ssl->version_max) {
- r = Curl_dyn_addf(&buf, ":TLSVER-%d-%d", ssl->version,
+ r = curlx_dyn_addf(&buf, ":TLSVER-%d-%d", ssl->version,
(ssl->version_max >> 16));
if(r)
goto out;
}
if(ssl->ssl_options) {
- r = Curl_dyn_addf(&buf, ":TLSOPT-%x", ssl->ssl_options);
+ r = curlx_dyn_addf(&buf, ":TLSOPT-%x", ssl->ssl_options);
if(r)
goto out;
}
if(ssl->cipher_list) {
- r = Curl_dyn_addf(&buf, ":CIPHER-%s", ssl->cipher_list);
+ r = curlx_dyn_addf(&buf, ":CIPHER-%s", ssl->cipher_list);
if(r)
goto out;
}
if(ssl->cipher_list13) {
- r = Curl_dyn_addf(&buf, ":CIPHER13-%s", ssl->cipher_list13);
+ r = curlx_dyn_addf(&buf, ":CIPHER13-%s", ssl->cipher_list13);
if(r)
goto out;
}
if(ssl->curves) {
- r = Curl_dyn_addf(&buf, ":CURVES-%s", ssl->curves);
+ r = curlx_dyn_addf(&buf, ":CURVES-%s", ssl->curves);
if(r)
goto out;
}
}
}
if(ssl->pinned_key && ssl->pinned_key[0]) {
- r = Curl_dyn_addf(&buf, ":Pinned-%s", ssl->pinned_key);
+ r = curlx_dyn_addf(&buf, ":Pinned-%s", ssl->pinned_key);
if(r)
goto out;
}
if(ssl->clientcert && ssl->clientcert[0]) {
- r = Curl_dyn_add(&buf, ":CCERT");
+ r = curlx_dyn_add(&buf, ":CCERT");
if(r)
goto out;
}
#ifdef USE_TLS_SRP
if(ssl->username || ssl->password) {
- r = Curl_dyn_add(&buf, ":SRP-AUTH");
+ r = curlx_dyn_add(&buf, ":SRP-AUTH");
if(r)
goto out;
}
r = CURLE_FAILED_INIT;
goto out;
}
- r = Curl_dyn_addf(&buf, ":IMPL-%s", tls_id);
+ r = curlx_dyn_addf(&buf, ":IMPL-%s", tls_id);
if(r)
goto out;
- r = Curl_dyn_addf(&buf, is_local ?
- CURL_SSLS_LOCAL_SUFFIX : CURL_SSLS_GLOBAL_SUFFIX);
+ r = curlx_dyn_addf(&buf, is_local ?
+ CURL_SSLS_LOCAL_SUFFIX : CURL_SSLS_GLOBAL_SUFFIX);
if(r)
goto out;
- *ppeer_key = Curl_dyn_take(&buf, &key_len);
+ *ppeer_key = curlx_dyn_take(&buf, &key_len);
/* we just added printable char, and dynbuf always 0 terminates,
* no need to track length */
out:
- Curl_dyn_free(&buf);
+ curlx_dyn_free(&buf);
return r;
}
Curl_ssl_scache_lock(data);
- Curl_dyn_init(&hbuf, (CURL_SHA256_DIGEST_LENGTH * 2) + 1);
- Curl_dyn_init(&sbuf, CURL_SSL_TICKET_MAX);
+ curlx_dyn_init(&hbuf, (CURL_SHA256_DIGEST_LENGTH * 2) + 1);
+ curlx_dyn_init(&sbuf, CURL_SSL_TICKET_MAX);
for(i = 0; scache && i < scache->peer_count; i++) {
peer = &scache->peers[i];
if(!peer->exportable)
continue;
- Curl_dyn_reset(&hbuf);
+ curlx_dyn_reset(&hbuf);
cf_scache_peer_remove_expired(peer, now);
n = Curl_llist_head(&peer->sessions);
if(n)
if(r)
goto out;
}
- if(!Curl_dyn_len(&hbuf)) {
- r = Curl_dyn_addn(&hbuf, peer->key_salt, sizeof(peer->key_salt));
+ if(!curlx_dyn_len(&hbuf)) {
+ r = curlx_dyn_addn(&hbuf, peer->key_salt, sizeof(peer->key_salt));
if(r)
goto out;
- r = Curl_dyn_addn(&hbuf, peer->key_hmac, sizeof(peer->key_hmac));
+ r = curlx_dyn_addn(&hbuf, peer->key_hmac, sizeof(peer->key_hmac));
if(r)
goto out;
}
- Curl_dyn_reset(&sbuf);
+ curlx_dyn_reset(&sbuf);
r = Curl_ssl_session_pack(data, s, &sbuf);
if(r)
goto out;
r = export_fn(data, userptr, peer->ssl_peer_key,
- Curl_dyn_uptr(&hbuf), Curl_dyn_len(&hbuf),
- Curl_dyn_uptr(&sbuf), Curl_dyn_len(&sbuf),
+ curlx_dyn_uptr(&hbuf), curlx_dyn_len(&hbuf),
+ curlx_dyn_uptr(&sbuf), curlx_dyn_len(&sbuf),
s->valid_until, s->ietf_tls_id,
s->alpn, s->earlydata_max);
if(r)
out:
Curl_ssl_scache_unlock(data);
- Curl_dyn_free(&hbuf);
- Curl_dyn_free(&sbuf);
+ curlx_dyn_free(&hbuf);
+ curlx_dyn_free(&sbuf);
return r;
}
static CURLcode spack_enc8(struct dynbuf *buf, uint8_t b)
{
- return Curl_dyn_addn(buf, &b, 1);
+ return curlx_dyn_addn(buf, &b, 1);
}
static CURLcode
uint8_t nval[2];
nval[0] = (uint8_t)(val >> 8);
nval[1] = (uint8_t)val;
- return Curl_dyn_addn(buf, nval, sizeof(nval));
+ return curlx_dyn_addn(buf, nval, sizeof(nval));
}
static CURLcode
nval[1] = (uint8_t)(val >> 16);
nval[2] = (uint8_t)(val >> 8);
nval[3] = (uint8_t)val;
- return Curl_dyn_addn(buf, nval, sizeof(nval));
+ return curlx_dyn_addn(buf, nval, sizeof(nval));
}
static CURLcode
nval[5] = (uint8_t)(val >> 16);
nval[6] = (uint8_t)(val >> 8);
nval[7] = (uint8_t)val;
- return Curl_dyn_addn(buf, nval, sizeof(nval));
+ return curlx_dyn_addn(buf, nval, sizeof(nval));
}
static CURLcode
return CURLE_BAD_FUNCTION_ARGUMENT;
r = spack_enc16(buf, (uint16_t)slen);
if(!r) {
- r = Curl_dyn_addn(buf, s, slen);
+ r = curlx_dyn_addn(buf, s, slen);
}
return r;
}
return CURLE_BAD_FUNCTION_ARGUMENT;
r = spack_enc16(buf, (uint16_t)data_len);
if(!r) {
- r = Curl_dyn_addn(buf, data, data_len);
+ r = curlx_dyn_addn(buf, data, data_len);
}
return r;
}
const struct wssl_x509_share *mb)
{
const struct ssl_general_config *cfg = &data->set.general_ssl;
- struct curltime now = Curl_now();
- timediff_t elapsed_ms = Curl_timediff(now, mb->time);
+ struct curltime now = curlx_now();
+ timediff_t elapsed_ms = curlx_timediff(now, mb->time);
timediff_t timeout_ms = cfg->ca_cache_timeout * (timediff_t)1000;
if(timeout_ms < 0)
free(share->CAfile);
}
- share->time = Curl_now();
+ share->time = curlx_now();
share->store = store;
share->CAfile = CAfile;
}
continue;
/* if there already is data in the string, add colon separator */
- if(Curl_dyn_len(buf)) {
- CURLcode result = Curl_dyn_addn(buf, ":", 1);
+ if(curlx_dyn_len(buf)) {
+ CURLcode result = curlx_dyn_addn(buf, ":", 1);
if(result)
return result;
}
n = strlen(str);
- if(Curl_dyn_addn(buf, str, n))
+ if(curlx_dyn_addn(buf, str, n))
return CURLE_OUT_OF_MEMORY;
}
const char *ciphers12 = conn_config->cipher_list;
const char *ciphers13 = conn_config->cipher_list13;
struct dynbuf c;
- Curl_dyn_init(&c, MAX_CIPHER_LEN);
+ curlx_dyn_init(&c, MAX_CIPHER_LEN);
if(ciphers13)
- result = Curl_dyn_add(&c, ciphers13);
+ result = curlx_dyn_add(&c, ciphers13);
else
result = wssl_add_default_ciphers(TRUE, &c);
if(!result) {
if(ciphers12) {
- if(Curl_dyn_len(&c))
- result = Curl_dyn_addn(&c, ":", 1);
+ if(curlx_dyn_len(&c))
+ result = curlx_dyn_addn(&c, ":", 1);
if(!result)
- result = Curl_dyn_add(&c, ciphers12);
+ result = curlx_dyn_add(&c, ciphers12);
}
else
result = wssl_add_default_ciphers(FALSE, &c);
if(result)
goto out;
- if(!wolfSSL_CTX_set_cipher_list(wctx->ssl_ctx, Curl_dyn_ptr(&c))) {
- failf(data, "failed setting cipher list: %s", Curl_dyn_ptr(&c));
- Curl_dyn_free(&c);
+ if(!wolfSSL_CTX_set_cipher_list(wctx->ssl_ctx, curlx_dyn_ptr(&c))) {
+ failf(data, "failed setting cipher list: %s", curlx_dyn_ptr(&c));
+ curlx_dyn_free(&c);
result = CURLE_SSL_CIPHER;
goto out;
}
- infof(data, "Cipher selection: %s", Curl_dyn_ptr(&c));
- Curl_dyn_free(&c);
+ infof(data, "Cipher selection: %s", curlx_dyn_ptr(&c));
+ curlx_dyn_free(&c);
}
#endif
char *b64str = NULL;
size_t blen = 0;
- result = Curl_base64_encode((const char *)echConfigs, echConfigsLen,
- &b64str, &blen);
+ result = curlx_base64_encode((const char *)echConfigs, echConfigsLen,
+ &b64str, &blen);
if(!result && b64str)
infof(data, "ECH: (not yet) retry_configs %s", b64str);
free(b64str);
#include "vtls_int.h"
#include "../sendf.h"
#include "../inet_pton.h"
-#include "../curl_base64.h"
+#include "../curlx/base64.h"
#include "x509asn1.h"
-#include "../dynbuf.h"
+#include "../curlx/dynbuf.h"
/* The last 3 #include files should be in this order */
#include "../curl_printf.h"
{
if(end - beg != 1)
return CURLE_BAD_FUNCTION_ARGUMENT;
- return Curl_dyn_add(store, *beg ? "TRUE": "FALSE");
+ return curlx_dyn_add(store, *beg ? "TRUE": "FALSE");
}
/*
CURLcode result = CURLE_OK;
while(!result && beg < end)
- result = Curl_dyn_addf(store, "%02x:", (unsigned char) *beg++);
+ result = curlx_dyn_addf(store, "%02x:", (unsigned char) *beg++);
return result;
}
do
val = (val << 8) | *(const unsigned char *) beg++;
while(beg < end);
- return Curl_dyn_addf(store, "%s%x", val >= 10 ? "0x" : "", val);
+ return curlx_dyn_addf(store, "%s%x", val >= 10 ? "0x" : "", val);
}
/*
if(type == CURL_ASN1_UTF8_STRING) {
/* Just copy. */
if(inlength)
- result = Curl_dyn_addn(to, from, inlength);
+ result = curlx_dyn_addn(to, from, inlength);
}
else {
while(!result && (from < end)) {
charsize++;
}
buf[0] = (char) wc;
- result = Curl_dyn_addn(to, buf, charsize);
+ result = curlx_dyn_addn(to, buf, charsize);
}
}
return result;
x = y / 40;
y -= x * 40;
- result = Curl_dyn_addf(store, "%u.%u", x, y);
+ result = curlx_dyn_addf(store, "%u.%u", x, y);
if(result)
return result;
y = *(const unsigned char *) beg++;
x = (x << 7) | (y & 0x7F);
} while(y & 0x80);
- result = Curl_dyn_addf(store, ".%u", x);
+ result = curlx_dyn_addf(store, ".%u", x);
}
return result;
}
if(beg < end) {
if(symbolic) {
struct dynbuf buf;
- Curl_dyn_init(&buf, CURL_X509_STR_MAX);
+ curlx_dyn_init(&buf, CURL_X509_STR_MAX);
result = encodeOID(&buf, beg, end);
if(!result) {
- const struct Curl_OID *op = searchOID(Curl_dyn_ptr(&buf));
+ const struct Curl_OID *op = searchOID(curlx_dyn_ptr(&buf));
if(op)
- result = Curl_dyn_add(store, op->textoid);
+ result = curlx_dyn_add(store, op->textoid);
else
- result = Curl_dyn_add(store, Curl_dyn_ptr(&buf));
- Curl_dyn_free(&buf);
+ result = curlx_dyn_add(store, curlx_dyn_ptr(&buf));
+ curlx_dyn_free(&buf);
}
}
else
tzl = end - tzp;
}
- return Curl_dyn_addf(store,
- "%.4s-%.2s-%.2s %.2s:%.2s:%c%c%s%.*s%s%.*s",
- beg, beg + 4, beg + 6,
- beg + 8, beg + 10, sec1, sec2,
- fracl ? ".": "", (int)fracl, fracp,
- sep, (int)tzl, tzp);
+ return curlx_dyn_addf(store,
+ "%.4s-%.2s-%.2s %.2s:%.2s:%c%c%s%.*s%s%.*s",
+ beg, beg + 4, beg + 6,
+ beg + 8, beg + 10, sec1, sec2,
+ fracl ? ".": "", (int)fracl, fracp,
+ sep, (int)tzl, tzp);
}
#ifdef UNITTESTS
tzp++;
tzl = end - tzp;
- return Curl_dyn_addf(store, "%u%.2s-%.2s-%.2s %.2s:%.2s:%.2s %.*s",
- 20 - (*beg >= '5'), beg, beg + 2, beg + 4,
- beg + 6, beg + 8, sec,
- (int)tzl, tzp);
+ return curlx_dyn_addf(store, "%u%.2s-%.2s-%.2s %.2s:%.2s:%.2s %.*s",
+ 20 - (*beg >= '5'), beg, beg + 2, beg + 4,
+ beg + 6, beg + 8, sec,
+ (int)tzl, tzp);
}
/*
result = octet2str(store, elem->beg, elem->end);
break;
case CURL_ASN1_NULL:
- result = Curl_dyn_addn(store, "", 1);
+ result = curlx_dyn_addn(store, "", 1);
break;
case CURL_ASN1_OBJECT_IDENTIFIER:
result = OID2str(store, elem->beg, elem->end, TRUE);
CURLcode result = CURLE_OK;
bool added = FALSE;
struct dynbuf temp;
- Curl_dyn_init(&temp, CURL_X509_STR_MAX);
+ curlx_dyn_init(&temp, CURL_X509_STR_MAX);
for(p1 = dn->beg; p1 < dn->end;) {
p1 = getASN1Element(&rdn, p1, dn->end);
result = CURLE_BAD_FUNCTION_ARGUMENT;
goto error;
}
- Curl_dyn_reset(&temp);
+ curlx_dyn_reset(&temp);
result = ASN1tostr(&temp, &oid, 0);
if(result)
goto error;
- str = Curl_dyn_ptr(&temp);
+ str = curlx_dyn_ptr(&temp);
if(!str) {
result = CURLE_BAD_FUNCTION_ARGUMENT;
;
if(added) {
if(p3 - str > 2)
- result = Curl_dyn_addn(store, "/", 1);
+ result = curlx_dyn_addn(store, "/", 1);
else
- result = Curl_dyn_addn(store, ", ", 2);
+ result = curlx_dyn_addn(store, ", ", 2);
if(result)
goto error;
}
/* Encode attribute name. */
- result = Curl_dyn_add(store, str);
+ result = curlx_dyn_add(store, str);
if(result)
goto error;
/* Generate equal sign. */
- result = Curl_dyn_addn(store, "=", 1);
+ result = curlx_dyn_addn(store, "=", 1);
if(result)
goto error;
result = ASN1tostr(store, &value, 0);
if(result)
goto error;
- Curl_dyn_reset(&temp);
+ curlx_dyn_reset(&temp);
added = TRUE; /* use separator for next */
}
}
error:
- Curl_dyn_free(&temp);
+ curlx_dyn_free(&temp);
return result;
}
const char *label,
struct dynbuf *ptr)
{
- size_t valuelen = Curl_dyn_len(ptr);
- char *value = Curl_dyn_ptr(ptr);
+ size_t valuelen = curlx_dyn_len(ptr);
+ char *value = curlx_dyn_ptr(ptr);
CURLcode result = Curl_ssl_push_certinfo_len(data, certnum, label,
value, valuelen);
CURLcode result;
struct dynbuf out;
- Curl_dyn_init(&out, CURL_X509_STR_MAX);
+ curlx_dyn_init(&out, CURL_X509_STR_MAX);
/* Generate a certificate information record for the public key. */
if(!result) {
if(data->set.ssl.certinfo)
result = ssl_push_certinfo_dyn(data, certnum, label, &out);
- Curl_dyn_free(&out);
+ curlx_dyn_free(&out);
}
return result;
}
if(certnum)
return CURLE_OK;
- Curl_dyn_init(&out, CURL_X509_STR_MAX);
+ curlx_dyn_init(&out, CURL_X509_STR_MAX);
/* Prepare the certificate information for curl_easy_getinfo(). */
/* Extract the certificate ASN.1 elements. */
if(result)
goto done;
}
- Curl_dyn_reset(&out);
+ curlx_dyn_reset(&out);
/* Issuer. */
result = DNtostr(&out, &cert.issuer);
if(result)
goto done;
}
- Curl_dyn_reset(&out);
+ curlx_dyn_reset(&out);
/* Version (always fits in less than 32 bits). */
version = 0;
for(ptr = cert.version.beg; ptr < cert.version.end; ptr++)
version = (version << 8) | *(const unsigned char *) ptr;
if(data->set.ssl.certinfo) {
- result = Curl_dyn_addf(&out, "%x", version);
+ result = curlx_dyn_addf(&out, "%x", version);
if(result)
goto done;
result = ssl_push_certinfo_dyn(data, certnum, "Version", &out);
if(result)
goto done;
- Curl_dyn_reset(&out);
+ curlx_dyn_reset(&out);
}
/* Serial number. */
if(result)
goto done;
}
- Curl_dyn_reset(&out);
+ curlx_dyn_reset(&out);
/* Signature algorithm .*/
result = dumpAlgo(&out, ¶m, cert.signatureAlgorithm.beg,
if(result)
goto done;
}
- Curl_dyn_reset(&out);
+ curlx_dyn_reset(&out);
/* Start Date. */
result = ASN1tostr(&out, &cert.notBefore, 0);
if(result)
goto done;
}
- Curl_dyn_reset(&out);
+ curlx_dyn_reset(&out);
/* Expire Date. */
result = ASN1tostr(&out, &cert.notAfter, 0);
if(result)
goto done;
}
- Curl_dyn_reset(&out);
+ curlx_dyn_reset(&out);
/* Public Key Algorithm. */
result = dumpAlgo(&out, ¶m, cert.subjectPublicKeyAlgorithm.beg,
goto done;
}
- rc = do_pubkey(data, certnum, Curl_dyn_ptr(&out),
+ rc = do_pubkey(data, certnum, curlx_dyn_ptr(&out),
¶m, &cert.subjectPublicKey);
if(rc) {
result = CURLE_OUT_OF_MEMORY; /* the most likely error */
goto done;
}
- Curl_dyn_reset(&out);
+ curlx_dyn_reset(&out);
/* Signature. */
result = ASN1tostr(&out, &cert.signature, 0);
if(result)
goto done;
}
- Curl_dyn_reset(&out);
+ curlx_dyn_reset(&out);
/* Generate PEM certificate. */
- result = Curl_base64_encode(cert.certificate.beg,
- cert.certificate.end - cert.certificate.beg,
- &certptr, &clen);
+ result = curlx_base64_encode(cert.certificate.beg,
+ cert.certificate.end - cert.certificate.beg,
+ &certptr, &clen);
if(result)
goto done;
-----END CERTIFICATE-----\n
*/
- Curl_dyn_reset(&out);
+ curlx_dyn_reset(&out);
/* Build the certificate string. */
- result = Curl_dyn_add(&out, "-----BEGIN CERTIFICATE-----\n");
+ result = curlx_dyn_add(&out, "-----BEGIN CERTIFICATE-----\n");
if(!result) {
size_t j = 0;
while(!result && (j < clen)) {
size_t chunksize = (clen - j) > 64 ? 64 : (clen - j);
- result = Curl_dyn_addn(&out, &certptr[j], chunksize);
+ result = curlx_dyn_addn(&out, &certptr[j], chunksize);
if(!result)
- result = Curl_dyn_addn(&out, "\n", 1);
+ result = curlx_dyn_addn(&out, "\n", 1);
j += chunksize;
}
if(!result)
- result = Curl_dyn_add(&out, "-----END CERTIFICATE-----\n");
+ result = curlx_dyn_add(&out, "-----END CERTIFICATE-----\n");
}
free(certptr);
if(!result)
done:
if(result)
failf(data, "Failed extracting certificate chain");
- Curl_dyn_free(&out);
+ curlx_dyn_free(&out);
return result;
}
#include "urldata.h"
#include "url.h"
#include "bufq.h"
-#include "dynbuf.h"
+#include "curlx/dynbuf.h"
#include "rand.h"
-#include "curl_base64.h"
+#include "curlx/base64.h"
#include "connect.h"
#include "sendf.h"
#include "multiif.h"
#include "transfer.h"
#include "select.h"
#include "nonblock.h"
-#include "strparse.h"
+#include "curlx/strparse.h"
/* The last 3 #include files should be in this order */
#include "curl_printf.h"
result = Curl_rand(data, (unsigned char *)rand, sizeof(rand));
if(result)
return result;
- result = Curl_base64_encode((char *)rand, sizeof(rand), &randstr, &randlen);
+ result = curlx_base64_encode((char *)rand, sizeof(rand), &randstr, &randlen);
if(result)
return result;
DEBUGASSERT(randlen < sizeof(keyval));
free(randstr);
for(i = 0; !result && (i < CURL_ARRAYSIZE(heads)); i++) {
if(!Curl_checkheaders(data, heads[i].name, strlen(heads[i].name))) {
- result = Curl_dyn_addf(req, "%s: %s\r\n", heads[i].name,
- heads[i].val);
+ result = curlx_dyn_addf(req, "%s: %s\r\n", heads[i].name,
+ heads[i].val);
}
}
k->upgr101 = UPGR101_WS;
const char *p = getenv("CURL_WS_CHUNK_SIZE");
if(p) {
curl_off_t l;
- if(!Curl_str_number(&p, &l, 1*1024*1024))
+ if(!curlx_str_number(&p, &l, 1*1024*1024))
chunk_size = (size_t)l;
}
}
const char *p = getenv("CURL_WS_CHUNK_EAGAIN");
if(p) {
curl_off_t l;
- if(!Curl_str_number(&p, &l, 1*1024*1024))
+ if(!curlx_str_number(&p, &l, 1*1024*1024))
chunk_egain = (size_t)l;
}
#endif
</ItemDefinitionGroup>
<ItemGroup>
CURL_LIB_C_FILES
+CURL_LIB_CURLX_C_FILES
CURL_LIB_VAUTH_C_FILES
CURL_LIB_VQUIC_C_FILES
CURL_LIB_VSSH_C_FILES
</ItemGroup>
<ItemGroup>
CURL_LIB_H_FILES
+CURL_LIB_CURLX_H_FILES
CURL_LIB_VAUTH_H_FILES
CURL_LIB_VQUIC_H_FILES
CURL_LIB_VSSH_H_FILES
<ClCompile>
<Optimization>MaxSpeed</Optimization>
<InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<StringPooling>true</StringPooling>
<RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
<ClCompile>
<Optimization>MaxSpeed</Optimization>
<InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<StringPooling>true</StringPooling>
<RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
<ClCompile>
<Optimization>MaxSpeed</Optimization>
<InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>NDEBUG;_CONSOLE;CURL_STATICLIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<StringPooling>true</StringPooling>
<RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
<ClCompile>
<Optimization>MaxSpeed</Optimization>
<InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>NDEBUG;_CONSOLE;CURL_STATICLIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<StringPooling>true</StringPooling>
<RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
</Midl>
<ClCompile>
<Optimization>Disabled</Optimization>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>_DEBUG;_CONSOLE;DEBUGBUILD;CURL_STATICLIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<MinimalRebuild>true</MinimalRebuild>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
</Midl>
<ClCompile>
<Optimization>Disabled</Optimization>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>_DEBUG;_CONSOLE;DEBUGBUILD;CURL_STATICLIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<MinimalRebuild>true</MinimalRebuild>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
</Midl>
<ClCompile>
<Optimization>Disabled</Optimization>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>_DEBUG;_CONSOLE;DEBUGBUILD;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<MinimalRebuild>true</MinimalRebuild>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
</Midl>
<ClCompile>
<Optimization>Disabled</Optimization>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>_DEBUG;_CONSOLE;DEBUGBUILD;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<MinimalRebuild>true</MinimalRebuild>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
</Midl>
<ClCompile>
<Optimization>Disabled</Optimization>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>_DEBUG;_CONSOLE;DEBUGBUILD;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<MinimalRebuild>true</MinimalRebuild>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
</Midl>
<ClCompile>
<Optimization>Disabled</Optimization>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>_DEBUG;_CONSOLE;DEBUGBUILD;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<MinimalRebuild>true</MinimalRebuild>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
</Midl>
<ClCompile>
<Optimization>Disabled</Optimization>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>_DEBUG;_CONSOLE;DEBUGBUILD;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<MinimalRebuild>true</MinimalRebuild>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
</Midl>
<ClCompile>
<Optimization>Disabled</Optimization>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>_DEBUG;_CONSOLE;DEBUGBUILD;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<MinimalRebuild>true</MinimalRebuild>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
</Midl>
<ClCompile>
<Optimization>Disabled</Optimization>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>_DEBUG;_CONSOLE;DEBUGBUILD;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<MinimalRebuild>true</MinimalRebuild>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
</Midl>
<ClCompile>
<Optimization>Disabled</Optimization>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>_DEBUG;_CONSOLE;DEBUGBUILD;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<MinimalRebuild>true</MinimalRebuild>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
<ClCompile>
<Optimization>MaxSpeed</Optimization>
<InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<StringPooling>true</StringPooling>
<RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
<ClCompile>
<Optimization>MaxSpeed</Optimization>
<InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<StringPooling>true</StringPooling>
<RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
<ClCompile>
<Optimization>MaxSpeed</Optimization>
<InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<StringPooling>true</StringPooling>
<RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
<ClCompile>
<Optimization>MaxSpeed</Optimization>
<InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<StringPooling>true</StringPooling>
<RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
<ClCompile>
<Optimization>MaxSpeed</Optimization>
<InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<StringPooling>true</StringPooling>
<RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
<ClCompile>
<Optimization>MaxSpeed</Optimization>
<InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<StringPooling>true</StringPooling>
<RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
</Midl>
<ClCompile>
<Optimization>Disabled</Optimization>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>_DEBUG;_CONSOLE;DEBUGBUILD;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<MinimalRebuild>true</MinimalRebuild>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
</Midl>
<ClCompile>
<Optimization>Disabled</Optimization>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>_DEBUG;_CONSOLE;DEBUGBUILD;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<MinimalRebuild>true</MinimalRebuild>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
<ClCompile>
<Optimization>MaxSpeed</Optimization>
<InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<StringPooling>true</StringPooling>
<RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
<ClCompile>
<Optimization>MaxSpeed</Optimization>
<InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<StringPooling>true</StringPooling>
<RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
</Midl>
<ClCompile>
<Optimization>Disabled</Optimization>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>_DEBUG;_CONSOLE;DEBUGBUILD;CURL_STATICLIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<MinimalRebuild>true</MinimalRebuild>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
</Midl>
<ClCompile>
<Optimization>Disabled</Optimization>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>_DEBUG;_CONSOLE;DEBUGBUILD;CURL_STATICLIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<MinimalRebuild>true</MinimalRebuild>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
<ClCompile>
<Optimization>MaxSpeed</Optimization>
<InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>NDEBUG;_CONSOLE;CURL_STATICLIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<StringPooling>true</StringPooling>
<RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
<ClCompile>
<Optimization>MaxSpeed</Optimization>
<InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>NDEBUG;_CONSOLE;CURL_STATICLIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<StringPooling>true</StringPooling>
<RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
</Midl>
<ClCompile>
<Optimization>Disabled</Optimization>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>_DEBUG;_CONSOLE;DEBUGBUILD;CURL_STATICLIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<MinimalRebuild>true</MinimalRebuild>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
</Midl>
<ClCompile>
<Optimization>Disabled</Optimization>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>_DEBUG;_CONSOLE;DEBUGBUILD;CURL_STATICLIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<MinimalRebuild>true</MinimalRebuild>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
<ClCompile>
<Optimization>MaxSpeed</Optimization>
<InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>NDEBUG;_CONSOLE;CURL_STATICLIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<StringPooling>true</StringPooling>
<RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
<ClCompile>
<Optimization>MaxSpeed</Optimization>
<InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>NDEBUG;_CONSOLE;CURL_STATICLIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<StringPooling>true</StringPooling>
<RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
</Midl>
<ClCompile>
<Optimization>Disabled</Optimization>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>_DEBUG;_CONSOLE;DEBUGBUILD;CURL_STATICLIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<MinimalRebuild>true</MinimalRebuild>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
</Midl>
<ClCompile>
<Optimization>Disabled</Optimization>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>_DEBUG;_CONSOLE;DEBUGBUILD;CURL_STATICLIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<MinimalRebuild>true</MinimalRebuild>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
<ClCompile>
<Optimization>MaxSpeed</Optimization>
<InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>NDEBUG;_CONSOLE;CURL_STATICLIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<StringPooling>true</StringPooling>
<RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
<ClCompile>
<Optimization>MaxSpeed</Optimization>
<InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>NDEBUG;_CONSOLE;CURL_STATICLIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<StringPooling>true</StringPooling>
<RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
</Midl>
<ClCompile>
<Optimization>Disabled</Optimization>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>_DEBUG;_CONSOLE;DEBUGBUILD;CURL_STATICLIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<MinimalRebuild>true</MinimalRebuild>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
</Midl>
<ClCompile>
<Optimization>Disabled</Optimization>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>_DEBUG;_CONSOLE;DEBUGBUILD;CURL_STATICLIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<MinimalRebuild>true</MinimalRebuild>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
<ClCompile>
<Optimization>MaxSpeed</Optimization>
<InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>NDEBUG;_CONSOLE;CURL_STATICLIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<StringPooling>true</StringPooling>
<RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
<ClCompile>
<Optimization>MaxSpeed</Optimization>
<InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>NDEBUG;_CONSOLE;CURL_STATICLIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<StringPooling>true</StringPooling>
<RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
</Midl>
<ClCompile>
<Optimization>Disabled</Optimization>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>_DEBUG;_CONSOLE;DEBUGBUILD;CURL_STATICLIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<MinimalRebuild>true</MinimalRebuild>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
</Midl>
<ClCompile>
<Optimization>Disabled</Optimization>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>_DEBUG;_CONSOLE;DEBUGBUILD;CURL_STATICLIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<MinimalRebuild>true</MinimalRebuild>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
</Midl>
<ClCompile>
<Optimization>Disabled</Optimization>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>_DEBUG;_CONSOLE;DEBUGBUILD;CURL_STATICLIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<MinimalRebuild>true</MinimalRebuild>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
</Midl>
<ClCompile>
<Optimization>Disabled</Optimization>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>_DEBUG;_CONSOLE;DEBUGBUILD;CURL_STATICLIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<MinimalRebuild>true</MinimalRebuild>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
<ClCompile>
<Optimization>MaxSpeed</Optimization>
<InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>NDEBUG;_CONSOLE;CURL_STATICLIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<StringPooling>true</StringPooling>
<RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
<ClCompile>
<Optimization>MaxSpeed</Optimization>
<InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>NDEBUG;_CONSOLE;CURL_STATICLIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<StringPooling>true</StringPooling>
<RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
<ClCompile>
<Optimization>MaxSpeed</Optimization>
<InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>NDEBUG;_CONSOLE;CURL_STATICLIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<StringPooling>true</StringPooling>
<RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
<ClCompile>
<Optimization>MaxSpeed</Optimization>
<InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>NDEBUG;_CONSOLE;CURL_STATICLIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<StringPooling>true</StringPooling>
<RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
</Link>
</ItemDefinitionGroup>
<ItemGroup>
+CURL_LIB_CURLX_C_FILES
CURL_SRC_X_C_FILES
CURL_SRC_C_FILES
</ItemGroup>
<ItemGroup>
+CURL_LIB_CURLX_H_FILES
CURL_SRC_X_H_FILES
CURL_SRC_H_FILES
</ItemGroup>
</ItemDefinitionGroup>
<ItemGroup>
CURL_LIB_C_FILES
+CURL_LIB_CURLX_C_FILES
CURL_LIB_VAUTH_C_FILES
CURL_LIB_VQUIC_C_FILES
CURL_LIB_VSSH_C_FILES
</ItemGroup>
<ItemGroup>
CURL_LIB_H_FILES
+CURL_LIB_CURLX_H_FILES
CURL_LIB_VAUTH_H_FILES
CURL_LIB_VQUIC_H_FILES
CURL_LIB_VSSH_H_FILES
<ClCompile>
<Optimization>MaxSpeed</Optimization>
<InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<StringPooling>true</StringPooling>
<RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
<ClCompile>
<Optimization>MaxSpeed</Optimization>
<InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<StringPooling>true</StringPooling>
<RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
<ClCompile>
<Optimization>MaxSpeed</Optimization>
<InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>NDEBUG;_CONSOLE;CURL_STATICLIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<StringPooling>true</StringPooling>
<RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
<ClCompile>
<Optimization>MaxSpeed</Optimization>
<InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>NDEBUG;_CONSOLE;CURL_STATICLIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<StringPooling>true</StringPooling>
<RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
</Midl>
<ClCompile>
<Optimization>Disabled</Optimization>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>_DEBUG;_CONSOLE;DEBUGBUILD;CURL_STATICLIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<MinimalRebuild>true</MinimalRebuild>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
</Midl>
<ClCompile>
<Optimization>Disabled</Optimization>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>_DEBUG;_CONSOLE;DEBUGBUILD;CURL_STATICLIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<MinimalRebuild>true</MinimalRebuild>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
</Midl>
<ClCompile>
<Optimization>Disabled</Optimization>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>_DEBUG;_CONSOLE;DEBUGBUILD;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<MinimalRebuild>true</MinimalRebuild>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
</Midl>
<ClCompile>
<Optimization>Disabled</Optimization>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>_DEBUG;_CONSOLE;DEBUGBUILD;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<MinimalRebuild>true</MinimalRebuild>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
</Midl>
<ClCompile>
<Optimization>Disabled</Optimization>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>_DEBUG;_CONSOLE;DEBUGBUILD;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<MinimalRebuild>true</MinimalRebuild>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
</Midl>
<ClCompile>
<Optimization>Disabled</Optimization>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>_DEBUG;_CONSOLE;DEBUGBUILD;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<MinimalRebuild>true</MinimalRebuild>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
</Midl>
<ClCompile>
<Optimization>Disabled</Optimization>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>_DEBUG;_CONSOLE;DEBUGBUILD;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<MinimalRebuild>true</MinimalRebuild>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
</Midl>
<ClCompile>
<Optimization>Disabled</Optimization>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>_DEBUG;_CONSOLE;DEBUGBUILD;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<MinimalRebuild>true</MinimalRebuild>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
</Midl>
<ClCompile>
<Optimization>Disabled</Optimization>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>_DEBUG;_CONSOLE;DEBUGBUILD;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<MinimalRebuild>true</MinimalRebuild>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
</Midl>
<ClCompile>
<Optimization>Disabled</Optimization>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>_DEBUG;_CONSOLE;DEBUGBUILD;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<MinimalRebuild>true</MinimalRebuild>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
<ClCompile>
<Optimization>MaxSpeed</Optimization>
<InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<StringPooling>true</StringPooling>
<RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
<ClCompile>
<Optimization>MaxSpeed</Optimization>
<InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<StringPooling>true</StringPooling>
<RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
<ClCompile>
<Optimization>MaxSpeed</Optimization>
<InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<StringPooling>true</StringPooling>
<RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
<ClCompile>
<Optimization>MaxSpeed</Optimization>
<InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<StringPooling>true</StringPooling>
<RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
<ClCompile>
<Optimization>MaxSpeed</Optimization>
<InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<StringPooling>true</StringPooling>
<RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
<ClCompile>
<Optimization>MaxSpeed</Optimization>
<InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<StringPooling>true</StringPooling>
<RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
</Midl>
<ClCompile>
<Optimization>Disabled</Optimization>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>_DEBUG;_CONSOLE;DEBUGBUILD;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<MinimalRebuild>true</MinimalRebuild>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
</Midl>
<ClCompile>
<Optimization>Disabled</Optimization>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>_DEBUG;_CONSOLE;DEBUGBUILD;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<MinimalRebuild>true</MinimalRebuild>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
<ClCompile>
<Optimization>MaxSpeed</Optimization>
<InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<StringPooling>true</StringPooling>
<RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
<ClCompile>
<Optimization>MaxSpeed</Optimization>
<InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<StringPooling>true</StringPooling>
<RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
</Midl>
<ClCompile>
<Optimization>Disabled</Optimization>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>_DEBUG;_CONSOLE;DEBUGBUILD;CURL_STATICLIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<MinimalRebuild>true</MinimalRebuild>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
</Midl>
<ClCompile>
<Optimization>Disabled</Optimization>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>_DEBUG;_CONSOLE;DEBUGBUILD;CURL_STATICLIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<MinimalRebuild>true</MinimalRebuild>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
<ClCompile>
<Optimization>MaxSpeed</Optimization>
<InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>NDEBUG;_CONSOLE;CURL_STATICLIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<StringPooling>true</StringPooling>
<RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
<ClCompile>
<Optimization>MaxSpeed</Optimization>
<InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>NDEBUG;_CONSOLE;CURL_STATICLIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<StringPooling>true</StringPooling>
<RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
</Midl>
<ClCompile>
<Optimization>Disabled</Optimization>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>_DEBUG;_CONSOLE;DEBUGBUILD;CURL_STATICLIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<MinimalRebuild>true</MinimalRebuild>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
</Midl>
<ClCompile>
<Optimization>Disabled</Optimization>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>_DEBUG;_CONSOLE;DEBUGBUILD;CURL_STATICLIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<MinimalRebuild>true</MinimalRebuild>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
<ClCompile>
<Optimization>MaxSpeed</Optimization>
<InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>NDEBUG;_CONSOLE;CURL_STATICLIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<StringPooling>true</StringPooling>
<RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
<ClCompile>
<Optimization>MaxSpeed</Optimization>
<InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>NDEBUG;_CONSOLE;CURL_STATICLIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<StringPooling>true</StringPooling>
<RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
</Midl>
<ClCompile>
<Optimization>Disabled</Optimization>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>_DEBUG;_CONSOLE;DEBUGBUILD;CURL_STATICLIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<MinimalRebuild>true</MinimalRebuild>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
</Midl>
<ClCompile>
<Optimization>Disabled</Optimization>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>_DEBUG;_CONSOLE;DEBUGBUILD;CURL_STATICLIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<MinimalRebuild>true</MinimalRebuild>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
<ClCompile>
<Optimization>MaxSpeed</Optimization>
<InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>NDEBUG;_CONSOLE;CURL_STATICLIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<StringPooling>true</StringPooling>
<RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
<ClCompile>
<Optimization>MaxSpeed</Optimization>
<InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>NDEBUG;_CONSOLE;CURL_STATICLIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<StringPooling>true</StringPooling>
<RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
</Midl>
<ClCompile>
<Optimization>Disabled</Optimization>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>_DEBUG;_CONSOLE;DEBUGBUILD;CURL_STATICLIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<MinimalRebuild>true</MinimalRebuild>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
</Midl>
<ClCompile>
<Optimization>Disabled</Optimization>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>_DEBUG;_CONSOLE;DEBUGBUILD;CURL_STATICLIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<MinimalRebuild>true</MinimalRebuild>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
<ClCompile>
<Optimization>MaxSpeed</Optimization>
<InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>NDEBUG;_CONSOLE;CURL_STATICLIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<StringPooling>true</StringPooling>
<RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
<ClCompile>
<Optimization>MaxSpeed</Optimization>
<InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>NDEBUG;_CONSOLE;CURL_STATICLIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<StringPooling>true</StringPooling>
<RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
</Midl>
<ClCompile>
<Optimization>Disabled</Optimization>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>_DEBUG;_CONSOLE;DEBUGBUILD;CURL_STATICLIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<MinimalRebuild>true</MinimalRebuild>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
</Midl>
<ClCompile>
<Optimization>Disabled</Optimization>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>_DEBUG;_CONSOLE;DEBUGBUILD;CURL_STATICLIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<MinimalRebuild>true</MinimalRebuild>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
</Midl>
<ClCompile>
<Optimization>Disabled</Optimization>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>_DEBUG;_CONSOLE;DEBUGBUILD;CURL_STATICLIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<MinimalRebuild>true</MinimalRebuild>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
</Midl>
<ClCompile>
<Optimization>Disabled</Optimization>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>_DEBUG;_CONSOLE;DEBUGBUILD;CURL_STATICLIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<MinimalRebuild>true</MinimalRebuild>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
<ClCompile>
<Optimization>MaxSpeed</Optimization>
<InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>NDEBUG;_CONSOLE;CURL_STATICLIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<StringPooling>true</StringPooling>
<RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
<ClCompile>
<Optimization>MaxSpeed</Optimization>
<InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>NDEBUG;_CONSOLE;CURL_STATICLIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<StringPooling>true</StringPooling>
<RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
<ClCompile>
<Optimization>MaxSpeed</Optimization>
<InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>NDEBUG;_CONSOLE;CURL_STATICLIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<StringPooling>true</StringPooling>
<RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
<ClCompile>
<Optimization>MaxSpeed</Optimization>
<InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>NDEBUG;_CONSOLE;CURL_STATICLIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<StringPooling>true</StringPooling>
<RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
</Link>
</ItemDefinitionGroup>
<ItemGroup>
+CURL_LIB_CURLX_C_FILES
CURL_SRC_X_C_FILES
CURL_SRC_C_FILES
</ItemGroup>
<ItemGroup>
+CURL_LIB_CURLX_H_FILES
CURL_SRC_X_H_FILES
CURL_SRC_H_FILES
</ItemGroup>
</ItemDefinitionGroup>
<ItemGroup>
CURL_LIB_C_FILES
+CURL_LIB_CURLX_C_FILES
CURL_LIB_VAUTH_C_FILES
CURL_LIB_VQUIC_C_FILES
CURL_LIB_VSSH_C_FILES
</ItemGroup>
<ItemGroup>
CURL_LIB_H_FILES
+CURL_LIB_CURLX_H_FILES
CURL_LIB_VAUTH_H_FILES
CURL_LIB_VQUIC_H_FILES
CURL_LIB_VSSH_H_FILES
<ClCompile>
<Optimization>MaxSpeed</Optimization>
<InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<StringPooling>true</StringPooling>
<RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
<ClCompile>
<Optimization>MaxSpeed</Optimization>
<InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<StringPooling>true</StringPooling>
<RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
<ClCompile>
<Optimization>MaxSpeed</Optimization>
<InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>NDEBUG;_CONSOLE;CURL_STATICLIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<StringPooling>true</StringPooling>
<RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
<ClCompile>
<Optimization>MaxSpeed</Optimization>
<InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>NDEBUG;_CONSOLE;CURL_STATICLIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<StringPooling>true</StringPooling>
<RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
</Midl>
<ClCompile>
<Optimization>Disabled</Optimization>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>_DEBUG;_CONSOLE;DEBUGBUILD;CURL_STATICLIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<MinimalRebuild>true</MinimalRebuild>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
</Midl>
<ClCompile>
<Optimization>Disabled</Optimization>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>_DEBUG;_CONSOLE;DEBUGBUILD;CURL_STATICLIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<MinimalRebuild>true</MinimalRebuild>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
</Midl>
<ClCompile>
<Optimization>Disabled</Optimization>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>_DEBUG;_CONSOLE;DEBUGBUILD;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<MinimalRebuild>true</MinimalRebuild>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
</Midl>
<ClCompile>
<Optimization>Disabled</Optimization>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>_DEBUG;_CONSOLE;DEBUGBUILD;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<MinimalRebuild>true</MinimalRebuild>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
</Midl>
<ClCompile>
<Optimization>Disabled</Optimization>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>_DEBUG;_CONSOLE;DEBUGBUILD;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<MinimalRebuild>true</MinimalRebuild>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
</Midl>
<ClCompile>
<Optimization>Disabled</Optimization>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>_DEBUG;_CONSOLE;DEBUGBUILD;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<MinimalRebuild>true</MinimalRebuild>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
</Midl>
<ClCompile>
<Optimization>Disabled</Optimization>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>_DEBUG;_CONSOLE;DEBUGBUILD;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<MinimalRebuild>true</MinimalRebuild>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
</Midl>
<ClCompile>
<Optimization>Disabled</Optimization>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>_DEBUG;_CONSOLE;DEBUGBUILD;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<MinimalRebuild>true</MinimalRebuild>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
</Midl>
<ClCompile>
<Optimization>Disabled</Optimization>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>_DEBUG;_CONSOLE;DEBUGBUILD;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<MinimalRebuild>true</MinimalRebuild>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
</Midl>
<ClCompile>
<Optimization>Disabled</Optimization>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>_DEBUG;_CONSOLE;DEBUGBUILD;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<MinimalRebuild>true</MinimalRebuild>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
<ClCompile>
<Optimization>MaxSpeed</Optimization>
<InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<StringPooling>true</StringPooling>
<RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
<ClCompile>
<Optimization>MaxSpeed</Optimization>
<InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<StringPooling>true</StringPooling>
<RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
<ClCompile>
<Optimization>MaxSpeed</Optimization>
<InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<StringPooling>true</StringPooling>
<RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
<ClCompile>
<Optimization>MaxSpeed</Optimization>
<InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<StringPooling>true</StringPooling>
<RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
<ClCompile>
<Optimization>MaxSpeed</Optimization>
<InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<StringPooling>true</StringPooling>
<RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
<ClCompile>
<Optimization>MaxSpeed</Optimization>
<InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<StringPooling>true</StringPooling>
<RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
</Midl>
<ClCompile>
<Optimization>Disabled</Optimization>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>_DEBUG;_CONSOLE;DEBUGBUILD;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<MinimalRebuild>true</MinimalRebuild>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
</Midl>
<ClCompile>
<Optimization>Disabled</Optimization>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>_DEBUG;_CONSOLE;DEBUGBUILD;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<MinimalRebuild>true</MinimalRebuild>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
<ClCompile>
<Optimization>MaxSpeed</Optimization>
<InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<StringPooling>true</StringPooling>
<RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
<ClCompile>
<Optimization>MaxSpeed</Optimization>
<InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<StringPooling>true</StringPooling>
<RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
</Midl>
<ClCompile>
<Optimization>Disabled</Optimization>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>_DEBUG;_CONSOLE;DEBUGBUILD;CURL_STATICLIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<MinimalRebuild>true</MinimalRebuild>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
</Midl>
<ClCompile>
<Optimization>Disabled</Optimization>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>_DEBUG;_CONSOLE;DEBUGBUILD;CURL_STATICLIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<MinimalRebuild>true</MinimalRebuild>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
<ClCompile>
<Optimization>MaxSpeed</Optimization>
<InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>NDEBUG;_CONSOLE;CURL_STATICLIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<StringPooling>true</StringPooling>
<RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
<ClCompile>
<Optimization>MaxSpeed</Optimization>
<InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>NDEBUG;_CONSOLE;CURL_STATICLIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<StringPooling>true</StringPooling>
<RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
</Midl>
<ClCompile>
<Optimization>Disabled</Optimization>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>_DEBUG;_CONSOLE;DEBUGBUILD;CURL_STATICLIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<MinimalRebuild>true</MinimalRebuild>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
</Midl>
<ClCompile>
<Optimization>Disabled</Optimization>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>_DEBUG;_CONSOLE;DEBUGBUILD;CURL_STATICLIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<MinimalRebuild>true</MinimalRebuild>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
<ClCompile>
<Optimization>MaxSpeed</Optimization>
<InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>NDEBUG;_CONSOLE;CURL_STATICLIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<StringPooling>true</StringPooling>
<RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
<ClCompile>
<Optimization>MaxSpeed</Optimization>
<InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>NDEBUG;_CONSOLE;CURL_STATICLIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<StringPooling>true</StringPooling>
<RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
</Midl>
<ClCompile>
<Optimization>Disabled</Optimization>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>_DEBUG;_CONSOLE;DEBUGBUILD;CURL_STATICLIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<MinimalRebuild>true</MinimalRebuild>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
</Midl>
<ClCompile>
<Optimization>Disabled</Optimization>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>_DEBUG;_CONSOLE;DEBUGBUILD;CURL_STATICLIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<MinimalRebuild>true</MinimalRebuild>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
<ClCompile>
<Optimization>MaxSpeed</Optimization>
<InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>NDEBUG;_CONSOLE;CURL_STATICLIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<StringPooling>true</StringPooling>
<RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
<ClCompile>
<Optimization>MaxSpeed</Optimization>
<InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>NDEBUG;_CONSOLE;CURL_STATICLIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<StringPooling>true</StringPooling>
<RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
</Midl>
<ClCompile>
<Optimization>Disabled</Optimization>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>_DEBUG;_CONSOLE;DEBUGBUILD;CURL_STATICLIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<MinimalRebuild>true</MinimalRebuild>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
</Midl>
<ClCompile>
<Optimization>Disabled</Optimization>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>_DEBUG;_CONSOLE;DEBUGBUILD;CURL_STATICLIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<MinimalRebuild>true</MinimalRebuild>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
<ClCompile>
<Optimization>MaxSpeed</Optimization>
<InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>NDEBUG;_CONSOLE;CURL_STATICLIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<StringPooling>true</StringPooling>
<RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
<ClCompile>
<Optimization>MaxSpeed</Optimization>
<InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>NDEBUG;_CONSOLE;CURL_STATICLIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<StringPooling>true</StringPooling>
<RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
</Midl>
<ClCompile>
<Optimization>Disabled</Optimization>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>_DEBUG;_CONSOLE;DEBUGBUILD;CURL_STATICLIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<MinimalRebuild>true</MinimalRebuild>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
</Midl>
<ClCompile>
<Optimization>Disabled</Optimization>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>_DEBUG;_CONSOLE;DEBUGBUILD;CURL_STATICLIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<MinimalRebuild>true</MinimalRebuild>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
</Midl>
<ClCompile>
<Optimization>Disabled</Optimization>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>_DEBUG;_CONSOLE;DEBUGBUILD;CURL_STATICLIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<MinimalRebuild>true</MinimalRebuild>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
</Midl>
<ClCompile>
<Optimization>Disabled</Optimization>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>_DEBUG;_CONSOLE;DEBUGBUILD;CURL_STATICLIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<MinimalRebuild>true</MinimalRebuild>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
<ClCompile>
<Optimization>MaxSpeed</Optimization>
<InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>NDEBUG;_CONSOLE;CURL_STATICLIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<StringPooling>true</StringPooling>
<RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
<ClCompile>
<Optimization>MaxSpeed</Optimization>
<InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>NDEBUG;_CONSOLE;CURL_STATICLIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<StringPooling>true</StringPooling>
<RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
<ClCompile>
<Optimization>MaxSpeed</Optimization>
<InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>NDEBUG;_CONSOLE;CURL_STATICLIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<StringPooling>true</StringPooling>
<RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
<ClCompile>
<Optimization>MaxSpeed</Optimization>
<InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
- <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\..\lib;..\..\..\..\lib\curlx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>NDEBUG;_CONSOLE;CURL_STATICLIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<StringPooling>true</StringPooling>
<RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
</Link>
</ItemDefinitionGroup>
<ItemGroup>
+CURL_LIB_CURLX_C_FILES
CURL_SRC_X_C_FILES
CURL_SRC_C_FILES
</ItemGroup>
<ItemGroup>
+CURL_LIB_CURLX_H_FILES
CURL_SRC_X_H_FILES
CURL_SRC_H_FILES
</ItemGroup>
) else if "!var!" == "CURL_SRC_RC_FILES" (
for /f "delims=" %%r in ('dir /b ..\src\*.rc') do call :element %1 src "%%r" %3
) else if "!var!" == "CURL_SRC_X_C_FILES" (
- call :element %1 lib "strparse.c" %3
call :element %1 lib "strcase.c" %3
- call :element %1 lib "timeval.c" %3
call :element %1 lib "nonblock.c" %3
- call :element %1 lib "warnless.c" %3
call :element %1 lib "curl_multibyte.c" %3
call :element %1 lib "version_win32.c" %3
- call :element %1 lib "dynbuf.c" %3
- call :element %1 lib "base64.c" %3
) else if "!var!" == "CURL_SRC_X_H_FILES" (
call :element %1 lib "config-win32.h" %3
call :element %1 lib "curl_setup.h" %3
- call :element %1 lib "strparse.h" %3
call :element %1 lib "strcase.h" %3
- call :element %1 lib "timeval.h" %3
call :element %1 lib "nonblock.h" %3
- call :element %1 lib "warnless.h" %3
call :element %1 lib "curl_ctype.h" %3
call :element %1 lib "curl_multibyte.h" %3
call :element %1 lib "version_win32.h" %3
- call :element %1 lib "dynbuf.h" %3
- call :element %1 lib "curl_base64.h" %3
) else if "!var!" == "CURL_LIB_C_FILES" (
for /f "delims=" %%c in ('dir /b ..\lib\*.c') do call :element %1 lib "%%c" %3
) else if "!var!" == "CURL_LIB_H_FILES" (
for /f "delims=" %%h in ('dir /b ..\lib\*.h') do call :element %1 lib "%%h" %3
) else if "!var!" == "CURL_LIB_RC_FILES" (
for /f "delims=" %%r in ('dir /b ..\lib\*.rc') do call :element %1 lib "%%r" %3
+ ) else if "!var!" == "CURL_LIB_CURLX_C_FILES" (
+ for /f "delims=" %%c in ('dir /b ..\lib\curlx\*.c') do call :element %1 lib\curlx "%%c" %3
+ ) else if "!var!" == "CURL_LIB_CURLX_H_FILES" (
+ for /f "delims=" %%h in ('dir /b ..\lib\curlx\*.h') do call :element %1 lib\curlx "%%h" %3
) else if "!var!" == "CURL_LIB_VAUTH_C_FILES" (
for /f "delims=" %%c in ('dir /b ..\lib\vauth\*.c') do call :element %1 lib\vauth "%%c" %3
) else if "!var!" == "CURL_LIB_VAUTH_H_FILES" (
set "TABS= "
) else if "%2" == "lib\vtls" (
set "TABS= "
+ ) else if "%2" == "lib\curlx" (
+ set "TABS= "
) else (
set "TABS= "
)
endif()
endif()
-# Get 'CURL_CFILES', 'CURLX_CFILES', 'CURL_HFILES', 'CURLTOOL_LIBCURL_CFILES' variables
+# Get 'CURL_CFILES', 'CURLX_CFILES', 'CURL_HFILES' variables
curl_transform_makefile_inc("Makefile.inc" "${CMAKE_CURRENT_BINARY_DIR}/Makefile.inc.cmake")
include("${CMAKE_CURRENT_BINARY_DIR}/Makefile.inc.cmake")
endif()
if(BUILD_STATIC_CURL)
- set(CURLX_CFILES ${CURLTOOL_LIBCURL_CFILES})
+ set(CURLX_CFILES "")
endif()
set_property(DIRECTORY APPEND PROPERTY INCLUDE_DIRECTORIES
"${PROJECT_BINARY_DIR}/lib" # for "curl_config.h"
"${PROJECT_SOURCE_DIR}/lib" # for "curl_setup.h"
+ "${PROJECT_SOURCE_DIR}/lib/curlx" # for curlx functions
# This is needed as tool_hugehelp.c is generated in the binary dir
"${PROJECT_SOURCE_DIR}/src" # for "tool_hugehelp.h"
)
curltool # special libcurltool library just for unittests
STATIC
EXCLUDE_FROM_ALL
- ${CURL_CFILES} ${CURLTOOL_LIBCURL_CFILES} ${CURL_HFILES}
+ ${CURL_CFILES} ${CURL_HFILES}
)
target_compile_definitions(curltool PUBLIC "CURL_STATICLIB" "UNITTESTS")
target_link_libraries(curltool PRIVATE ${CURL_LIBS})
-I$(top_builddir)/lib \
-I$(top_builddir)/src \
-I$(top_srcdir)/lib \
+ -I$(top_srcdir)/lib/curlx \
-I$(top_srcdir)/src
bin_PROGRAMS = curl
if USE_UNITY
if USE_CPPFLAG_CURL_STATICLIB
-curl_CURLX = $(CURLTOOL_LIBCURL_CFILES)
+curl_CURLX =
else
curl_CURLX = $(CURLX_CFILES)
endif
libcurltool_la_CFLAGS =
libcurltool_la_LDFLAGS = -static $(LINKFLAGS)
if USE_UNITY
-libcurltool_unity.c: $(top_srcdir)/scripts/mk-unity.pl $(CURL_CFILES) $(CURLTOOL_LIBCURL_CFILES)
- @PERL@ $(top_srcdir)/scripts/mk-unity.pl $(srcdir) $(CURL_CFILES) $(CURLTOOL_LIBCURL_CFILES) > libcurltool_unity.c
+libcurltool_unity.c: $(top_srcdir)/scripts/mk-unity.pl $(CURL_CFILES) $(curl_CURLX)
+ @PERL@ $(top_srcdir)/scripts/mk-unity.pl $(srcdir) $(CURL_CFILES) $(curl_CURLX) > libcurltool_unity.c
nodist_libcurltool_la_SOURCES = libcurltool_unity.c
libcurltool_la_SOURCES =
# CSRC2 = file4.c file5.c file6.c
# CSOURCES = $(CSRC1) $(CSRC2)
-# libcurl sources to include in curltool lib we use for test binaries
-CURLTOOL_LIBCURL_CFILES = \
- ../lib/base64.c \
- ../lib/dynbuf.c \
- ../lib/timeval.c
-
# libcurl has sources that provide functions named curlx_* that are not part of
# the official API, but we reuse the code here to avoid duplication.
CURLX_CFILES = \
- ../lib/base64.c \
+ ../lib/curlx/base64.c \
../lib/curl_multibyte.c \
- ../lib/dynbuf.c \
+ ../lib/curlx/dynbuf.c \
../lib/nonblock.c \
- ../lib/strparse.c \
+ ../lib/curlx/strparse.c \
../lib/strcase.c \
- ../lib/timediff.c \
- ../lib/timeval.c \
+ ../lib/curlx/timediff.c \
+ ../lib/curlx/timeval.c \
../lib/version_win32.c \
- ../lib/warnless.c
+ ../lib/curlx/warnless.c
CURLX_HFILES = \
../lib/curl_ctype.h \
../lib/curl_multibyte.h \
../lib/curl_setup.h \
- ../lib/dynbuf.h \
+ ../lib/curlx/dynbuf.h \
../lib/nonblock.h \
- ../lib/strparse.h \
+ ../lib/curlx/strparse.h \
../lib/strcase.h \
- ../lib/timediff.h \
- ../lib/timeval.h \
+ ../lib/curlx/timediff.h \
+ ../lib/curlx/timeval.h \
../lib/version_win32.h \
- ../lib/warnless.h
+ ../lib/curlx/warnless.h
CURL_CFILES = \
slist_wc.c \
#endif
#include "terminal.h"
-#include "curlx.h"
-
-#include "memdebug.h" /* keep this as LAST include */
+#include <curlx.h>
+#include <memdebug.h> /* keep this as LAST include */
#ifdef HAVE_TERMIOS_H
# include <termios.h>
***************************************************************************/
#include "tool_setup.h"
-#include "curlx.h"
+#include <curlx.h>
#include "tool_cfgable.h"
#include "tool_msgs.h"
#include "tool_cb_dbg.h"
#include "tool_util.h"
-#include "memdebug.h" /* keep this as LAST include */
+#include <memdebug.h> /* keep this as LAST include */
static void dump(const char *timebuf, const char *idsbuf, const char *text,
FILE *stream, const unsigned char *ptr, size_t size,
***************************************************************************/
#include "tool_setup.h"
-#include "strcase.h"
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
-#include "curlx.h"
+#include <curlx.h>
#include "tool_cfgable.h"
#include "tool_doswin.h"
#include "tool_operate.h"
#include "tool_libinfo.h"
-#include "memdebug.h" /* keep this as LAST include */
+#include <memdebug.h> /* keep this as LAST include */
static char *parse_filename(const char *ptr, size_t len);
***************************************************************************/
#include "tool_setup.h"
-#include "curlx.h"
+#include <curlx.h>
#include "tool_cfgable.h"
#include "tool_cb_prg.h"
#include "tool_operate.h"
#include "terminal.h"
-#include "memdebug.h" /* keep this as LAST include */
+#include <memdebug.h> /* keep this as LAST include */
#define MAX_BARLENGTH 400
#define MIN_BARLENGTH 20
#include <sys/select.h>
#endif
-#include "curlx.h"
+#include <curlx.h>
#include "tool_cfgable.h"
#include "tool_cb_rea.h"
#include "tool_msgs.h"
#include "tool_sleep.h"
-#include "memdebug.h" /* keep this as LAST include */
+#include <memdebug.h> /* keep this as LAST include */
/*
** callback for CURLOPT_READFUNCTION
***************************************************************************/
#include "tool_setup.h"
-#include "curlx.h"
+#include <curlx.h>
#include "tool_cfgable.h"
#include "tool_operate.h"
#include "tool_cb_see.h"
-#include "memdebug.h" /* keep this as LAST include */
+#include <memdebug.h> /* keep this as LAST include */
/*
** callback for CURLOPT_SEEKFUNCTION
#include <sys/stat.h>
-#include "curlx.h"
+#include <curlx.h>
#include "tool_cfgable.h"
#include "tool_msgs.h"
#include "tool_cb_wrt.h"
#include "tool_operate.h"
-#include "memdebug.h" /* keep this as LAST include */
+#include <memdebug.h> /* keep this as LAST include */
#ifdef _WIN32
#define OPENMODE S_IREAD | S_IWRITE
#include "tool_formparse.h"
#include "tool_paramhlp.h"
#include "tool_main.h"
-#include "curlx.h"
-
-#include "memdebug.h" /* keep this as LAST include */
+#include <curlx.h>
+#include <memdebug.h> /* keep this as LAST include */
void config_init(struct OperationConfig *config)
{
* SPDX-License-Identifier: curl
*
***************************************************************************/
+
+#include <curl/mprintf.h>
#include "tool_setup.h"
#include "tool_sdecls.h"
#include "tool_urlglob.h"
#endif
#endif
+/* make the tool use the libcurl *printf family */
+# undef printf
+# undef fprintf
+# undef msnprintf
+# undef vprintf
+# undef vfprintf
+# undef mvsnprintf
+# undef aprintf
+# undef vaprintf
+# define printf curl_mprintf
+# define fprintf curl_mfprintf
+# define msnprintf curl_msnprintf
+# define vprintf curl_mvprintf
+# define vfprintf curl_mvfprintf
+# define mvsnprintf curl_mvsnprintf
+# define aprintf curl_maprintf
+# define vaprintf curl_mvaprintf
+
+#define checkprefix(a,b) curl_strnequal(b, STRCONST(a))
+
struct GlobalConfig;
struct State {
struct OperationConfig {
struct State state; /* for create_transfer() */
- struct curlx_dynbuf postdata;
+ struct dynbuf postdata;
char *useragent;
struct curl_slist *cookies; /* cookies to serialize into a single line */
char *cookiejar; /* write to this file */
# include <direct.h>
#endif
-#include "curlx.h"
+#include <curlx.h>
#include "tool_dirhie.h"
#include "tool_msgs.h"
-#include "dynbuf.h"
-#include "memdebug.h" /* keep this as LAST include */
+#include <memdebug.h> /* keep this as LAST include */
#if defined(_WIN32) || (defined(MSDOS) && !defined(__DJGPP__))
# define mkdir(x,y) (mkdir)((x))
{
CURLcode result = CURLE_OK;
size_t outlen = strlen(outfile);
- struct curlx_dynbuf dirbuf;
+ struct dynbuf dirbuf;
curlx_dyn_init(&dirbuf, outlen + 1);
#include "tool_bname.h"
#include "tool_doswin.h"
-#include "curlx.h"
-#include "memdebug.h" /* keep this as LAST include */
+#include <curlx.h>
+#include <memdebug.h> /* keep this as LAST include */
#ifdef _WIN32
# undef PATH_MAX
#ifndef CURL_DISABLE_LIBCURL_OPTION
-#include "curlx.h"
+#include <curlx.h>
#include "tool_cfgable.h"
#include "tool_easysrc.h"
#include "tool_msgs.h"
-#include "memdebug.h" /* keep this as LAST include */
+#include <memdebug.h> /* keep this as LAST include */
/* global variable definitions, for easy-interface source code generation */
#include "tool_filetime.h"
#include "tool_cfgable.h"
#include "tool_msgs.h"
-#include "curlx.h"
+#include <curlx.h>
#ifdef HAVE_UTIME_H
# include <utime.h>
#include <curlx.h>
#include "tool_findfile.h"
+#include "tool_cfgable.h"
#include "memdebug.h" /* keep this as LAST include */
***************************************************************************/
#include "tool_setup.h"
-#include "strcase.h"
-
-#include "curlx.h"
+#include <curlx.h>
#include "tool_cfgable.h"
#include "tool_msgs.h"
#include "tool_paramhlp.h"
#include "tool_formparse.h"
-#include "memdebug.h" /* keep this as LAST include */
+#include <memdebug.h> /* keep this as LAST include */
/* tool_mime functions. */
static struct tool_mime *tool_mime_new(struct tool_mime *parent,
***************************************************************************/
#include "tool_setup.h"
-#include "strcase.h"
-
-#include "curlx.h"
-
+#include <curlx.h>
#include "tool_binmode.h"
#include "tool_cfgable.h"
#include "tool_cb_prg.h"
#include "tool_paramhlp.h"
#include "tool_parsecfg.h"
#include "tool_main.h"
-#include "dynbuf.h"
#include "tool_stderr.h"
#include "var.h"
-#include "memdebug.h" /* keep this as LAST include */
+#include <memdebug.h> /* keep this as LAST include */
#define ALLOW_BLANK TRUE
#define DENY_BLANK FALSE
char *n;
replace_url_encoded_space_by_plus(enc);
if(nlen > 0) { /* only append '=' if we have a name */
- struct curlx_dynbuf dyn;
+ struct dynbuf dyn;
curlx_dyn_init(&dyn, MAX_DATAURLENCODE);
if(curlx_dyn_addn(&dyn, nextarg, nlen) ||
curlx_dyn_addn(&dyn, "=", 1) ||
break;
}
- if((len == 3) && strncasecompare(name, "all", 3)) {
+ if((len == 3) && curl_strnequal(name, "all", 3)) {
global->traceids = toggle;
global->tracetime = toggle;
result = curl_global_trace(token);
if(result)
goto out;
}
- else if((len == 3) && strncasecompare(name, "ids", 3)) {
+ else if((len == 3) && curl_strnequal(name, "ids", 3)) {
global->traceids = toggle;
}
- else if((len == 4) && strncasecompare(name, "time", 4)) {
+ else if((len == 4) && curl_strnequal(name, "time", 4)) {
global->tracetime = toggle;
}
else {
size_t size = 0;
ParameterError err = PARAM_OK;
char *query;
- struct curlx_dynbuf dyn;
+ struct dynbuf dyn;
curlx_dyn_init(&dyn, MAX_QUERY_LEN);
if(*nextarg == '+') {
{
if(nextarg && (nextarg[0] == '@')) {
/* read URLs from a file, treat all as -O */
- struct curlx_dynbuf line;
+ struct dynbuf line;
ParameterError err = PARAM_OK;
bool error = FALSE;
bool fromstdin = !strcmp("-", &nextarg[1]);
ParameterError err = PARAM_OK;
if(!feature_ech)
err = PARAM_LIBCURL_DOESNT_SUPPORT;
- else if(strlen(nextarg) > 4 && strncasecompare("pn:", nextarg, 3)) {
+ else if(strlen(nextarg) > 4 && curl_strnequal("pn:", nextarg, 3)) {
/* a public_name */
err = getstr(&config->ech_public, nextarg, DENY_BLANK);
}
- else if(strlen(nextarg) > 5 && strncasecompare("ecl:", nextarg, 4)) {
+ else if(strlen(nextarg) > 5 && curl_strnequal("ecl:", nextarg, 4)) {
/* an ECHConfigList */
if('@' != *(nextarg + 4)) {
err = getstr(&config->ech_config, nextarg, DENY_BLANK);
goto error;
}
else if(expand && nextarg) {
- struct curlx_dynbuf nbuf;
+ struct dynbuf nbuf;
bool replaced;
if((ARGTYPE(a->desc) != ARG_STRG) &&
***************************************************************************/
#include "tool_setup.h"
-#include "curlx.h"
+#include <curlx.h>
#include "tool_help.h"
#include "tool_libinfo.h"
#include "tool_cb_prg.h"
#include "tool_hugehelp.h"
#include "tool_getparam.h"
+#include "tool_cfgable.h"
#include "terminal.h"
-#include "memdebug.h" /* keep this as LAST include */
+#include <memdebug.h> /* keep this as LAST include */
struct category_descriptors {
const char *opt;
***************************************************************************/
#include "tool_setup.h"
-#include "strcase.h"
-
-#include "curlx.h"
+#include <curlx.h>
#include "tool_cfgable.h"
#include "tool_msgs.h"
#include "tool_getparam.h"
#include "tool_helpers.h"
-
-#include "memdebug.h" /* keep this as LAST include */
+#include <memdebug.h> /* keep this as LAST include */
/*
** Helper functions that are used from more than one source file.
#include "tool_setup.h"
#ifndef CURL_DISABLE_IPFS
-#include "curlx.h"
-#include "dynbuf.h"
+#include <curlx.h>
#include "tool_cfgable.h"
#include "tool_msgs.h"
#include "tool_ipfs.h"
-
-#include "memdebug.h" /* keep this as LAST include */
+#include <memdebug.h> /* keep this as LAST include */
/* ensure input ends in slash */
static CURLcode ensure_trailing_slash(char **input)
if(*input && **input) {
size_t len = strlen(*input);
if(((*input)[len - 1] != '/')) {
- struct curlx_dynbuf dyn;
+ struct dynbuf dyn;
curlx_dyn_init(&dyn, len + 2);
if(curlx_dyn_addn(&dyn, *input, len)) {
if(gateway_file) {
int c;
- struct curlx_dynbuf dyn;
+ struct dynbuf dyn;
curlx_dyn_init(&dyn, MAX_GATEWAY_URL_LEN);
/* get the first line of the gateway file, ignore the rest */
***************************************************************************/
#include "tool_setup.h"
-#include "strcase.h"
-
-#include "curlx.h"
-
+#include <curlx.h>
#include "tool_libinfo.h"
-
-#include "memdebug.h" /* keep this as LAST include */
+#include <memdebug.h> /* keep this as LAST include */
/* global variable definitions, for libcurl runtime info */
#include <fcntl.h>
#endif
-#include "curlx.h"
+#include <curlx.h>
#include "tool_cfgable.h"
#include "tool_doswin.h"
* the library level code from this client-side is ugly, but we do this
* anyway for convenience.
*/
-#include "memdebug.h" /* keep this as LAST include */
+#include <memdebug.h> /* keep this as LAST include */
#ifdef __VMS
/*
***************************************************************************/
#include "tool_setup.h"
-#include "curlx.h"
+#include <curlx.h>
#include "tool_cfgable.h"
#include "tool_msgs.h"
#include "tool_cb_prg.h"
#include "terminal.h"
-#include "memdebug.h" /* keep this as LAST include */
+#include <memdebug.h> /* keep this as LAST include */
#define WARN_PREFIX "Warning: "
#define NOTE_PREFIX "Note: "
#include <uv.h>
#endif
-#include "curlx.h"
+#include <curlx.h>
#include "tool_binmode.h"
#include "tool_cfgable.h"
#include "tool_hugehelp.h"
#include "tool_progress.h"
#include "tool_ipfs.h"
-#include "dynbuf.h"
+
#ifdef DEBUGBUILD
/* libcurl's debug-only curl_easy_perform_ev() */
CURL_EXTERN CURLcode curl_easy_perform_ev(CURL *easy);
my_setopt_slist(curl, CURLOPT_PREQUOTE, config->prequote);
if(config->cookies) {
- struct curlx_dynbuf cookies;
+ struct dynbuf cookies;
struct curl_slist *cl;
/* The maximum size needs to match MAX_NAME in cookie.h */
#include "tool_setup.h"
#include "tool_operate.h"
-#include "strcase.h"
-
-#include "curlx.h"
-
+#include <curlx.h>
#include "tool_cfgable.h"
#include "tool_doswin.h"
#include "tool_operhlp.h"
#include "tool_msgs.h"
-
-#include "memdebug.h" /* keep this as LAST include */
+#include <memdebug.h> /* keep this as LAST include */
void clean_getout(struct OperationConfig *config)
{
***************************************************************************/
#include "tool_setup.h"
-#include "strcase.h"
-#include "curlx.h"
+#include <curlx.h>
#include "tool_cfgable.h"
#include "tool_getparam.h"
#include "tool_libinfo.h"
#include "tool_util.h"
#include "tool_version.h"
-#include "dynbuf.h"
-#include "memdebug.h" /* keep this as LAST include */
+#include <memdebug.h> /* keep this as LAST include */
struct getout *new_getout(struct OperationConfig *config)
{
ParameterError file2string(char **bufp, FILE *file)
{
- struct curlx_dynbuf dyn;
+ struct dynbuf dyn;
curlx_dyn_init(&dyn, MAX_FILE2STRING);
if(file) {
do {
{
if(file) {
size_t nread;
- struct curlx_dynbuf dyn;
+ struct dynbuf dyn;
curl_off_t offset = 0;
curl_off_t throwaway = 0;
const char * const *val, char **ostr, const char *str)
{
const char **protoset;
- struct curlx_dynbuf obuf;
+ struct dynbuf obuf;
size_t proto;
CURLcode result;
/* no password present, prompt for one */
char passwd[2048] = "";
char prompt[256];
- struct curlx_dynbuf dyn;
+ struct dynbuf dyn;
curlx_dyn_init(&dyn, MAX_USERPWDLENGTH);
if(osep)
***************************************************************************/
#include "tool_setup.h"
-#include "curlx.h"
-
+#include <curlx.h>
#include "tool_cfgable.h"
#include "tool_getparam.h"
#include "tool_helpers.h"
#include "tool_msgs.h"
#include "tool_parsecfg.h"
#include "tool_util.h"
-#include "dynbuf.h"
-
-#include "memdebug.h" /* keep this as LAST include */
+#include <memdebug.h> /* keep this as LAST include */
/* only acknowledge colon or equals as separators if the option was not
specified with an initial dash! */
char *param;
int lineno = 0;
bool dashed_option;
- struct curlx_dynbuf buf;
+ struct dynbuf buf;
bool fileerror = FALSE;
curlx_dyn_init(&buf, MAX_CONFIG_LINE_LENGTH);
DEBUGASSERT(filename);
int parseconfig(const char *filename, struct GlobalConfig *config);
-bool my_get_line(FILE *fp, struct curlx_dynbuf *db, bool *error);
+bool my_get_line(FILE *fp, struct dynbuf *db, bool *error);
#endif /* HEADER_CURL_TOOL_PARSECFG_H */
#include "tool_operate.h"
#include "tool_progress.h"
#include "tool_util.h"
-
-#include "curlx.h"
+#include <curlx.h>
/* The point of this function would be to return a string of the input data,
but never longer than 5 columns (+ one zero byte).
#ifndef CURL_DISABLE_LIBCURL_OPTION
-#include "curlx.h"
-
+#include <curlx.h>
#include "tool_cfgable.h"
#include "tool_easysrc.h"
#include "tool_setopt.h"
#include "tool_msgs.h"
-#include "dynbuf.h"
-
-#include "memdebug.h" /* keep this as LAST include */
+#include <memdebug.h> /* keep this as LAST include */
/* Lookup tables for converting setopt values back to symbols */
/* For enums, values may be in any order. */
const char *s;
unsigned int cutoff = 0;
CURLcode result;
- struct curlx_dynbuf escaped;
+ struct dynbuf escaped;
curlx_dyn_init(&escaped, 4 * MAX_STRING_LENGTH_OUTPUT + 3);
***************************************************************************/
#include "tool_setup.h"
-#include "curlx.h"
+#include <curlx.h>
#include "tool_cfgable.h"
#include "tool_cb_dbg.h"
#include "tool_msgs.h"
#include "tool_setopt.h"
#include "tool_ssls.h"
-#include "dynbuf.h"
-#include "curl_base64.h"
#include "tool_parsecfg.h"
/* The maximum line length for an ecoded session ticket */
***************************************************************************/
#include "tool_setup.h"
-#include "curlx.h"
+#include <curlx.h>
#include "tool_cfgable.h"
#include "tool_doswin.h"
#include "tool_urlglob.h"
#include "tool_vms.h"
-#include "dynbuf.h"
-
-#include "memdebug.h" /* keep this as LAST include */
+#include <memdebug.h> /* keep this as LAST include */
#define GLOBERROR(string, column, code) \
glob->error = string, glob->pos = column, code
char numbuf[18];
const char *appendthis = "";
size_t appendlen = 0;
- struct curlx_dynbuf dyn;
+ struct dynbuf dyn;
*result = NULL;
#include "tool_setup.h"
#include "tool_util.h"
-
-#include "curlx.h"
-#include "memdebug.h" /* keep this as LAST include */
+#include <curlx.h>
+#include <memdebug.h> /* keep this as LAST include */
#ifdef _WIN32
/* If we have enough space, build the RC filename */
remaining = sizeof(filebuffer) - strlen(filebuffer);
if(strlen(filename) < remaining - 1) {
- msnprintf(lastdirchar, remaining, "%s%s", DIR_CHAR, filename);
+ curl_msnprintf(lastdirchar, remaining, "%s%s", DIR_CHAR, filename);
*pathp = filebuffer;
return fopen(filebuffer, FOPEN_READTEXT);
}
#include <unixlib.h>
#endif
-#include "curlx.h"
-
+#include <curlx.h>
#include "curlmsg_vms.h"
#include "tool_vms.h"
-
-#include "memdebug.h" /* keep this as LAST include */
+#include <memdebug.h> /* keep this as LAST include */
void decc$__posix_exit(int __status);
void decc$exit(int __status);
***************************************************************************/
#include "tool_setup.h"
-#include "curlx.h"
+#include <curlx.h>
#include "tool_cfgable.h"
#include "tool_writeout.h"
#include "tool_writeout_json.h"
-#include "dynbuf.h"
-
-#include "memdebug.h" /* keep this as LAST include */
+#include <memdebug.h> /* keep this as LAST include */
static int writeTime(FILE *stream, const struct writeoutvar *wovar,
struct per_transfer *per, CURLcode per_result,
***************************************************************************/
#include "tool_setup.h"
-#include "curlx.h"
+#include <curlx.h>
#include "tool_cfgable.h"
#include "tool_writeout_json.h"
#include "tool_writeout.h"
Return 0 on success, non-zero on error.
*/
int jsonquoted(const char *in, size_t len,
- struct curlx_dynbuf *out, bool lowercase)
+ struct dynbuf *out, bool lowercase)
{
const unsigned char *i = (const unsigned char *)in;
const unsigned char *in_end = &i[len];
void jsonWriteString(FILE *stream, const char *in, bool lowercase)
{
- struct curlx_dynbuf out;
+ struct dynbuf out;
curlx_dyn_init(&out, MAX_JSON_STRING);
if(!jsonquoted(in, strlen(in), &out, lowercase)) {
#include "tool_writeout.h"
int jsonquoted(const char *in, size_t len,
- struct curlx_dynbuf *out, bool lowercase);
+ struct dynbuf *out, bool lowercase);
void ourWriteOutJSON(FILE *stream, const struct writeoutvar mappings[],
size_t nentries,
***************************************************************************/
#include "tool_setup.h"
-#include "curlx.h"
-
+#include <curlx.h>
#include "tool_cfgable.h"
#include "tool_getparam.h"
#include "tool_helpers.h"
#include "tool_findfile.h"
#include "tool_msgs.h"
#include "tool_parsecfg.h"
-#include "dynbuf.h"
-#include "curl_base64.h"
#include "tool_paramhlp.h"
#include "tool_writeout_json.h"
#include "var.h"
-
-#include "memdebug.h" /* keep this as LAST include */
+#include <memdebug.h> /* keep this as LAST include */
#define MAX_EXPAND_CONTENT 10000000
#define MAX_VAR_LEN 128 /* max length of a name */
size_t clen, /* content length */
char *f, /* functions */
size_t flen, /* function string length */
- struct curlx_dynbuf *out)
+ struct dynbuf *out)
{
bool alloc = FALSE;
ParameterError err = PARAM_OK;
}
ParameterError varexpand(struct GlobalConfig *global,
- const char *line, struct curlx_dynbuf *out,
+ const char *line, struct dynbuf *out,
bool *replaced)
{
CURLcode result;
else {
char *value;
size_t vlen = 0;
- struct curlx_dynbuf buf;
+ struct dynbuf buf;
const struct tool_var *v = varcontent(global, name, nlen);
if(v) {
value = (char *)CURL_UNCONST(v->content);
***************************************************************************/
#include "tool_getparam.h"
-#include "dynbuf.h"
+#include <curlx.h>
struct tool_var {
struct tool_var *next;
ParameterError setvariable(struct GlobalConfig *global, const char *input);
ParameterError varexpand(struct GlobalConfig *global,
- const char *line, struct curlx_dynbuf *out,
+ const char *line, struct dynbuf *out,
bool *replaced);
/* free everything */
<verify>
<stdout>
-Curl_str_word
+curlx_str_word
0: ("word") 0, "word" [4], line 4
1: ("word ") 0, "word" [4], line 4
2: (" word ") 2, "" [0], line 0
6: ("perfect") 0, "perfect" [7], line 7
7: ("") 2, "" [0], line 0
8: ("longerth") 1, "" [0], line 0
-Curl_str_until
+curlx_str_until
0: ("word") 0, "wor" [3], line 3
1: ("word ") 0, "wor" [3], line 3
2: (" word ") 0, " wor" [4], line 4
6: ("perfect") 0, "perfect" [7], line 7
7: ("") 2, "" [0], line 0
8: ("longerth") 1, "" [0], line 0
-Curl_str_quotedword
+curlx_str_quotedword
0: (""word"") 0, "word" [4], line 6
1: (""word") 4, "" [0], line 0
2: ("word"") 3, "" [0], line 0
9: ("""") 0, "" [0], line 2
10: ("") 3, "" [0], line 0
11: (""longerth"") 1, "" [0], line 0
-Curl_str_single
+curlx_str_single
0: ("a") 0, line 1
1: ("aa") 0, line 1
2: ("A") 5, line 0
4: ("\") 5, line 0
5: (" ") 5, line 0
6: ("") 5, line 0
-Curl_str_singlespace
+curlx_str_singlespace
0: ("a") 5, line 0
1: ("aa") 5, line 0
2: ("A") 5, line 0
7: ("
") 5, line 0
8: ("") 5, line 0
-Curl_str_single
+curlx_str_single
0: ("a") 0, line 1
1: ("aa") 0, line 1
2: ("A") 5, line 0
4: ("\") 5, line 0
5: (" ") 5, line 0
6: ("") 5, line 0
-Curl_str_number
+curlx_str_number
0: ("1") 0, [1] line 1
1: ("10000") 7, [0] line 0
2: ("1234") 0, [1234] line 4
9: ("-12") 8, [0] line 0
10: (" 123") 8, [0] line 0
11: ("") 8, [0] line 0
-Curl_str_number varying max
+curlx_str_number varying max
0: ("00") max 8 == 0, [0]
1: ("1") max 8 == 0, [1]
2: ("1") max 1 == 0, [1]
10: ("10") max 10 == 0, [10]
11: ("11") max 10 == 7, [0]
12: ("12") max 10 == 7, [0]
-Curl_str_hex varying max
+curlx_str_hex varying max
0: ("00") max 8 == 0, [0]
1: ("1") max 8 == 0, [1]
2: ("1") max 1 == 0, [1]
17: ("10") max 16 == 0, [16]
18: ("11") max 16 == 7, [0]
19: ("12") max 16 == 7, [0]
-Curl_str_octal varying max
+curlx_str_octal varying max
0: ("00") max 4 == 0, [0]
1: ("1") max 4 == 0, [1]
2: ("1") max 4 == 0, [1]
12: ("12") max 9 == 7, [0]
13: ("13") max 9 == 7, [0]
14: ("8") max 10 == 8, [0]
-Curl_str_number / max
+curlx_str_number / max
0: ("9223372036854775807") 0, [9223372036854775807] line 19
1: ("9223372036854775808") 7, [0] line 0
2: ("18446744073709551615") 7, [0] line 0
16: ("7777777777777777777") 0, [7777777777777777777] line 19
17: ("8888888888888888888") 0, [8888888888888888888] line 19
18: ("999999999999999999") 0, [999999999999999999] line 18
-Curl_str_newline
+curlx_str_newline
0: (%61) 6, line 0
1: (%61) 6, line 0
2: (%41) 6, line 0
8: (%0d) 0, line 1
9: (%0c) 6, line 0
10: (%00) 6, line 0
-Curl_str_hex
+curlx_str_hex
0: ("1") 0, [1] line 1
1: ("1000") 0, [4096] line 4
2: ("1234") 0, [4660] line 4
9: ("-12") 8, [0] line 0
10: (" 123") 8, [0] line 0
11: ("") 8, [0] line 0
-Curl_str_octal
+curlx_str_octal
0: ("1") 0, [1] line 1
1: ("1000") 0, [512] line 4
2: ("1234") 0, [668] line 4
9: ("-12") 8, [0] line 0
10: (" 123") 8, [0] line 0
11: ("") 8, [0] line 0
-Curl_str_octal / max
+curlx_str_octal / max
0: ("777777777777777777777") 0, [9223372036854775807] line 21
1: ("1000000000000000000000") 7, [0] line 0
2: ("111111111111111111111") 0, [1317624576693539401] line 21
5: ("444444444444444444444") 0, [5270498306774157604] line 21
6: ("555555555555555555555") 0, [6588122883467697005] line 21
7: ("666666666666666666666") 0, [7905747460161236406] line 21
-Curl_str_hex / max
+curlx_str_hex / max
0: ("7FFFFFFFFFFFFFFF") 0, [9223372036854775807] line 16
1: ("8000000000000000") 7, [0] line 0
2: ("1111111111111111") 0, [1229782938247303441] line 16
#
###########################################################################
-# Get 'LIBTESTPROGS', '*_SOURCES', 'TESTUTIL', 'TSTTRACE', 'WARNLESS', 'MULTIBYTE', 'INET_PTON', 'TIMEDIFF', 'THREADS',
+# Get 'LIBTESTPROGS', '*_SOURCES', 'TESTUTIL', 'TSTTRACE', 'WARNLESS', 'MULTIBYTE', 'INET_PTON', 'TIMEDIFF', 'THREADS', 'MEMPTR'
# 'FIRSTFILES' variables
curl_transform_makefile_inc("Makefile.inc" "${CMAKE_CURRENT_BINARY_DIR}/Makefile.inc.cmake")
include("${CMAKE_CURRENT_BINARY_DIR}/Makefile.inc.cmake")
list(APPEND libtests_SOURCES ${TESTUTIL} ${TSTTRACE})
if(LIB_SELECTED STREQUAL LIB_SHARED)
# These are part of the libcurl static lib. Add them here when linking shared.
- list(APPEND libtests_SOURCES ${WARNLESS} ${MULTIBYTE} ${INET_PTON} ${TIMEDIFF} ${THREADS})
+ list(APPEND libtests_SOURCES ${WARNLESS} ${MULTIBYTE} ${INET_PTON} ${TIMEDIFF} ${THREADS} ${MEMPTR})
endif()
endif()
target_include_directories(${_target_name} PRIVATE
"${PROJECT_BINARY_DIR}/lib" # for "curl_config.h"
"${PROJECT_SOURCE_DIR}/lib" # for "curl_setup.h"
+ "${PROJECT_SOURCE_DIR}/lib/curlx" # for curlx
"${PROJECT_SOURCE_DIR}/src" # for "tool_binmode.h"
"${PROJECT_SOURCE_DIR}/tests/libtest" # to be able to build generated tests
"${PROJECT_SOURCE_DIR}/tests/unit" # for curlcheck.h
AM_CPPFLAGS = -I$(top_srcdir)/include \
-I$(top_builddir)/lib \
-I$(top_srcdir)/lib \
+ -I$(top_srcdir)/lib/curlx \
-I$(top_srcdir)/src \
-I$(top_srcdir)/tests/libtest \
-I$(top_srcdir)/tests/unit
if USE_CPPFLAG_CURL_STATICLIB
else
# These are part of the libcurl static lib. Add them here when linking shared.
-libtests_SOURCES += $(WARNLESS) $(MULTIBYTE) $(INET_PTON) $(TIMEDIFF) $(THREADS)
+libtests_SOURCES += $(WARNLESS) $(MULTIBYTE) $(INET_PTON) $(TIMEDIFF) $(THREADS) $(MEMPTR)
endif
else
noinst_PROGRAMS = $(LIBTESTPROGS)
# files used only in some libcurl test programs
TESTUTIL = testutil.c testutil.h
TSTTRACE = testtrace.c testtrace.h
-WARNLESS = ../../lib/warnless.c ../../lib/warnless.h
+WARNLESS = ../../lib/curlx/warnless.c ../../lib/curlx/warnless.h
MULTIBYTE = ../../lib/curl_multibyte.c ../../lib/curl_multibyte.h
THREADS = ../../lib/curl_threads.c ../../lib/curl_threads.h
+MEMPTR = memptr.c
# these files are used in every single test program below
-TIMEDIFF = ../../lib/timediff.c ../../lib/timediff.h
+TIMEDIFF = ../../lib/curlx/timediff.c ../../lib/curlx/timediff.h
FIRSTFILES = first.c first.h
SUPPORTFILES = $(TIMEDIFF) $(FIRSTFILES) test.h
lib3105_SOURCES = lib3105.c $(SUPPORTFILES)
-lib3207_SOURCES = lib3207.c $(SUPPORTFILES) $(TESTUTIL) $(THREADS) $(WARNLESS) $(MULTIBYTE)
+lib3207_SOURCES = lib3207.c $(SUPPORTFILES) $(TESTUTIL) $(THREADS) $(WARNLESS) $(MULTIBYTE) $(MEMPTR)
lib3207_LDADD = $(TESTUTIL_LIBS)
lib3208_SOURCES = lib3208.c $(SUPPORTFILES) $(TESTUTIL)
#endif
#include "memdebug.h"
-#include "timediff.h"
+#include "curlx/timediff.h"
#include "tool_binmode.h"
int select_wrapper(int nfds, fd_set *rd, fd_set *wr, fd_set *exc,
if(len > 200)
return NULL;
for(i = 0; i < len; i++, p += 3)
- msnprintf(p, 4, "%02x ", buf[i]);
+ curl_msnprintf(p, 4, "%02x ", buf[i]);
return dump;
}
basearg = 2;
if(argc < (basearg + 1)) {
- fprintf(stderr, "Pass testname and URL as arguments please\n");
+ curl_mfprintf(stderr, "Pass testname and URL as arguments please\n");
return 1;
}
}
if(!test_func) {
- fprintf(stderr, "Test '%s' not found.\n", test_name);
+ curl_mfprintf(stderr, "Test '%s' not found.\n", test_name);
return 1;
}
}
basearg = 1;
if(argc < (basearg + 1)) {
- fprintf(stderr, "Pass URL as argument please\n");
+ curl_mfprintf(stderr, "Pass URL as argument please\n");
return 1;
}
URL = argv[basearg]; /* provide this to the rest */
- fprintf(stderr, "URL: %s\n", URL);
+ curl_mfprintf(stderr, "URL: %s\n", URL);
result = test_func(URL);
- fprintf(stderr, "Test ended with result %d\n", result);
+ curl_mfprintf(stderr, "Test ended with result %d\n", result);
#ifdef _WIN32
/* flush buffers of all streams regardless of mode */
replyselector = (p->flags & F_CONTENTRANGE) ? 1 : 0;
if(p->flags & F_HTTP416)
replyselector += 2;
- msnprintf(urlbuf, sizeof(urlbuf), "%s%04u", url, replyselector);
+ curl_msnprintf(urlbuf, sizeof(urlbuf), "%s%04u", url, replyselector);
test_setopt(curl, CURLOPT_URL, urlbuf);
test_setopt(curl, CURLOPT_VERBOSE, 1L);
test_setopt(curl, CURLOPT_RESUME_FROM, (p->flags & F_RESUME) ? 3L : 0L);
hasbody = 0;
res = curl_easy_perform(curl);
if(res != p->result) {
- printf("%zd: bad error code (%d): resume=%s, fail=%s, http416=%s, "
- "content-range=%s, expected=%d\n", num, res,
- (p->flags & F_RESUME) ? "yes": "no",
- (p->flags & F_FAIL) ? "yes": "no",
- (p->flags & F_HTTP416) ? "yes": "no",
- (p->flags & F_CONTENTRANGE) ? "yes": "no",
- p->result);
+ curl_mprintf("%zd: bad error code (%d): resume=%s, fail=%s, http416=%s, "
+ "content-range=%s, expected=%d\n", num, res,
+ (p->flags & F_RESUME) ? "yes": "no",
+ (p->flags & F_FAIL) ? "yes": "no",
+ (p->flags & F_HTTP416) ? "yes": "no",
+ (p->flags & F_CONTENTRANGE) ? "yes": "no",
+ p->result);
return 1;
}
if(hasbody && (p->flags & F_IGNOREBODY)) {
- printf("body should be ignored and is not: resume=%s, fail=%s, "
- "http416=%s, content-range=%s\n",
- (p->flags & F_RESUME) ? "yes": "no",
- (p->flags & F_FAIL) ? "yes": "no",
- (p->flags & F_HTTP416) ? "yes": "no",
- (p->flags & F_CONTENTRANGE) ? "yes": "no");
+ curl_mprintf("body should be ignored and is not: resume=%s, fail=%s, "
+ "http416=%s, content-range=%s\n",
+ (p->flags & F_RESUME) ? "yes": "no",
+ (p->flags & F_FAIL) ? "yes": "no",
+ (p->flags & F_HTTP416) ? "yes": "no",
+ (p->flags & F_CONTENTRANGE) ? "yes": "no");
return 1;
}
return 0;
int status = 0;
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
- fprintf(stderr, "curl_global_init() failed\n");
+ curl_mfprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
for(i = 0; i < CURL_ARRAYSIZE(testparams); i++) {
curl = curl_easy_init();
if(!curl) {
- fprintf(stderr, "curl_easy_init() failed\n");
+ curl_mfprintf(stderr, "curl_easy_init() failed\n");
curl_global_cleanup();
return TEST_ERR_MAJOR_BAD;
}
}
curl_global_cleanup();
- printf("%d\n", status);
+ curl_mprintf("%d\n", status);
return (CURLcode)status;
test_cleanup:
long httpcode = 0;
/* end of a response */
result = curl_easy_getinfo(st->easy, CURLINFO_RESPONSE_CODE, &httpcode);
- fprintf(stderr, "header_callback, get status: %ld, %d\n",
- httpcode, result);
+ curl_mfprintf(stderr, "header_callback, get status: %ld, %d\n",
+ httpcode, result);
if(httpcode < 100 || httpcode >= 1000) {
- fprintf(stderr, "header_callback, invalid status: %ld, %d\n",
- httpcode, result);
+ curl_mfprintf(stderr, "header_callback, invalid status: %ld, %d\n",
+ httpcode, result);
return CURLE_WRITE_ERROR;
}
st->http_status = (int)httpcode;
if(st->http_status >= 200 && st->http_status < 300) {
result = curl_easy_getinfo(st->easy, CURLINFO_CONTENT_LENGTH_DOWNLOAD_T,
&clen);
- fprintf(stderr, "header_callback, info Content-Length: %ld, %d\n",
- (long)clen, result);
+ curl_mfprintf(stderr, "header_callback, info Content-Length: %ld, %d\n",
+ (long)clen, result);
if(result) {
st->result = result;
return CURLE_WRITE_ERROR;
}
if(clen < 0) {
- fprintf(stderr, "header_callback, expected known Content-Length, "
- "got: %ld\n", (long)clen);
+ curl_mfprintf(stderr,
+ "header_callback, expected known Content-Length, "
+ "got: %ld\n", (long)clen);
return CURLE_WRITE_ERROR;
}
}
int num;
mres = curl_multi_wait(multi, NULL, 0, TEST_HANG_TIMEOUT, &num);
if(mres != CURLM_OK) {
- printf("curl_multi_wait() returned %d\n", mres);
+ curl_mprintf("curl_multi_wait() returned %d\n", mres);
res = TEST_ERR_MAJOR_BAD;
goto test_cleanup;
}
abort_on_test_timeout();
- fprintf(stderr, "ping\n");
+ curl_mfprintf(stderr, "ping\n");
before = tutil_tvnow();
multi_perform(mhandle, &still_running);
after = tutil_tvnow();
e = tutil_tvdiff(after, before);
- fprintf(stderr, "pong = %ld\n", e);
+ curl_mfprintf(stderr, "pong = %ld\n", e);
if(e > MAX_BLOCKED_TIME_MS) {
res = CURLE_TOO_LARGE;
return res;
}
- msnprintf(redirect, sizeof(redirect), "google.com:%s:%s", libtest_arg2,
- libtest_arg3);
+ curl_msnprintf(redirect, sizeof(redirect), "google.com:%s:%s", libtest_arg2,
+ libtest_arg3);
start_test_timing();
dns_cache_list = curl_slist_append(NULL, redirect);
if(!dns_cache_list) {
- fprintf(stderr, "curl_slist_append() failed\n");
+ curl_mfprintf(stderr, "curl_slist_append() failed\n");
curl_global_cleanup();
return TEST_ERR_MAJOR_BAD;
}
/* Create fake DNS entries for serverX.example.com for all handles */
for(i = 0; i < NUM_HANDLES; i++) {
- msnprintf(dnsentry, sizeof(dnsentry), "server%d.example.com:%s:%s",
- i + 1, port, address);
- printf("%s\n", dnsentry);
+ curl_msnprintf(dnsentry, sizeof(dnsentry), "server%d.example.com:%s:%s",
+ i + 1, port, address);
+ curl_mprintf("%s\n", dnsentry);
slist2 = curl_slist_append(slist, dnsentry);
if(!slist2) {
- fprintf(stderr, "curl_slist_append() failed\n");
+ curl_mfprintf(stderr, "curl_slist_append() failed\n");
goto test_cleanup;
}
slist = slist2;
/* get an easy handle */
easy_init(curl[i]);
/* specify target */
- msnprintf(target_url, sizeof(target_url),
- "http://server%d.example.com:%s/path/1506%04i",
- i + 1, port, i + 1);
+ curl_msnprintf(target_url, sizeof(target_url),
+ "http://server%d.example.com:%s/path/1506%04i",
+ i + 1, port, i + 1);
target_url[sizeof(target_url) - 1] = '\0';
easy_setopt(curl[i], CURLOPT_URL, target_url);
/* go verbose */
easy_setopt(curl[i], CURLOPT_RESOLVE, slist);
}
- fprintf(stderr, "Start at URL 0\n");
+ curl_mfprintf(stderr, "Start at URL 0\n");
for(i = 0; i < NUM_HANDLES; i++) {
/* add handle to multi */
rc = select(maxfd + 1, &fdread, &fdwrite, &fdexcep, &timeout);
if(tutil_tvdiff(tutil_tvnow(), mp_start) > MULTI_PERFORM_HANG_TIMEOUT) {
- fprintf(stderr, "ABORTING TEST, since it seems "
- "that it would have run forever.\n");
+ curl_mfprintf(stderr, "ABORTING TEST, since it seems "
+ "that it would have run forever.\n");
break;
}
curl_multi_cleanup(m);
curl_global_cleanup();
- printf("We are done\n");
+ curl_mprintf("We are done\n");
return res;
}
code = curl_easy_perform(curl);
if(CURLE_OK != code) {
- fprintf(stderr, "%s:%d curl_easy_perform() failed, "
- "with code %d (%s)\n",
- __FILE__, __LINE__, code, curl_easy_strerror(code));
+ curl_mfprintf(stderr, "%s:%d curl_easy_perform() failed, "
+ "with code %d (%s)\n",
+ __FILE__, __LINE__, code, curl_easy_strerror(code));
res = TEST_ERR_MAJOR_BAD;
goto test_cleanup;
}
code = curl_easy_getinfo(curl, CURLINFO_HEADER_SIZE, &headerSize);
if(CURLE_OK != code) {
- fprintf(stderr, "%s:%d curl_easy_getinfo() failed, "
- "with code %d (%s)\n",
- __FILE__, __LINE__, code, curl_easy_strerror(code));
+ curl_mfprintf(stderr, "%s:%d curl_easy_getinfo() failed, "
+ "with code %d (%s)\n",
+ __FILE__, __LINE__, code, curl_easy_strerror(code));
res = TEST_ERR_MAJOR_BAD;
goto test_cleanup;
}
- printf("header length is ........: %ld\n", headerSize);
- printf("header length should be..: %lu\n", realHeaderSize);
+ curl_mprintf("header length is ........: %ld\n", headerSize);
+ curl_mprintf("header length should be..: %lu\n", realHeaderSize);
test_cleanup:
/* Create fake DNS entries for serverX.example.com for all handles */
for(i = 0; i < NUM_URLS; i++) {
- msnprintf(dnsentry, sizeof(dnsentry), "server%d.example.com:%s:%s", i + 1,
- port, address);
- printf("%s\n", dnsentry);
+ curl_msnprintf(dnsentry, sizeof(dnsentry),
+ "server%d.example.com:%s:%s", i + 1, port, address);
+ curl_mprintf("%s\n", dnsentry);
slist2 = curl_slist_append(slist, dnsentry);
if(!slist2) {
- fprintf(stderr, "curl_slist_append() failed\n");
+ curl_mfprintf(stderr, "curl_slist_append() failed\n");
goto test_cleanup;
}
slist = slist2;
/* get NUM_HANDLES easy handles */
for(i = 0; i < NUM_URLS; i++) {
/* specify target */
- msnprintf(target_url, sizeof(target_url),
- "http://server%d.example.com:%s/path/1510%04i",
- i + 1, port, i + 1);
+ curl_msnprintf(target_url, sizeof(target_url),
+ "http://server%d.example.com:%s/path/1510%04i",
+ i + 1, port, i + 1);
target_url[sizeof(target_url) - 1] = '\0';
easy_setopt(curl, CURLOPT_URL, target_url);
(void)URL; /* URL is setup in the code */
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
- fprintf(stderr, "curl_global_init() failed\n");
+ curl_mfprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
- msnprintf(dnsentry, sizeof(dnsentry), "server.example.curl:%s:%s",
- port, address);
- printf("%s\n", dnsentry);
+ curl_msnprintf(dnsentry, sizeof(dnsentry), "server.example.curl:%s:%s",
+ port, address);
+ curl_mprintf("%s\n", dnsentry);
slist = curl_slist_append(slist, dnsentry);
/* get NUM_HANDLES easy handles */
/* get an easy handle */
easy_init(curl[i]);
/* specify target */
- msnprintf(target_url, sizeof(target_url),
- "http://server.example.curl:%s/path/1512%04i",
- port, i + 1);
+ curl_msnprintf(target_url, sizeof(target_url),
+ "http://server.example.curl:%s/path/1512%04i",
+ port, i + 1);
target_url[sizeof(target_url) - 1] = '\0';
easy_setopt(curl[i], CURLOPT_URL, target_url);
/* go verbose */
(void)dlnow;
(void)ultotal;
(void)ulnow;
- printf("PROGRESSFUNCTION called\n");
+ curl_mprintf("PROGRESSFUNCTION called\n");
return 1;
}
int i;
int count = 2;
- msnprintf(dns_entry, sizeof(dns_entry), "testserver.example.com:%s:%s",
- port, address);
+ curl_msnprintf(dns_entry, sizeof(dns_entry), "testserver.example.com:%s:%s",
+ port, address);
start_test_timing();
for(i = 1; i <= count; i++) {
char target_url[256];
- msnprintf(target_url, sizeof(target_url),
- "http://testserver.example.com:%s/%s%04d", port, path, i);
+ curl_msnprintf(target_url, sizeof(target_url),
+ "http://testserver.example.com:%s/%s%04d", port, path, i);
/* second request must succeed like the first one */
res = do_one_request(multi, target_url, dns_entry);
if(res != CURLE_OK) {
- fprintf(stderr, "request %s failed with %d\n", target_url, res);
+ curl_mfprintf(stderr, "request %s failed with %d\n", target_url, res);
goto test_cleanup;
}
if(!strcmp(URL, "check")) {
#if (defined(_WIN32) || defined(__CYGWIN__))
- printf("Windows TCP does not deliver response data but reports "
- "CONNABORTED\n");
+ curl_mprintf("Windows TCP does not deliver response data but reports "
+ "CONNABORTED\n");
return TEST_ERR_FAILURE; /* skip since it fails on Windows without
workaround */
#else
pooh.sizeleft = strlen(testdata);
if(curl_global_init(CURL_GLOBAL_ALL)) {
- fprintf(stderr, "curl_global_init() failed\n");
+ curl_mfprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
curl = curl_easy_init();
if(!curl) {
- fprintf(stderr, "curl_easy_init() failed\n");
+ curl_mfprintf(stderr, "curl_easy_init() failed\n");
curl_global_cleanup();
return TEST_ERR_MAJOR_BAD;
}
#endif
curl = curl_easy_init();
if(!curl) {
- fprintf(stderr, "curl_easy_init() failed\n");
+ curl_mfprintf(stderr, "curl_easy_init() failed\n");
curl_global_cleanup();
return TEST_ERR_MAJOR_BAD;
}
curl_easy_getinfo(curl, CURLINFO_REDIRECT_URL, &redirectUrl);
test_setopt(curl, CURLOPT_WRITEFUNCTION, writecb);
- printf("res %d\n"
- "status %ld\n"
- "redirects %ld\n"
- "effectiveurl %s\n"
- "redirecturl %s\n",
- res,
- curlResponseCode,
- curlRedirectCount,
- effectiveUrl,
- redirectUrl ? redirectUrl : "blank");
+ curl_mprintf("res %d\n"
+ "status %ld\n"
+ "redirects %ld\n"
+ "effectiveurl %s\n"
+ "redirecturl %s\n",
+ res,
+ curlResponseCode,
+ curlRedirectCount,
+ effectiveUrl,
+ redirectUrl ? redirectUrl : "blank");
test_cleanup:
struct upload_status upload_ctx = {0};
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
- fprintf(stderr, "curl_global_init() failed\n");
+ curl_mfprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
curl = curl_easy_init();
if(!curl) {
- fprintf(stderr, "curl_easy_init() failed\n");
+ curl_mfprintf(stderr, "curl_easy_init() failed\n");
curl_global_cleanup();
return TEST_ERR_MAJOR_BAD;
}
curl_off_t uploadSize;
curl_easy_getinfo(curl, CURLINFO_SIZE_UPLOAD_T, &uploadSize);
- printf("uploadSize = %ld\n", (long)uploadSize);
+ curl_mprintf("uploadSize = %ld\n", (long)uploadSize);
if((size_t) uploadSize == sizeof(g_Data)) {
- printf("!!!!!!!!!! PASS\n");
+ curl_mprintf("!!!!!!!!!! PASS\n");
}
else {
- printf("sent %d, libcurl says %d\n",
- (int)sizeof(g_Data), (int)uploadSize);
+ curl_mprintf("sent %d, libcurl says %d\n",
+ (int)sizeof(g_Data), (int)uploadSize);
}
}
else {
- printf("curl_easy_perform() failed. e = %d\n", code);
+ curl_mprintf("curl_easy_perform() failed. e = %d\n", code);
}
test_cleanup:
curl_slist_free_all(pHeaderList);
ret = run(hnd, 1, 2);
if(ret)
- fprintf(stderr, "error (%d) %s\n", ret, buffer);
+ curl_mfprintf(stderr, "error (%d) %s\n", ret, buffer);
ret = run(hnd, 12000, 1);
if(ret != CURLE_OPERATION_TIMEDOUT)
- fprintf(stderr, "error (%d) %s\n", ret, buffer);
+ curl_mfprintf(stderr, "error (%d) %s\n", ret, buffer);
else
ret = CURLE_OK;
struct curl_slist *hhl = NULL;
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
- fprintf(stderr, "curl_global_init() failed\n");
+ curl_mfprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
curl = curl_easy_init();
if(!curl) {
- fprintf(stderr, "curl_easy_init() failed\n");
+ curl_mfprintf(stderr, "curl_easy_init() failed\n");
curl_global_cleanup();
return TEST_ERR_MAJOR_BAD;
}
struct curl_slist *hhl = NULL, *phl = NULL, *tmp = NULL;
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
- fprintf(stderr, "curl_global_init() failed\n");
+ curl_mfprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
curl = curl_easy_init();
if(!curl) {
- fprintf(stderr, "curl_easy_init() failed\n");
+ curl_mfprintf(stderr, "curl_easy_init() failed\n");
curl_global_cleanup();
return TEST_ERR_MAJOR_BAD;
}
struct curl_slist *hhl = NULL, *tmp = NULL;
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
- fprintf(stderr, "curl_global_init() failed\n");
+ curl_mfprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
curl = curl_easy_init();
if(!curl) {
- fprintf(stderr, "curl_easy_init() failed\n");
+ curl_mfprintf(stderr, "curl_easy_init() failed\n");
curl_global_cleanup();
return TEST_ERR_MAJOR_BAD;
}
struct curl_slist *phl = NULL;
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
- fprintf(stderr, "curl_global_init() failed\n");
+ curl_mfprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
curl = curl_easy_init();
if(!curl) {
- fprintf(stderr, "curl_easy_init() failed\n");
+ curl_mfprintf(stderr, "curl_easy_init() failed\n");
curl_global_cleanup();
return TEST_ERR_MAJOR_BAD;
}
CURL *curl = NULL;
CURLcode res = CURLE_FAILED_INIT;
char bURL[512];
- msnprintf(bURL, sizeof(bURL),
- "%s HTTP/1.1\r\nGET http://1529.com/1529", URL);
+ curl_msnprintf(bURL, sizeof(bURL),
+ "%s HTTP/1.1\r\nGET http://1529.com/1529", URL);
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
- fprintf(stderr, "curl_global_init() failed\n");
+ curl_mfprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
curl = curl_easy_init();
if(!curl) {
- fprintf(stderr, "curl_easy_init() failed\n");
+ curl_mfprintf(stderr, "curl_easy_init() failed\n");
curl_global_cleanup();
return TEST_ERR_MAJOR_BAD;
}
(void)purpose;
(void)address;
(void)clientp;
- fprintf(stderr, "opensocket() returns CURL_SOCKET_BAD\n");
+ curl_mfprintf(stderr, "opensocket() returns CURL_SOCKET_BAD\n");
return CURL_SOCKET_BAD;
}
(void)URL;
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
- fprintf(stderr, "curl_global_init() failed\n");
+ curl_mfprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
curl = curl_easy_init();
if(!curl) {
- fprintf(stderr, "curl_easy_init() failed\n");
+ curl_mfprintf(stderr, "curl_easy_init() failed\n");
curl_global_cleanup();
return TEST_ERR_MAJOR_BAD;
}
mc = curl_multi_fdset(multi_handle, &fdread, &fdwrite, &fdexcep, &maxfd);
if(mc != CURLM_OK) {
- fprintf(stderr, "curl_multi_fdset() failed, code %d.\n", mc);
+ curl_mfprintf(stderr, "curl_multi_fdset() failed, code %d.\n", mc);
break;
}
do {
msg = curl_multi_info_read(multi_handle, &msgs_left);
if(msg && msg->msg == CURLMSG_DONE) {
- printf("HTTP transfer completed with status %d\n", msg->data.result);
+ curl_mprintf("HTTP transfer completed with status %d\n",
+ msg->data.result);
break;
}
res = curl_easy_perform(curl);
if(res) {
- fprintf(stderr, "%s:%d curl_easy_perform() failed with code %d (%s)\n",
- __FILE__, __LINE__, res, curl_easy_strerror(res));
+ curl_mfprintf(stderr,
+ "%s:%d curl_easy_perform() failed with code %d (%s)\n",
+ __FILE__, __LINE__, res, curl_easy_strerror(res));
goto test_cleanup;
}
res = curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &httpcode);
if(res) {
- fprintf(stderr, "%s:%d curl_easy_getinfo() failed with code %d (%s)\n",
- __FILE__, __LINE__, res, curl_easy_strerror(res));
+ curl_mfprintf(stderr,
+ "%s:%d curl_easy_getinfo() failed with code %d (%s)\n",
+ __FILE__, __LINE__, res, curl_easy_strerror(res));
goto test_cleanup;
}
if(httpcode != 200) {
- fprintf(stderr, "%s:%d unexpected response code %ld\n",
- __FILE__, __LINE__, httpcode);
+ curl_mfprintf(stderr, "%s:%d unexpected response code %ld\n",
+ __FILE__, __LINE__, httpcode);
res = CURLE_HTTP_RETURNED_ERROR;
goto test_cleanup;
}
res = curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &httpcode);
if(res) {
- fprintf(stderr, "%s:%d curl_easy_getinfo() failed with code %d (%s)\n",
- __FILE__, __LINE__, res, curl_easy_strerror(res));
+ curl_mfprintf(stderr,
+ "%s:%d curl_easy_getinfo() failed with code %d (%s)\n",
+ __FILE__, __LINE__, res, curl_easy_strerror(res));
goto test_cleanup;
}
if(httpcode) {
- fprintf(stderr, "%s:%d curl_easy_reset failed to zero the response code\n"
- "possible regression of github bug 1017\n", __FILE__, __LINE__);
+ curl_mfprintf(stderr,
+ "%s:%d curl_easy_reset failed to zero the response code\n"
+ "possible regression of github bug 1017\n",
+ __FILE__, __LINE__);
res = CURLE_HTTP_RETURNED_ERROR;
goto test_cleanup;
}
res = curl_easy_perform(curl);
if(res != CURLE_OK) {
- fprintf(stderr, "curl_easy_perform() failed with %d\n", res);
+ curl_mfprintf(stderr, "curl_easy_perform() failed with %d\n", res);
return TEST_ERR_MAJOR_BAD;
}
res = curl_easy_getinfo(curl, CURLINFO_NUM_CONNECTS, &connections);
if(res != CURLE_OK) {
- fprintf(stderr, "curl_easy_getinfo() failed\n");
+ curl_mfprintf(stderr, "curl_easy_getinfo() failed\n");
return TEST_ERR_MAJOR_BAD;
}
- fprintf(stderr, "%s: expected: %ld connections; actual: %ld connections\n",
- description, expected_connections, connections);
+ curl_mfprintf(stderr,
+ "%s: expected: %ld connections; actual: %ld connections\n",
+ description, expected_connections, connections);
if(connections != expected_connections) {
return TEST_ERR_FAILURE;
CURLcode result;
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
- fprintf(stderr, "curl_global_init() failed\n");
+ curl_mfprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
curl = curl_easy_init();
if(!curl) {
- fprintf(stderr, "curl_easy_init() failed\n");
+ curl_mfprintf(stderr, "curl_easy_init() failed\n");
curl_global_cleanup();
return TEST_ERR_MAJOR_BAD;
}
res = curl_easy_getinfo(curl, CURLINFO_FILETIME, &filetime);
if(res) {
- fprintf(stderr, "%s:%d curl_easy_getinfo() failed with code %d (%s)\n",
- __FILE__, __LINE__, res, curl_easy_strerror(res));
+ curl_mfprintf(stderr,
+ "%s:%d curl_easy_getinfo() failed with code %d (%s)\n",
+ __FILE__, __LINE__, res, curl_easy_strerror(res));
goto test_cleanup;
}
if(filetime != -1) {
- fprintf(stderr, "%s:%d filetime init failed; expected -1 but is %ld\n",
- __FILE__, __LINE__, filetime);
+ curl_mfprintf(stderr,
+ "%s:%d filetime init failed; expected -1 but is %ld\n",
+ __FILE__, __LINE__, filetime);
res = CURLE_FAILED_INIT;
goto test_cleanup;
}
res = curl_easy_perform(curl);
if(res) {
- fprintf(stderr, "%s:%d curl_easy_perform() failed with code %d (%s)\n",
- __FILE__, __LINE__, res, curl_easy_strerror(res));
+ curl_mfprintf(stderr,
+ "%s:%d curl_easy_perform() failed with code %d (%s)\n",
+ __FILE__, __LINE__, res, curl_easy_strerror(res));
goto test_cleanup;
}
res = curl_easy_getinfo(curl, CURLINFO_FILETIME, &filetime);
if(res) {
- fprintf(stderr, "%s:%d curl_easy_getinfo() failed with code %d (%s)\n",
- __FILE__, __LINE__, res, curl_easy_strerror(res));
+ curl_mfprintf(stderr,
+ "%s:%d curl_easy_getinfo() failed with code %d (%s)\n",
+ __FILE__, __LINE__, res, curl_easy_strerror(res));
goto test_cleanup;
}
if(filetime != 30) {
- fprintf(stderr, "%s:%d filetime of http resource is incorrect; "
- "expected 30 but is %ld\n",
- __FILE__, __LINE__, filetime);
+ curl_mfprintf(stderr, "%s:%d filetime of http resource is incorrect; "
+ "expected 30 but is %ld\n",
+ __FILE__, __LINE__, filetime);
res = CURLE_HTTP_RETURNED_ERROR;
goto test_cleanup;
}
dupe = curl_easy_duphandle(curl);
if(!dupe) {
- fprintf(stderr, "%s:%d curl_easy_duphandle() failed\n",
- __FILE__, __LINE__);
+ curl_mfprintf(stderr, "%s:%d curl_easy_duphandle() failed\n",
+ __FILE__, __LINE__);
res = CURLE_FAILED_INIT;
goto test_cleanup;
}
res = curl_easy_getinfo(dupe, CURLINFO_FILETIME, &filetime);
if(res) {
- fprintf(stderr, "%s:%d curl_easy_getinfo() failed with code %d (%s)\n",
- __FILE__, __LINE__, res, curl_easy_strerror(res));
+ curl_mfprintf(stderr,
+ "%s:%d curl_easy_getinfo() failed with code %d (%s)\n",
+ __FILE__, __LINE__, res, curl_easy_strerror(res));
goto test_cleanup;
}
if(filetime != -1) {
- fprintf(stderr, "%s:%d filetime init failed; expected -1 but is %ld\n",
- __FILE__, __LINE__, filetime);
+ curl_mfprintf(stderr,
+ "%s:%d filetime init failed; expected -1 but is %ld\n",
+ __FILE__, __LINE__, filetime);
res = CURLE_FAILED_INIT;
goto test_cleanup;
}
res = curl_easy_getinfo(curl, CURLINFO_FILETIME, &filetime);
if(res) {
- fprintf(stderr, "%s:%d curl_easy_getinfo() failed with code %d (%s)\n",
- __FILE__, __LINE__, res, curl_easy_strerror(res));
+ curl_mfprintf(stderr,
+ "%s:%d curl_easy_getinfo() failed with code %d (%s)\n",
+ __FILE__, __LINE__, res, curl_easy_strerror(res));
goto test_cleanup;
}
if(filetime != -1) {
- fprintf(stderr, "%s:%d filetime init failed; expected -1 but is %ld\n",
- __FILE__, __LINE__, filetime);
+ curl_mfprintf(stderr,
+ "%s:%d filetime init failed; expected -1 but is %ld\n",
+ __FILE__, __LINE__, filetime);
res = CURLE_FAILED_INIT;
goto test_cleanup;
}
res = curl_easy_getinfo(curl, CURLINFO_PROTOCOL, &protocol);
)
if(res) {
- fprintf(stderr, "%s:%d curl_easy_getinfo() failed with code %d (%s)\n",
- __FILE__, __LINE__, res, curl_easy_strerror(res));
+ curl_mfprintf(stderr,
+ "%s:%d curl_easy_getinfo() failed with code %d (%s)\n",
+ __FILE__, __LINE__, res, curl_easy_strerror(res));
goto test_cleanup;
}
if(protocol) {
- fprintf(stderr, "%s:%d protocol init failed; expected 0 but is %ld\n",
- __FILE__, __LINE__, protocol);
+ curl_mfprintf(stderr,
+ "%s:%d protocol init failed; expected 0 but is %ld\n",
+ __FILE__, __LINE__, protocol);
res = CURLE_FAILED_INIT;
goto test_cleanup;
}
res = curl_easy_perform(curl);
if(res) {
- fprintf(stderr, "%s:%d curl_easy_perform() failed with code %d (%s)\n",
- __FILE__, __LINE__, res, curl_easy_strerror(res));
+ curl_mfprintf(stderr,
+ "%s:%d curl_easy_perform() failed with code %d (%s)\n",
+ __FILE__, __LINE__, res, curl_easy_strerror(res));
goto test_cleanup;
}
res = curl_easy_getinfo(curl, CURLINFO_PROTOCOL, &protocol);
)
if(res) {
- fprintf(stderr, "%s:%d curl_easy_getinfo() failed with code %d (%s)\n",
- __FILE__, __LINE__, res, curl_easy_strerror(res));
+ curl_mfprintf(stderr,
+ "%s:%d curl_easy_getinfo() failed with code %d (%s)\n",
+ __FILE__, __LINE__, res, curl_easy_strerror(res));
goto test_cleanup;
}
if(protocol != CURLPROTO_HTTP) {
- fprintf(stderr, "%s:%d protocol of http resource is incorrect; "
- "expected %d but is %ld\n",
- __FILE__, __LINE__, CURLPROTO_HTTP, protocol);
+ curl_mfprintf(stderr,
+ "%s:%d protocol of http resource is incorrect; "
+ "expected %d but is %ld\n",
+ __FILE__, __LINE__, CURLPROTO_HTTP, protocol);
res = CURLE_HTTP_RETURNED_ERROR;
goto test_cleanup;
}
dupe = curl_easy_duphandle(curl);
if(!dupe) {
- fprintf(stderr, "%s:%d curl_easy_duphandle() failed\n",
- __FILE__, __LINE__);
+ curl_mfprintf(stderr, "%s:%d curl_easy_duphandle() failed\n",
+ __FILE__, __LINE__);
res = CURLE_FAILED_INIT;
goto test_cleanup;
}
res = curl_easy_getinfo(dupe, CURLINFO_PROTOCOL, &protocol);
)
if(res) {
- fprintf(stderr, "%s:%d curl_easy_getinfo() failed with code %d (%s)\n",
- __FILE__, __LINE__, res, curl_easy_strerror(res));
+ curl_mfprintf(stderr,
+ "%s:%d curl_easy_getinfo() failed with code %d (%s)\n",
+ __FILE__, __LINE__, res, curl_easy_strerror(res));
goto test_cleanup;
}
if(protocol) {
- fprintf(stderr, "%s:%d protocol init failed; expected 0 but is %ld\n",
- __FILE__, __LINE__, protocol);
+ curl_mfprintf(stderr,
+ "%s:%d protocol init failed; expected 0 but is %ld\n",
+ __FILE__, __LINE__, protocol);
res = CURLE_FAILED_INIT;
goto test_cleanup;
}
res = curl_easy_getinfo(curl, CURLINFO_PROTOCOL, &protocol);
)
if(res) {
- fprintf(stderr, "%s:%d curl_easy_getinfo() failed with code %d (%s)\n",
- __FILE__, __LINE__, res, curl_easy_strerror(res));
+ curl_mfprintf(stderr,
+ "%s:%d curl_easy_getinfo() failed with code %d (%s)\n",
+ __FILE__, __LINE__, res, curl_easy_strerror(res));
goto test_cleanup;
}
if(protocol) {
- fprintf(stderr, "%s:%d protocol init failed; expected 0 but is %ld\n",
- __FILE__, __LINE__, protocol);
+ curl_mfprintf(stderr,
+ "%s:%d protocol init failed; expected 0 but is %ld\n",
+ __FILE__, __LINE__, protocol);
res = CURLE_FAILED_INIT;
goto test_cleanup;
}
res = curl_easy_getinfo(curl, CURLINFO_SCHEME, &scheme);
if(res) {
- fprintf(stderr, "%s:%d curl_easy_getinfo() failed with code %d (%s)\n",
- __FILE__, __LINE__, res, curl_easy_strerror(res));
+ curl_mfprintf(stderr,
+ "%s:%d curl_easy_getinfo() failed with code %d (%s)\n",
+ __FILE__, __LINE__, res, curl_easy_strerror(res));
goto test_cleanup;
}
if(scheme) {
- fprintf(stderr, "%s:%d scheme init failed; expected NULL\n",
- __FILE__, __LINE__);
+ curl_mfprintf(stderr,
+ "%s:%d scheme init failed; expected NULL\n",
+ __FILE__, __LINE__);
res = CURLE_FAILED_INIT;
goto test_cleanup;
}
res = curl_easy_perform(curl);
if(res) {
- fprintf(stderr, "%s:%d curl_easy_perform() failed with code %d (%s)\n",
- __FILE__, __LINE__, res, curl_easy_strerror(res));
+ curl_mfprintf(stderr,
+ "%s:%d curl_easy_perform() failed with code %d (%s)\n",
+ __FILE__, __LINE__, res, curl_easy_strerror(res));
goto test_cleanup;
}
res = curl_easy_getinfo(curl, CURLINFO_SCHEME, &scheme);
if(res) {
- fprintf(stderr, "%s:%d curl_easy_getinfo() failed with code %d (%s)\n",
- __FILE__, __LINE__, res, curl_easy_strerror(res));
+ curl_mfprintf(stderr,
+ "%s:%d curl_easy_getinfo() failed with code %d (%s)\n",
+ __FILE__, __LINE__, res, curl_easy_strerror(res));
goto test_cleanup;
}
if(!scheme || memcmp(scheme, "http", 5) != 0) {
- fprintf(stderr, "%s:%d scheme of http resource is incorrect; "
- "expected 'http' but is %s\n",
- __FILE__, __LINE__,
- (scheme == NULL ? "NULL" : "invalid"));
+ curl_mfprintf(stderr, "%s:%d scheme of http resource is incorrect; "
+ "expected 'http' but is %s\n",
+ __FILE__, __LINE__,
+ (scheme == NULL ? "NULL" : "invalid"));
res = CURLE_HTTP_RETURNED_ERROR;
goto test_cleanup;
}
dupe = curl_easy_duphandle(curl);
if(!dupe) {
- fprintf(stderr, "%s:%d curl_easy_duphandle() failed\n",
- __FILE__, __LINE__);
+ curl_mfprintf(stderr, "%s:%d curl_easy_duphandle() failed\n",
+ __FILE__, __LINE__);
res = CURLE_FAILED_INIT;
goto test_cleanup;
}
res = curl_easy_getinfo(dupe, CURLINFO_SCHEME, &scheme);
if(res) {
- fprintf(stderr, "%s:%d curl_easy_getinfo() failed with code %d (%s)\n",
- __FILE__, __LINE__, res, curl_easy_strerror(res));
+ curl_mfprintf(stderr,
+ "%s:%d curl_easy_getinfo() failed with code %d (%s)\n",
+ __FILE__, __LINE__, res, curl_easy_strerror(res));
goto test_cleanup;
}
if(scheme) {
- fprintf(stderr, "%s:%d scheme init failed; expected NULL\n",
- __FILE__, __LINE__);
+ curl_mfprintf(stderr, "%s:%d scheme init failed; expected NULL\n",
+ __FILE__, __LINE__);
res = CURLE_FAILED_INIT;
goto test_cleanup;
}
res = curl_easy_getinfo(curl, CURLINFO_SCHEME, &scheme);
if(res) {
- fprintf(stderr, "%s:%d curl_easy_getinfo() failed with code %d (%s)\n",
- __FILE__, __LINE__, res, curl_easy_strerror(res));
+ curl_mfprintf(stderr,
+ "%s:%d curl_easy_getinfo() failed with code %d (%s)\n",
+ __FILE__, __LINE__, res, curl_easy_strerror(res));
goto test_cleanup;
}
if(scheme) {
- fprintf(stderr, "%s:%d scheme init failed; expected NULL\n",
- __FILE__, __LINE__);
+ curl_mfprintf(stderr, "%s:%d scheme init failed; expected NULL\n",
+ __FILE__, __LINE__);
res = CURLE_FAILED_INIT;
goto test_cleanup;
}
(void)URL; /* we don't use this */
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
- fprintf(stderr, "curl_global_init() failed\n");
+ curl_mfprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
asize = (int)sizeof(a);
ptr = curl_easy_escape(NULL, (const char *)a, asize);
- printf("%s\n", ptr);
+ curl_mprintf("%s\n", ptr);
curl_free(ptr);
/* deprecated API */
res = TEST_ERR_MAJOR_BAD;
goto test_cleanup;
}
- printf("%s\n", ptr);
+ curl_mprintf("%s\n", ptr);
raw = curl_easy_unescape(NULL, ptr, (int)strlen(ptr), &outlen);
- printf("outlen == %d\n", outlen);
- printf("unescape == original? %s\n",
- memcmp(raw, a, outlen) ? "no" : "YES");
+ curl_mprintf("outlen == %d\n", outlen);
+ curl_mprintf("unescape == original? %s\n",
+ memcmp(raw, a, outlen) ? "no" : "YES");
curl_free(raw);
/* deprecated API */
goto test_cleanup;
}
outlen = (int)strlen(raw);
- printf("[old] outlen == %d\n", outlen);
- printf("[old] unescape == original? %s\n",
- memcmp(raw, a, outlen) ? "no" : "YES");
+ curl_mprintf("[old] outlen == %d\n", outlen);
+ curl_mprintf("[old] unescape == original? %s\n",
+ memcmp(raw, a, outlen) ? "no" : "YES");
curl_free(raw);
curl_free(ptr);
/* weird input length */
ptr = curl_easy_escape(NULL, (const char *)a, -1);
- printf("escape -1 length: %s\n", ptr);
+ curl_mprintf("escape -1 length: %s\n", ptr);
/* weird input length */
outlen = 2017; /* just a value */
ptr = curl_easy_unescape(NULL, "moahahaha", -1, &outlen);
- printf("unescape -1 length: %s %d\n", ptr, outlen);
+ curl_mprintf("unescape -1 length: %s %d\n", ptr, outlen);
test_cleanup:
curl_free(ptr);
curl_url_strerror((CURLUcode)-INT_MAX);
/* NOLINTEND(clang-analyzer-optin.core.EnumCastOutOfRange) */
for(easyret = CURLE_OK; easyret <= CURL_LAST; easyret++) {
- printf("e%d: %s\n", (int)easyret, curl_easy_strerror(easyret));
+ curl_mprintf("e%d: %s\n", (int)easyret, curl_easy_strerror(easyret));
}
for(multiret = CURLM_CALL_MULTI_PERFORM; multiret <= CURLM_LAST;
multiret++) {
- printf("m%d: %s\n", (int)multiret, curl_multi_strerror(multiret));
+ curl_mprintf("m%d: %s\n", (int)multiret, curl_multi_strerror(multiret));
}
for(shareret = CURLSHE_OK; shareret <= CURLSHE_LAST; shareret++) {
- printf("s%d: %s\n", (int)shareret, curl_share_strerror(shareret));
+ curl_mprintf("s%d: %s\n", (int)shareret, curl_share_strerror(shareret));
}
for(urlret = CURLUE_OK; urlret <= CURLUE_LAST; urlret++) {
- printf("u%d: %s\n", (int)urlret, curl_url_strerror(urlret));
+ curl_mprintf("u%d: %s\n", (int)urlret, curl_url_strerror(urlret));
}
return res;
curl_easy_pause(st->easy, CURLPAUSE_CONT);
}
}
- fprintf(stderr, "xferinfo: paused %d\n", st->halted);
+ curl_mfprintf(stderr, "xferinfo: paused %d\n", st->halted);
return 0; /* go on */
}
return len;
}
if(len)
- printf("Got bytes but pausing!\n");
+ curl_mprintf("Got bytes but pausing!\n");
st->halted = 1;
return CURL_WRITEFUNC_PAUSE;
}
static int geterr(const char *name, CURLcode val, int lineno)
{
- printf("CURLINFO_%s returned %d, \"%s\" on line %d\n",
- name, val, curl_easy_strerror(val), lineno);
+ curl_mprintf("CURLINFO_%s returned %d, \"%s\" on line %d\n",
+ name, val, curl_easy_strerror(val), lineno);
return (int)val;
}
bool ok)
{
if(ok)
- printf("%s on %s is OK\n", key, where);
+ curl_mprintf("%s on %s is OK\n", key, where);
else
- printf("%s on %s is WRONG: %" CURL_FORMAT_CURL_OFF_T "\n",
- key, where, time);
+ curl_mprintf("%s on %s is WRONG: %" CURL_FORMAT_CURL_OFF_T "\n",
+ key, where, time);
}
static void check_time(CURL *easy, int key, const char *name,
if(res)
goto test_cleanup;
- fprintf(stderr, "****************************** Do it again\n");
+ curl_mfprintf(stderr, "****************************** Do it again\n");
res = curl_easy_perform(curl);
}
int num;
mres = curl_multi_wait(multi, NULL, 0, TEST_HANG_TIMEOUT, &num);
if(mres != CURLM_OK) {
- printf("curl_multi_wait() returned %d\n", mres);
+ curl_mprintf("curl_multi_wait() returned %d\n", mres);
res = TEST_ERR_MAJOR_BAD;
goto test_cleanup;
}
(void)dltotal;
(void)ulnow;
(void)ultotal;
- fprintf(stderr, "xferinfo fail!\n");
+ curl_mfprintf(stderr, "xferinfo fail!\n");
return 1; /* fail as fast as we can */
}
int num;
mres = curl_multi_wait(multi, NULL, 0, TEST_HANG_TIMEOUT, &num);
if(mres != CURLM_OK) {
- printf("curl_multi_wait() returned %d\n", mres);
+ curl_mprintf("curl_multi_wait() returned %d\n", mres);
res = TEST_ERR_MAJOR_BAD;
goto test_cleanup;
}
(void)data;
(void)laccess;
(void)useptr;
- printf("-> Mutex lock %s\n", ldata_names[data]);
+ curl_mprintf("-> Mutex lock %s\n", ldata_names[data]);
}
static void test_unlock(CURL *handle, curl_lock_data data, void *useptr)
(void)handle;
(void)data;
(void)useptr;
- printf("<- Mutex unlock %s\n", ldata_names[data]);
+ curl_mprintf("<- Mutex unlock %s\n", ldata_names[data]);
}
/* test function */
share = curl_share_init();
if(!share) {
- fprintf(stderr, "curl_share_init() failed\n");
+ curl_mfprintf(stderr, "curl_share_init() failed\n");
goto test_cleanup;
}
/* Check for errors */
if(res != CURLE_OK) {
- fprintf(stderr, "curl_easy_perform() failed: %s\n",
- curl_easy_strerror(res));
+ curl_mfprintf(stderr, "curl_easy_perform() failed: %s\n",
+ curl_easy_strerror(res));
goto test_cleanup;
}
}
(void)ultotal;
(void)ulnow;
res = curl_easy_recv(curl, buffer, 256, &n);
- printf("curl_easy_recv returned %d\n", res);
+ curl_mprintf("curl_easy_recv returned %d\n", res);
res = curl_easy_send(curl, buffer, n, &n);
- printf("curl_easy_send returned %d\n", res);
+ curl_mprintf("curl_easy_send returned %d\n", res);
return 1;
}
code = curl_easy_perform(curl);
if(CURLE_OK != code) {
- fprintf(stderr, "%s:%d curl_easy_perform() failed, "
- "with code %d (%s)\n",
- __FILE__, __LINE__, code, curl_easy_strerror(code));
+ curl_mfprintf(stderr, "%s:%d curl_easy_perform() failed, "
+ "with code %d (%s)\n",
+ __FILE__, __LINE__, code, curl_easy_strerror(code));
res = TEST_ERR_MAJOR_BAD;
goto test_cleanup;
}
- printf("Max = %ld\n", (long)info.largest);
+ curl_mprintf("Max = %ld\n", (long)info.largest);
test_cleanup:
easy_setopt(curl, CURLOPT_URL, URL);
res = curl_easy_perform(curl);
if(res) {
- fprintf(stderr, "curl_easy_perform() returned %d (%s)\n",
- res, curl_easy_strerror(res));
+ curl_mfprintf(stderr, "curl_easy_perform() returned %d (%s)\n",
+ res, curl_easy_strerror(res));
goto test_cleanup;
}
res = curl_easy_getinfo(curl, CURLINFO_PROTOCOL, &protocol);
)
if(res) {
- fprintf(stderr, "curl_easy_getinfo() returned %d (%s)\n",
- res, curl_easy_strerror(res));
+ curl_mfprintf(stderr, "curl_easy_getinfo() returned %d (%s)\n",
+ res, curl_easy_strerror(res));
goto test_cleanup;
}
- printf("Protocol: %lx\n", protocol);
+ curl_mprintf("Protocol: %lx\n", protocol);
curl_easy_cleanup(curl);
curl_global_cleanup();
longurl[EXCESSIVE-1] = 0;
res = curl_easy_setopt(curl, CURLOPT_URL, longurl);
- printf("CURLOPT_URL %d bytes URL == %d\n",
- EXCESSIVE, res);
+ curl_mprintf("CURLOPT_URL %d bytes URL == %d\n",
+ EXCESSIVE, res);
res = curl_easy_setopt(curl, CURLOPT_POSTFIELDS, longurl);
- printf("CURLOPT_POSTFIELDS %d bytes data == %d\n",
- EXCESSIVE, res);
+ curl_mprintf("CURLOPT_POSTFIELDS %d bytes data == %d\n",
+ EXCESSIVE, res);
u = curl_url();
if(u) {
CURLUcode uc = curl_url_set(u, CURLUPART_URL, longurl, 0);
- printf("CURLUPART_URL %d bytes URL == %d (%s)\n",
- EXCESSIVE, (int)uc, curl_url_strerror(uc));
+ curl_mprintf("CURLUPART_URL %d bytes URL == %d (%s)\n",
+ EXCESSIVE, (int)uc, curl_url_strerror(uc));
uc = curl_url_set(u, CURLUPART_SCHEME, longurl, CURLU_NON_SUPPORT_SCHEME);
- printf("CURLUPART_SCHEME %d bytes scheme == %d (%s)\n",
- EXCESSIVE, (int)uc, curl_url_strerror(uc));
+ curl_mprintf("CURLUPART_SCHEME %d bytes scheme == %d (%s)\n",
+ EXCESSIVE, (int)uc, curl_url_strerror(uc));
uc = curl_url_set(u, CURLUPART_USER, longurl, 0);
- printf("CURLUPART_USER %d bytes user == %d (%s)\n",
- EXCESSIVE, (int)uc, curl_url_strerror(uc));
+ curl_mprintf("CURLUPART_USER %d bytes user == %d (%s)\n",
+ EXCESSIVE, (int)uc, curl_url_strerror(uc));
curl_url_cleanup(u);
}
size_t n;
rc = curl_url_get(u, parts[i].part, &p, getflags);
if(!rc && p) {
- msnprintf(bufp, len, "%s%s", buf[0]?" | ":"", p);
+ curl_msnprintf(bufp, len, "%s%s", buf[0]?" | ":"", p);
}
else
- msnprintf(bufp, len, "%s[%d]", buf[0]?" | ":"", (int)rc);
+ curl_msnprintf(bufp, len, "%s[%d]", buf[0]?" | ":"", (int)rc);
n = strlen(bufp);
bufp += n;
curl_free(p);
}
if(strcmp(buf, wanted)) {
- fprintf(stderr, "in: %s\nwanted: %s\ngot: %s\n", in, wanted, buf);
+ curl_mfprintf(stderr, "in: %s\nwanted: %s\ngot: %s\n", in, wanted, buf);
return 1;
}
return 0;
static int checkurl(const char *org, const char *url, const char *out)
{
if(strcmp(out, url)) {
- fprintf(stderr,
- "Org: %s\n"
- "Wanted: %s\n"
- "Got : %s\n",
- org, out, url);
+ curl_mfprintf(stderr,
+ "Org: %s\n"
+ "Wanted: %s\n"
+ "Got : %s\n",
+ org, out, url);
return 1;
}
return 0;
CURLUPart what = part2id(part);
#if 0
/* for debugging this */
- fprintf(stderr, "%s = \"%s\" [%d]\n", part, value, (int)what);
+ curl_mfprintf(stderr, "%s = \"%s\" [%d]\n", part, value, (int)what);
#endif
if(what > CURLUPART_ZONEID)
- fprintf(stderr, "UNKNOWN part '%s'\n", part);
+ curl_mfprintf(stderr, "UNKNOWN part '%s'\n", part);
if(!strcmp("NULL", value))
uc = curl_url_set(u, what, NULL, setflags);
rc = curl_url_set(urlp, CURLUPART_URL, set_url_list[i].set,
set_url_list[i].setflags);
if(rc) {
- fprintf(stderr, "%s:%d Set URL %s returned %d (%s)\n",
- __FILE__, __LINE__, set_url_list[i].set,
- (int)rc, curl_url_strerror(rc));
+ curl_mfprintf(stderr, "%s:%d Set URL %s returned %d (%s)\n",
+ __FILE__, __LINE__, set_url_list[i].set,
+ (int)rc, curl_url_strerror(rc));
error++;
}
else {
char *url = NULL;
rc = curl_url_get(urlp, CURLUPART_URL, &url, 0);
if(rc) {
- fprintf(stderr, "%s:%d Get URL returned %d (%s)\n",
- __FILE__, __LINE__, (int)rc, curl_url_strerror(rc));
+ curl_mfprintf(stderr, "%s:%d Get URL returned %d (%s)\n",
+ __FILE__, __LINE__, (int)rc, curl_url_strerror(rc));
error++;
}
else {
}
}
else if(rc != set_url_list[i].ucode) {
- fprintf(stderr, "Set URL\nin: %s\nreturned %d (expected %d)\n",
- set_url_list[i].in, (int)rc, set_url_list[i].ucode);
+ curl_mfprintf(stderr, "Set URL\nin: %s\nreturned %d (expected %d)\n",
+ set_url_list[i].in, (int)rc, set_url_list[i].ucode);
error++;
}
curl_url_cleanup(urlp);
setget_parts_list[i].setflags);
if(uc != setget_parts_list[i].pcode) {
- fprintf(stderr, "updateurl\nin: %s\nreturned %d (expected %d)\n",
- setget_parts_list[i].set, (int)uc, setget_parts_list[i].pcode);
+ curl_mfprintf(stderr, "updateurl\nin: %s\nreturned %d (expected %d)\n",
+ setget_parts_list[i].set,
+ (int)uc, setget_parts_list[i].pcode);
error++;
}
if(!uc) {
curl_free(url);
}
else if(rc != CURLUE_OK) {
- fprintf(stderr, "Set parts\nin: %s\nreturned %d (expected %d)\n",
- setget_parts_list[i].in, (int)rc, 0);
+ curl_mfprintf(stderr, "Set parts\nin: %s\nreturned %d (expected %d)\n",
+ setget_parts_list[i].in, (int)rc, 0);
error++;
}
curl_url_cleanup(urlp);
set_parts_list[i].setflags);
if(uc != set_parts_list[i].pcode) {
- fprintf(stderr, "updateurl\nin: %s\nreturned %d (expected %d)\n",
- set_parts_list[i].set, (int)uc, set_parts_list[i].pcode);
+ curl_mfprintf(stderr, "updateurl\nin: %s\nreturned %d (expected %d)\n",
+ set_parts_list[i].set, (int)uc, set_parts_list[i].pcode);
error++;
}
if(!uc) {
rc = curl_url_get(urlp, CURLUPART_URL, &url, 0);
if(rc) {
- fprintf(stderr, "%s:%d Get URL returned %d (%s)\n",
- __FILE__, __LINE__, (int)rc, curl_url_strerror(rc));
+ curl_mfprintf(stderr, "%s:%d Get URL returned %d (%s)\n",
+ __FILE__, __LINE__, (int)rc, curl_url_strerror(rc));
error++;
}
else if(checkurl(set_parts_list[i].in, url, set_parts_list[i].out)) {
curl_free(url);
}
else if(rc != set_parts_list[i].ucode) {
- fprintf(stderr, "Set parts\nin: %s\nreturned %d (expected %d)\n",
- set_parts_list[i].in, (int)rc, set_parts_list[i].ucode);
+ curl_mfprintf(stderr, "Set parts\nin: %s\nreturned %d (expected %d)\n",
+ set_parts_list[i].in, (int)rc, set_parts_list[i].ucode);
error++;
}
curl_url_cleanup(urlp);
rc = curl_url_get(urlp, CURLUPART_URL, &url, get_url_list[i].getflags);
if(rc) {
- fprintf(stderr, "%s:%d returned %d (%s). URL: '%s'\n",
- __FILE__, __LINE__, (int)rc, curl_url_strerror(rc),
- get_url_list[i].in);
+ curl_mfprintf(stderr, "%s:%d returned %d (%s). URL: '%s'\n",
+ __FILE__, __LINE__, (int)rc, curl_url_strerror(rc),
+ get_url_list[i].in);
error++;
}
else {
curl_free(url);
}
if(rc != get_url_list[i].ucode) {
- fprintf(stderr, "Get URL\nin: %s\nreturned %d (expected %d)\n",
- get_url_list[i].in, (int)rc, get_url_list[i].ucode);
+ curl_mfprintf(stderr, "Get URL\nin: %s\nreturned %d (expected %d)\n",
+ get_url_list[i].in, (int)rc, get_url_list[i].ucode);
error++;
}
curl_url_cleanup(urlp);
get_parts_list[i].in,
get_parts_list[i].urlflags);
if(rc != get_parts_list[i].ucode) {
- fprintf(stderr, "Get parts\nin: %s\nreturned %d (expected %d)\n",
- get_parts_list[i].in, (int)rc, get_parts_list[i].ucode);
+ curl_mfprintf(stderr, "Get parts\nin: %s\nreturned %d (expected %d)\n",
+ get_parts_list[i].in, (int)rc, get_parts_list[i].ucode);
error++;
}
else if(get_parts_list[i].ucode) {
if(error)
;
else if(rc != append_list[i].ucode) {
- fprintf(stderr, "Append\nin: %s\nreturned %d (expected %d)\n",
- append_list[i].in, (int)rc, append_list[i].ucode);
+ curl_mfprintf(stderr, "Append\nin: %s\nreturned %d (expected %d)\n",
+ append_list[i].in, (int)rc, append_list[i].ucode);
error++;
}
else if(append_list[i].ucode) {
char *url;
rc = curl_url_get(urlp, CURLUPART_URL, &url, 0);
if(rc) {
- fprintf(stderr, "%s:%d Get URL returned %d (%s)\n",
- __FILE__, __LINE__, (int)rc, curl_url_strerror(rc));
+ curl_mfprintf(stderr, "%s:%d Get URL returned %d (%s)\n",
+ __FILE__, __LINE__, (int)rc, curl_url_strerror(rc));
error++;
}
else {
rc = curl_url_set(u, CURLUPART_URL,
"https://[fe80::20c:29ff:fe9c:409b%25eth0]/hello.html", 0);
if(rc != CURLUE_OK) {
- fprintf(stderr, "%s:%d curl_url_set returned %d (%s)\n",
- __FILE__, __LINE__, (int)rc, curl_url_strerror(rc));
+ curl_mfprintf(stderr, "%s:%d curl_url_set returned %d (%s)\n",
+ __FILE__, __LINE__, (int)rc, curl_url_strerror(rc));
error++;
}
rc = curl_url_get(u, CURLUPART_HOST, &url, 0);
if(rc != CURLUE_OK) {
- fprintf(stderr, "%s:%d curl_url_get CURLUPART_HOST returned %d (%s)\n",
- __FILE__, __LINE__, (int)rc, curl_url_strerror(rc));
+ curl_mfprintf(stderr,
+ "%s:%d curl_url_get CURLUPART_HOST returned %d (%s)\n",
+ __FILE__, __LINE__, (int)rc, curl_url_strerror(rc));
error++;
}
else {
rc = curl_url_set(u, CURLUPART_HOST, "[::1]", 0);
if(rc != CURLUE_OK) {
- fprintf(stderr, "%s:%d curl_url_set CURLUPART_HOST returned %d (%s)\n",
- __FILE__, __LINE__, (int)rc, curl_url_strerror(rc));
+ curl_mfprintf(stderr,
+ "%s:%d curl_url_set CURLUPART_HOST returned %d (%s)\n",
+ __FILE__, __LINE__, (int)rc, curl_url_strerror(rc));
error++;
}
rc = curl_url_get(u, CURLUPART_URL, &url, 0);
if(rc != CURLUE_OK) {
- fprintf(stderr, "%s:%d curl_url_get CURLUPART_URL returned %d (%s)\n",
- __FILE__, __LINE__, (int)rc, curl_url_strerror(rc));
+ curl_mfprintf(stderr,
+ "%s:%d curl_url_get CURLUPART_URL returned %d (%s)\n",
+ __FILE__, __LINE__, (int)rc, curl_url_strerror(rc));
error++;
}
else {
rc = curl_url_set(u, CURLUPART_HOST, "example.com", 0);
if(rc != CURLUE_OK) {
- fprintf(stderr, "%s:%d curl_url_set CURLUPART_HOST returned %d (%s)\n",
- __FILE__, __LINE__, (int)rc, curl_url_strerror(rc));
+ curl_mfprintf(stderr,
+ "%s:%d curl_url_set CURLUPART_HOST returned %d (%s)\n",
+ __FILE__, __LINE__, (int)rc, curl_url_strerror(rc));
error++;
}
rc = curl_url_get(u, CURLUPART_URL, &url, 0);
if(rc != CURLUE_OK) {
- fprintf(stderr, "%s:%d curl_url_get CURLUPART_URL returned %d (%s)\n",
- __FILE__, __LINE__, (int)rc, curl_url_strerror(rc));
+ curl_mfprintf(stderr,
+ "%s:%d curl_url_get CURLUPART_URL returned %d (%s)\n",
+ __FILE__, __LINE__, (int)rc, curl_url_strerror(rc));
error++;
}
else {
rc = curl_url_set(u, CURLUPART_HOST,
"[fe80::20c:29ff:fe9c:409b%25eth0]", 0);
if(rc != CURLUE_OK) {
- fprintf(stderr, "%s:%d curl_url_set CURLUPART_HOST returned %d (%s)\n",
- __FILE__, __LINE__, (int)rc, curl_url_strerror(rc));
+ curl_mfprintf(stderr,
+ "%s:%d curl_url_set CURLUPART_HOST returned %d (%s)\n",
+ __FILE__, __LINE__, (int)rc, curl_url_strerror(rc));
error++;
}
rc = curl_url_get(u, CURLUPART_URL, &url, 0);
if(rc != CURLUE_OK) {
- fprintf(stderr, "%s:%d curl_url_get CURLUPART_URL returned %d (%s)\n",
- __FILE__, __LINE__, (int)rc, curl_url_strerror(rc));
+ curl_mfprintf(stderr,
+ "%s:%d curl_url_get CURLUPART_URL returned %d (%s)\n",
+ __FILE__, __LINE__, (int)rc, curl_url_strerror(rc));
error++;
}
else {
rc = curl_url_get(u, CURLUPART_HOST, &url, 0);
if(rc != CURLUE_OK) {
- fprintf(stderr, "%s:%d curl_url_get CURLUPART_HOST returned %d (%s)\n",
- __FILE__, __LINE__, (int)rc, curl_url_strerror(rc));
+ curl_mfprintf(stderr,
+ "%s:%d curl_url_get CURLUPART_HOST returned %d (%s)\n",
+ __FILE__, __LINE__, (int)rc, curl_url_strerror(rc));
error++;
}
else {
rc = curl_url_get(u, CURLUPART_ZONEID, &url, 0);
if(rc != CURLUE_OK) {
- fprintf(stderr, "%s:%d curl_url_get CURLUPART_ZONEID returned %d (%s)\n",
- __FILE__, __LINE__, (int)rc, curl_url_strerror(rc));
+ curl_mfprintf(stderr,
+ "%s:%d curl_url_get CURLUPART_ZONEID returned %d (%s)\n",
+ __FILE__, __LINE__, (int)rc, curl_url_strerror(rc));
error++;
}
else {
rc = curl_url_set(u, CURLUPART_ZONEID, "clown", 0);
if(rc != CURLUE_OK) {
- fprintf(stderr, "%s:%d curl_url_set CURLUPART_ZONEID returned %d (%s)\n",
- __FILE__, __LINE__, (int)rc, curl_url_strerror(rc));
+ curl_mfprintf(stderr,
+ "%s:%d curl_url_set CURLUPART_ZONEID returned %d (%s)\n",
+ __FILE__, __LINE__, (int)rc, curl_url_strerror(rc));
error++;
}
rc = curl_url_get(u, CURLUPART_URL, &url, 0);
if(rc != CURLUE_OK) {
- fprintf(stderr, "%s:%d curl_url_get CURLUPART_URL returned %d (%s)\n",
- __FILE__, __LINE__, (int)rc, curl_url_strerror(rc));
+ curl_mfprintf(stderr,
+ "%s:%d curl_url_get CURLUPART_URL returned %d (%s)\n",
+ __FILE__, __LINE__, (int)rc, curl_url_strerror(rc));
error++;
}
else {
rc = curl_url_get(u, CURLUPART_SCHEME, &p, 0);
if(rc != CURLUE_NO_SCHEME)
- fprintf(stderr, "unexpected return code line %u\n", __LINE__);
+ curl_mfprintf(stderr, "unexpected return code line %u\n", __LINE__);
rc = curl_url_get(u, CURLUPART_HOST, &p, 0);
if(rc != CURLUE_NO_HOST)
- fprintf(stderr, "unexpected return code line %u\n", __LINE__);
+ curl_mfprintf(stderr, "unexpected return code line %u\n", __LINE__);
rc = curl_url_get(u, CURLUPART_USER, &p, 0);
if(rc != CURLUE_NO_USER)
- fprintf(stderr, "unexpected return code line %u\n", __LINE__);
+ curl_mfprintf(stderr, "unexpected return code line %u\n", __LINE__);
rc = curl_url_get(u, CURLUPART_PASSWORD, &p, 0);
if(rc != CURLUE_NO_PASSWORD)
- fprintf(stderr, "unexpected return code line %u\n", __LINE__);
+ curl_mfprintf(stderr, "unexpected return code line %u\n", __LINE__);
rc = curl_url_get(u, CURLUPART_OPTIONS, &p, 0);
if(rc != CURLUE_NO_OPTIONS)
- fprintf(stderr, "unexpected return code line %u\n", __LINE__);
+ curl_mfprintf(stderr, "unexpected return code line %u\n", __LINE__);
rc = curl_url_get(u, CURLUPART_PATH, &p, 0);
if(rc != CURLUE_OK)
- fprintf(stderr, "unexpected return code line %u\n", __LINE__);
+ curl_mfprintf(stderr, "unexpected return code line %u\n", __LINE__);
else
curl_free(p);
rc = curl_url_get(u, CURLUPART_QUERY, &p, 0);
if(rc != CURLUE_NO_QUERY)
- fprintf(stderr, "unexpected return code line %u\n", __LINE__);
+ curl_mfprintf(stderr, "unexpected return code line %u\n", __LINE__);
rc = curl_url_get(u, CURLUPART_FRAGMENT, &p, 0);
if(rc != CURLUE_NO_FRAGMENT)
- fprintf(stderr, "unexpected return code line %u\n", __LINE__);
+ curl_mfprintf(stderr, "unexpected return code line %u\n", __LINE__);
rc = curl_url_get(u, CURLUPART_ZONEID, &p, 0);
if(rc != CURLUE_NO_ZONEID)
- fprintf(stderr, "unexpected return code %u on line %u\n", (int)rc,
+ curl_mfprintf(stderr, "unexpected return code %u on line %u\n", (int)rc,
__LINE__);
curl_url_cleanup(u);
for(i = 0; clear_url_list[i].in && !error; i++) {
rc = curl_url_set(u, clear_url_list[i].part, clear_url_list[i].in, 0);
if(rc != CURLUE_OK)
- fprintf(stderr, "unexpected return code line %u\n", __LINE__);
+ curl_mfprintf(stderr, "unexpected return code line %u\n", __LINE__);
rc = curl_url_set(u, CURLUPART_URL, NULL, 0);
if(rc != CURLUE_OK)
- fprintf(stderr, "unexpected return code line %u\n", __LINE__);
+ curl_mfprintf(stderr, "unexpected return code line %u\n", __LINE__);
rc = curl_url_get(u, clear_url_list[i].part, &p, 0);
if(rc != clear_url_list[i].ucode || (clear_url_list[i].out &&
0 != strcmp(p, clear_url_list[i].out))) {
- fprintf(stderr, "unexpected return code line %u\n", __LINE__);
+ curl_mfprintf(stderr, "unexpected return code line %u\n", __LINE__);
error++;
}
if(rc == CURLUE_OK)
for(i = 0; i < 7; i++) {
char *partp;
- msnprintf(total, sizeof(total),
- "%s://%s:%s@%s/%s?%s#%s",
- (i == 0) ? &bigpart[1] : smallpart,
- (i == 1) ? &bigpart[1] : smallpart,
- (i == 2) ? &bigpart[1] : smallpart,
- (i == 3) ? &bigpart[1] : smallpart,
- (i == 4) ? &bigpart[1] : smallpart,
- (i == 5) ? &bigpart[1] : smallpart,
- (i == 6) ? &bigpart[1] : smallpart);
+ curl_msnprintf(total, sizeof(total),
+ "%s://%s:%s@%s/%s?%s#%s",
+ (i == 0) ? &bigpart[1] : smallpart,
+ (i == 1) ? &bigpart[1] : smallpart,
+ (i == 2) ? &bigpart[1] : smallpart,
+ (i == 3) ? &bigpart[1] : smallpart,
+ (i == 4) ? &bigpart[1] : smallpart,
+ (i == 5) ? &bigpart[1] : smallpart,
+ (i == 6) ? &bigpart[1] : smallpart);
rc = curl_url_set(urlp, CURLUPART_URL, total, CURLU_NON_SUPPORT_SCHEME);
if((!i && (rc != CURLUE_BAD_SCHEME)) ||
(i && rc)) {
- printf("URL %u: failed to parse [%s]\n", i, total);
+ curl_mprintf("URL %u: failed to parse [%s]\n", i, total);
error++;
}
if(!rc) {
curl_url_get(urlp, part[i], &partp, 0);
if(!partp || strcmp(partp, &bigpart[1 - (i == 4)])) {
- printf("URL %u part %u: failure\n", i, part[i]);
+ curl_mprintf("URL %u part %u: failure\n", i, part[i]);
error++;
}
curl_free(partp);
goto err;
if(strcmp(h_str, copy_str)) {
- printf("Original: %s\nParsed: %s\nCopy: %s\n",
- url[i], h_str, copy_str);
+ curl_mprintf("Original: %s\nParsed: %s\nCopy: %s\n",
+ url[i], h_str, copy_str);
goto err;
}
curl_free(copy_str);
if(clear_url())
return (CURLcode)8;
- printf("success\n");
+ curl_mprintf("success\n");
return CURLE_OK;
}
time_after_wait = tutil_tvnow();
if(tutil_tvdiff(time_after_wait, time_before_wait) < 500) {
- fprintf(stderr, "%s:%d curl_multi_poll returned too early\n",
- __FILE__, __LINE__);
+ curl_mfprintf(stderr, "%s:%d curl_multi_poll returned too early\n",
+ __FILE__, __LINE__);
res = TEST_ERR_MAJOR_BAD;
goto test_cleanup;
}
time_after_wait = tutil_tvnow();
if(tutil_tvdiff(time_after_wait, time_before_wait) > 500) {
- fprintf(stderr, "%s:%d curl_multi_poll returned too late\n",
- __FILE__, __LINE__);
+ curl_mfprintf(stderr, "%s:%d curl_multi_poll returned too late\n",
+ __FILE__, __LINE__);
res = TEST_ERR_MAJOR_BAD;
goto test_cleanup;
}
time_after_wait = tutil_tvnow();
if(tutil_tvdiff(time_after_wait, time_before_wait) < 500) {
- fprintf(stderr, "%s:%d curl_multi_poll returned too early\n",
- __FILE__, __LINE__);
+ curl_mfprintf(stderr, "%s:%d curl_multi_poll returned too early\n",
+ __FILE__, __LINE__);
res = TEST_ERR_MAJOR_BAD;
goto test_cleanup;
}
time_after_wait = tutil_tvnow();
if(tutil_tvdiff(time_after_wait, time_before_wait) > 500) {
- fprintf(stderr, "%s:%d curl_multi_poll returned too late\n",
- __FILE__, __LINE__);
+ curl_mfprintf(stderr, "%s:%d curl_multi_poll returned too late\n",
+ __FILE__, __LINE__);
res = TEST_ERR_MAJOR_BAD;
goto test_cleanup;
}
time_after_wait = tutil_tvnow();
if(tutil_tvdiff(time_after_wait, time_before_wait) < 500) {
- fprintf(stderr, "%s:%d curl_multi_poll returned too early\n",
- __FILE__, __LINE__);
+ curl_mfprintf(stderr, "%s:%d curl_multi_poll returned too early\n",
+ __FILE__, __LINE__);
res = TEST_ERR_MAJOR_BAD;
goto test_cleanup;
}
if(!result)
tid_valid = true;
else {
- fprintf(stderr, "%s:%d Couldn't create thread, errno %d\n",
- __FILE__, __LINE__, result);
+ curl_mfprintf(stderr, "%s:%d Couldn't create thread, errno %d\n",
+ __FILE__, __LINE__, result);
goto test_cleanup;
}
finished_num++;
}
else {
- fprintf(stderr, "%s:%d Got an unexpected message from curl: %i\n",
- __FILE__, __LINE__, (int)message->msg);
+ curl_mfprintf(stderr,
+ "%s:%d Got an unexpected message from curl: %i\n",
+ __FILE__, __LINE__, (int)message->msg);
res = TEST_ERR_MAJOR_BAD;
goto test_cleanup;
}
}
if(CONN_NUM != started_num) {
- fprintf(stderr, "%s:%d Not all connections started: %d of %d\n",
- __FILE__, __LINE__, started_num, CONN_NUM);
+ curl_mfprintf(stderr, "%s:%d Not all connections started: %d of %d\n",
+ __FILE__, __LINE__, started_num, CONN_NUM);
goto test_cleanup;
}
if(CONN_NUM != finished_num) {
- fprintf(stderr, "%s:%d Not all connections finished: %d of %d\n",
- __FILE__, __LINE__, started_num, CONN_NUM);
+ curl_mfprintf(stderr, "%s:%d Not all connections finished: %d of %d\n",
+ __FILE__, __LINE__, started_num, CONN_NUM);
goto test_cleanup;
}
if(res)
goto test_cleanup;
- fprintf(stderr, "****************************** Do it again\n");
+ curl_mfprintf(stderr, "****************************** Do it again\n");
res = curl_easy_perform(curl);
}
}
int testno = atoi(libtest_arg2);
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
- fprintf(stderr, "curl_global_init() failed\n");
+ curl_mfprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
curl = curl_easy_init();
if(!curl) {
- fprintf(stderr, "curl_easy_init() failed\n");
+ curl_mfprintf(stderr, "curl_easy_init() failed\n");
curl_global_cleanup();
return TEST_ERR_MAJOR_BAD;
}
int testno = atoi(libtest_arg2);
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
- fprintf(stderr, "curl_global_init() failed\n");
+ curl_mfprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
curl = curl_easy_init();
if(!curl) {
- fprintf(stderr, "curl_easy_init() failed\n");
+ curl_mfprintf(stderr, "curl_easy_init() failed\n");
curl_global_cleanup();
return TEST_ERR_MAJOR_BAD;
}
struct curl_slist *hhl = NULL;
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
- fprintf(stderr, "curl_global_init() failed\n");
+ curl_mfprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
curl = curl_easy_init();
if(!curl) {
- fprintf(stderr, "curl_easy_init() failed\n");
+ curl_mfprintf(stderr, "curl_easy_init() failed\n");
curl_global_cleanup();
return TEST_ERR_MAJOR_BAD;
}
all because we haven't been able to configure the resolver to use an
non-responsive DNS server. At least we exercise the flow.
*/
- fprintf(stderr,
- "CURLOPT_DNS_SERVERS not supported; "
- "assuming curl_multi_remove_handle() will block\n");
+ curl_mfprintf(stderr,
+ "CURLOPT_DNS_SERVERS not supported; "
+ "assuming curl_multi_remove_handle() will block\n");
timeout = TEST_HANG_TIMEOUT / 2;
}
multi_add_handle(multiHandle, curl);
/* This should move the handle from INIT => CONNECT => WAITRESOLVE. */
- fprintf(stderr, "curl_multi_perform()...\n");
+ curl_mfprintf(stderr, "curl_multi_perform()...\n");
multi_perform(multiHandle, &stillRunning);
- fprintf(stderr, "curl_multi_perform() succeeded\n");
+ curl_mfprintf(stderr, "curl_multi_perform() succeeded\n");
/* Start measuring how long it takes to remove the handle. */
- fprintf(stderr, "curl_multi_remove_handle()...\n");
+ curl_mfprintf(stderr, "curl_multi_remove_handle()...\n");
start_test_timing();
mres = curl_multi_remove_handle(multiHandle, curl);
if(mres) {
- fprintf(stderr, "curl_multi_remove_handle() failed, with code %d\n", mres);
+ curl_mfprintf(stderr,
+ "curl_multi_remove_handle() failed, with code %d\n", mres);
res = TEST_ERR_MULTI;
goto test_cleanup;
}
- fprintf(stderr, "curl_multi_remove_handle() succeeded\n");
+ curl_mfprintf(stderr, "curl_multi_remove_handle() succeeded\n");
/* Fail the test if it took too long to remove. This happens after the fact,
and says "it seems that it would have run forever", which isn't true, but
if(res)
goto test_cleanup;
- printf("Retry-After %" CURL_FORMAT_CURL_OFF_T "\n", retry);
+ curl_mprintf("Retry-After %" CURL_FORMAT_CURL_OFF_T "\n", retry);
test_cleanup:
res = TEST_ERR_FAILURE;
goto test_cleanup;
}
- n += msnprintf(protolist + n, sizeof(protolist) - n, ",%s", *proto);
+ n += curl_msnprintf(protolist + n, sizeof(protolist) - n, ",%s", *proto);
if(curl_strequal(*proto, "http"))
httpcode = CURLE_OK;
if(curl_strequal(*proto, "https"))
for(i = 0; prots[i].in; i++) {
res = curl_easy_setopt(curl, CURLOPT_PROTOCOLS_STR, prots[i].in);
if(res != *prots[i].exp) {
- printf("unexpectedly '%s' returned %d\n", prots[i].in, res);
+ curl_mprintf("unexpectedly '%s' returned %d\n", prots[i].in, res);
break;
}
}
- printf("Tested %u strings\n", i);
+ curl_mprintf("Tested %u strings\n", i);
test_cleanup:
curl_easy_cleanup(curl);
struct curl_slist *hhl = NULL, *list;
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
- fprintf(stderr, "curl_global_init() failed\n");
+ curl_mfprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
curl = curl_easy_init();
if(!curl) {
- fprintf(stderr, "curl_easy_init() failed\n");
+ curl_mfprintf(stderr, "curl_easy_init() failed\n");
curl_global_cleanup();
return TEST_ERR_MAJOR_BAD;
}
easy_setopt(curl, CURLOPT_PORT, 1L);
res = curl_easy_perform(curl);
if(res != CURLE_COULDNT_CONNECT && res != CURLE_OPERATION_TIMEDOUT) {
- fprintf(stderr, "failure expected, "
- "curl_easy_perform returned %d: <%s>, <%s>\n",
- res, curl_easy_strerror(res), error_buffer);
+ curl_mfprintf(stderr, "failure expected, "
+ "curl_easy_perform returned %d: <%s>, <%s>\n",
+ res, curl_easy_strerror(res), error_buffer);
if(res == CURLE_OK)
res = TEST_ERR_MAJOR_BAD; /* force an error return */
goto test_cleanup;
/* print the used url */
curl_url_get(curlu, CURLUPART_URL, &url_after, 0);
- fprintf(stderr, "curlu now: <%s>\n", url_after);
+ curl_mfprintf(stderr, "curlu now: <%s>\n", url_after);
curl_free(url_after);
url_after = NULL;
res = curl_easy_perform(curl);
if(res)
- fprintf(stderr, "success expected, "
- "curl_easy_perform returned %d: <%s>, <%s>\n",
- res, curl_easy_strerror(res), error_buffer);
+ curl_mfprintf(stderr, "success expected, "
+ "curl_easy_perform returned %d: <%s>, <%s>\n",
+ res, curl_easy_strerror(res), error_buffer);
/* print url */
curl_url_get(curlu, CURLUPART_URL, &url_after, 0);
- fprintf(stderr, "curlu now: <%s>\n", url_after);
+ curl_mfprintf(stderr, "curlu now: <%s>\n", url_after);
test_cleanup:
curl_free(url_after);
curl_easy_setopt(curl, CURLOPT_VERBOSE, 1L);
res = curl_easy_perform(curl);
if(!res)
- fprintf(stderr, "failure expected, "
- "curl_easy_perform returned %ld: <%s>, <%s>\n",
- (long) res, curl_easy_strerror(res), error_buffer);
+ curl_mfprintf(stderr, "failure expected, "
+ "curl_easy_perform returned %ld: <%s>, <%s>\n",
+ (long) res, curl_easy_strerror(res), error_buffer);
/* print the used url */
if(!curl_easy_getinfo(curl, CURLINFO_EFFECTIVE_URL, &url_after))
- printf("Effective URL: %s\n", url_after);
+ curl_mprintf("Effective URL: %s\n", url_after);
curl_easy_cleanup(curl);
curl_global_cleanup();
memset(testbuf, 'A', MAX_INPUT_LENGTH + 1);
testbuf[MAX_INPUT_LENGTH + 1] = 0;
- printf("string length: %d\n", (int)strlen(testbuf));
+ curl_mprintf("string length: %d\n", (int)strlen(testbuf));
for(o = curl_easy_option_next(NULL);
o;
break;
default:
/* all other return codes are unexpected */
- fprintf(stderr, "curl_easy_setopt(%s...) returned %d\n",
- o->name, result);
+ curl_mfprintf(stderr, "curl_easy_setopt(%s...) returned %d\n",
+ o->name, result);
error++;
break;
}
#include "warnless.h"
#include "memdebug.h"
-#define print_err(name, exp) \
- fprintf(stderr, "Type mismatch for CURLOPT_%s (expected %s)\n", name, exp);
+#define print_err(name, exp) \
+ curl_mfprintf(stderr, "Type mismatch for CURLOPT_%s (expected %s)\n", \
+ name, exp);
CURLcode test(char *URL)
{
strcpy(e->name, host);
e->includeSubDomains = FALSE;
strcpy(e->expire, expire);
- fprintf(stderr, "add '%s'\n", host);
+ curl_mfprintf(stderr, "add '%s'\n", host);
}
else
return CURLSTS_DONE;
{
(void)easy;
(void)userp;
- printf("[%zu/%zu] %s %s\n", i->index, i->total, e->name, e->expire);
+ curl_mprintf("[%zu/%zu] %s %s\n", i->index, i->total, e->name, e->expire);
return CURLSTS_OK;
}
hnd = NULL;
if(res == CURLE_OPERATION_TIMEDOUT) /* we expect that on Windows */
res = CURLE_COULDNT_CONNECT;
- printf("First request returned %d\n", res);
+ curl_mprintf("First request returned %d\n", res);
res = CURLE_OK;
easy_init(hnd);
res = curl_easy_perform(hnd);
curl_easy_cleanup(hnd);
hnd = NULL;
- printf("Second request returned %d\n", res);
+ curl_mprintf("Second request returned %d\n", res);
test_cleanup:
curl_easy_cleanup(hnd);
CURLcode res = CURLE_OK;
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
- fprintf(stderr, "curl_global_init() failed\n");
+ curl_mfprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
#endif
res = curl_easy_perform(curl);
if(res) {
- printf("res: %d\n", res);
+ curl_mprintf("res: %d\n", res);
}
curl_easy_cleanup(curl);
}
curl_easy_option_by_id(o->id);
if(ename->id != o->id) {
- printf("name lookup id %d doesn't match %d\n",
- ename->id, o->id);
+ curl_mprintf("name lookup id %d doesn't match %d\n",
+ ename->id, o->id);
}
else if(eid->id != o->id) {
- printf("ID lookup %d doesn't match %d\n",
- ename->id, o->id);
+ curl_mprintf("ID lookup %d doesn't match %d\n",
+ ename->id, o->id);
}
}
curl_global_cleanup();
struct curl_slist *list = NULL;
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
- fprintf(stderr, "curl_global_init() failed\n");
+ curl_mfprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
curl = curl_easy_init();
if(!curl) {
- fprintf(stderr, "curl_easy_init() failed\n");
+ curl_mfprintf(stderr, "curl_easy_init() failed\n");
curl_global_cleanup();
return TEST_ERR_MAJOR_BAD;
}
struct curl_slist *list = NULL;
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
- fprintf(stderr, "curl_global_init() failed\n");
+ curl_mfprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
curl = curl_easy_init();
if(!curl) {
- fprintf(stderr, "curl_easy_init() failed\n");
+ curl_mfprintf(stderr, "curl_easy_init() failed\n");
curl_global_cleanup();
return TEST_ERR_MAJOR_BAD;
}
struct curl_slist *list = NULL;
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
- fprintf(stderr, "curl_global_init() failed\n");
+ curl_mfprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
curl = curl_easy_init();
if(!curl) {
- fprintf(stderr, "curl_easy_init() failed\n");
+ curl_mfprintf(stderr, "curl_easy_init() failed\n");
curl_global_cleanup();
return TEST_ERR_MAJOR_BAD;
}
struct curl_slist *list = NULL;
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
- fprintf(stderr, "curl_global_init() failed\n");
+ curl_mfprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
curl = curl_easy_init();
if(!curl) {
- fprintf(stderr, "curl_easy_init() failed\n");
+ curl_mfprintf(stderr, "curl_easy_init() failed\n");
curl_global_cleanup();
return TEST_ERR_MAJOR_BAD;
}
struct curl_slist *list = NULL;
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
- fprintf(stderr, "curl_global_init() failed\n");
+ curl_mfprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
curl = curl_easy_init();
if(!curl) {
- fprintf(stderr, "curl_easy_init() failed\n");
+ curl_mfprintf(stderr, "curl_easy_init() failed\n");
curl_global_cleanup();
return TEST_ERR_MAJOR_BAD;
}
unsigned char data[] = {0x70, 0x6f, 0x73, 0x74, 0, 0x44, 0x61, 0x74, 0x61};
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
- fprintf(stderr, "curl_global_init() failed\n");
+ curl_mfprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
curl = curl_easy_init();
if(!curl) {
- fprintf(stderr, "curl_easy_init() failed\n");
+ curl_mfprintf(stderr, "curl_easy_init() failed\n");
curl_global_cleanup();
return TEST_ERR_MAJOR_BAD;
}
m = curl_multi_perform(multi, &running_handles);
if(m)
- fprintf(stderr, "curl_multi_perform failed\n");
+ curl_mfprintf(stderr, "curl_multi_perform failed\n");
}
/* Close the easy handle *before* the multi handle. Doing it the other
way around avoids the issue. */
size_t index = 0;
size_t amount = header->amount;
do {
- printf("- %s == %s (%u/%u)\n", header->name, header->value,
- (int)index, (int)amount);
+ curl_mprintf("- %s == %s (%u/%u)\n", header->name, header->value,
+ (int)index, (int)amount);
if(++index == amount)
break;
}
else {
/* only one of this */
- printf(" %s == %s\n", header->name, header->value);
+ curl_mprintf(" %s == %s\n", header->name, header->value);
}
}
}
/* !checksrc! disable EQUALSNULL 1 */
while((header = curl_easy_nextheader(easy, type, 0, prev)) != NULL) {
- printf(" %s == %s (%u/%u)\n", header->name, header->value,
- (int)header->index, (int)header->amount);
+ curl_mprintf(" %s == %s (%u/%u)\n", header->name, header->value,
+ (int)header->index, (int)header->amount);
prev = header;
}
}
}
res = curl_easy_perform(easy);
if(res) {
- printf("badness: %d\n", res);
+ curl_mprintf("badness: %d\n", res);
}
showem(easy, CURLH_CONNECT|CURLH_HEADER|CURLH_TRAILER|CURLH_1XX);
easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L);
res = curl_easy_perform(curl);
if(res) {
- fprintf(stderr, "curl_easy_perform() failed: %s\n",
- curl_easy_strerror(res));
+ curl_mfprintf(stderr, "curl_easy_perform() failed: %s\n",
+ curl_easy_strerror(res));
goto test_cleanup;
}
if(h)
count++;
} while(h);
- printf("count = %u\n", count);
+ curl_mprintf("count = %u\n", count);
/* perform another request - without redirect */
easy_setopt(curl, CURLOPT_URL, libtest_arg2);
res = curl_easy_perform(curl);
if(res) {
- fprintf(stderr, "curl_easy_perform() failed: %s\n",
- curl_easy_strerror(res));
+ curl_mfprintf(stderr, "curl_easy_perform() failed: %s\n",
+ curl_easy_strerror(res));
goto test_cleanup;
}
if(h)
count++;
} while(h);
- printf("count = %u\n", count);
+ curl_mprintf("count = %u\n", count);
test_cleanup:
curl_easy_cleanup(curl);
struct curl_slist *connect_to = NULL;
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
- fprintf(stderr, "curl_global_init() failed\n");
+ curl_mfprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
curl = curl_easy_init();
if(!curl) {
- fprintf(stderr, "curl_easy_init() failed\n");
+ curl_mfprintf(stderr, "curl_easy_init() failed\n");
curl_global_cleanup();
return TEST_ERR_MAJOR_BAD;
}
struct curl_slist *connect_to = NULL;
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
- fprintf(stderr, "curl_global_init() failed\n");
+ curl_mfprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
curl = curl_easy_init();
if(!curl) {
- fprintf(stderr, "curl_easy_init() failed\n");
+ curl_mfprintf(stderr, "curl_easy_init() failed\n");
curl_global_cleanup();
return TEST_ERR_MAJOR_BAD;
}
struct curl_slist *connect_to = NULL;
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
- fprintf(stderr, "curl_global_init() failed\n");
+ curl_mfprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
curl = curl_easy_init();
if(!curl) {
- fprintf(stderr, "curl_easy_init() failed\n");
+ curl_mfprintf(stderr, "curl_easy_init() failed\n");
curl_global_cleanup();
return TEST_ERR_MAJOR_BAD;
}
struct curl_slist *connect_to = NULL;
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
- fprintf(stderr, "curl_global_init() failed\n");
+ curl_mfprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
curl = curl_easy_init();
if(!curl) {
- fprintf(stderr, "curl_easy_init() failed\n");
+ curl_mfprintf(stderr, "curl_easy_init() failed\n");
curl_global_cleanup();
return TEST_ERR_MAJOR_BAD;
}
struct curl_slist *connect_to = NULL;
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
- fprintf(stderr, "curl_global_init() failed\n");
+ curl_mfprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
curl = curl_easy_init();
if(!curl) {
- fprintf(stderr, "curl_easy_init() failed\n");
+ curl_mfprintf(stderr, "curl_easy_init() failed\n");
curl_global_cleanup();
return TEST_ERR_MAJOR_BAD;
}
port = (unsigned short)atoi(libtest_arg3);
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
- fprintf(stderr, "curl_global_init() failed\n");
+ curl_mfprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
*/
client_fd = socket(AF_INET, SOCK_STREAM, 0);
if(client_fd == CURL_SOCKET_BAD) {
- fprintf(stderr, "socket creation error\n");
+ curl_mfprintf(stderr, "socket creation error\n");
goto test_cleanup;
}
serv_addr.sin_port = htons(port);
if(my_inet_pton(AF_INET, libtest_arg2, &serv_addr.sin_addr) <= 0) {
- fprintf(stderr, "inet_pton failed\n");
+ curl_mfprintf(stderr, "inet_pton failed\n");
goto test_cleanup;
}
status = connect(client_fd, (struct sockaddr*)&serv_addr, sizeof(serv_addr));
if(status < 0) {
- fprintf(stderr, "connection failed\n");
+ curl_mfprintf(stderr, "connection failed\n");
goto test_cleanup;
}
curl = curl_easy_init();
if(!curl) {
- fprintf(stderr, "curl_easy_init() failed\n");
+ curl_mfprintf(stderr, "curl_easy_init() failed\n");
goto test_cleanup;
}
CURLcode test(char *URL)
{
(void)URL;
- printf("lacks inet_pton\n");
+ curl_mprintf("lacks inet_pton\n");
return CURLE_OK;
}
#endif
struct curl_slist *connect_to = NULL;
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
- fprintf(stderr, "curl_global_init() failed\n");
+ curl_mfprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
curl = curl_easy_init();
if(!curl) {
- fprintf(stderr, "curl_easy_init() failed\n");
+ curl_mfprintf(stderr, "curl_easy_init() failed\n");
curl_global_cleanup();
return TEST_ERR_MAJOR_BAD;
}
struct curl_slist *connect_to = NULL;
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
- fprintf(stderr, "curl_global_init() failed\n");
+ curl_mfprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
curl = curl_easy_init();
if(!curl) {
- fprintf(stderr, "curl_easy_init() failed\n");
+ curl_mfprintf(stderr, "curl_easy_init() failed\n");
curl_global_cleanup();
return TEST_ERR_MAJOR_BAD;
}
struct curl_slist *connect_to = NULL;
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
- fprintf(stderr, "curl_global_init() failed\n");
+ curl_mfprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
curl = curl_easy_init();
if(!curl) {
- fprintf(stderr, "curl_easy_init() failed\n");
+ curl_mfprintf(stderr, "curl_easy_init() failed\n");
curl_global_cleanup();
return TEST_ERR_MAJOR_BAD;
}
struct curl_slist *connect_to = NULL;
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
- fprintf(stderr, "curl_global_init() failed\n");
+ curl_mfprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
curl = curl_easy_init();
if(!curl) {
- fprintf(stderr, "curl_easy_init() failed\n");
+ curl_mfprintf(stderr, "curl_easy_init() failed\n");
curl_global_cleanup();
return TEST_ERR_MAJOR_BAD;
}
struct curl_slist *connect_to = NULL;
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
- fprintf(stderr, "curl_global_init() failed\n");
+ curl_mfprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
curl = curl_easy_init();
if(!curl) {
- fprintf(stderr, "curl_easy_init() failed\n");
+ curl_mfprintf(stderr, "curl_easy_init() failed\n");
curl_global_cleanup();
return TEST_ERR_MAJOR_BAD;
}
struct curl_slist *connect_to = NULL;
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
- fprintf(stderr, "curl_global_init() failed\n");
+ curl_mfprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
curl = curl_easy_init();
if(!curl) {
- fprintf(stderr, "curl_easy_init() failed\n");
+ curl_mfprintf(stderr, "curl_easy_init() failed\n");
curl_global_cleanup();
return TEST_ERR_MAJOR_BAD;
}
res = curl_easy_getinfo(curl, CURLINFO_EFFECTIVE_URL, &effective);
if(res)
goto test_cleanup;
- printf("effective URL: %s\n", effective);
+ curl_mprintf("effective URL: %s\n", effective);
/* second transfer: set URL + query in the second CURLU handle */
res = curl_easy_getinfo(curl, CURLINFO_EFFECTIVE_URL, &effective);
if(res)
goto test_cleanup;
- printf("effective URL: %s\n", effective);
+ curl_mprintf("effective URL: %s\n", effective);
/* third transfer: append extra query in the second CURLU handle, but do not
res = curl_easy_getinfo(curl, CURLINFO_EFFECTIVE_URL, &effective);
if(res)
goto test_cleanup;
- printf("effective URL: %s\n", effective);
+ curl_mprintf("effective URL: %s\n", effective);
test_cleanup:
struct curl_slist *list = NULL;
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
- fprintf(stderr, "curl_global_init() failed\n");
+ curl_mfprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
curl = curl_easy_init();
if(!curl) {
- fprintf(stderr, "curl_easy_init() failed\n");
+ curl_mfprintf(stderr, "curl_easy_init() failed\n");
curl_global_cleanup();
return TEST_ERR_MAJOR_BAD;
}
size_t sent;
CURLcode result =
curl_ws_send(curl, send_payload, strlen(send_payload), &sent, CURLWS_PING);
- fprintf(stderr,
- "ws: curl_ws_send returned %d, sent %d\n", result, (int)sent);
+ curl_mfprintf(stderr,
+ "ws: curl_ws_send returned %d, sent %d\n", result, (int)sent);
return result;
}
curl_ws_recv(curl, buffer, sizeof(buffer), &rlen, &rflags);
if(rflags & CURLWS_PONG) {
int same = 0;
- fprintf(stderr, "ws: got PONG back\n");
+ curl_mfprintf(stderr, "ws: got PONG back\n");
if(rlen == strlen(expected_payload)) {
if(!memcmp(expected_payload, buffer, rlen)) {
- fprintf(stderr, "ws: got the same payload back\n");
+ curl_mfprintf(stderr, "ws: got the same payload back\n");
same = 1;
}
}
if(!same)
- fprintf(stderr, "ws: did NOT get the same payload back\n");
+ curl_mfprintf(stderr, "ws: did NOT get the same payload back\n");
}
else {
- fprintf(stderr, "recv_pong: got %d bytes rflags %x\n", (int)rlen, rflags);
+ curl_mfprintf(stderr, "recv_pong: got %d bytes rflags %x\n",
+ (int)rlen, rflags);
}
- fprintf(stderr, "ws: curl_ws_recv returned %d, received %d\n", result,
- (int)rlen);
+ curl_mfprintf(stderr, "ws: curl_ws_recv returned %d, received %d\n", result,
+ (int)rlen);
return result;
}
size_t sent;
CURLcode result =
curl_ws_send(curl, "", 0, &sent, CURLWS_CLOSE);
- fprintf(stderr,
- "ws: curl_ws_send returned %d, sent %d\n", result, (int)sent);
+ curl_mfprintf(stderr,
+ "ws: curl_ws_send returned %d, sent %d\n", result, (int)sent);
}
static void websocket(CURL *curl)
{
int i = 0;
- fprintf(stderr, "ws: websocket() starts\n");
+ curl_mfprintf(stderr, "ws: websocket() starts\n");
do {
if(send_ping(curl, "foobar"))
return;
0x8a, 0x0
};
size_t incoming = nitems;
- fprintf(stderr, "Called CURLOPT_WRITEFUNCTION with %d bytes: ",
- (int)nitems);
+ curl_mfprintf(stderr, "Called CURLOPT_WRITEFUNCTION with %d bytes: ",
+ (int)nitems);
for(i = 0; i < nitems; i++)
- fprintf(stderr, "%02x ", (unsigned char)buffer[i]);
- fprintf(stderr, "\n");
+ curl_mfprintf(stderr, "%02x ", (unsigned char)buffer[i]);
+ curl_mfprintf(stderr, "\n");
(void)size;
if(buffer[0] == 0x89) {
CURLcode result;
- fprintf(stderr, "send back a simple PONG\n");
+ curl_mfprintf(stderr, "send back a simple PONG\n");
result = curl_ws_send(easy, pong, 2, &sent, 0, 0);
if(result)
nitems = 0;
}
if(nitems != incoming)
- fprintf(stderr, "returns error from callback\n");
+ curl_mfprintf(stderr, "returns error from callback\n");
return nitems;
}
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, writecb);
curl_easy_setopt(curl, CURLOPT_WRITEDATA, curl);
res = curl_easy_perform(curl);
- fprintf(stderr, "curl_easy_perform() returned %d\n", res);
+ curl_mfprintf(stderr, "curl_easy_perform() returned %d\n", res);
#if 0
if(res == CURLE_OK)
websocket(curl);
return;
for(i = 0; i < wd->blen; ++i)
- printf("%02x ", (unsigned char)wd->buf[i]);
+ curl_mprintf("%02x ", (unsigned char)wd->buf[i]);
- printf("\n");
+ curl_mprintf("\n");
if(wd->has_meta)
- printf("RECFLAGS: %x\n", wd->meta_flags);
+ curl_mprintf("RECFLAGS: %x\n", wd->meta_flags);
else
- fprintf(stderr, "RECFLAGS: NULL\n");
+ curl_mfprintf(stderr, "RECFLAGS: NULL\n");
wd->blen = 0;
wd->nwrites = 0;
}
incoming = add_data(ws_data, buffer, incoming, meta);
if(nitems != incoming)
- fprintf(stderr, "returns error from callback\n");
+ curl_mfprintf(stderr, "returns error from callback\n");
return nitems;
}
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, writecb);
curl_easy_setopt(curl, CURLOPT_WRITEDATA, &ws_data);
res = curl_easy_perform(curl);
- fprintf(stderr, "curl_easy_perform() returned %d\n", res);
+ curl_mfprintf(stderr, "curl_easy_perform() returned %d\n", res);
/* always cleanup */
curl_easy_cleanup(curl);
flush_data(&ws_data);
CURLcode result =
curl_ws_send(curl, send_payload, strlen(send_payload), &sent, 0,
CURLWS_PING);
- fprintf(stderr,
- "ws: curl_ws_send returned %d, sent %d\n", result, (int)sent);
+ curl_mfprintf(stderr,
+ "ws: curl_ws_send returned %d, sent %d\n", result, (int)sent);
return result;
}
if(!result) {
if(meta->flags & CURLWS_PONG) {
int same = 0;
- fprintf(stderr, "ws: got PONG back\n");
+ curl_mfprintf(stderr, "ws: got PONG back\n");
if(rlen == strlen(expected_payload)) {
if(!memcmp(expected_payload, buffer, rlen)) {
- fprintf(stderr, "ws: got the same payload back\n");
+ curl_mfprintf(stderr, "ws: got the same payload back\n");
same = 1;
}
}
if(!same)
- fprintf(stderr, "ws: did NOT get the same payload back\n");
+ curl_mfprintf(stderr, "ws: did NOT get the same payload back\n");
}
else {
- fprintf(stderr, "recv_pong: got %d bytes rflags %x\n", (int)rlen,
- meta->flags);
+ curl_mfprintf(stderr, "recv_pong: got %d bytes rflags %x\n", (int)rlen,
+ meta->flags);
}
}
- fprintf(stderr, "ws: curl_ws_recv returned %d, received %d\n", result,
- (int)rlen);
+ curl_mfprintf(stderr, "ws: curl_ws_recv returned %d, received %d\n", result,
+ (int)rlen);
return result;
}
if(result)
return result;
- fprintf(stderr, "recv_any: got %u bytes rflags %x\n", (int)rlen,
- meta->flags);
+ curl_mfprintf(stderr, "recv_any: got %u bytes rflags %x\n", (int)rlen,
+ meta->flags);
return CURLE_OK;
}
size_t sent;
CURLcode result =
curl_ws_send(curl, "", 0, &sent, 0, CURLWS_CLOSE);
- fprintf(stderr,
- "ws: curl_ws_send returned %d, sent %u\n", result, (int)sent);
+ curl_mfprintf(stderr,
+ "ws: curl_ws_send returned %d, sent %u\n", result, (int)sent);
}
static void websocket(CURL *curl)
{
int i = 0;
- fprintf(stderr, "ws: websocket() starts\n");
+ curl_mfprintf(stderr, "ws: websocket() starts\n");
do {
recv_any(curl);
- fprintf(stderr, "Send ping\n");
+ curl_mfprintf(stderr, "Send ping\n");
if(send_ping(curl, "foobar"))
return;
- fprintf(stderr, "Receive pong\n");
+ curl_mfprintf(stderr, "Receive pong\n");
if(recv_pong(curl, "foobar")) {
- printf("Connection closed\n");
+ curl_mprintf("Connection closed\n");
return;
}
sleep(2);
curl_easy_setopt(curl, CURLOPT_VERBOSE, 1L);
curl_easy_setopt(curl, CURLOPT_CONNECT_ONLY, 2L); /* websocket style */
res = curl_easy_perform(curl);
- fprintf(stderr, "curl_easy_perform() returned %d\n", res);
+ curl_mfprintf(stderr, "curl_easy_perform() returned %d\n", res);
if(res == CURLE_OK)
websocket(curl);
size_t sent;
CURLcode result =
curl_ws_send(curl, "", 0, &sent, 0, CURLWS_CLOSE);
- fprintf(stderr,
- "ws: curl_ws_send returned %d, sent %d\n", result, (int)sent);
+ curl_mfprintf(stderr,
+ "ws: curl_ws_send returned %d, sent %d\n", result, (int)sent);
}
static void websocket(CURL *curl)
/* crude busy-loop */
continue;
fclose(save);
- printf("curl_ws_recv returned %d\n", result);
+ curl_mprintf("curl_ws_recv returned %d\n", result);
return;
}
- printf("%d: nread %zu Age %d Flags %x "
- "Offset %" CURL_FORMAT_CURL_OFF_T " "
- "Bytesleft %" CURL_FORMAT_CURL_OFF_T "\n",
- (int)i,
- nread, meta->age, meta->flags, meta->offset, meta->bytesleft);
+ curl_mprintf("%d: nread %zu Age %d Flags %x "
+ "Offset %" CURL_FORMAT_CURL_OFF_T " "
+ "Bytesleft %" CURL_FORMAT_CURL_OFF_T "\n",
+ (int)i,
+ nread, meta->age, meta->flags, meta->offset, meta->bytesleft);
i += meta->len;
fwrite(buffer, 1, nread, save);
}
curl_easy_setopt(curl, CURLOPT_VERBOSE, 1L);
curl_easy_setopt(curl, CURLOPT_CONNECT_ONLY, 2L); /* websocket style */
res = curl_easy_perform(curl);
- fprintf(stderr, "curl_easy_perform() returned %d\n", res);
+ curl_mfprintf(stderr, "curl_easy_perform() returned %d\n", res);
if(res == CURLE_OK)
websocket(curl);
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, cb_curl);
curl_easy_setopt(curl, CURLOPT_URL, URL);
res = curl_easy_perform(curl);
- printf("Returned %d, should be %d.\n", res, CURLE_WRITE_ERROR);
+ curl_mprintf("Returned %d, should be %d.\n", res, CURLE_WRITE_ERROR);
fflush(stdout);
curl_easy_cleanup(curl);
curl_global_cleanup();
curldupe = curl_easy_duphandle(curl);
if(curldupe) {
res = curl_easy_perform(curldupe);
- printf("Returned %d, should be %d.\n", res, CURLE_WRITE_ERROR);
+ curl_mprintf("Returned %d, should be %d.\n", res, CURLE_WRITE_ERROR);
fflush(stdout);
curl_easy_cleanup(curldupe);
}
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, writecb);
curl_easy_setopt(curl, CURLOPT_WRITEDATA, curl);
res = curl_easy_perform(curl);
- printf("Returned %d, should be %d.\n", res, CURLE_RECV_ERROR);
+ curl_mprintf("Returned %d, should be %d.\n", res, CURLE_RECV_ERROR);
/* always cleanup */
curl_easy_cleanup(curl);
size_t sent;
CURLcode result =
curl_ws_send(curl, "", 0, &sent, 0, CURLWS_CLOSE);
- fprintf(stderr,
- "ws: curl_ws_send returned %d, sent %zu\n", result, sent);
+ curl_mfprintf(stderr,
+ "ws: curl_ws_send returned %d, sent %zu\n", result, sent);
}
static void websocket_frame(CURL *curl, FILE *save, int expected_flags)
if(result == CURLE_AGAIN)
/* crude busy-loop */
continue;
- printf("curl_ws_recv returned %d\n", result);
+ curl_mprintf("curl_ws_recv returned %d\n", result);
return;
}
- printf("%d: nread %zu Age %d Flags %x "
- "Offset %" CURL_FORMAT_CURL_OFF_T " "
- "Bytesleft %" CURL_FORMAT_CURL_OFF_T "\n",
- (int)total_read,
- nread, meta->age, meta->flags, meta->offset, meta->bytesleft);
+ curl_mprintf("%d: nread %zu Age %d Flags %x "
+ "Offset %" CURL_FORMAT_CURL_OFF_T " "
+ "Bytesleft %" CURL_FORMAT_CURL_OFF_T "\n",
+ (int)total_read,
+ nread, meta->age, meta->flags, meta->offset, meta->bytesleft);
assert(meta->flags == expected_flags);
total_read += nread;
fwrite(buffer, 1, nread, save);
curl_easy_setopt(curl, CURLOPT_VERBOSE, 1L);
curl_easy_setopt(curl, CURLOPT_CONNECT_ONLY, 2L); /* websocket style */
res = curl_easy_perform(curl);
- fprintf(stderr, "curl_easy_perform() returned %d\n", res);
+ curl_mfprintf(stderr, "curl_easy_perform() returned %d\n", res);
if(res == CURLE_OK)
websocket(curl);
/* upon ping, respond with input data, disconnect, mark a success */
if(frame->flags & CURLWS_PING) {
- fprintf(stderr, "write_cb received ping with %zd bytes\n",
- size * nitems);
- fprintf(stderr, "\n");
+ curl_mfprintf(stderr, "write_cb received ping with %zd bytes\n",
+ size * nitems);
+ curl_mfprintf(stderr, "\n");
for(i = 0; i < size * nitems; i++) {
- fprintf(stderr, "%02X%s", (int)b[i],
- (i % 10 == 0 && i != 0) ? "\n" : " ");
+ curl_mfprintf(stderr, "%02X%s", (int)b[i],
+ (i % 10 == 0 && i != 0) ? "\n" : " ");
}
- fprintf(stderr, "\n");
- fprintf(stderr, "write_cb sending pong response\n");
+ curl_mfprintf(stderr, "\n");
+ curl_mfprintf(stderr, "write_cb sending pong response\n");
curl_ws_send(curl, b, size * nitems, &sent, 0, CURLWS_PONG);
- fprintf(stderr, "write_cb closing websocket\n");
+ curl_mfprintf(stderr, "write_cb closing websocket\n");
curl_ws_send(curl, NULL, 0, &sent, 0, CURLWS_CLOSE);
ping_check->pinged = 1;
}
else {
- fprintf(stderr, "ping_check_cb: non-ping message, frame->flags %x\n",
- frame->flags);
+ curl_mfprintf(stderr, "ping_check_cb: non-ping message, frame->flags %x\n",
+ frame->flags);
}
return size * nitems;
curl_easy_setopt(curl, CURLOPT_WRITEDATA, &state);
res = curl_easy_perform(curl);
- fprintf(stderr, "curl_easy_perform() returned %u\n", (int)res);
+ curl_mfprintf(stderr, "curl_easy_perform() returned %u\n", (int)res);
res = state.pinged ? 0 : 1;
(void)URL;
- msnprintf(dnsentry, sizeof(dnsentry), "localhost:%s:%s",
- port, address);
- printf("%s\n", dnsentry);
+ curl_msnprintf(dnsentry, sizeof(dnsentry), "localhost:%s:%s",
+ port, address);
+ curl_mprintf("%s\n", dnsentry);
slist = curl_slist_append(slist, dnsentry);
if(!slist) {
- fprintf(stderr, "curl_slist_append() failed\n");
+ curl_mfprintf(stderr, "curl_slist_append() failed\n");
goto test_cleanup;
}
/* get an easy handle */
easy_init(curl[i]);
/* specify target */
- msnprintf(target_url, sizeof(target_url),
- "https://localhost:%s/path/2402%04i",
- port, i + 1);
+ curl_msnprintf(target_url, sizeof(target_url),
+ "https://localhost:%s/path/2402%04i",
+ port, i + 1);
target_url[sizeof(target_url) - 1] = '\0';
easy_setopt(curl[i], CURLOPT_URL, target_url);
/* go http2 */
easy_setopt(curl[i], CURLOPT_RESOLVE, slist);
}
- fprintf(stderr, "Start at URL 0\n");
+ curl_mfprintf(stderr, "Start at URL 0\n");
for(i = 0; i < NUM_HANDLES; i++) {
/* add handle to multi */
(void)URL;
- msnprintf(dnsentry, sizeof(dnsentry), "localhost:%s:%s",
- port, address);
- printf("%s\n", dnsentry);
+ curl_msnprintf(dnsentry, sizeof(dnsentry), "localhost:%s:%s",
+ port, address);
+ curl_mprintf("%s\n", dnsentry);
slist = curl_slist_append(slist, dnsentry);
if(!slist) {
- fprintf(stderr, "curl_slist_append() failed\n");
+ curl_mfprintf(stderr, "curl_slist_append() failed\n");
goto test_cleanup;
}
/* get an easy handle */
easy_init(curl[i]);
/* specify target */
- msnprintf(target_url, sizeof(target_url),
- "https://localhost:%s/path/2404%04i",
- port, i + 1);
+ curl_msnprintf(target_url, sizeof(target_url),
+ "https://localhost:%s/path/2404%04i",
+ port, i + 1);
target_url[sizeof(target_url) - 1] = '\0';
easy_setopt(curl[i], CURLOPT_URL, target_url);
/* go http2 */
easy_setopt(curl[i], CURLOPT_STREAM_WEIGHT, (long)128 + i);
}
- fprintf(stderr, "Start at URL 0\n");
+ curl_mfprintf(stderr, "Start at URL 0\n");
for(i = 0; i < NUM_HANDLES; i++) {
/* add handle to multi */
#define test_check(expected_fds) \
if(res != CURLE_OK) { \
- fprintf(stderr, "test failed with code: %d\n", res); \
+ curl_mfprintf(stderr, "test failed with code: %d\n", res); \
goto test_cleanup; \
} \
else if(fd_count != expected_fds) { \
- fprintf(stderr, "Max number of waitfds: %d not as expected: %d\n", \
+ curl_mfprintf(stderr, "Max number of waitfds: %d not as expected: %d\n", \
fd_count, expected_fds); \
res = TEST_ERR_FAILURE; \
goto test_cleanup; \
mc = curl_multi_waitfds(multi, NULL, 0, NULL);
if(mc != CURLM_BAD_FUNCTION_ARGUMENT) {
- fprintf(stderr, "curl_multi_waitfds() return code %d instead of "
- "CURLM_BAD_FUNCTION_ARGUMENT.\n", mc);
+ curl_mfprintf(stderr, "curl_multi_waitfds() return code %d instead of "
+ "CURLM_BAD_FUNCTION_ARGUMENT.\n", mc);
res = TEST_ERR_FAILURE;
break;
}
mc = curl_multi_waitfds(multi, NULL, 1, NULL);
if(mc != CURLM_BAD_FUNCTION_ARGUMENT) {
- fprintf(stderr, "curl_multi_waitfds() return code %d instead of "
- "CURLM_BAD_FUNCTION_ARGUMENT.\n", mc);
+ curl_mfprintf(stderr, "curl_multi_waitfds() return code %d instead of "
+ "CURLM_BAD_FUNCTION_ARGUMENT.\n", mc);
res = TEST_ERR_FAILURE;
break;
}
mc = curl_multi_waitfds(multi, NULL, 1, &fd_count);
if(mc != CURLM_BAD_FUNCTION_ARGUMENT) {
- fprintf(stderr, "curl_multi_waitfds() return code %d instead of "
- "CURLM_BAD_FUNCTION_ARGUMENT.\n", mc);
+ curl_mfprintf(stderr, "curl_multi_waitfds() return code %d instead of "
+ "CURLM_BAD_FUNCTION_ARGUMENT.\n", mc);
res = TEST_ERR_FAILURE;
break;
}
mc = curl_multi_waitfds(multi, ufds, 10, &fd_count);
if(mc != CURLM_OK) {
- fprintf(stderr, "curl_multi_waitfds() failed, code %d.\n", mc);
+ curl_mfprintf(stderr, "curl_multi_waitfds() failed, code %d.\n", mc);
res = TEST_ERR_FAILURE;
break;
}
mc = curl_multi_waitfds(multi, NULL, 0, &fd_count_chk);
if(mc != CURLM_OK) {
- fprintf(stderr, "curl_multi_waitfds() failed, code %d.\n", mc);
+ curl_mfprintf(stderr, "curl_multi_waitfds() failed, code %d.\n", mc);
res = TEST_ERR_FAILURE;
break;
}
if(fd_count_chk < fd_count) {
- fprintf(stderr, "curl_multi_waitfds() should return at least the number "
- "of fds needed\n");
+ curl_mfprintf(stderr,
+ "curl_multi_waitfds() should return at least the number "
+ "of fds needed\n");
res = TEST_ERR_FAILURE;
break;
}
mc = curl_multi_waitfds(multi, ufds1, fd_count - 1, &fd_count_chk);
if(mc != CURLM_OUT_OF_MEMORY) {
- fprintf(stderr, "curl_multi_waitfds() return code %d instead of "
- "CURLM_OUT_OF_MEMORY.\n", mc);
+ curl_mfprintf(stderr, "curl_multi_waitfds() return code %d instead of "
+ "CURLM_OUT_OF_MEMORY.\n", mc);
res = TEST_ERR_FAILURE;
break;
}
if(fd_count_chk < fd_count) {
- fprintf(stderr, "curl_multi_waitfds() sould return the amount of fds "
- "needed if enough isn't passed in.\n");
+ curl_mfprintf(stderr,
+ "curl_multi_waitfds() sould return the amount of fds "
+ "needed if enough isn't passed in.\n");
res = TEST_ERR_FAILURE;
break;
}
mc = curl_multi_waitfds(multi, ufds, 0, NULL);
if(mc != CURLM_OUT_OF_MEMORY) {
- fprintf(stderr, "curl_multi_waitfds() return code %d instead of "
- "CURLM_OUT_OF_MEMORY.\n", mc);
+ curl_mfprintf(stderr, "curl_multi_waitfds() return code %d instead of "
+ "CURLM_OUT_OF_MEMORY.\n", mc);
res = TEST_ERR_FAILURE;
break;
}
mc = curl_multi_waitfds(multi, ufds, 0, &fd_count_chk);
if(mc != CURLM_OUT_OF_MEMORY) {
- fprintf(stderr, "curl_multi_waitfds() return code %d instead of "
- "CURLM_OUT_OF_MEMORY.\n", mc);
+ curl_mfprintf(stderr, "curl_multi_waitfds() return code %d instead of "
+ "CURLM_OUT_OF_MEMORY.\n", mc);
res = TEST_ERR_FAILURE;
break;
}
if(fd_count_chk < fd_count) {
- fprintf(stderr, "curl_multi_waitfds() sould return the amount of fds "
- "needed if enough isn't passed in.\n");
+ curl_mfprintf(stderr,
+ "curl_multi_waitfds() sould return the amount of fds "
+ "needed if enough isn't passed in.\n");
res = TEST_ERR_FAILURE;
break;
}
mc = curl_multi_poll(multi1, ufds, fd_count, 500, &numfds);
if(mc != CURLM_OK) {
- fprintf(stderr, "curl_multi_poll() failed, code %d.\\n", mc);
+ curl_mfprintf(stderr, "curl_multi_poll() failed, code %d.\\n", mc);
res = TEST_ERR_FAILURE;
break;
}
mc = curl_multi_waitfds(multi, ufds, 10, &fd_count);
if(mc != CURLM_OK) {
- fprintf(stderr, "curl_multi_waitfds() failed, code %d.\n", mc);
+ curl_mfprintf(stderr, "curl_multi_waitfds() failed, code %d.\n", mc);
res = TEST_ERR_FAILURE;
goto test_cleanup;
}
else if(fd_count > 0) {
- fprintf(stderr, "curl_multi_waitfds() returned non-zero count of "
- "waitfds: %d.\n", fd_count);
+ curl_mfprintf(stderr, "curl_multi_waitfds() returned non-zero count of "
+ "waitfds: %d.\n", fd_count);
res = TEST_ERR_FAILURE;
goto test_cleanup;
}
mc = curl_multi_waitfds(multi, ufds, 10, &fd_count);
if(mc != CURLM_OK) {
- fprintf(stderr, "curl_multi_waitfds() failed, code %d.\n", mc);
+ curl_mfprintf(stderr, "curl_multi_waitfds() failed, code %d.\n", mc);
res = TEST_ERR_FAILURE;
goto test_cleanup;
}
else if(fd_count > 0) {
- fprintf(stderr, "curl_multi_waitfds() returned non-zero count of "
- "waitfds: %d.\n", fd_count);
+ curl_mfprintf(stderr, "curl_multi_waitfds() returned non-zero count of "
+ "waitfds: %d.\n", fd_count);
res = TEST_ERR_FAILURE;
goto test_cleanup;
}
(void)URL;
- msnprintf(dnsentry, sizeof(dnsentry), "localhost:%s:%s",
- port, address);
- printf("%s\n", dnsentry);
+ curl_msnprintf(dnsentry, sizeof(dnsentry), "localhost:%s:%s",
+ port, address);
+ curl_mprintf("%s\n", dnsentry);
slist = curl_slist_append(slist, dnsentry);
if(!slist) {
- fprintf(stderr, "curl_slist_append() failed\n");
+ curl_mfprintf(stderr, "curl_slist_append() failed\n");
goto test_cleanup;
}
/* get an easy handle */
easy_init(curl[i]);
/* specify target */
- msnprintf(target_url, sizeof(target_url),
- "https://localhost:%s/path/2502%04i",
- port, i + 1);
+ curl_msnprintf(target_url, sizeof(target_url),
+ "https://localhost:%s/path/2502%04i",
+ port, i + 1);
target_url[sizeof(target_url) - 1] = '\0';
easy_setopt(curl[i], CURLOPT_URL, target_url);
/* go http2 */
easy_setopt(curl[i], CURLOPT_RESOLVE, slist);
}
- fprintf(stderr, "Start at URL 0\n");
+ curl_mfprintf(stderr, "Start at URL 0\n");
for(i = 0; i < NUM_HANDLES; i++) {
/* add handle to multi */
curl_easy_setopt(curl, CURLOPT_URL, URL);
ret = curl_easy_perform(curl);
if(ret) {
- fprintf(stderr, "%s:%d curl_easy_perform() failed with code %d (%s)\n",
- __FILE__, __LINE__, ret, curl_easy_strerror(ret));
+ curl_mfprintf(stderr,
+ "%s:%d curl_easy_perform() failed with code %d (%s)\n",
+ __FILE__, __LINE__, ret, curl_easy_strerror(ret));
goto test_cleanup;
}
curl_easy_getinfo(curl, CURLINFO_REDIRECT_URL, &follow_url);
curl_easy_getinfo(curl, CURLINFO_RETRY_AFTER, &retry_after);
- printf("Retry-After %" CURL_FORMAT_CURL_OFF_T "\n", retry_after);
+ curl_mprintf("Retry-After %" CURL_FORMAT_CURL_OFF_T "\n", retry_after);
curl_easy_setopt(curl, CURLOPT_URL, follow_url);
ret = curl_easy_perform(curl);
if(ret) {
- fprintf(stderr, "%s:%d curl_easy_perform() failed with code %d (%s)\n",
- __FILE__, __LINE__, ret, curl_easy_strerror(ret));
+ curl_mfprintf(stderr,
+ "%s:%d curl_easy_perform() failed with code %d (%s)\n",
+ __FILE__, __LINE__, ret, curl_easy_strerror(ret));
goto test_cleanup;
}
curl_easy_reset(curl);
curl_easy_getinfo(curl, CURLINFO_RETRY_AFTER, &retry_after);
- printf("Retry-After %" CURL_FORMAT_CURL_OFF_T "\n", retry_after);
+ curl_mprintf("Retry-After %" CURL_FORMAT_CURL_OFF_T "\n", retry_after);
}
test_cleanup:
struct curl_slist *icy = NULL;
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
- fprintf(stderr, "curl_global_init() failed\n");
+ curl_mfprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
curl = curl_easy_init();
if(!curl) {
- fprintf(stderr, "curl_easy_init() failed\n");
+ curl_mfprintf(stderr, "curl_easy_init() failed\n");
curl_global_cleanup();
return TEST_ERR_MAJOR_BAD;
}
ver = curl_version_info(CURLVERSION_NOW);
if((ver->features & CURL_VERSION_THREADSAFE) == 0) {
- fprintf(stderr, "%s:%d On Windows but the "
- "CURL_VERSION_THREADSAFE feature flag is not set\n",
- __FILE__, __LINE__);
+ curl_mfprintf(stderr, "%s:%d On Windows but the "
+ "CURL_VERSION_THREADSAFE feature flag is not set\n",
+ __FILE__, __LINE__);
return TEST_ERR_MAJOR_BAD;
}
th = _beginthreadex(NULL, 0, run_thread, &results[i], 0, NULL);
#endif
if(!th) {
- fprintf(stderr, "%s:%d Couldn't create thread, errno %lu\n",
- __FILE__, __LINE__, GetLastError());
+ curl_mfprintf(stderr, "%s:%d Couldn't create thread, errno %lu\n",
+ __FILE__, __LINE__, GetLastError());
tid_count = i;
test_failure = TEST_ERR_MAJOR_BAD;
goto cleanup;
WaitForSingleObject((HANDLE)ths[i], INFINITE);
CloseHandle((HANDLE)ths[i]);
if(results[i] != CURLE_OK) {
- fprintf(stderr, "%s:%d thread[%u]: curl_global_init() failed,"
- "with code %d (%s)\n", __FILE__, __LINE__,
- i, (int) results[i], curl_easy_strerror(results[i]));
+ curl_mfprintf(stderr, "%s:%d thread[%u]: curl_global_init() failed,"
+ "with code %d (%s)\n", __FILE__, __LINE__,
+ i, (int) results[i], curl_easy_strerror(results[i]));
test_failure = TEST_ERR_MAJOR_BAD;
}
}
ver = curl_version_info(CURLVERSION_NOW);
if((ver->features & CURL_VERSION_THREADSAFE) == 0) {
- fprintf(stderr, "%s:%d Have pthread but the "
- "CURL_VERSION_THREADSAFE feature flag is not set\n",
- __FILE__, __LINE__);
+ curl_mfprintf(stderr, "%s:%d Have pthread but the "
+ "CURL_VERSION_THREADSAFE feature flag is not set\n",
+ __FILE__, __LINE__);
return TEST_ERR_MAJOR_BAD;
}
results[i] = CURL_LAST; /* initialize with invalid value */
res = pthread_create(&tids[i], NULL, run_thread, &results[i]);
if(res) {
- fprintf(stderr, "%s:%d Couldn't create thread, errno %d\n",
- __FILE__, __LINE__, res);
+ curl_mfprintf(stderr, "%s:%d Couldn't create thread, errno %d\n",
+ __FILE__, __LINE__, res);
tid_count = i;
test_failure = TEST_ERR_MAJOR_BAD;
goto cleanup;
for(i = 0; i < tid_count; i++) {
pthread_join(tids[i], NULL);
if(results[i] != CURLE_OK) {
- fprintf(stderr, "%s:%d thread[%u]: curl_global_init() failed,"
- "with code %d (%s)\n", __FILE__, __LINE__,
- i, (int) results[i], curl_easy_strerror(results[i]));
+ curl_mfprintf(stderr, "%s:%d thread[%u]: curl_global_init() failed,"
+ "with code %d (%s)\n", __FILE__, __LINE__,
+ i, (int) results[i], curl_easy_strerror(results[i]));
test_failure = TEST_ERR_MAJOR_BAD;
}
}
ver = curl_version_info(CURLVERSION_NOW);
if((ver->features & CURL_VERSION_THREADSAFE) != 0) {
- fprintf(stderr, "%s:%d No pthread but the "
- "CURL_VERSION_THREADSAFE feature flag is set\n",
- __FILE__, __LINE__);
+ curl_mfprintf(stderr, "%s:%d No pthread but the "
+ "CURL_VERSION_THREADSAFE feature flag is set\n",
+ __FILE__, __LINE__);
return TEST_ERR_MAJOR_BAD;
}
return CURLE_OK;
CURL *curl;
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
- fprintf(stderr, "curl_global_init() failed\n");
+ curl_mfprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
curl = curl_easy_init();
if(!curl) {
- fprintf(stderr, "curl_easy_init() failed\n");
+ curl_mfprintf(stderr, "curl_easy_init() failed\n");
curl_global_cleanup();
return TEST_ERR_MAJOR_BAD;
}
res = curl_easy_perform(curl);
if(res != CURLE_OK) {
- fprintf(stderr, "Failed to send DESCRIBE: %d\n", res);
+ curl_mfprintf(stderr, "Failed to send DESCRIBE: %d\n", res);
res = TEST_ERR_MAJOR_BAD;
goto test_cleanup;
}
CURL *curl;
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
- fprintf(stderr, "curl_global_init() failed\n");
+ curl_mfprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
curl = curl_easy_init();
if(!curl) {
- fprintf(stderr, "curl_easy_init() failed\n");
+ curl_mfprintf(stderr, "curl_easy_init() failed\n");
curl_global_cleanup();
return TEST_ERR_MAJOR_BAD;
}
}
if(subject && issuer) {
- printf("cert %d\n", cert);
- printf(" subject: %s\n", subject);
- printf(" issuer: %s\n", issuer);
+ curl_mprintf("cert %d\n", cert);
+ curl_mprintf(" subject: %s\n", subject);
+ curl_mprintf(" issuer: %s\n", issuer);
if(last_issuer) {
/* If the last certificate's issuer matches the current certificate's
* subject, then the chain is in order */
if(strcmp(last_issuer, subject) != 0) {
- fprintf(stderr, "cert %d issuer does not match cert %d subject\n",
- cert - 1, cert);
- fprintf(stderr, "certificate chain is not in order\n");
+ curl_mfprintf(stderr,
+ "cert %d issuer does not match cert %d subject\n",
+ cert - 1, cert);
+ curl_mfprintf(stderr, "certificate chain is not in order\n");
return false;
}
}
last_issuer = issuer;
}
- printf("certificate chain is in order\n");
+ curl_mprintf("certificate chain is in order\n");
return true;
}
CURLcode res = CURLE_OK;
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
- fprintf(stderr, "curl_global_init() failed\n");
+ curl_mfprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
curl = curl_easy_init();
if(!curl) {
- fprintf(stderr, "curl_easy_init() failed\n");
+ curl_mfprintf(stderr, "curl_easy_init() failed\n");
curl_global_cleanup();
return TEST_ERR_MAJOR_BAD;
}
res = curl_easy_perform(curl);
if(res) {
- fprintf(stderr, "curl_easy_perform() failed: %s\n",
- curl_easy_strerror(res));
+ curl_mfprintf(stderr, "curl_easy_perform() failed: %s\n",
+ curl_easy_strerror(res));
}
test_cleanup:
res = curl_easy_perform(curl);
if(res) {
- fprintf(stderr, "curl_easy_perform() failed: %s\n",
- curl_easy_strerror(res));
+ curl_mfprintf(stderr, "curl_easy_perform() failed: %s\n",
+ curl_easy_strerror(res));
}
test_cleanup:
mc += curl_multi_remove_handle(multi, curls);
if(mc) {
- fprintf(stderr, "%d was unexpected\n", (int)mc);
+ curl_mfprintf(stderr, "%d was unexpected\n", (int)mc);
i = CURLE_FAILED_INIT;
}
char *data = (char *)malloc(realsize + 1);
struct curl_slist *item_append = NULL;
if(!data) {
- printf("not enough memory (malloc returned NULL)\n");
+ curl_mprintf("not enough memory (malloc returned NULL)\n");
return 0;
}
memcpy(data, contents, realsize);
mem->contents = item_append;
}
else {
- printf("not enough memory (curl_slist_append returned NULL)\n");
+ curl_mprintf("not enough memory (curl_slist_append returned NULL)\n");
return 0;
}
return realsize;
curl_easy_cleanup(curl);
/* Check for errors */
if(res != CURLE_OK) {
- fprintf(stderr, "curl_easy_perform() failed: %s\n",
- curl_easy_strerror(res));
+ curl_mfprintf(stderr, "curl_easy_perform() failed: %s\n",
+ curl_easy_strerror(res));
goto test_cleanup;
}
}
share = curl_share_init();
if(!share) {
- fprintf(stderr, "curl_share_init() failed\n");
+ curl_mfprintf(stderr, "curl_share_init() failed\n");
goto test_cleanup;
}
else {
struct curl_slist *item = ctx[i].contents;
while(item) {
- printf("%s", item->data);
+ curl_mprintf("%s", item->data);
item = item->next;
}
}
int num;
mres = curl_multi_wait(multi, NULL, 0, TEST_HANG_TIMEOUT, &num);
if(mres != CURLM_OK) {
- printf("curl_multi_wait() returned %d\n", mres);
+ curl_mprintf("curl_multi_wait() returned %d\n", mres);
res = TEST_ERR_MAJOR_BAD;
goto test_cleanup;
}
{
(void)clientp;
(void)purpose;
- printf("[OPEN] counter: %d\n", ++testcounter);
+ curl_mprintf("[OPEN] counter: %d\n", ++testcounter);
return socket(addr->family, addr->socktype, addr->protocol);
}
static int tst_closesocket(void *clientp, curl_socket_t sock)
{
(void)clientp;
- printf("[CLOSE] counter: %d\n", testcounter--);
+ curl_mprintf("[CLOSE] counter: %d\n", testcounter--);
return sclose(sock);
}
char *ipstr = NULL;
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
- fprintf(stderr, "curl_global_init() failed\n");
+ curl_mfprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
curl = curl_easy_init();
if(!curl) {
- fprintf(stderr, "curl_easy_init() failed\n");
+ curl_mfprintf(stderr, "curl_easy_init() failed\n");
curl_global_cleanup();
return TEST_ERR_MAJOR_BAD;
}
curl_off_t time_posttransfer;
curl_off_t time_starttransfer;
curl_off_t time_total;
- fprintf(moo, "IP %s\n", ipstr);
+ curl_mfprintf(moo, "IP %s\n", ipstr);
curl_easy_getinfo(curl, CURLINFO_NAMELOOKUP_TIME_T, &time_namelookup);
curl_easy_getinfo(curl, CURLINFO_CONNECT_TIME_T, &time_connect);
curl_easy_getinfo(curl, CURLINFO_PRETRANSFER_TIME_T,
/* since the timing will always vary we only compare relative
differences between these 5 times */
if(time_namelookup > time_connect) {
- fprintf(moo, "namelookup vs connect: %" CURL_FORMAT_CURL_OFF_T
- ".%06ld %" CURL_FORMAT_CURL_OFF_T ".%06ld\n",
- (time_namelookup / 1000000),
- (long)(time_namelookup % 1000000),
- (time_connect / 1000000), (long)(time_connect % 1000000));
+ curl_mfprintf(moo, "namelookup vs connect: %" CURL_FORMAT_CURL_OFF_T
+ ".%06ld %" CURL_FORMAT_CURL_OFF_T ".%06ld\n",
+ (time_namelookup / 1000000),
+ (long)(time_namelookup % 1000000),
+ (time_connect / 1000000),
+ (long)(time_connect % 1000000));
}
if(time_connect > time_pretransfer) {
- fprintf(moo, "connect vs pretransfer: %" CURL_FORMAT_CURL_OFF_T
- ".%06ld %" CURL_FORMAT_CURL_OFF_T ".%06ld\n",
- (time_connect / 1000000), (long)(time_connect % 1000000),
- (time_pretransfer / 1000000),
- (long)(time_pretransfer % 1000000));
+ curl_mfprintf(moo, "connect vs pretransfer: %"
+ CURL_FORMAT_CURL_OFF_T
+ ".%06ld %" CURL_FORMAT_CURL_OFF_T ".%06ld\n",
+ (time_connect / 1000000),
+ (long)(time_connect % 1000000),
+ (time_pretransfer / 1000000),
+ (long)(time_pretransfer % 1000000));
}
if(time_pretransfer > time_posttransfer) {
- fprintf(moo, "pretransfer vs posttransfer: %" CURL_FORMAT_CURL_OFF_T
- ".%06ld %" CURL_FORMAT_CURL_OFF_T ".%06ld\n",
- (time_pretransfer / 1000000),
- (long)(time_pretransfer % 1000000),
- (time_posttransfer / 1000000),
- (long)(time_posttransfer % 1000000));
+ curl_mfprintf(moo, "pretransfer vs posttransfer: %"
+ CURL_FORMAT_CURL_OFF_T
+ ".%06ld %" CURL_FORMAT_CURL_OFF_T ".%06ld\n",
+ (time_pretransfer / 1000000),
+ (long)(time_pretransfer % 1000000),
+ (time_posttransfer / 1000000),
+ (long)(time_posttransfer % 1000000));
}
if(time_pretransfer > time_starttransfer) {
- fprintf(moo, "pretransfer vs starttransfer: %" CURL_FORMAT_CURL_OFF_T
- ".%06ld %" CURL_FORMAT_CURL_OFF_T ".%06ld\n",
- (time_pretransfer / 1000000),
- (long)(time_pretransfer % 1000000),
- (time_starttransfer / 1000000),
- (long)(time_starttransfer % 1000000));
+ curl_mfprintf(moo, "pretransfer vs starttransfer: %"
+ CURL_FORMAT_CURL_OFF_T
+ ".%06ld %" CURL_FORMAT_CURL_OFF_T ".%06ld\n",
+ (time_pretransfer / 1000000),
+ (long)(time_pretransfer % 1000000),
+ (time_starttransfer / 1000000),
+ (long)(time_starttransfer % 1000000));
}
if(time_starttransfer > time_total) {
- fprintf(moo, "starttransfer vs total: %" CURL_FORMAT_CURL_OFF_T
- ".%06ld %" CURL_FORMAT_CURL_OFF_T ".%06ld\n",
- (time_starttransfer / 1000000),
- (long)(time_starttransfer % 1000000),
- (time_total / 1000000), (long)(time_total % 1000000));
+ curl_mfprintf(moo, "starttransfer vs total: %" CURL_FORMAT_CURL_OFF_T
+ ".%06ld %" CURL_FORMAT_CURL_OFF_T ".%06ld\n",
+ (time_starttransfer / 1000000),
+ (long)(time_starttransfer % 1000000),
+ (time_total / 1000000),
+ (long)(time_total % 1000000));
}
if(time_posttransfer > time_total) {
- fprintf(moo, "posttransfer vs total: %" CURL_FORMAT_CURL_OFF_T
- ".%06ld %" CURL_FORMAT_CURL_OFF_T ".%06ld\n",
- (time_posttransfer / 1000000),
- (long)(time_posttransfer % 1000000),
- (time_total / 1000000), (long)(time_total % 1000000));
+ curl_mfprintf(moo, "posttransfer vs total: %" CURL_FORMAT_CURL_OFF_T
+ ".%06ld %" CURL_FORMAT_CURL_OFF_T ".%06ld\n",
+ (time_posttransfer / 1000000),
+ (long)(time_posttransfer % 1000000),
+ (time_total / 1000000),
+ (long)(time_total % 1000000));
}
fclose(moo);
(void)URL; /* we don't use this */
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
- fprintf(stderr, "curl_global_init() failed\n");
+ curl_mfprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
curl = curl_easy_init();
if(!curl) {
- fprintf(stderr, "curl_easy_init() failed\n");
+ curl_mfprintf(stderr, "curl_easy_init() failed\n");
curl_global_cleanup();
return TEST_ERR_MAJOR_BAD;
}
interval.tv_sec = 1;
interval.tv_usec = 0;
- fprintf(stderr, "curl_multi_perform()\n");
+ curl_mfprintf(stderr, "curl_multi_perform()\n");
multi_perform(m, &running);
int num;
mres = curl_multi_wait(m, NULL, 0, TEST_HANG_TIMEOUT, &num);
if(mres != CURLM_OK) {
- printf("curl_multi_wait() returned %d\n", mres);
+ curl_mprintf("curl_multi_wait() returned %d\n", mres);
res = TEST_ERR_MAJOR_BAD;
goto test_cleanup;
}
/* This is where this code is expected to reach */
int numleft;
CURLMsg *msg = curl_multi_info_read(m, &numleft);
- fprintf(stderr, "Expected: not running\n");
+ curl_mfprintf(stderr, "Expected: not running\n");
if(msg && !numleft)
res = TEST_ERR_SUCCESS; /* this is where we should be */
else
res = TEST_ERR_FAILURE; /* not correct */
break; /* done */
}
- fprintf(stderr, "running == %d\n", running);
+ curl_mfprintf(stderr, "running == %d\n", running);
FD_ZERO(&rd);
FD_ZERO(&wr);
FD_ZERO(&exc);
- fprintf(stderr, "curl_multi_fdset()\n");
+ curl_mfprintf(stderr, "curl_multi_fdset()\n");
multi_fdset(m, &rd, &wr, &exc, &maxfd);
const char *buf_2 = "RNTO 505-forreal";
if(!libtest_arg2) {
- fprintf(stderr, "Usage: <url> <file-to-upload>\n");
+ curl_mfprintf(stderr, "Usage: <url> <file-to-upload>\n");
return TEST_ERR_USAGE;
}
hd_src = fopen(libtest_arg2, "rb");
if(!hd_src) {
- fprintf(stderr, "fopen failed with error (%d) %s\n",
- errno, strerror(errno));
- fprintf(stderr, "Error opening file '%s'\n", libtest_arg2);
+ curl_mfprintf(stderr, "fopen failed with error (%d) %s\n",
+ errno, strerror(errno));
+ curl_mfprintf(stderr, "Error opening file '%s'\n", libtest_arg2);
return TEST_ERR_MAJOR_BAD; /* if this happens things are major weird */
}
#endif
if(hd == -1) {
/* can't open file, bail out */
- fprintf(stderr, "fstat() failed with error (%d) %s\n",
- errno, strerror(errno));
- fprintf(stderr, "Error opening file '%s'\n", libtest_arg2);
+ curl_mfprintf(stderr, "fstat() failed with error (%d) %s\n",
+ errno, strerror(errno));
+ curl_mfprintf(stderr, "Error opening file '%s'\n", libtest_arg2);
fclose(hd_src);
return TEST_ERR_MAJOR_BAD;
}
if(!file_info.st_size) {
- fprintf(stderr, "File %s has zero size!\n", libtest_arg2);
+ curl_mfprintf(stderr, "File %s has zero size!\n", libtest_arg2);
fclose(hd_src);
return TEST_ERR_MAJOR_BAD;
}
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
- fprintf(stderr, "curl_global_init() failed\n");
+ curl_mfprintf(stderr, "curl_global_init() failed\n");
fclose(hd_src);
return TEST_ERR_MAJOR_BAD;
}
/* get a curl handle */
curl = curl_easy_init();
if(!curl) {
- fprintf(stderr, "curl_easy_init() failed\n");
+ curl_mfprintf(stderr, "curl_easy_init() failed\n");
curl_global_cleanup();
fclose(hd_src);
return TEST_ERR_MAJOR_BAD;
hl = curl_slist_append(headerlist, buf_1);
if(!hl) {
- fprintf(stderr, "curl_slist_append() failed\n");
+ curl_mfprintf(stderr, "curl_slist_append() failed\n");
curl_easy_cleanup(curl);
curl_global_cleanup();
fclose(hd_src);
}
headerlist = curl_slist_append(hl, buf_2);
if(!headerlist) {
- fprintf(stderr, "curl_slist_append() failed\n");
+ curl_mfprintf(stderr, "curl_slist_append() failed\n");
curl_slist_free_all(hl);
curl_easy_cleanup(curl);
curl_global_cleanup();
locknum = 2;
break;
default:
- fprintf(stderr, "lock: no such data: %d\n", (int)data);
+ curl_mfprintf(stderr, "lock: no such data: %d\n", (int)data);
return;
}
/* detect locking of locked locks */
if(locks[locknum]) {
- printf("lock: double locked %s\n", what);
+ curl_mprintf("lock: double locked %s\n", what);
return;
}
locks[locknum]++;
- printf("lock: %-6s [%s]: %d\n", what, user->text, user->counter);
+ curl_mprintf("lock: %-6s [%s]: %d\n", what, user->text, user->counter);
user->counter++;
}
locknum = 2;
break;
default:
- fprintf(stderr, "unlock: no such data: %d\n", (int)data);
+ curl_mfprintf(stderr, "unlock: no such data: %d\n", (int)data);
return;
}
/* detect unlocking of unlocked locks */
if(!locks[locknum]) {
- printf("unlock: double unlocked %s\n", what);
+ curl_mprintf("unlock: double unlocked %s\n", what);
return;
}
locks[locknum]--;
- printf("unlock: %-6s [%s]: %d\n", what, user->text, user->counter);
+ curl_mprintf("unlock: %-6s [%s]: %d\n", what, user->text, user->counter);
user->counter++;
}
curl = curl_easy_init();
if(!curl) {
- fprintf(stderr, "curl_easy_init() failed\n");
+ curl_mfprintf(stderr, "curl_easy_init() failed\n");
return NULL;
}
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(curl, CURLOPT_URL, tdata->url);
curl_easy_setopt(curl, CURLOPT_COOKIEFILE, "");
- printf("CURLOPT_SHARE\n");
+ curl_mprintf("CURLOPT_SHARE\n");
curl_easy_setopt(curl, CURLOPT_SHARE, tdata->share);
- printf("PERFORM\n");
+ curl_mprintf("PERFORM\n");
code = curl_easy_perform(curl);
if(code) {
int i = 0;
- fprintf(stderr, "perform url '%s' repeat %d failed, curlcode %d\n",
+ curl_mfprintf(stderr, "perform url '%s' repeat %d failed, curlcode %d\n",
tdata->url, i, (int)code);
}
- printf("CLEANUP\n");
+ curl_mprintf("CLEANUP\n");
curl_easy_cleanup(curl);
curl_slist_free_all(headers);
user.text = "Pigs in space";
user.counter = 0;
- printf("GLOBAL_INIT\n");
+ curl_mprintf("GLOBAL_INIT\n");
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
- fprintf(stderr, "curl_global_init() failed\n");
+ curl_mfprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
/* prepare share */
- printf("SHARE_INIT\n");
+ curl_mprintf("SHARE_INIT\n");
share = curl_share_init();
if(!share) {
- fprintf(stderr, "curl_share_init() failed\n");
+ curl_mfprintf(stderr, "curl_share_init() failed\n");
curl_global_cleanup();
return TEST_ERR_MAJOR_BAD;
}
if(CURLSHE_OK == scode) {
- printf("CURLSHOPT_LOCKFUNC\n");
+ curl_mprintf("CURLSHOPT_LOCKFUNC\n");
scode = curl_share_setopt(share, CURLSHOPT_LOCKFUNC, test_lock);
}
if(CURLSHE_OK == scode) {
- printf("CURLSHOPT_UNLOCKFUNC\n");
+ curl_mprintf("CURLSHOPT_UNLOCKFUNC\n");
scode = curl_share_setopt(share, CURLSHOPT_UNLOCKFUNC, test_unlock);
}
if(CURLSHE_OK == scode) {
- printf("CURLSHOPT_USERDATA\n");
+ curl_mprintf("CURLSHOPT_USERDATA\n");
scode = curl_share_setopt(share, CURLSHOPT_USERDATA, &user);
}
if(CURLSHE_OK == scode) {
- printf("CURL_LOCK_DATA_COOKIE\n");
+ curl_mprintf("CURL_LOCK_DATA_COOKIE\n");
scode = curl_share_setopt(share, CURLSHOPT_SHARE, CURL_LOCK_DATA_COOKIE);
}
if(CURLSHE_OK == scode) {
- printf("CURL_LOCK_DATA_DNS\n");
+ curl_mprintf("CURL_LOCK_DATA_DNS\n");
scode = curl_share_setopt(share, CURLSHOPT_SHARE, CURL_LOCK_DATA_DNS);
}
if(CURLSHE_OK != scode) {
- fprintf(stderr, "curl_share_setopt() failed\n");
+ curl_mfprintf(stderr, "curl_share_setopt() failed\n");
curl_share_cleanup(share);
curl_global_cleanup();
return TEST_ERR_MAJOR_BAD;
/* initial cookie manipulation */
curl = curl_easy_init();
if(!curl) {
- fprintf(stderr, "curl_easy_init() failed\n");
+ curl_mfprintf(stderr, "curl_easy_init() failed\n");
curl_share_cleanup(share);
curl_global_cleanup();
return TEST_ERR_MAJOR_BAD;
}
- printf("CURLOPT_SHARE\n");
+ curl_mprintf("CURLOPT_SHARE\n");
test_setopt(curl, CURLOPT_SHARE, share);
- printf("CURLOPT_COOKIELIST injected_and_clobbered\n");
+ curl_mprintf("CURLOPT_COOKIELIST injected_and_clobbered\n");
test_setopt(curl, CURLOPT_COOKIELIST,
"Set-Cookie: injected_and_clobbered=yes; "
"domain=host.foo.com; expires=Sat Feb 2 11:56:27 GMT 2030");
- printf("CURLOPT_COOKIELIST ALL\n");
+ curl_mprintf("CURLOPT_COOKIELIST ALL\n");
test_setopt(curl, CURLOPT_COOKIELIST, "ALL");
- printf("CURLOPT_COOKIELIST session\n");
+ curl_mprintf("CURLOPT_COOKIELIST session\n");
test_setopt(curl, CURLOPT_COOKIELIST, "Set-Cookie: session=elephants");
- printf("CURLOPT_COOKIELIST injected\n");
+ curl_mprintf("CURLOPT_COOKIELIST injected\n");
test_setopt(curl, CURLOPT_COOKIELIST,
"Set-Cookie: injected=yes; domain=host.foo.com; "
"expires=Sat Feb 2 11:56:27 GMT 2030");
- printf("CURLOPT_COOKIELIST SESS\n");
+ curl_mprintf("CURLOPT_COOKIELIST SESS\n");
test_setopt(curl, CURLOPT_COOKIELIST, "SESS");
- printf("CLEANUP\n");
+ curl_mprintf("CLEANUP\n");
curl_easy_cleanup(curl);
tdata.share = share;
/* simulate thread, direct call of "thread" function */
- printf("*** run %d\n",i);
+ curl_mprintf("*** run %d\n",i);
test_fire(&tdata);
curl_free(tdata.url);
/* fetch another one and save cookies */
- printf("*** run %d\n", i);
+ curl_mprintf("*** run %d\n", i);
curl = curl_easy_init();
if(!curl) {
- fprintf(stderr, "curl_easy_init() failed\n");
+ curl_mfprintf(stderr, "curl_easy_init() failed\n");
curl_share_cleanup(share);
curl_global_cleanup();
return TEST_ERR_MAJOR_BAD;
headers = sethost(NULL);
test_setopt(curl, CURLOPT_HTTPHEADER, headers);
test_setopt(curl, CURLOPT_URL, url);
- printf("CURLOPT_SHARE\n");
+ curl_mprintf("CURLOPT_SHARE\n");
test_setopt(curl, CURLOPT_SHARE, share);
- printf("CURLOPT_COOKIEJAR\n");
+ curl_mprintf("CURLOPT_COOKIEJAR\n");
test_setopt(curl, CURLOPT_COOKIEJAR, JAR);
- printf("CURLOPT_COOKIELIST FLUSH\n");
+ curl_mprintf("CURLOPT_COOKIELIST FLUSH\n");
test_setopt(curl, CURLOPT_COOKIELIST, "FLUSH");
- printf("PERFORM\n");
+ curl_mprintf("PERFORM\n");
curl_easy_perform(curl);
- printf("CLEANUP\n");
+ curl_mprintf("CLEANUP\n");
curl_easy_cleanup(curl);
curl_free(url);
curl_slist_free_all(headers);
/* load cookies */
curl = curl_easy_init();
if(!curl) {
- fprintf(stderr, "curl_easy_init() failed\n");
+ curl_mfprintf(stderr, "curl_easy_init() failed\n");
curl_share_cleanup(share);
curl_global_cleanup();
return TEST_ERR_MAJOR_BAD;
headers = sethost(NULL);
test_setopt(curl, CURLOPT_HTTPHEADER, headers);
test_setopt(curl, CURLOPT_URL, url);
- printf("CURLOPT_SHARE\n");
+ curl_mprintf("CURLOPT_SHARE\n");
test_setopt(curl, CURLOPT_SHARE, share);
- printf("CURLOPT_COOKIELIST ALL\n");
+ curl_mprintf("CURLOPT_COOKIELIST ALL\n");
test_setopt(curl, CURLOPT_COOKIELIST, "ALL");
- printf("CURLOPT_COOKIEJAR\n");
+ curl_mprintf("CURLOPT_COOKIEJAR\n");
test_setopt(curl, CURLOPT_COOKIEFILE, JAR);
- printf("CURLOPT_COOKIELIST RELOAD\n");
+ curl_mprintf("CURLOPT_COOKIELIST RELOAD\n");
test_setopt(curl, CURLOPT_COOKIELIST, "RELOAD");
res = CURLE_OK;
code = curl_easy_getinfo(curl, CURLINFO_COOKIELIST, &cookies);
if(code != CURLE_OK) {
- fprintf(stderr, "curl_easy_getinfo() failed\n");
+ curl_mfprintf(stderr, "curl_easy_getinfo() failed\n");
res = TEST_ERR_MAJOR_BAD;
goto test_cleanup;
}
- printf("loaded cookies:\n");
+ curl_mprintf("loaded cookies:\n");
if(!cookies) {
- fprintf(stderr, " reloading cookies from '%s' failed\n", JAR);
+ curl_mfprintf(stderr, " reloading cookies from '%s' failed\n", JAR);
res = TEST_ERR_MAJOR_BAD;
goto test_cleanup;
}
- printf("-----------------\n");
+ curl_mprintf("-----------------\n");
next_cookie = cookies;
while(next_cookie) {
- printf(" %s\n", next_cookie->data);
+ curl_mprintf(" %s\n", next_cookie->data);
next_cookie = next_cookie->next;
}
- printf("-----------------\n");
+ curl_mprintf("-----------------\n");
curl_slist_free_all(cookies);
/* try to free share, expect to fail because share is in use */
- printf("try SHARE_CLEANUP...\n");
+ curl_mprintf("try SHARE_CLEANUP...\n");
scode = curl_share_cleanup(share);
if(scode == CURLSHE_OK) {
- fprintf(stderr, "curl_share_cleanup succeed but error expected\n");
+ curl_mfprintf(stderr, "curl_share_cleanup succeed but error expected\n");
share = NULL;
}
else {
- printf("SHARE_CLEANUP failed, correct\n");
+ curl_mprintf("SHARE_CLEANUP failed, correct\n");
}
test_cleanup:
/* clean up last handle */
- printf("CLEANUP\n");
+ curl_mprintf("CLEANUP\n");
curl_easy_cleanup(curl);
curl_slist_free_all(headers);
curl_free(url);
/* free share */
- printf("SHARE_CLEANUP\n");
+ curl_mprintf("SHARE_CLEANUP\n");
scode = curl_share_cleanup(share);
if(scode != CURLSHE_OK)
- fprintf(stderr, "curl_share_cleanup failed, code errno %d\n",
+ curl_mfprintf(stderr, "curl_share_cleanup failed, code errno %d\n",
(int)scode);
- printf("GLOBAL_CLEANUP\n");
+ curl_mprintf("GLOBAL_CLEANUP\n");
curl_global_cleanup();
return res;
pooh.sizeleft = strlen(testdata);
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
- fprintf(stderr, "curl_global_init() failed\n");
+ curl_mfprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
curl = curl_easy_init();
if(!curl) {
- fprintf(stderr, "curl_easy_init() failed\n");
+ curl_mfprintf(stderr, "curl_easy_init() failed\n");
curl_global_cleanup();
return TEST_ERR_MAJOR_BAD;
}
custom_strdup,
custom_calloc);
if(res != CURLE_OK) {
- fprintf(stderr, "curl_global_init_mem() failed\n");
+ curl_mfprintf(stderr, "curl_global_init_mem() failed\n");
return TEST_ERR_MAJOR_BAD;
}
curl = curl_easy_init();
if(!curl) {
- fprintf(stderr, "curl_easy_init() failed\n");
+ curl_mfprintf(stderr, "curl_easy_init() failed\n");
curl_global_cleanup();
return TEST_ERR_MAJOR_BAD;
}
str = curl_easy_escape(curl, (char *)a, asize); /* uses realloc() */
if(seen)
- printf("Callbacks were invoked!\n");
+ curl_mprintf("Callbacks were invoked!\n");
test_cleanup:
if(data) {
size_t len = strlen(data);
if(size*nmemb < len) {
- fprintf(stderr, "read buffer is too small to run test\n");
+ curl_mfprintf(stderr, "read buffer is too small to run test\n");
return 0;
}
memcpy(ptr, data, len);
pooh.counter = 0;
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
- fprintf(stderr, "curl_global_init() failed\n");
+ curl_mfprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
curl = curl_easy_init();
if(!curl) {
- fprintf(stderr, "curl_easy_init() failed\n");
+ curl_mfprintf(stderr, "curl_easy_init() failed\n");
curl_global_cleanup();
return TEST_ERR_MAJOR_BAD;
}
slist = curl_slist_append(slist, "Transfer-Encoding: chunked");
if(!slist) {
- fprintf(stderr, "curl_slist_append() failed\n");
+ curl_mfprintf(stderr, "curl_slist_append() failed\n");
curl_easy_cleanup(curl);
curl_global_cleanup();
return TEST_ERR_MAJOR_BAD;
CURL *curl;
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
- fprintf(stderr, "curl_global_init() failed\n");
+ curl_mfprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
curl = curl_easy_init();
if(!curl) {
- fprintf(stderr, "curl_easy_init() failed\n");
+ curl_mfprintf(stderr, "curl_easy_init() failed\n");
curl_global_cleanup();
return TEST_ERR_MAJOR_BAD;
}
CURLcode res = CURLE_OK;
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
- fprintf(stderr, "curl_global_init() failed\n");
+ curl_mfprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
curl = curl_easy_init();
if(!curl) {
- fprintf(stderr, "curl_easy_init() failed\n");
+ curl_mfprintf(stderr, "curl_easy_init() failed\n");
curl_global_cleanup();
return TEST_ERR_MAJOR_BAD;
}
CURLcode res = CURLE_OK;
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
- fprintf(stderr, "curl_global_init() failed\n");
+ curl_mfprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
curl = curl_easy_init();
if(!curl) {
- fprintf(stderr, "curl_easy_init() failed\n");
+ curl_mfprintf(stderr, "curl_easy_init() failed\n");
curl_global_cleanup();
return TEST_ERR_MAJOR_BAD;
}
CURLcode res = CURLE_OK;
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
- fprintf(stderr, "curl_global_init() failed\n");
+ curl_mfprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
curl = curl_easy_init();
if(!curl) {
- fprintf(stderr, "curl_easy_init() failed\n");
+ curl_mfprintf(stderr, "curl_easy_init() failed\n");
curl_global_cleanup();
return TEST_ERR_MAJOR_BAD;
}
CURLcode res = CURLE_OK;
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
- fprintf(stderr, "curl_global_init() failed\n");
+ curl_mfprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
curl = curl_easy_init();
if(!curl) {
- fprintf(stderr, "curl_easy_init() failed\n");
+ curl_mfprintf(stderr, "curl_easy_init() failed\n");
curl_global_cleanup();
return TEST_ERR_MAJOR_BAD;
}
for(i = 0; dates[i].input; i++) {
time_t out = curl_getdate(dates[i].input, NULL);
if(out != dates[i].output) {
- printf("WRONGLY %s => %ld (instead of %ld)\n",
+ curl_mprintf("WRONGLY %s => %ld (instead of %ld)\n",
dates[i].input, (long)out, (long)dates[i].output);
error++;
}
static void store_errmsg(const char *msg, int err)
{
if(!err)
- msnprintf(msgbuff, sizeof(msgbuff), "%s", msg);
+ curl_msnprintf(msgbuff, sizeof(msgbuff), "%s", msg);
else
- msnprintf(msgbuff, sizeof(msgbuff), "%s, errno %d, %s", msg,
+ curl_msnprintf(msgbuff, sizeof(msgbuff), "%s, errno %d, %s", msg,
err, strerror(err));
}
fpa[i] = fopen(DEV_NULL, FOPEN_READTEXT);
if(!fpa[i]) {
store_errmsg("fopen failed", errno);
- fprintf(stderr, "%s\n", msgbuff);
+ curl_mfprintf(stderr, "%s\n", msgbuff);
ret = 0;
break;
}
{
#ifdef RLIM_INFINITY
if(val == RLIM_INFINITY) {
- msnprintf(buf, len, "INFINITY");
+ curl_msnprintf(buf, len, "INFINITY");
return;
}
#endif
#ifdef HAVE_LONGLONG
if(sizeof(rlim_t) > sizeof(long))
- msnprintf(buf, len, "%llu", (unsigned long long)val);
+ curl_msnprintf(buf, len, "%llu", (unsigned long long)val);
else
#endif
{
if(sizeof(rlim_t) < sizeof(long))
- msnprintf(buf, len, "%u", (unsigned int)val);
+ curl_msnprintf(buf, len, "%u", (unsigned int)val);
else
- msnprintf(buf, len, "%lu", (unsigned long)val);
+ curl_msnprintf(buf, len, "%lu", (unsigned long)val);
}
}
if(getrlimit(RLIMIT_NOFILE, &rl) != 0) {
store_errmsg("getrlimit() failed", errno);
- fprintf(stderr, "%s\n", msgbuff);
+ curl_mfprintf(stderr, "%s\n", msgbuff);
return -1;
}
/* show initial open file limits */
rlim2str(strbuff, sizeof(strbuff), rl.rlim_cur);
- fprintf(stderr, "initial soft limit: %s\n", strbuff);
+ curl_mfprintf(stderr, "initial soft limit: %s\n", strbuff);
rlim2str(strbuff, sizeof(strbuff), rl.rlim_max);
- fprintf(stderr, "initial hard limit: %s\n", strbuff);
+ curl_mfprintf(stderr, "initial hard limit: %s\n", strbuff);
/* show our constants */
- fprintf(stderr, "test518 FD_SETSIZE: %d\n", FD_SETSIZE);
- fprintf(stderr, "test518 NUM_OPEN : %d\n", NUM_OPEN);
- fprintf(stderr, "test518 NUM_NEEDED: %d\n", NUM_NEEDED);
+ curl_mfprintf(stderr, "test518 FD_SETSIZE: %d\n", FD_SETSIZE);
+ curl_mfprintf(stderr, "test518 NUM_OPEN : %d\n", NUM_OPEN);
+ curl_mfprintf(stderr, "test518 NUM_NEEDED: %d\n", NUM_NEEDED);
/*
* if soft limit and hard limit are different we ask the
#ifdef OPEN_MAX
if((rl.rlim_cur > 0) &&
(rl.rlim_cur < OPEN_MAX)) {
- fprintf(stderr, "raising soft limit up to OPEN_MAX\n");
+ curl_mfprintf(stderr, "raising soft limit up to OPEN_MAX\n");
rl.rlim_cur = OPEN_MAX;
if(setrlimit(RLIMIT_NOFILE, &rl) != 0) {
/* on failure don't abort just issue a warning */
store_errmsg("setrlimit() failed", errno);
- fprintf(stderr, "%s\n", msgbuff);
+ curl_mfprintf(stderr, "%s\n", msgbuff);
msgbuff[0] = '\0';
}
}
#endif
- fprintf(stderr, "raising soft limit up to hard limit\n");
+ curl_mfprintf(stderr, "raising soft limit up to hard limit\n");
rl.rlim_cur = rl.rlim_max;
if(setrlimit(RLIMIT_NOFILE, &rl) != 0) {
/* on failure don't abort just issue a warning */
store_errmsg("setrlimit() failed", errno);
- fprintf(stderr, "%s\n", msgbuff);
+ curl_mfprintf(stderr, "%s\n", msgbuff);
msgbuff[0] = '\0';
}
if(getrlimit(RLIMIT_NOFILE, &rl) != 0) {
store_errmsg("getrlimit() failed", errno);
- fprintf(stderr, "%s\n", msgbuff);
+ curl_mfprintf(stderr, "%s\n", msgbuff);
return -3;
}
/* show current open file limits */
rlim2str(strbuff, sizeof(strbuff), rl.rlim_cur);
- fprintf(stderr, "current soft limit: %s\n", strbuff);
+ curl_mfprintf(stderr, "current soft limit: %s\n", strbuff);
rlim2str(strbuff, sizeof(strbuff), rl.rlim_max);
- fprintf(stderr, "current hard limit: %s\n", strbuff);
+ curl_mfprintf(stderr, "current hard limit: %s\n", strbuff);
} /* (rl.rlim_cur != rl.rlim_max) */
(rl.rlim_cur <= num_open.rlim_cur)) {
rlim2str(strbuff2, sizeof(strbuff2), rl.rlim_cur);
rlim2str(strbuff1, sizeof(strbuff1), num_open.rlim_cur);
- msnprintf(strbuff, sizeof(strbuff), "fds needed %s > system limit %s",
+ curl_msnprintf(strbuff, sizeof(strbuff), "fds needed %s > system limit %s",
strbuff1, strbuff2);
store_errmsg(strbuff, 0);
- fprintf(stderr, "%s\n", msgbuff);
+ curl_mfprintf(stderr, "%s\n", msgbuff);
return -4;
}
do {
num_open.rlim_max = sizeof(*memchunk) * nitems;
rlim2str(strbuff, sizeof(strbuff), num_open.rlim_max);
- fprintf(stderr, "allocating memchunk %s byte array\n", strbuff);
+ curl_mfprintf(stderr, "allocating memchunk %s byte array\n", strbuff);
memchunk = malloc(sizeof(*memchunk) * (size_t)nitems);
if(!memchunk) {
- fprintf(stderr, "memchunk, malloc() failed\n");
+ curl_mfprintf(stderr, "memchunk, malloc() failed\n");
nitems /= 2;
}
} while(nitems && !memchunk);
if(!memchunk) {
store_errmsg("memchunk, malloc() failed", errno);
- fprintf(stderr, "%s\n", msgbuff);
+ curl_mfprintf(stderr, "%s\n", msgbuff);
return -5;
}
/* initialize it to fight lazy allocation */
- fprintf(stderr, "initializing memchunk array\n");
+ curl_mfprintf(stderr, "initializing memchunk array\n");
for(i = 0; i < nitems; i++)
memchunk[i] = -1;
if((size_t)(num_open.rlim_max) > ((size_t)-1) / sizeof(*testfd)) {
rlim2str(strbuff1, sizeof(strbuff1), num_open.rlim_max);
- msnprintf(strbuff, sizeof(strbuff), "unable to allocate an array for %s "
- "file descriptors, would overflow size_t", strbuff1);
+ curl_msnprintf(strbuff, sizeof(strbuff),
+ "unable to allocate an array for %s "
+ "file descriptors, would overflow size_t", strbuff1);
store_errmsg(strbuff, 0);
- fprintf(stderr, "%s\n", msgbuff);
+ curl_mfprintf(stderr, "%s\n", msgbuff);
free(memchunk);
return -6;
}
/* allocate array for file descriptors */
rlim2str(strbuff, sizeof(strbuff), num_open.rlim_max);
- fprintf(stderr, "allocating array for %s file descriptors\n", strbuff);
+ curl_mfprintf(stderr, "allocating array for %s file descriptors\n", strbuff);
testfd = malloc(sizeof(*testfd) * (size_t)(num_open.rlim_max));
if(!testfd) {
store_errmsg("testfd, malloc() failed", errno);
- fprintf(stderr, "%s\n", msgbuff);
+ curl_mfprintf(stderr, "%s\n", msgbuff);
free(memchunk);
return -7;
}
/* initialize it to fight lazy allocation */
- fprintf(stderr, "initializing testfd array\n");
+ curl_mfprintf(stderr, "initializing testfd array\n");
for(num_open.rlim_cur = 0;
num_open.rlim_cur < num_open.rlim_max;
testfd[num_open.rlim_cur] = -1;
rlim2str(strbuff, sizeof(strbuff), num_open.rlim_max);
- fprintf(stderr, "trying to open %s file descriptors\n", strbuff);
+ curl_mfprintf(stderr, "trying to open %s file descriptors\n", strbuff);
/* open a dummy descriptor */
testfd[0] = open(DEV_NULL, O_RDONLY);
if(testfd[0] < 0) {
- msnprintf(strbuff, sizeof(strbuff), "opening of %s failed", DEV_NULL);
+ curl_msnprintf(strbuff, sizeof(strbuff), "opening of %s failed", DEV_NULL);
store_errmsg(strbuff, errno);
- fprintf(stderr, "%s\n", msgbuff);
+ curl_mfprintf(stderr, "%s\n", msgbuff);
free(testfd);
testfd = NULL;
free(memchunk);
testfd[num_open.rlim_cur] = -1;
rlim2str(strbuff1, sizeof(strbuff1), num_open.rlim_cur);
- msnprintf(strbuff, sizeof(strbuff), "dup() attempt %s failed", strbuff1);
- fprintf(stderr, "%s\n", strbuff);
+ curl_msnprintf(strbuff, sizeof(strbuff), "dup() attempt %s failed",
+ strbuff1);
+ curl_mfprintf(stderr, "%s\n", strbuff);
rlim2str(strbuff1, sizeof(strbuff1), num_open.rlim_cur);
- msnprintf(strbuff, sizeof(strbuff), "fds system limit seems close to %s",
- strbuff1);
- fprintf(stderr, "%s\n", strbuff);
+ curl_msnprintf(strbuff, sizeof(strbuff),
+ "fds system limit seems close to %s", strbuff1);
+ curl_mfprintf(stderr, "%s\n", strbuff);
num_open.rlim_max = NUM_NEEDED;
rlim2str(strbuff2, sizeof(strbuff2), num_open.rlim_max);
rlim2str(strbuff1, sizeof(strbuff1), num_open.rlim_cur);
- msnprintf(strbuff, sizeof(strbuff), "fds needed %s > system limit %s",
- strbuff2, strbuff1);
+ curl_msnprintf(strbuff, sizeof(strbuff),
+ "fds needed %s > system limit %s", strbuff2, strbuff1);
store_errmsg(strbuff, 0);
- fprintf(stderr, "%s\n", msgbuff);
+ curl_mfprintf(stderr, "%s\n", msgbuff);
for(num_open.rlim_cur = 0;
testfd[num_open.rlim_cur] >= 0;
}
rlim2str(strbuff, sizeof(strbuff), num_open.rlim_max);
- fprintf(stderr, "%s file descriptors open\n", strbuff);
+ curl_mfprintf(stderr, "%s file descriptors open\n", strbuff);
#if !defined(HAVE_POLL) && !defined(USE_WINSOCK)
num_open.rlim_cur = FD_SETSIZE - SAFETY_MARGIN;
if(num_open.rlim_max > num_open.rlim_cur) {
- msnprintf(strbuff, sizeof(strbuff), "select limit is FD_SETSIZE %d",
+ curl_msnprintf(strbuff, sizeof(strbuff), "select limit is FD_SETSIZE %d",
FD_SETSIZE);
store_errmsg(strbuff, 0);
- fprintf(stderr, "%s\n", msgbuff);
+ curl_mfprintf(stderr, "%s\n", msgbuff);
close_file_descriptors();
free(memchunk);
return -10;
rl.rlim_cur++) {
if((testfd[rl.rlim_cur] > 0) &&
((unsigned int)testfd[rl.rlim_cur] > num_open.rlim_cur)) {
- msnprintf(strbuff, sizeof(strbuff), "select limit is FD_SETSIZE %d",
+ curl_msnprintf(strbuff, sizeof(strbuff), "select limit is FD_SETSIZE %d",
FD_SETSIZE);
store_errmsg(strbuff, 0);
- fprintf(stderr, "%s\n", msgbuff);
+ curl_mfprintf(stderr, "%s\n", msgbuff);
close_file_descriptors();
free(memchunk);
return -11;
if(!fopen_works()) {
rlim2str(strbuff1, sizeof(strbuff1), num_open.rlim_max);
- msnprintf(strbuff, sizeof(strbuff), "fopen fails with %s fds open",
+ curl_msnprintf(strbuff, sizeof(strbuff), "fopen fails with %s fds open",
strbuff1);
- fprintf(stderr, "%s\n", msgbuff);
- msnprintf(strbuff, sizeof(strbuff), "fopen fails with lots of fds open");
+ curl_mfprintf(stderr, "%s\n", msgbuff);
+ curl_msnprintf(strbuff, sizeof(strbuff),
+ "fopen fails with lots of fds open");
store_errmsg(strbuff, 0);
close_file_descriptors();
free(memchunk);
if(!strcmp(URL, "check")) {
/* used by the test script to ask if we can run this test or not */
if(test_rlimit(FALSE)) {
- fprintf(stdout, "test_rlimit problem: %s\n", msgbuff);
+ curl_mfprintf(stdout, "test_rlimit problem: %s\n", msgbuff);
return TEST_ERR_FAILURE;
}
return CURLE_OK; /* sure, run this! */
and close them all once the test is over */
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
- fprintf(stderr, "curl_global_init() failed\n");
+ curl_mfprintf(stderr, "curl_global_init() failed\n");
close_file_descriptors();
return TEST_ERR_MAJOR_BAD;
}
curl = curl_easy_init();
if(!curl) {
- fprintf(stderr, "curl_easy_init() failed\n");
+ curl_mfprintf(stderr, "curl_easy_init() failed\n");
close_file_descriptors();
curl_global_cleanup();
return TEST_ERR_MAJOR_BAD;
CURLcode test(char *URL)
{
(void)URL;
- printf("system lacks necessary system function(s)");
+ curl_mprintf("system lacks necessary system function(s)");
return 1; /* skip test */
}
CURL *curl;
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
- fprintf(stderr, "curl_global_init() failed\n");
+ curl_mfprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
curl = curl_easy_init();
if(!curl) {
- fprintf(stderr, "curl_easy_init() failed\n");
+ curl_mfprintf(stderr, "curl_easy_init() failed\n");
curl_global_cleanup();
return TEST_ERR_MAJOR_BAD;
}
CURL *curl;
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
- fprintf(stderr, "curl_global_init() failed\n");
+ curl_mfprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
curl = curl_easy_init();
if(!curl) {
- fprintf(stderr, "curl_easy_init() failed\n");
+ curl_mfprintf(stderr, "curl_easy_init() failed\n");
curl_global_cleanup();
return TEST_ERR_MAJOR_BAD;
}
CURL *curl;
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
- fprintf(stderr, "curl_global_init() failed\n");
+ curl_mfprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
curl = curl_easy_init();
if(!curl) {
- fprintf(stderr, "curl_easy_init() failed\n");
+ curl_mfprintf(stderr, "curl_easy_init() failed\n");
curl_global_cleanup();
return TEST_ERR_MAJOR_BAD;
}
CURL *curl;
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
- fprintf(stderr, "curl_global_init() failed\n");
+ curl_mfprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
curl = curl_easy_init();
if(!curl) {
- fprintf(stderr, "curl_easy_init() failed\n");
+ curl_mfprintf(stderr, "curl_easy_init() failed\n");
curl_global_cleanup();
return TEST_ERR_MAJOR_BAD;
}
CURL *curl;
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
- fprintf(stderr, "curl_global_init() failed\n");
+ curl_mfprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
curl = curl_easy_init();
if(!curl) {
- fprintf(stderr, "curl_easy_init() failed\n");
+ curl_mfprintf(stderr, "curl_easy_init() failed\n");
curl_global_cleanup();
return TEST_ERR_MAJOR_BAD;
}
if(!libtest_arg2) {
#ifdef LIB529
/* test 529 */
- fprintf(stderr, "Usage: lib529 [url] [uploadfile]\n");
+ curl_mfprintf(stderr, "Usage: lib529 [url] [uploadfile]\n");
#else
/* test 525 */
- fprintf(stderr, "Usage: lib525 [url] [uploadfile]\n");
+ curl_mfprintf(stderr, "Usage: lib525 [url] [uploadfile]\n");
#endif
return TEST_ERR_USAGE;
}
hd_src = fopen(libtest_arg2, "rb");
if(!hd_src) {
- fprintf(stderr, "fopen failed with error (%d) %s\n",
+ curl_mfprintf(stderr, "fopen failed with error (%d) %s\n",
errno, strerror(errno));
- fprintf(stderr, "Error opening file '%s'\n", libtest_arg2);
+ curl_mfprintf(stderr, "Error opening file '%s'\n", libtest_arg2);
return TEST_ERR_FOPEN;
}
#endif
if(hd == -1) {
/* can't open file, bail out */
- fprintf(stderr, "fstat() failed with error (%d) %s\n",
+ curl_mfprintf(stderr, "fstat() failed with error (%d) %s\n",
errno, strerror(errno));
- fprintf(stderr, "Error opening file '%s'\n", libtest_arg2);
+ curl_mfprintf(stderr, "Error opening file '%s'\n", libtest_arg2);
fclose(hd_src);
return TEST_ERR_FSTAT;
}
multi_add_handle(m, curl[current]);
- fprintf(stderr, "Start at URL 0\n");
+ curl_mfprintf(stderr, "Start at URL 0\n");
for(;;) {
struct timeval interval;
curl[current] = NULL;
#endif
if(++current < NUM_HANDLES) {
- fprintf(stderr, "Advancing to URL %d\n", current);
+ curl_mfprintf(stderr, "Advancing to URL %d\n", current);
#ifdef LIB532
/* first remove the only handle we use */
curl_multi_remove_handle(m, curl[0]);
int i;
if(mention)
- fprintf(stderr, "Remove socket fd %d\n", (int) fd);
+ curl_mfprintf(stderr, "Remove socket fd %d\n", (int) fd);
for(i = 0; i < sockets->count; ++i) {
if(sockets->sockets[i] == fd) {
* To ensure we only have each file descriptor once, we remove it then add
* it again.
*/
- fprintf(stderr, "Add socket fd %d for %s\n", (int) fd, what);
+ curl_mfprintf(stderr, "Add socket fd %d for %s\n", (int) fd, what);
removeFd(sockets, fd, 0);
/*
* Allocate array storage when required.
(void)easy; /* unused */
(void)socketp; /* unused */
- fprintf(stderr, "CURLMOPT_SOCKETFUNCTION called: %u\n", socket_calls++);
+ curl_mfprintf(stderr, "CURLMOPT_SOCKETFUNCTION called: %u\n",
+ socket_calls++);
if(socket_calls == max_socket_calls) {
- fprintf(stderr, "curlSocketCallback returns error\n");
+ curl_mfprintf(stderr, "curlSocketCallback returns error\n");
return -1;
}
struct timeval *timeout = userp;
(void)multi; /* unused */
- fprintf(stderr, "CURLMOPT_TIMERFUNCTION called: %u\n", timer_calls++);
+ curl_mfprintf(stderr, "CURLMOPT_TIMERFUNCTION called: %u\n", timer_calls++);
if(timer_calls == max_timer_calls) {
- fprintf(stderr, "curlTimerCallback returns error\n");
+ curl_mfprintf(stderr, "curlTimerCallback returns error\n");
return -1;
}
if(timeout_ms != -1) {
*success = 0;
}
else {
- fprintf(stderr, "Got an unexpected message from curl: %i\n",
+ curl_mfprintf(stderr, "Got an unexpected message from curl: %i\n",
message->msg);
result = 1;
*success = 0;
int numhandles = 0;
CURLMcode result = curl_multi_socket_action(curl, s, evBitmask, &numhandles);
if(result != CURLM_OK) {
- fprintf(stderr, "Curl error on %s (%i) %s\n",
+ curl_mfprintf(stderr, "Curl error on %s (%i) %s\n",
info, result, curl_multi_strerror(result));
}
return (int)result;
timer_calls = 0; /* reset the globals */
socket_calls = 0;
- fprintf(stderr, "start test: %d %d\n", timercb, socketcb);
+ curl_mfprintf(stderr, "start test: %d %d\n", timercb, socketcb);
start_test_timing();
res_global_init(CURL_GLOBAL_ALL);
}
if(!success) {
- fprintf(stderr, "Error getting file.\n");
+ curl_mfprintf(stderr, "Error getting file.\n");
res = TEST_ERR_MAJOR_BAD;
}
test_cleanup:
/* proper cleanup sequence */
- fprintf(stderr, "cleanup: %d %d\n", timercb, socketcb);
+ curl_mfprintf(stderr, "cleanup: %d %d\n", timercb, socketcb);
curl_multi_remove_handle(m, curl);
curl_easy_cleanup(curl);
curl_multi_cleanup(m);
callback calls */
rc = testone(URL, 0, 0);
if(rc)
- fprintf(stderr, "test 0/0 failed: %d\n", rc);
+ curl_mfprintf(stderr, "test 0/0 failed: %d\n", rc);
rc = testone(URL, 1, 0);
if(!rc)
- fprintf(stderr, "test 1/0 failed: %d\n", rc);
+ curl_mfprintf(stderr, "test 1/0 failed: %d\n", rc);
rc = testone(URL, 2, 0);
if(!rc)
- fprintf(stderr, "test 2/0 failed: %d\n", rc);
+ curl_mfprintf(stderr, "test 2/0 failed: %d\n", rc);
rc = testone(URL, 0, 1);
if(!rc)
- fprintf(stderr, "test 0/1 failed: %d\n", rc);
+ curl_mfprintf(stderr, "test 0/1 failed: %d\n", rc);
rc = testone(URL, 0, 2);
if(!rc)
- fprintf(stderr, "test 0/2 failed: %d\n", rc);
+ curl_mfprintf(stderr, "test 0/2 failed: %d\n", rc);
return CURLE_OK;
}
multi_add_handle(m, curl);
- fprintf(stderr, "Start at URL 0\n");
+ curl_mfprintf(stderr, "Start at URL 0\n");
for(;;) {
struct timeval interval;
if(!running) {
if(!current++) {
- fprintf(stderr, "Advancing to URL 1\n");
+ curl_mfprintf(stderr, "Advancing to URL 1\n");
/* remove the handle we use */
curl_multi_remove_handle(m, curl);
{
long wasproxy;
if(!curl_easy_getinfo(curl, CURLINFO_USED_PROXY, &wasproxy)) {
- printf("This %sthe proxy\n", wasproxy ? "used ":
+ curl_mprintf("This %sthe proxy\n", wasproxy ? "used ":
"DID NOT use ");
}
}
struct curl_slist *host = NULL;
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
- fprintf(stderr, "curl_global_init() failed\n");
+ curl_mfprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
curl = curl_easy_init();
if(!curl) {
- fprintf(stderr, "curl_easy_init() failed\n");
+ curl_mfprintf(stderr, "curl_easy_init() failed\n");
curl_global_cleanup();
return TEST_ERR_MAJOR_BAD;
}
static void store_errmsg(const char *msg, int err)
{
if(!err)
- msnprintf(msgbuff, sizeof(msgbuff), "%s", msg);
+ curl_msnprintf(msgbuff, sizeof(msgbuff), "%s", msg);
else
- msnprintf(msgbuff, sizeof(msgbuff), "%s, errno %d, %s", msg,
+ curl_msnprintf(msgbuff, sizeof(msgbuff), "%s, errno %d, %s", msg,
err, strerror(err));
}
fpa[i] = fopen(DEV_NULL, FOPEN_READTEXT);
if(!fpa[i]) {
store_errmsg("fopen failed", errno);
- fprintf(stderr, "%s\n", msgbuff);
+ curl_mfprintf(stderr, "%s\n", msgbuff);
ret = 0;
break;
}
{
#ifdef RLIM_INFINITY
if(val == RLIM_INFINITY) {
- msnprintf(buf, len, "INFINITY");
+ curl_msnprintf(buf, len, "INFINITY");
return;
}
#endif
#ifdef HAVE_LONGLONG
if(sizeof(rlim_t) > sizeof(long))
- msnprintf(buf, len, "%llu", (unsigned long long)val);
+ curl_msnprintf(buf, len, "%llu", (unsigned long long)val);
else
#endif
{
if(sizeof(rlim_t) < sizeof(long))
- msnprintf(buf, len, "%u", (unsigned int)val);
+ curl_msnprintf(buf, len, "%u", (unsigned int)val);
else
- msnprintf(buf, len, "%lu", (unsigned long)val);
+ curl_msnprintf(buf, len, "%lu", (unsigned long)val);
}
}
if(getrlimit(RLIMIT_NOFILE, &rl) != 0) {
store_errmsg("getrlimit() failed", errno);
- fprintf(stderr, "%s\n", msgbuff);
+ curl_mfprintf(stderr, "%s\n", msgbuff);
return -1;
}
/* show initial open file limits */
rlim2str(strbuff, sizeof(strbuff), rl.rlim_cur);
- fprintf(stderr, "initial soft limit: %s\n", strbuff);
+ curl_mfprintf(stderr, "initial soft limit: %s\n", strbuff);
rlim2str(strbuff, sizeof(strbuff), rl.rlim_max);
- fprintf(stderr, "initial hard limit: %s\n", strbuff);
+ curl_mfprintf(stderr, "initial hard limit: %s\n", strbuff);
/* If the OS allows a HUGE number of open files, we do not run.
* Modern debian sid reports a limit of 134217724 and this tests
* takes minutes. */
#define LIMIT_CAP (256*1024)
if(rl.rlim_cur > LIMIT_CAP) {
- fprintf(stderr, "soft limit above %ld, not running\n", (long)LIMIT_CAP);
+ curl_mfprintf(stderr, "soft limit above %ld, not running\n",
+ (long)LIMIT_CAP);
return -2;
}
#ifdef OPEN_MAX
if((rl.rlim_cur > 0) &&
(rl.rlim_cur < OPEN_MAX)) {
- fprintf(stderr, "raising soft limit up to OPEN_MAX\n");
+ curl_mfprintf(stderr, "raising soft limit up to OPEN_MAX\n");
rl.rlim_cur = OPEN_MAX;
if(setrlimit(RLIMIT_NOFILE, &rl) != 0) {
/* on failure don't abort just issue a warning */
store_errmsg("setrlimit() failed", errno);
- fprintf(stderr, "%s\n", msgbuff);
+ curl_mfprintf(stderr, "%s\n", msgbuff);
msgbuff[0] = '\0';
}
}
#endif
- fprintf(stderr, "raising soft limit up to hard limit\n");
+ curl_mfprintf(stderr, "raising soft limit up to hard limit\n");
rl.rlim_cur = rl.rlim_max;
if(setrlimit(RLIMIT_NOFILE, &rl) != 0) {
/* on failure don't abort just issue a warning */
store_errmsg("setrlimit() failed", errno);
- fprintf(stderr, "%s\n", msgbuff);
+ curl_mfprintf(stderr, "%s\n", msgbuff);
msgbuff[0] = '\0';
}
if(getrlimit(RLIMIT_NOFILE, &rl) != 0) {
store_errmsg("getrlimit() failed", errno);
- fprintf(stderr, "%s\n", msgbuff);
+ curl_mfprintf(stderr, "%s\n", msgbuff);
return -3;
}
/* show current open file limits */
rlim2str(strbuff, sizeof(strbuff), rl.rlim_cur);
- fprintf(stderr, "current soft limit: %s\n", strbuff);
+ curl_mfprintf(stderr, "current soft limit: %s\n", strbuff);
rlim2str(strbuff, sizeof(strbuff), rl.rlim_max);
- fprintf(stderr, "current hard limit: %s\n", strbuff);
+ curl_mfprintf(stderr, "current hard limit: %s\n", strbuff);
} /* (rl.rlim_cur != rl.rlim_max) */
do {
num_open.rlim_max = sizeof(*memchunk) * nitems;
rlim2str(strbuff, sizeof(strbuff), num_open.rlim_max);
- fprintf(stderr, "allocating memchunk %s byte array\n", strbuff);
+ curl_mfprintf(stderr, "allocating memchunk %s byte array\n", strbuff);
memchunk = malloc(sizeof(*memchunk) * (size_t)nitems);
if(!memchunk) {
- fprintf(stderr, "memchunk, malloc() failed\n");
+ curl_mfprintf(stderr, "memchunk, malloc() failed\n");
nitems /= 2;
}
} while(nitems && !memchunk);
if(!memchunk) {
store_errmsg("memchunk, malloc() failed", errno);
- fprintf(stderr, "%s\n", msgbuff);
+ curl_mfprintf(stderr, "%s\n", msgbuff);
return -4;
}
/* initialize it to fight lazy allocation */
- fprintf(stderr, "initializing memchunk array\n");
+ curl_mfprintf(stderr, "initializing memchunk array\n");
for(i = 0; i < nitems; i++)
memchunk[i] = -1;
if((size_t)(num_open.rlim_max) > ((size_t)-1) / sizeof(*testfd)) {
rlim2str(strbuff1, sizeof(strbuff1), num_open.rlim_max);
- msnprintf(strbuff, sizeof(strbuff), "unable to allocate an array for %s "
- "file descriptors, would overflow size_t", strbuff1);
+ curl_msnprintf(strbuff, sizeof(strbuff),
+ "unable to allocate an array for %s "
+ "file descriptors, would overflow size_t", strbuff1);
store_errmsg(strbuff, 0);
- fprintf(stderr, "%s\n", msgbuff);
+ curl_mfprintf(stderr, "%s\n", msgbuff);
free(memchunk);
return -5;
}
do {
rlim2str(strbuff, sizeof(strbuff), num_open.rlim_max);
- fprintf(stderr, "allocating array for %s file descriptors\n", strbuff);
+ curl_mfprintf(stderr, "allocating array for %s file descriptors\n",
+ strbuff);
testfd = malloc(sizeof(*testfd) * (size_t)(num_open.rlim_max));
if(!testfd) {
- fprintf(stderr, "testfd, malloc() failed\n");
+ curl_mfprintf(stderr, "testfd, malloc() failed\n");
num_open.rlim_max /= 2;
}
} while(num_open.rlim_max && !testfd);
if(!testfd) {
store_errmsg("testfd, malloc() failed", errno);
- fprintf(stderr, "%s\n", msgbuff);
+ curl_mfprintf(stderr, "%s\n", msgbuff);
free(memchunk);
return -6;
}
/* initialize it to fight lazy allocation */
- fprintf(stderr, "initializing testfd array\n");
+ curl_mfprintf(stderr, "initializing testfd array\n");
for(num_open.rlim_cur = 0;
num_open.rlim_cur < num_open.rlim_max;
testfd[num_open.rlim_cur] = -1;
rlim2str(strbuff, sizeof(strbuff), num_open.rlim_max);
- fprintf(stderr, "trying to open %s file descriptors\n", strbuff);
+ curl_mfprintf(stderr, "trying to open %s file descriptors\n", strbuff);
/* open a dummy descriptor */
testfd[0] = open(DEV_NULL, O_RDONLY);
if(testfd[0] < 0) {
- msnprintf(strbuff, sizeof(strbuff), "opening of %s failed", DEV_NULL);
+ curl_msnprintf(strbuff, sizeof(strbuff), "opening of %s failed", DEV_NULL);
store_errmsg(strbuff, errno);
- fprintf(stderr, "%s\n", msgbuff);
+ curl_mfprintf(stderr, "%s\n", msgbuff);
free(testfd);
testfd = NULL;
free(memchunk);
testfd[num_open.rlim_cur] = -1;
rlim2str(strbuff1, sizeof(strbuff1), num_open.rlim_cur);
- msnprintf(strbuff, sizeof(strbuff), "dup() attempt %s failed", strbuff1);
- fprintf(stderr, "%s\n", strbuff);
+ curl_msnprintf(strbuff, sizeof(strbuff), "dup() attempt %s failed",
+ strbuff1);
+ curl_mfprintf(stderr, "%s\n", strbuff);
rlim2str(strbuff1, sizeof(strbuff1), num_open.rlim_cur);
- msnprintf(strbuff, sizeof(strbuff), "fds system limit seems close to %s",
- strbuff1);
- fprintf(stderr, "%s\n", strbuff);
+ curl_msnprintf(strbuff, sizeof(strbuff),
+ "fds system limit seems close to %s", strbuff1);
+ curl_mfprintf(stderr, "%s\n", strbuff);
num_open.rlim_max = num_open.rlim_cur - SAFETY_MARGIN;
num_open.rlim_cur -= num_open.rlim_max;
rlim2str(strbuff1, sizeof(strbuff1), num_open.rlim_cur);
- msnprintf(strbuff, sizeof(strbuff), "closing %s file descriptors",
- strbuff1);
- fprintf(stderr, "%s\n", strbuff);
+ curl_msnprintf(strbuff, sizeof(strbuff), "closing %s file descriptors",
+ strbuff1);
+ curl_mfprintf(stderr, "%s\n", strbuff);
for(num_open.rlim_cur = num_open.rlim_max;
testfd[num_open.rlim_cur] >= 0;
}
rlim2str(strbuff, sizeof(strbuff), num_open.rlim_max);
- fprintf(stderr, "shrinking array for %s file descriptors\n", strbuff);
+ curl_mfprintf(stderr, "shrinking array for %s file descriptors\n",
+ strbuff);
/* we don't care if we can't shrink it */
}
rlim2str(strbuff, sizeof(strbuff), num_open.rlim_max);
- fprintf(stderr, "%s file descriptors open\n", strbuff);
+ curl_mfprintf(stderr, "%s file descriptors open\n", strbuff);
#if !defined(HAVE_POLL) && !defined(USE_WINSOCK)
num_open.rlim_cur = FD_SETSIZE - SAFETY_MARGIN;
if(num_open.rlim_max > num_open.rlim_cur) {
- msnprintf(strbuff, sizeof(strbuff), "select limit is FD_SETSIZE %d",
+ curl_msnprintf(strbuff, sizeof(strbuff), "select limit is FD_SETSIZE %d",
FD_SETSIZE);
store_errmsg(strbuff, 0);
- fprintf(stderr, "%s\n", msgbuff);
+ curl_mfprintf(stderr, "%s\n", msgbuff);
close_file_descriptors();
free(memchunk);
return -8;
rl.rlim_cur++) {
if((testfd[rl.rlim_cur] > 0) &&
((unsigned int)testfd[rl.rlim_cur] > num_open.rlim_cur)) {
- msnprintf(strbuff, sizeof(strbuff), "select limit is FD_SETSIZE %d",
+ curl_msnprintf(strbuff, sizeof(strbuff), "select limit is FD_SETSIZE %d",
FD_SETSIZE);
store_errmsg(strbuff, 0);
- fprintf(stderr, "%s\n", msgbuff);
+ curl_mfprintf(stderr, "%s\n", msgbuff);
close_file_descriptors();
free(memchunk);
return -9;
if(!fopen_works()) {
rlim2str(strbuff1, sizeof(strbuff1), num_open.rlim_max);
- msnprintf(strbuff, sizeof(strbuff), "fopen fails with %s fds open",
- strbuff1);
- fprintf(stderr, "%s\n", msgbuff);
- msnprintf(strbuff, sizeof(strbuff), "fopen fails with lots of fds open");
+ curl_msnprintf(strbuff, sizeof(strbuff), "fopen fails with %s fds open",
+ strbuff1);
+ curl_mfprintf(stderr, "%s\n", msgbuff);
+ curl_msnprintf(strbuff, sizeof(strbuff),
+ "fopen fails with lots of fds open");
store_errmsg(strbuff, 0);
close_file_descriptors();
free(memchunk);
if(!strcmp(URL, "check")) {
/* used by the test script to ask if we can run this test or not */
if(test_rlimit(FALSE)) {
- fprintf(stdout, "test_rlimit problem: %s\n", msgbuff);
+ curl_mfprintf(stdout, "test_rlimit problem: %s\n", msgbuff);
return TEST_ERR_FAILURE;
}
return CURLE_OK; /* sure, run this! */
and close them all once the test is over */
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
- fprintf(stderr, "curl_global_init() failed\n");
+ curl_mfprintf(stderr, "curl_global_init() failed\n");
close_file_descriptors();
return TEST_ERR_MAJOR_BAD;
}
curl = curl_easy_init();
if(!curl) {
- fprintf(stderr, "curl_easy_init() failed\n");
+ curl_mfprintf(stderr, "curl_easy_init() failed\n");
close_file_descriptors();
curl_global_cleanup();
return TEST_ERR_MAJOR_BAD;
CURLcode test(char *URL)
{
(void)URL;
- printf("system lacks necessary system function(s)");
+ curl_mprintf("system lacks necessary system function(s)");
return TEST_ERR_MAJOR_BAD; /* skip test */
}
struct curl_slist *slist = NULL;
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
- fprintf(stderr, "curl_global_init() failed\n");
+ curl_mfprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
curl = curl_easy_init();
if(!curl) {
- fprintf(stderr, "curl_easy_init() failed\n");
+ curl_mfprintf(stderr, "curl_easy_init() failed\n");
curl_global_cleanup();
return TEST_ERR_MAJOR_BAD;
}
if(msg->msg == CURLMSG_DONE) {
int i;
CURL *e = msg->easy_handle;
- fprintf(stderr, "R: %d - %s\n", (int)msg->data.result,
+ curl_mfprintf(stderr, "R: %d - %s\n", (int)msg->data.result,
curl_easy_strerror(msg->data.result));
curl_multi_remove_handle(cm, e);
curl_easy_cleanup(e);
}
}
else
- fprintf(stderr, "E: CURLMsg (%d)\n", (int)msg->msg);
+ curl_mfprintf(stderr, "E: CURLMsg (%d)\n", (int)msg->msg);
}
res_test_timedout();
if(test_argc < 4)
return TEST_ERR_MAJOR_BAD;
- msnprintf(buffer, sizeof(buffer), "Host: %s", HOST);
+ curl_msnprintf(buffer, sizeof(buffer), "Host: %s", HOST);
/* now add a custom Host: header */
headers = curl_slist_append(headers, buffer);
if(!headers) {
- fprintf(stderr, "curl_slist_append() failed\n");
+ curl_mfprintf(stderr, "curl_slist_append() failed\n");
return TEST_ERR_MAJOR_BAD;
}
if(res)
goto test_cleanup;
- fprintf(stderr, "lib540: now we do the request again\n");
+ curl_mfprintf(stderr, "lib540: now we do the request again\n");
res = loop(1, cm, URL, PROXYUSERPWD, headers);
struct_stat file_info;
if(!libtest_arg2) {
- fprintf(stderr, "Usage: <url> <file-to-upload>\n");
+ curl_mfprintf(stderr, "Usage: <url> <file-to-upload>\n");
return TEST_ERR_USAGE;
}
hd_src = fopen(libtest_arg2, "rb");
if(!hd_src) {
- fprintf(stderr, "fopen failed with error (%d) %s\n",
+ curl_mfprintf(stderr, "fopen failed with error (%d) %s\n",
errno, strerror(errno));
- fprintf(stderr, "Error opening file '%s'\n", libtest_arg2);
+ curl_mfprintf(stderr, "Error opening file '%s'\n", libtest_arg2);
return TEST_ERR_MAJOR_BAD; /* if this happens things are major weird */
}
#endif
if(hd == -1) {
/* can't open file, bail out */
- fprintf(stderr, "fstat() failed with error (%d) %s\n",
+ curl_mfprintf(stderr, "fstat() failed with error (%d) %s\n",
errno, strerror(errno));
- fprintf(stderr, "Error opening file '%s'\n", libtest_arg2);
+ curl_mfprintf(stderr, "Error opening file '%s'\n", libtest_arg2);
fclose(hd_src);
return TEST_ERR_MAJOR_BAD;
}
if(!file_info.st_size) {
- fprintf(stderr, "File %s has zero size!\n", libtest_arg2);
+ curl_mfprintf(stderr, "File %s has zero size!\n", libtest_arg2);
fclose(hd_src);
return TEST_ERR_MAJOR_BAD;
}
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
- fprintf(stderr, "curl_global_init() failed\n");
+ curl_mfprintf(stderr, "curl_global_init() failed\n");
fclose(hd_src);
return TEST_ERR_MAJOR_BAD;
}
/* get a curl handle */
curl = curl_easy_init();
if(!curl) {
- fprintf(stderr, "curl_easy_init() failed\n");
+ curl_mfprintf(stderr, "curl_easy_init() failed\n");
curl_global_cleanup();
fclose(hd_src);
return TEST_ERR_MAJOR_BAD;
CURLcode res = CURLE_OK;
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
- fprintf(stderr, "curl_global_init() failed\n");
+ curl_mfprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
/* get a curl handle */
curl = curl_easy_init();
if(!curl) {
- fprintf(stderr, "curl_easy_init() failed\n");
+ curl_mfprintf(stderr, "curl_easy_init() failed\n");
curl_global_cleanup();
return TEST_ERR_MAJOR_BAD;
}
global_init(CURL_GLOBAL_ALL);
easy = curl_easy_init();
if(!easy) {
- fprintf(stderr, "curl_easy_init() failed\n");
+ curl_mfprintf(stderr, "curl_easy_init() failed\n");
res = TEST_ERR_MAJOR_BAD;
}
else {
char *s = curl_easy_escape(easy, (const char *)a, asize);
if(s) {
- printf("%s\n", s);
+ curl_mprintf("%s\n", s);
curl_free(s);
}
s = curl_easy_escape(easy, "", 0);
if(s) {
- printf("IN: '' OUT: '%s'\n", s);
+ curl_mprintf("IN: '' OUT: '%s'\n", s);
curl_free(s);
}
s = curl_easy_escape(easy, " 123", 3);
if(s) {
- printf("IN: ' 12' OUT: '%s'\n", s);
+ curl_mprintf("IN: ' 12' OUT: '%s'\n", s);
curl_free(s);
}
CURLcode res = CURLE_OK;
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
- fprintf(stderr, "curl_global_init() failed\n");
+ curl_mfprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
curl = curl_easy_init();
if(!curl) {
- fprintf(stderr, "curl_easy_init() failed\n");
+ curl_mfprintf(stderr, "curl_easy_init() failed\n");
curl_global_cleanup();
return TEST_ERR_MAJOR_BAD;
}
if(*counter) {
/* only do this once and then require a clearing of this */
- fprintf(stderr, "READ ALREADY DONE!\n");
+ curl_mfprintf(stderr, "READ ALREADY DONE!\n");
return 0;
}
(*counter)++; /* bump */
if(size * nmemb >= strlen(UPLOADTHIS)) {
- fprintf(stderr, "READ!\n");
+ curl_mfprintf(stderr, "READ!\n");
strcpy(ptr, UPLOADTHIS);
return strlen(UPLOADTHIS);
}
- fprintf(stderr, "READ NOT FINE!\n");
+ curl_mfprintf(stderr, "READ NOT FINE!\n");
return 0;
}
static curlioerr ioctlcallback(CURL *handle,
int *counter = (int *)clientp;
(void)handle; /* unused */
if(cmd == CURLIOCMD_RESTARTREAD) {
- fprintf(stderr, "REWIND!\n");
+ curl_mfprintf(stderr, "REWIND!\n");
*counter = 0; /* clear counter to make the read callback restart */
}
return CURLIOE_OK;
#endif
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
- fprintf(stderr, "curl_global_init() failed\n");
+ curl_mfprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
curl = curl_easy_init();
if(!curl) {
- fprintf(stderr, "curl_easy_init() failed\n");
+ curl_mfprintf(stderr, "curl_easy_init() failed\n");
curl_global_cleanup();
return TEST_ERR_MAJOR_BAD;
}
CURL *curl;
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
- fprintf(stderr, "curl_global_init() failed\n");
+ curl_mfprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
curl = curl_easy_init();
if(!curl) {
- fprintf(stderr, "curl_easy_init() failed\n");
+ curl_mfprintf(stderr, "curl_easy_init() failed\n");
curl_global_cleanup();
return TEST_ERR_MAJOR_BAD;
}
/* without the hex output, we can fit more on screen */
width = 0x40;
- fprintf(stream, "%s, %zu bytes (0x%zx)\n", text, size, size);
+ curl_mfprintf(stream, "%s, %zu bytes (0x%zx)\n", text, size, size);
for(i = 0; i < size; i += width) {
- fprintf(stream, "%04zx: ", i);
+ curl_mfprintf(stream, "%04zx: ", i);
if(!nohex) {
/* hex not disabled, show it */
for(c = 0; c < width; c++)
if(i + c < size)
- fprintf(stream, "%02x ", ptr[i + c]);
+ curl_mfprintf(stream, "%02x ", ptr[i + c]);
else
fputs(" ", stream);
}
i += (c + 2 - width);
break;
}
- fprintf(stream, "%c",
+ curl_mfprintf(stream, "%c",
(ptr[i + c] >= 0x20) && (ptr[i + c] < 0x80) ? ptr[i + c] : '.');
/* check again for 0D0A, to avoid an extra \n if it's at width */
if(nohex && (i + c + 2 < size) && ptr[i + c + 1] == 0x0D &&
switch(type) {
case CURLINFO_TEXT:
- fprintf(stderr, "== Info: %s", (char *)data);
+ curl_mfprintf(stderr, "== Info: %s", (char *)data);
return 0;
case CURLINFO_HEADER_OUT:
text = "=> Send header";
void *stream)
{
int amount = curlx_uztosi(size * nmemb);
- printf("%.*s", amount, (char *)ptr);
+ curl_mprintf("%.*s", amount, (char *)ptr);
(void)stream;
return size * nmemb;
}
{
(void)clientp;
if(cmd == CURLIOCMD_RESTARTREAD) {
- printf("APPLICATION received a CURLIOCMD_RESTARTREAD request\n");
- printf("APPLICATION ** REWINDING! **\n");
+ curl_mprintf("APPLICATION received a CURLIOCMD_RESTARTREAD request\n");
+ curl_mprintf("APPLICATION ** REWINDING! **\n");
current_offset = 0;
return CURLIOE_OK;
}
struct curl_slist *headerlist = NULL, *hl;
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
- fprintf(stderr, "curl_global_init() failed\n");
+ curl_mfprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
curl = curl_easy_init();
if(!curl) {
- fprintf(stderr, "curl_easy_init() failed\n");
+ curl_mfprintf(stderr, "curl_easy_init() failed\n");
curl_global_cleanup();
return TEST_ERR_MAJOR_BAD;
}
for(i = 0; i < NUM_HEADERS; i++) {
- int len = msnprintf(testbuf, sizeof(testbuf), "Header%d: ", i);
+ int len = curl_msnprintf(testbuf, sizeof(testbuf), "Header%d: ", i);
memset(&testbuf[len], 'A', SIZE_HEADERS);
testbuf[len + SIZE_HEADERS] = 0; /* null-terminate */
hl = curl_slist_append(headerlist, testbuf);
}
if(formrc)
- printf("curl_formadd(1) = %d\n", (int)formrc);
+ curl_mprintf("curl_formadd(1) = %d\n", (int)formrc);
/* Now add the same data with another name and make it not look like
a file upload but still using the callback */
CURLFORM_END);
)
if(formrc)
- printf("curl_formadd(2) = %d\n", (int)formrc);
+ curl_mprintf("curl_formadd(2) = %d\n", (int)formrc);
CURL_IGNORE_DEPRECATION(
/* Fill in the filename field */
CURLFORM_END);
)
if(formrc)
- printf("curl_formadd(3) = %d\n", (int)formrc);
+ curl_mprintf("curl_formadd(3) = %d\n", (int)formrc);
CURL_IGNORE_DEPRECATION(
/* Fill in a submit field too */
CURLFORM_END);
)
if(formrc)
- printf("curl_formadd(4) = %d\n", (int)formrc);
+ curl_mprintf("curl_formadd(4) = %d\n", (int)formrc);
CURL_IGNORE_DEPRECATION(
formrc = curl_formadd(&formpost, &lastptr,
CURLFORM_END);
)
if(formrc)
- printf("curl_formadd(5) = %d\n", (int)formrc);
+ curl_mprintf("curl_formadd(5) = %d\n", (int)formrc);
curl = curl_easy_init();
if(!curl) {
- fprintf(stderr, "curl_easy_init() failed\n");
+ curl_mfprintf(stderr, "curl_easy_init() failed\n");
CURL_IGNORE_DEPRECATION(
curl_formfree(formpost);
)
CURLcode res;
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
- fprintf(stderr, "curl_global_init() failed\n");
+ curl_mfprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
if(*counter) {
/* only do this once and then require a clearing of this */
- fprintf(stderr, "READ ALREADY DONE!\n");
+ curl_mfprintf(stderr, "READ ALREADY DONE!\n");
return 0;
}
(*counter)++; /* bump */
if(size * nmemb >= strlen(uploadthis)) {
- fprintf(stderr, "READ!\n");
+ curl_mfprintf(stderr, "READ!\n");
strcpy(ptr, uploadthis);
return strlen(uploadthis);
}
- fprintf(stderr, "READ NOT FINE!\n");
+ curl_mfprintf(stderr, "READ NOT FINE!\n");
return 0;
}
static curlioerr ioctlcallback(CURL *handle,
int *counter = (int *)clientp;
(void)handle; /* unused */
if(cmd == CURLIOCMD_RESTARTREAD) {
- fprintf(stderr, "REWIND!\n");
+ curl_mfprintf(stderr, "REWIND!\n");
*counter = 0; /* clear counter to make the read callback restart */
}
return CURLIOE_OK;
#endif
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
- fprintf(stderr, "curl_global_init() failed\n");
+ curl_mfprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
curl = curl_easy_init();
if(!curl) {
- fprintf(stderr, "curl_easy_init() failed\n");
+ curl_mfprintf(stderr, "curl_easy_init() failed\n");
curl_global_cleanup();
return TEST_ERR_MAJOR_BAD;
}
#else
if((size_t)write(STDOUT_FILENO, buf, nread) != nread) {
#endif
- fprintf(stderr, "write() failed: errno %d (%s)\n",
+ curl_mfprintf(stderr, "write() failed: errno %d (%s)\n",
errno, strerror(errno));
res = TEST_ERR_FAILURE;
break;
if(memcmp(us_test[i].result,
us_test[i].expected,
strlen(us_test[i].expected))) {
- printf("unsigned short test #%.2d: Failed (Expected: %s Got: %s)\n",
- i, us_test[i].expected, us_test[i].result);
+ curl_mprintf("unsigned short test #%.2d: Failed "
+ "(Expected: %s Got: %s)\n",
+ i, us_test[i].expected, us_test[i].result);
failed++;
}
}
if(!failed)
- printf("All curl_mprintf() unsigned short tests OK!\n");
+ curl_mprintf("All curl_mprintf() unsigned short tests OK!\n");
else
- printf("Some curl_mprintf() unsigned short tests Failed!\n");
+ curl_mprintf("Some curl_mprintf() unsigned short tests Failed!\n");
return failed;
}
if(memcmp(ss_test[i].result,
ss_test[i].expected,
strlen(ss_test[i].expected))) {
- printf("signed short test #%.2d: Failed (Expected: %s Got: %s)\n",
+ curl_mprintf("signed short test #%.2d: Failed (Expected: %s Got: %s)\n",
i, ss_test[i].expected, ss_test[i].result);
failed++;
}
}
if(!failed)
- printf("All curl_mprintf() signed short tests OK!\n");
+ curl_mprintf("All curl_mprintf() signed short tests OK!\n");
else
- printf("Some curl_mprintf() signed short tests Failed!\n");
+ curl_mprintf("Some curl_mprintf() signed short tests Failed!\n");
return failed;
}
if(memcmp(ui_test[i].result,
ui_test[i].expected,
strlen(ui_test[i].expected))) {
- printf("unsigned int test #%.2d: Failed (Expected: %s Got: %s)\n",
+ curl_mprintf("unsigned int test #%.2d: Failed (Expected: %s Got: %s)\n",
i, ui_test[i].expected, ui_test[i].result);
failed++;
}
}
if(!failed)
- printf("All curl_mprintf() unsigned int tests OK!\n");
+ curl_mprintf("All curl_mprintf() unsigned int tests OK!\n");
else
- printf("Some curl_mprintf() unsigned int tests Failed!\n");
+ curl_mprintf("Some curl_mprintf() unsigned int tests Failed!\n");
return failed;
}
if(memcmp(si_test[i].result,
si_test[i].expected,
strlen(si_test[i].expected))) {
- printf("signed int test #%.2d: Failed (Expected: %s Got: %s)\n",
+ curl_mprintf("signed int test #%.2d: Failed (Expected: %s Got: %s)\n",
i, si_test[i].expected, si_test[i].result);
failed++;
}
}
if(!failed)
- printf("All curl_mprintf() signed int tests OK!\n");
+ curl_mprintf("All curl_mprintf() signed int tests OK!\n");
else
- printf("Some curl_mprintf() signed int tests Failed!\n");
+ curl_mprintf("Some curl_mprintf() signed int tests Failed!\n");
return failed;
}
if(memcmp(ul_test[i].result,
ul_test[i].expected,
strlen(ul_test[i].expected))) {
- printf("unsigned long test #%.2d: Failed (Expected: %s Got: %s)\n",
+ curl_mprintf("unsigned long test #%.2d: Failed (Expected: %s Got: %s)\n",
i, ul_test[i].expected, ul_test[i].result);
failed++;
}
}
if(!failed)
- printf("All curl_mprintf() unsigned long tests OK!\n");
+ curl_mprintf("All curl_mprintf() unsigned long tests OK!\n");
else
- printf("Some curl_mprintf() unsigned long tests Failed!\n");
+ curl_mprintf("Some curl_mprintf() unsigned long tests Failed!\n");
return failed;
}
if(memcmp(sl_test[i].result,
sl_test[i].expected,
strlen(sl_test[i].expected))) {
- printf("signed long test #%.2d: Failed (Expected: %s Got: %s)\n",
+ curl_mprintf("signed long test #%.2d: Failed (Expected: %s Got: %s)\n",
i, sl_test[i].expected, sl_test[i].result);
failed++;
}
}
if(!failed)
- printf("All curl_mprintf() signed long tests OK!\n");
+ curl_mprintf("All curl_mprintf() signed long tests OK!\n");
else
- printf("Some curl_mprintf() signed long tests Failed!\n");
+ curl_mprintf("Some curl_mprintf() signed long tests Failed!\n");
return failed;
}
if(memcmp(co_test[i].result,
co_test[i].expected,
strlen(co_test[i].expected))) {
- printf("curl_off_t test #%.2d: Failed (Expected: %s Got: %s)\n",
+ curl_mprintf("curl_off_t test #%.2d: Failed (Expected: %s Got: %s)\n",
i, co_test[i].expected, co_test[i].result);
failed++;
}
}
if(!failed)
- printf("All curl_mprintf() curl_off_t tests OK!\n");
+ curl_mprintf("All curl_mprintf() curl_off_t tests OK!\n");
else
- printf("Some curl_mprintf() curl_off_t tests Failed!\n");
+ curl_mprintf("Some curl_mprintf() curl_off_t tests Failed!\n");
return failed;
}
{
if(strcmp(buf, buf2)) {
/* they shouldn't differ */
- printf("sprintf line %d failed:\nwe '%s'\nsystem: '%s'\n",
+ curl_mprintf("sprintf line %d failed:\nwe '%s'\nsystem: '%s'\n",
linenumber, buf, buf2);
return 1;
}
size_t buflen = strlen(buf);
if(len != buflen) {
/* they shouldn't differ */
- printf("sprintf strlen:%d failed:\nwe '%zu'\nsystem: '%zu'\n",
+ curl_mprintf("sprintf strlen:%d failed:\nwe '%zu'\nsystem: '%zu'\n",
linenumber, buflen, len);
return 1;
}
errors += string_check(buf, "foo ");
if(!errors)
- printf("All curl_mprintf() strings tests OK!\n");
+ curl_mprintf("All curl_mprintf() strings tests OK!\n");
else
- printf("Some curl_mprintf() string tests Failed!\n");
+ curl_mprintf("Some curl_mprintf() string tests Failed!\n");
return errors;
}
0, 1, 2, 3, 4, 5, 6, 7); /* 8 */
if(rc != 128) {
- printf("curl_mprintf() returned %d and not 128!\n", rc);
+ curl_mprintf("curl_mprintf() returned %d and not 128!\n", rc);
errors++;
}
0, 1, 2, 3, 4, 5, 6, 7, 8); /* 9 */
if(rc) {
- printf("curl_mprintf() returned %d and not 0\n", rc);
+ curl_mprintf("curl_mprintf() returned %d and not 0\n", rc);
errors++;
}
errors += test_width_precision();
if(errors)
- printf("Some curl_mprintf() weird arguments tests failed!\n");
+ curl_mprintf("Some curl_mprintf() weird arguments tests failed!\n");
return errors;
}
errors += strlen_check(buf, 5);
if(!errors)
- printf("All float strings tests OK!\n");
+ curl_mprintf("All float strings tests OK!\n");
else
- printf("test_float_formatting Failed!\n");
+ curl_mprintf("test_float_formatting Failed!\n");
return errors;
}
#endif
if(!errors)
- printf("All curl_mprintf() octal & hexadecimal tests OK!\n");
+ curl_mprintf("All curl_mprintf() octal & hexadecimal tests OK!\n");
else
- printf("Some curl_mprintf() octal & hexadecimal tests Failed!\n");
+ curl_mprintf("Some curl_mprintf() octal & hexadecimal tests Failed!\n");
return errors;
}
(void)URL; /* we don't use this */
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
- fprintf(stderr, "curl_global_init() failed\n");
+ curl_mfprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
CURL *curl;
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
- fprintf(stderr, "curl_global_init() failed\n");
+ curl_mfprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
curl = curl_easy_init();
if(!curl) {
- fprintf(stderr, "curl_easy_init() failed\n");
+ curl_mfprintf(stderr, "curl_easy_init() failed\n");
curl_global_cleanup();
return TEST_ERR_MAJOR_BAD;
}
CURLcode res = CURLE_OK;
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
- fprintf(stderr, "curl_global_init() failed\n");
+ curl_mfprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
/* get a curl handle */
curl = curl_easy_init();
if(!curl) {
- fprintf(stderr, "curl_easy_init() failed\n");
+ curl_mfprintf(stderr, "curl_easy_init() failed\n");
curl_global_cleanup();
return TEST_ERR_MAJOR_BAD;
}
multi_add_handle(m, curl);
- fprintf(stderr, "Start at URL 0\n");
+ curl_mfprintf(stderr, "Start at URL 0\n");
for(;;) {
struct timeval interval;
double content_length = 3;
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
- fprintf(stderr, "curl_global_init() failed\n");
+ curl_mfprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
curl = curl_easy_init();
if(!curl) {
- fprintf(stderr, "curl_easy_init() failed\n");
+ curl_mfprintf(stderr, "curl_easy_init() failed\n");
curl_global_cleanup();
return TEST_ERR_MAJOR_BAD;
}
)
moo = fopen(libtest_arg2, "wb");
if(moo) {
- fprintf(moo, "CL %.0f\n", content_length);
+ curl_mfprintf(moo, "CL %.0f\n", content_length);
fclose(moo);
}
}
struct curl_slist *custom_headers = NULL;
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
- fprintf(stderr, "curl_global_init() failed\n");
+ curl_mfprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
curl = curl_easy_init();
if(!curl) {
- fprintf(stderr, "curl_easy_init() failed\n");
+ curl_mfprintf(stderr, "curl_easy_init() failed\n");
curl_global_cleanup();
return TEST_ERR_MAJOR_BAD;
}
struct curl_slist *custom_headers = NULL;
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
- fprintf(stderr, "curl_global_init() failed\n");
+ curl_mfprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
curl = curl_easy_init();
if(!curl) {
- fprintf(stderr, "curl_easy_init() failed\n");
+ curl_mfprintf(stderr, "curl_easy_init() failed\n");
curl_global_cleanup();
return TEST_ERR_MAJOR_BAD;
}
sdp = open(libtest_arg2, O_RDONLY);
if(sdp == -1) {
- fprintf(stderr, "can't open %s\n", libtest_arg2);
+ curl_mfprintf(stderr, "can't open %s\n", libtest_arg2);
res = TEST_ERR_MAJOR_BAD;
goto test_cleanup;
}
sdpf = fopen(libtest_arg2, "rb");
if(!sdpf) {
- fprintf(stderr, "can't fopen %s\n", libtest_arg2);
+ curl_mfprintf(stderr, "can't fopen %s\n", libtest_arg2);
res = TEST_ERR_MAJOR_BAD;
goto test_cleanup;
}
FILE *idfile = fopen(libtest_arg2, "wb");
if(!idfile) {
- fprintf(stderr, "couldn't open the Session ID File\n");
+ curl_mfprintf(stderr, "couldn't open the Session ID File\n");
return TEST_ERR_MAJOR_BAD;
}
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
- fprintf(stderr, "curl_global_init() failed\n");
+ curl_mfprintf(stderr, "curl_global_init() failed\n");
fclose(idfile);
return TEST_ERR_MAJOR_BAD;
}
curl = curl_easy_init();
if(!curl) {
- fprintf(stderr, "curl_easy_init() failed\n");
+ curl_mfprintf(stderr, "curl_easy_init() failed\n");
curl_global_cleanup();
fclose(idfile);
return TEST_ERR_MAJOR_BAD;
test_setopt(curl, CURLOPT_RTSP_REQUEST, CURL_RTSPREQ_SETUP);
res = curl_easy_perform(curl);
if(res != (int)CURLE_BAD_FUNCTION_ARGUMENT) {
- fprintf(stderr, "This should have failed. "
+ curl_mfprintf(stderr, "This should have failed. "
"Cannot setup without a Transport: header");
res = TEST_ERR_MAJOR_BAD;
goto test_cleanup;
goto test_cleanup;
curl_easy_getinfo(curl, CURLINFO_RTSP_SESSION_ID, &rtsp_session_id);
- fprintf(idfile, "Got Session ID: [%s]\n", rtsp_session_id);
+ curl_mfprintf(idfile, "Got Session ID: [%s]\n", rtsp_session_id);
rtsp_session_id = NULL;
stream_uri = suburl(URL, request++);
char *stream_uri = NULL;
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
- fprintf(stderr, "curl_global_init() failed\n");
+ curl_mfprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
curl = curl_easy_init();
if(!curl) {
- fprintf(stderr, "curl_easy_init() failed\n");
+ curl_mfprintf(stderr, "curl_easy_init() failed\n");
curl_global_cleanup();
return TEST_ERR_MAJOR_BAD;
}
res = curl_easy_perform(curl);
if(res != (int)CURLE_RTSP_CSEQ_ERROR) {
- fprintf(stderr, "Failed to detect CSeq mismatch");
+ curl_mfprintf(stderr, "Failed to detect CSeq mismatch");
res = TEST_ERR_MAJOR_BAD;
goto test_cleanup;
}
res = CURLE_OK;
}
else {
- fprintf(stderr, "Failed to detect a Session ID mismatch");
+ curl_mfprintf(stderr, "Failed to detect a Session ID mismatch");
res = TEST_ERR_FAILURE;
}
message_size = curlx_uztosi(size * nmemb) - 4;
- printf("RTP: message size %d, channel %d\n", message_size, channel);
+ curl_mprintf("RTP: message size %d, channel %d\n", message_size, channel);
if(message_size != coded_size) {
- printf("RTP embedded size (%d) does not match the write size (%d).\n",
- coded_size, message_size);
+ curl_mprintf("RTP embedded size (%d) does not match "
+ "the write size (%d).\n",
+ coded_size, message_size);
return failure;
}
for(i = 0; i < message_size; i += RTP_DATA_SIZE) {
if(message_size - i > RTP_DATA_SIZE) {
if(memcmp(RTP_DATA, data + i, RTP_DATA_SIZE) != 0) {
- printf("RTP PAYLOAD CORRUPTED [%s]\n", data + i);
+ curl_mprintf("RTP PAYLOAD CORRUPTED [%s]\n", data + i);
/* return failure; */
}
}
else {
if(memcmp(RTP_DATA, data + i, message_size - i) != 0) {
- printf("RTP PAYLOAD END CORRUPTED (%d), [%s]\n",
+ curl_mprintf("RTP PAYLOAD END CORRUPTED (%d), [%s]\n",
message_size - i, data + i);
/* return failure; */
}
}
rtp_packet_count++;
- fprintf(stderr, "packet count is %d\n", rtp_packet_count);
+ curl_mfprintf(stderr, "packet count is %d\n", rtp_packet_count);
return size * nmemb;
}
FILE *protofile = fopen(libtest_arg2, "wb");
if(!protofile) {
- fprintf(stderr, "Couldn't open the protocol dump file\n");
+ curl_mfprintf(stderr, "Couldn't open the protocol dump file\n");
return TEST_ERR_MAJOR_BAD;
}
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
- fprintf(stderr, "curl_global_init() failed\n");
+ curl_mfprintf(stderr, "curl_global_init() failed\n");
fclose(protofile);
return TEST_ERR_MAJOR_BAD;
}
curl = curl_easy_init();
if(!curl) {
- fprintf(stderr, "curl_easy_init() failed\n");
+ curl_mfprintf(stderr, "curl_easy_init() failed\n");
fclose(protofile);
curl_global_cleanup();
return TEST_ERR_MAJOR_BAD;
if(res)
goto test_cleanup;
- fprintf(stderr, "PLAY COMPLETE\n");
+ curl_mfprintf(stderr, "PLAY COMPLETE\n");
/* Use Receive to get the rest of the data */
while(!res && rtp_packet_count < 19) {
- fprintf(stderr, "LOOPY LOOP!\n");
+ curl_mfprintf(stderr, "LOOPY LOOP!\n");
test_setopt(curl, CURLOPT_RTSP_REQUEST, CURL_RTSPREQ_RECEIVE);
res = curl_easy_perform(curl);
}
struct curl_slist *custom_headers = NULL;
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
- fprintf(stderr, "curl_global_init() failed\n");
+ curl_mfprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
curl = curl_easy_init();
if(!curl) {
- fprintf(stderr, "curl_easy_init() failed\n");
+ curl_mfprintf(stderr, "curl_easy_init() failed\n");
curl_global_cleanup();
return TEST_ERR_MAJOR_BAD;
}
/* PUT style GET_PARAMETERS */
params = open(libtest_arg2, O_RDONLY);
if(params == -1) {
- fprintf(stderr, "can't open %s\n", libtest_arg2);
+ curl_mfprintf(stderr, "can't open %s\n", libtest_arg2);
res = TEST_ERR_MAJOR_BAD;
goto test_cleanup;
}
paramsf = fopen(libtest_arg2, "rb");
if(!paramsf) {
- fprintf(stderr, "can't fopen %s\n", libtest_arg2);
+ curl_mfprintf(stderr, "can't fopen %s\n", libtest_arg2);
res = TEST_ERR_MAJOR_BAD;
goto test_cleanup;
}
curl_easy_getinfo(c, CURLINFO_CONNECT_TIME, &connect_time);
if(connect_time < dbl_epsilon) {
- fprintf(stderr, "connect time %e is < epsilon %e\n",
+ curl_mfprintf(stderr, "connect time %e is < epsilon %e\n",
connect_time, dbl_epsilon);
res = TEST_ERR_MAJOR_BAD;
}
const char *pattern, const char *string)
{
(void)ptr;
- fprintf(stderr, "lib574: match string '%s' against pattern '%s'\n",
+ curl_mfprintf(stderr, "lib574: match string '%s' against pattern '%s'\n",
string, pattern);
return CURL_FNMATCHFUNC_MATCH;
}
CURL *curl;
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
- fprintf(stderr, "curl_global_init() failed\n");
+ curl_mfprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
curl = curl_easy_init();
if(!curl) {
- fprintf(stderr, "curl_easy_init() failed\n");
+ curl_mfprintf(stderr, "curl_easy_init() failed\n");
curl_global_cleanup();
return TEST_ERR_MAJOR_BAD;
}
res = curl_easy_perform(curl);
if(res) {
- fprintf(stderr, "curl_easy_perform() failed %d\n", res);
+ curl_mfprintf(stderr, "curl_easy_perform() failed %d\n", res);
goto test_cleanup;
}
res = curl_easy_perform(curl);
if(res) {
- fprintf(stderr, "curl_easy_perform() failed %d\n", res);
+ curl_mfprintf(stderr, "curl_easy_perform() failed %d\n", res);
goto test_cleanup;
}
struct chunk_data *ch_d = ptr;
ch_d->remains = remains;
- printf("=============================================================\n");
- printf("Remains: %d\n", remains);
- printf("Filename: %s\n", finfo->filename);
+ curl_mprintf("=================================="
+ "===========================\n");
+ curl_mprintf("Remains: %d\n", remains);
+ curl_mprintf("Filename: %s\n", finfo->filename);
if(finfo->strings.perm) {
- printf("Permissions: %s", finfo->strings.perm);
+ curl_mprintf("Permissions: %s", finfo->strings.perm);
if(finfo->flags & CURLFINFOFLAG_KNOWN_PERM)
- printf(" (parsed => %o)", finfo->perm);
- printf("\n");
+ curl_mprintf(" (parsed => %o)", finfo->perm);
+ curl_mprintf("\n");
}
- printf("Size: %ldB\n", (long)finfo->size);
+ curl_mprintf("Size: %ldB\n", (long)finfo->size);
if(finfo->strings.user)
- printf("User: %s\n", finfo->strings.user);
+ curl_mprintf("User: %s\n", finfo->strings.user);
if(finfo->strings.group)
- printf("Group: %s\n", finfo->strings.group);
+ curl_mprintf("Group: %s\n", finfo->strings.group);
if(finfo->strings.time)
- printf("Time: %s\n", finfo->strings.time);
- printf("Filetype: ");
+ curl_mprintf("Time: %s\n", finfo->strings.time);
+ curl_mprintf("Filetype: ");
switch(finfo->filetype) {
case CURLFILETYPE_FILE:
- printf("regular file\n");
+ curl_mprintf("regular file\n");
break;
case CURLFILETYPE_DIRECTORY:
- printf("directory\n");
+ curl_mprintf("directory\n");
break;
case CURLFILETYPE_SYMLINK:
- printf("symlink\n");
- printf("Target: %s\n", finfo->strings.target);
+ curl_mprintf("symlink\n");
+ curl_mprintf("Target: %s\n", finfo->strings.target);
break;
default:
- printf("other type\n");
+ curl_mprintf("other type\n");
break;
}
if(finfo->filetype == CURLFILETYPE_FILE) {
ch_d->print_content = 1;
- printf("Content:\n"
+ curl_mprintf("Content:\n"
"-------------------------------------------------------------\n");
}
if(strcmp(finfo->filename, "someothertext.txt") == 0) {
- printf("# THIS CONTENT WAS SKIPPED IN CHUNK_BGN CALLBACK #\n");
+ curl_mprintf("# THIS CONTENT WAS SKIPPED IN CHUNK_BGN CALLBACK #\n");
return CURL_CHUNK_BGN_FUNC_SKIP;
}
return CURL_CHUNK_BGN_FUNC_OK;
struct chunk_data *ch_d = ptr;
if(ch_d->print_content) {
ch_d->print_content = 0;
- printf("-------------------------------------------------------------\n");
+ curl_mprintf("-------------------------------------------"
+ "------------------\n");
}
if(ch_d->remains == 1)
- printf("=============================================================\n");
+ curl_mprintf("==========================================="
+ "==================\n");
return CURL_CHUNK_END_FUNC_OK;
}
if(moo) {
if((size_t)ultotal == data_size && (size_t)ulnow == data_size)
- fprintf(moo, "PASSED, UL data matched data size\n");
+ curl_mfprintf(moo, "PASSED, UL data matched data size\n");
else
- fprintf(moo, "Progress callback called with UL %f out of %f\n",
+ curl_mfprintf(moo, "Progress callback called with UL %f out of %f\n",
ulnow, ultotal);
fclose(moo);
}
CURLcode res = CURLE_OK;
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
- fprintf(stderr, "curl_global_init() failed\n");
+ curl_mfprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
curl = curl_easy_init();
if(!curl) {
- fprintf(stderr, "curl_easy_init() failed\n");
+ curl_mfprintf(stderr, "curl_easy_init() failed\n");
curl_global_cleanup();
return TEST_ERR_MAJOR_BAD;
}
static void progress_final_report(void)
{
FILE *moo = fopen(libtest_arg2, "ab");
- fprintf(moo ? moo : stderr, "Progress: end UL %zu/%zu\n",
+ curl_mfprintf(moo ? moo : stderr, "Progress: end UL %zu/%zu\n",
last_ul, last_ul_total);
if(moo)
fclose(moo);
else
- fprintf(stderr, "Progress: end UL, can't open %s\n", libtest_arg2);
+ curl_mfprintf(stderr, "Progress: end UL, can't open %s\n", libtest_arg2);
started = FALSE;
}
last_ul_total = (size_t)ultotal;
if(!started) {
FILE *moo = fopen(libtest_arg2, "ab");
- fprintf(moo ? moo : stderr, "Progress: start UL %zu/%zu\n",
+ curl_mfprintf(moo ? moo : stderr, "Progress: start UL %zu/%zu\n",
last_ul, last_ul_total);
if(moo)
fclose(moo);
else
- fprintf(stderr, "Progress: start UL, can't open %s\n", libtest_arg2);
+ curl_mfprintf(stderr, "Progress: start UL, can't open %s\n",
+ libtest_arg2);
started = TRUE;
}
pooh.counter = 0;
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
- fprintf(stderr, "curl_global_init() failed\n");
+ curl_mfprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
curl = curl_easy_init();
if(!curl) {
- fprintf(stderr, "curl_easy_init() failed\n");
+ curl_mfprintf(stderr, "curl_easy_init() failed\n");
curl_global_cleanup();
return TEST_ERR_MAJOR_BAD;
}
slist = curl_slist_append(slist, "Transfer-Encoding: chunked");
if(!slist) {
- fprintf(stderr, "curl_slist_append() failed\n");
+ curl_mfprintf(stderr, "curl_slist_append() failed\n");
curl_easy_cleanup(curl);
curl_global_cleanup();
return TEST_ERR_MAJOR_BAD;
int i;
if(mention)
- fprintf(stderr, "Remove socket fd %d\n", (int) fd);
+ curl_mfprintf(stderr, "Remove socket fd %d\n", (int) fd);
for(i = 0; i < sockets->count; ++i) {
if(sockets->sockets[i] == fd) {
* To ensure we only have each file descriptor once, we remove it then add
* it again.
*/
- fprintf(stderr, "Add socket fd %d for %s\n", (int) fd, what);
+ curl_mfprintf(stderr, "Add socket fd %d for %s\n", (int) fd, what);
removeFd(sockets, fd, 0);
/*
* Allocate array storage when required.
}
else if(sockets->count >= sockets->max_count) {
/* this can't happen in normal cases */
- fprintf(stderr, "too many file handles error\n");
+ curl_mfprintf(stderr, "too many file handles error\n");
exit(2);
}
/*
*success = 0;
}
else {
- fprintf(stderr, "Got an unexpected message from curl: %i\n",
+ curl_mfprintf(stderr, "Got an unexpected message from curl: %i\n",
(int)message->msg);
result = 1;
*success = 0;
int numhandles = 0;
CURLMcode result = curl_multi_socket_action(curl, s, evBitmask, &numhandles);
if(result != CURLM_OK) {
- fprintf(stderr, "Curl error on %s (%i) %s\n",
+ curl_mfprintf(stderr, "Curl error on %s (%i) %s\n",
info, result, curl_multi_strerror(result));
}
}
start_test_timing();
if(!libtest_arg3) {
- fprintf(stderr, "Usage: lib582 [url] [filename] [username]\n");
+ curl_mfprintf(stderr, "Usage: lib582 [url] [filename] [username]\n");
return TEST_ERR_USAGE;
}
hd_src = fopen(libtest_arg2, "rb");
if(!hd_src) {
- fprintf(stderr, "fopen() failed with error (%d) %s\n",
+ curl_mfprintf(stderr, "fopen() failed with error (%d) %s\n",
errno, strerror(errno));
- fprintf(stderr, "Error opening file '%s'\n", libtest_arg2);
+ curl_mfprintf(stderr, "Error opening file '%s'\n", libtest_arg2);
return TEST_ERR_FOPEN;
}
#endif
if(hd == -1) {
/* can't open file, bail out */
- fprintf(stderr, "fstat() failed with error (%d) %s\n",
+ curl_mfprintf(stderr, "fstat() failed with error (%d) %s\n",
errno, strerror(errno));
- fprintf(stderr, "Error opening file '%s'\n", libtest_arg2);
+ curl_mfprintf(stderr, "Error opening file '%s'\n", libtest_arg2);
fclose(hd_src);
return TEST_ERR_FSTAT;
}
- fprintf(stderr, "Set to upload %d bytes\n", (int)file_info.st_size);
+ curl_mfprintf(stderr, "Set to upload %d bytes\n", (int)file_info.st_size);
res_global_init(CURL_GLOBAL_ALL);
if(res) {
}
if(!success) {
- fprintf(stderr, "Error uploading file.\n");
+ curl_mfprintf(stderr, "Error uploading file.\n");
res = TEST_ERR_MAJOR_BAD;
}
/* this tests if removing an easy handle immediately after multi
perform has been called succeeds or not. */
- fprintf(stderr, "curl_multi_perform()...\n");
+ curl_mfprintf(stderr, "curl_multi_perform()...\n");
multi_perform(multiHandle, &stillRunning);
- fprintf(stderr, "curl_multi_perform() succeeded\n");
+ curl_mfprintf(stderr, "curl_multi_perform() succeeded\n");
- fprintf(stderr, "curl_multi_remove_handle()...\n");
+ curl_mfprintf(stderr, "curl_multi_remove_handle()...\n");
mres = curl_multi_remove_handle(multiHandle, curl);
if(mres) {
- fprintf(stderr, "curl_multi_remove_handle() failed, "
+ curl_mfprintf(stderr, "curl_multi_remove_handle() failed, "
"with code %d\n", (int)mres);
res = TEST_ERR_MULTI;
}
else
- fprintf(stderr, "curl_multi_remove_handle() succeeded\n");
+ curl_mfprintf(stderr, "curl_multi_remove_handle() succeeded\n");
test_cleanup:
what = "ssl_session";
break;
default:
- fprintf(stderr, "lock: no such data: %d\n", (int)data);
+ curl_mfprintf(stderr, "lock: no such data: %d\n", (int)data);
return;
}
- printf("lock: %-6s [%s]: %d\n", what, user->text, user->counter);
+ curl_mprintf("lock: %-6s [%s]: %d\n", what, user->text, user->counter);
user->counter++;
}
what = "ssl_session";
break;
default:
- fprintf(stderr, "unlock: no such data: %d\n", (int)data);
+ curl_mfprintf(stderr, "unlock: no such data: %d\n", (int)data);
return;
}
- printf("unlock: %-6s [%s]: %d\n", what, user->text, user->counter);
+ curl_mprintf("unlock: %-6s [%s]: %d\n", what, user->text, user->counter);
user->counter++;
}
curl = curl_easy_init();
if(!curl) {
- fprintf(stderr, "curl_easy_init() failed\n");
+ curl_mfprintf(stderr, "curl_easy_init() failed\n");
return NULL;
}
curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 0L);
curl_easy_setopt(curl, CURLOPT_VERBOSE, 1L);
curl_easy_setopt(curl, CURLOPT_URL, tdata->url);
- printf("CURLOPT_SHARE\n");
+ curl_mprintf("CURLOPT_SHARE\n");
curl_easy_setopt(curl, CURLOPT_SHARE, tdata->share);
- printf("PERFORM\n");
+ curl_mprintf("PERFORM\n");
code = curl_easy_perform(curl);
if(code != CURLE_OK) {
int i = 0;
- fprintf(stderr, "perform url '%s' repeat %d failed, curlcode %d\n",
+ curl_mfprintf(stderr, "perform url '%s' repeat %d failed, curlcode %d\n",
tdata->url, i, (int)code);
}
- printf("CLEANUP\n");
+ curl_mprintf("CLEANUP\n");
curl_easy_cleanup(curl);
return NULL;
user.text = "Pigs in space";
user.counter = 0;
- printf("GLOBAL_INIT\n");
+ curl_mprintf("GLOBAL_INIT\n");
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
- fprintf(stderr, "curl_global_init() failed\n");
+ curl_mfprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
/* prepare share */
- printf("SHARE_INIT\n");
+ curl_mprintf("SHARE_INIT\n");
share = curl_share_init();
if(!share) {
- fprintf(stderr, "curl_share_init() failed\n");
+ curl_mfprintf(stderr, "curl_share_init() failed\n");
curl_global_cleanup();
return TEST_ERR_MAJOR_BAD;
}
if(CURLSHE_OK == scode) {
- printf("CURLSHOPT_LOCKFUNC\n");
+ curl_mprintf("CURLSHOPT_LOCKFUNC\n");
scode = curl_share_setopt(share, CURLSHOPT_LOCKFUNC, test_lock);
}
if(CURLSHE_OK == scode) {
- printf("CURLSHOPT_UNLOCKFUNC\n");
+ curl_mprintf("CURLSHOPT_UNLOCKFUNC\n");
scode = curl_share_setopt(share, CURLSHOPT_UNLOCKFUNC, test_unlock);
}
if(CURLSHE_OK == scode) {
- printf("CURLSHOPT_USERDATA\n");
+ curl_mprintf("CURLSHOPT_USERDATA\n");
scode = curl_share_setopt(share, CURLSHOPT_USERDATA, &user);
}
if(CURLSHE_OK == scode) {
- printf("CURL_LOCK_DATA_SSL_SESSION\n");
+ curl_mprintf("CURL_LOCK_DATA_SSL_SESSION\n");
scode = curl_share_setopt(share, CURLSHOPT_SHARE,
CURL_LOCK_DATA_SSL_SESSION);
}
if(CURLSHE_OK != scode) {
- fprintf(stderr, "curl_share_setopt() failed\n");
+ curl_mfprintf(stderr, "curl_share_setopt() failed\n");
curl_share_cleanup(share);
curl_global_cleanup();
return TEST_ERR_MAJOR_BAD;
tdata.share = share;
/* simulate thread, direct call of "thread" function */
- printf("*** run %d\n",i);
+ curl_mprintf("*** run %d\n",i);
test_fire(&tdata);
}
/* fetch another one */
- printf("*** run %d\n", i);
+ curl_mprintf("*** run %d\n", i);
curl = curl_easy_init();
if(!curl) {
- fprintf(stderr, "curl_easy_init() failed\n");
+ curl_mfprintf(stderr, "curl_easy_init() failed\n");
curl_share_cleanup(share);
curl_global_cleanup();
return TEST_ERR_MAJOR_BAD;
url = URL;
test_setopt(curl, CURLOPT_URL, url);
- printf("CURLOPT_SHARE\n");
+ curl_mprintf("CURLOPT_SHARE\n");
test_setopt(curl, CURLOPT_SHARE, share);
- printf("PERFORM\n");
+ curl_mprintf("PERFORM\n");
res = curl_easy_perform(curl);
/* try to free share, expect to fail because share is in use */
- printf("try SHARE_CLEANUP...\n");
+ curl_mprintf("try SHARE_CLEANUP...\n");
scode = curl_share_cleanup(share);
if(scode == CURLSHE_OK) {
- fprintf(stderr, "curl_share_cleanup succeed but error expected\n");
+ curl_mfprintf(stderr, "curl_share_cleanup succeed but error expected\n");
share = NULL;
}
else {
- printf("SHARE_CLEANUP failed, correct\n");
+ curl_mprintf("SHARE_CLEANUP failed, correct\n");
}
test_cleanup:
/* clean up last handle */
- printf("CLEANUP\n");
+ curl_mprintf("CLEANUP\n");
curl_easy_cleanup(curl);
/* free share */
- printf("SHARE_CLEANUP\n");
+ curl_mprintf("SHARE_CLEANUP\n");
scode = curl_share_cleanup(share);
if(scode != CURLSHE_OK)
- fprintf(stderr, "curl_share_cleanup failed, code errno %d\n",
+ curl_mfprintf(stderr, "curl_share_cleanup failed, code errno %d\n",
(int)scode);
- printf("GLOBAL_CLEANUP\n");
+ curl_mprintf("GLOBAL_CLEANUP\n");
curl_global_cleanup();
return res;
CURLcode res = CURLE_OK;
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
- fprintf(stderr, "curl_global_init() failed\n");
+ curl_mfprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
curl = curl_easy_init();
if(!curl) {
- fprintf(stderr, "curl_easy_init() failed\n");
+ curl_mfprintf(stderr, "curl_easy_init() failed\n");
curl_global_cleanup();
return TEST_ERR_MAJOR_BAD;
}
long usedauth = 0;
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
- fprintf(stderr, "curl_global_init() failed\n");
+ curl_mfprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
curl = curl_easy_init();
if(!curl) {
- fprintf(stderr, "curl_easy_init() failed\n");
+ curl_mfprintf(stderr, "curl_easy_init() failed\n");
curl_global_cleanup();
return TEST_ERR_MAJOR_BAD;
}
res = curl_easy_getinfo(curl, CURLINFO_PROXYAUTH_USED, &usedauth);
if(CURLAUTH_NTLM != usedauth) {
- printf("CURLINFO_PROXYAUTH_USED did not say NTLM\n");
+ curl_mprintf("CURLINFO_PROXYAUTH_USED did not say NTLM\n");
}
test_cleanup:
upload = fopen(libtest_arg3, "rb");
if(!upload) {
- fprintf(stderr, "fopen() failed with error (%d) %s\n",
+ curl_mfprintf(stderr, "fopen() failed with error (%d) %s\n",
errno, strerror(errno));
- fprintf(stderr, "Error opening file '%s'\n", libtest_arg3);
+ curl_mfprintf(stderr, "Error opening file '%s'\n", libtest_arg3);
return TEST_ERR_FOPEN;
}
CURL *curl;
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
- fprintf(stderr, "curl_global_init() failed\n");
+ curl_mfprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
curl = curl_easy_init();
if(!curl) {
- fprintf(stderr, "curl_easy_init() failed\n");
+ curl_mfprintf(stderr, "curl_easy_init() failed\n");
curl_global_cleanup();
return TEST_ERR_MAJOR_BAD;
}
res = curl_easy_perform(curl);
if(res) {
- fprintf(stderr, "retrieve 1 failed\n");
+ curl_mfprintf(stderr, "retrieve 1 failed\n");
goto test_cleanup;
}
res = curl_easy_perform(curl);
if(res)
- fprintf(stderr, "retrieve 2 failed\n");
+ curl_mfprintf(stderr, "retrieve 2 failed\n");
test_cleanup:
if((dltotal > 0.0) && (dlnow > dltotal)) {
/* this should not happen with test case 599 */
- printf("%.0f > %.0f !!\n", dltotal, dlnow);
+ curl_mprintf("%.0f > %.0f !!\n", dltotal, dlnow);
return -1;
}
double content_length = 0.0;
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
- fprintf(stderr, "curl_global_init() failed\n");
+ curl_mfprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
curl = curl_easy_init();
if(!curl) {
- fprintf(stderr, "curl_easy_init() failed\n");
+ curl_mfprintf(stderr, "curl_easy_init() failed\n");
curl_global_cleanup();
return TEST_ERR_MAJOR_BAD;
}
)
moo = fopen(libtest_arg2, "wb");
if(moo) {
- fprintf(moo, "CL %.0f\n", content_length);
+ curl_mfprintf(moo, "CL %.0f\n", content_length);
fclose(moo);
}
}
curl = curl_easy_init();
if(!curl) {
- fprintf(stderr, "curl_easy_init() failed\n");
+ curl_mfprintf(stderr, "curl_easy_init() failed\n");
curl_global_cleanup();
return TEST_ERR_MAJOR_BAD;
}
mime = curl_mime_init(curl);
if(!mime) {
- fprintf(stderr, "curl_mime_init() failed\n");
+ curl_mfprintf(stderr, "curl_mime_init() failed\n");
curl_easy_cleanup(curl);
curl_global_cleanup();
return TEST_ERR_MAJOR_BAD;
part = curl_mime_addpart(mime);
if(!part) {
- fprintf(stderr, "curl_mime_addpart(1) failed\n");
+ curl_mfprintf(stderr, "curl_mime_addpart(1) failed\n");
curl_mime_free(mime);
curl_easy_cleanup(curl);
curl_global_cleanup();
}
if(res)
- printf("curl_mime_xxx(1) = %s\n", curl_easy_strerror(res));
+ curl_mprintf("curl_mime_xxx(1) = %s\n", curl_easy_strerror(res));
/* Now add the same data with another name and make it not look like
a file upload but still using the callback */
part = curl_mime_addpart(mime);
if(!part) {
- fprintf(stderr, "curl_mime_addpart(2) failed\n");
+ curl_mfprintf(stderr, "curl_mime_addpart(2) failed\n");
curl_mime_free(mime);
curl_easy_cleanup(curl);
curl_global_cleanup();
NULL, NULL, &pooh2);
if(res)
- printf("curl_mime_xxx(2) = %s\n", curl_easy_strerror(res));
+ curl_mprintf("curl_mime_xxx(2) = %s\n", curl_easy_strerror(res));
part = curl_mime_addpart(mime);
if(!part) {
- fprintf(stderr, "curl_mime_addpart(3) failed\n");
+ curl_mfprintf(stderr, "curl_mime_addpart(3) failed\n");
curl_mime_free(mime);
curl_easy_cleanup(curl);
curl_global_cleanup();
CURL_ZERO_TERMINATED);
if(res)
- printf("curl_mime_xxx(3) = %s\n", curl_easy_strerror(res));
+ curl_mprintf("curl_mime_xxx(3) = %s\n", curl_easy_strerror(res));
/* Fill in a submit field too */
part = curl_mime_addpart(mime);
if(!part) {
- fprintf(stderr, "curl_mime_addpart(4) failed\n");
+ curl_mfprintf(stderr, "curl_mime_addpart(4) failed\n");
curl_mime_free(mime);
curl_easy_cleanup(curl);
curl_global_cleanup();
CURL_ZERO_TERMINATED);
if(res)
- printf("curl_mime_xxx(4) = %s\n", curl_easy_strerror(res));
+ curl_mprintf("curl_mime_xxx(4) = %s\n", curl_easy_strerror(res));
part = curl_mime_addpart(mime);
if(!part) {
- fprintf(stderr, "curl_mime_addpart(5) failed\n");
+ curl_mfprintf(stderr, "curl_mime_addpart(5) failed\n");
curl_mime_free(mime);
curl_easy_cleanup(curl);
curl_global_cleanup();
res = curl_mime_data(part, "blah blah", 9);
if(res)
- printf("curl_mime_xxx(5) = %s\n", curl_easy_strerror(res));
+ curl_mprintf("curl_mime_xxx(5) = %s\n", curl_easy_strerror(res));
/* First set the URL that is about to receive our POST. */
test_setopt(curl, CURLOPT_URL, URL);
CURLcode res;
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
- fprintf(stderr, "curl_global_init() failed\n");
+ curl_mfprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
long contentlength = 0;
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
- fprintf(stderr, "curl_global_init() failed\n");
+ curl_mfprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
CURLFORM_END);
)
if(formrc) {
- printf("curl_formadd(1) = %d\n", (int) formrc);
+ curl_mprintf("curl_formadd(1) = %d\n", (int) formrc);
goto test_cleanup;
}
CURLFORM_END);
)
if(formrc) {
- printf("curl_formadd(2) = %d\n", (int) formrc);
+ curl_mprintf("curl_formadd(2) = %d\n", (int) formrc);
goto test_cleanup;
}
CURLFORM_END);
)
if(formrc) {
- printf("curl_formadd(3) = %d\n", (int) formrc);
+ curl_mprintf("curl_formadd(3) = %d\n", (int) formrc);
goto test_cleanup;
}
CURLFORM_END);
)
if(formrc) {
- printf("curl_formadd(4) = %d\n", (int) formrc);
+ curl_mprintf("curl_formadd(4) = %d\n", (int) formrc);
goto test_cleanup;
}
CURLFORM_END);
)
if(formrc) {
- printf("curl_formadd(5) = %d\n", (int) formrc);
+ curl_mprintf("curl_formadd(5) = %d\n", (int) formrc);
goto test_cleanup;
}
CURLFORM_END);
)
if(formrc) {
- printf("curl_formadd(6) = %d\n", (int) formrc);
+ curl_mprintf("curl_formadd(6) = %d\n", (int) formrc);
goto test_cleanup;
}
curl = curl_easy_init();
if(!curl) {
- fprintf(stderr, "curl_easy_init() failed\n");
+ curl_mfprintf(stderr, "curl_easy_init() failed\n");
goto test_cleanup;
}
testbuf[sizeof(testbuf)-1] = 0; /* null-terminate */
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
- fprintf(stderr, "curl_global_init() failed\n");
+ curl_mfprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
CURLFORM_END);
)
if(formrc)
- printf("curl_formadd(1) = %d\n", (int) formrc);
+ curl_mprintf("curl_formadd(1) = %d\n", (int) formrc);
curl = curl_easy_init();
if(!curl) {
- fprintf(stderr, "curl_easy_init() failed\n");
+ curl_mfprintf(stderr, "curl_easy_init() failed\n");
CURL_IGNORE_DEPRECATION(
curl_formfree(formpost);
)
memset(&testbuf[i * 10], 65 + (i % 26), 10);
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
- fprintf(stderr, "curl_global_init() failed\n");
+ curl_mfprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
curl = curl_easy_init();
if(!curl) {
- fprintf(stderr, "curl_easy_init() failed\n");
+ curl_mfprintf(stderr, "curl_easy_init() failed\n");
res = TEST_ERR_MAJOR_BAD;
goto test_cleanup;
}
/* Build mime structure. */
mime = curl_mime_init(curl);
if(!mime) {
- fprintf(stderr, "curl_mime_init() failed\n");
+ curl_mfprintf(stderr, "curl_mime_init() failed\n");
res = TEST_ERR_MAJOR_BAD;
goto test_cleanup;
}
part = curl_mime_addpart(mime);
if(!part) {
- fprintf(stderr, "curl_mime_addpart() failed\n");
+ curl_mfprintf(stderr, "curl_mime_addpart() failed\n");
res = TEST_ERR_MAJOR_BAD;
goto test_cleanup;
}
res = curl_mime_filename(part, "myfile.jpg");
if(res) {
- fprintf(stderr, "curl_mime_filename() failed\n");
+ curl_mfprintf(stderr, "curl_mime_filename() failed\n");
goto test_cleanup;
}
res = curl_mime_type(part, "image/jpeg");
if(res) {
- fprintf(stderr, "curl_mime_type() failed\n");
+ curl_mfprintf(stderr, "curl_mime_type() failed\n");
goto test_cleanup;
}
res = curl_mime_data(part, testbuf, sizeof(testbuf));
if(res) {
- fprintf(stderr, "curl_mime_data() failed\n");
+ curl_mfprintf(stderr, "curl_mime_data() failed\n");
goto test_cleanup;
}
res = curl_mime_encoder(part, "base64");
if(res) {
- fprintf(stderr, "curl_mime_encoder() failed\n");
+ curl_mfprintf(stderr, "curl_mime_encoder() failed\n");
goto test_cleanup;
}
/* Prepare recipients. */
recipients = curl_slist_append(NULL, "someone@example.com");
if(!recipients) {
- fprintf(stderr, "curl_slist_append() failed\n");
+ curl_mfprintf(stderr, "curl_slist_append() failed\n");
goto test_cleanup;
}
*/
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
- fprintf(stderr, "curl_global_init() failed\n");
+ curl_mfprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
/* Duplicate the handle. */
easy2 = curl_easy_duphandle(easy);
if(!easy2) {
- fprintf(stderr, "curl_easy_duphandle() failed\n");
+ curl_mfprintf(stderr, "curl_easy_duphandle() failed\n");
res = TEST_ERR_FAILURE;
goto test_cleanup;
}
/* Perform on the first handle: should not send any data. */
res = curl_easy_perform(easy);
if(res != CURLE_OK) {
- fprintf(stderr, "curl_easy_perform(original) failed\n");
+ curl_mfprintf(stderr, "curl_easy_perform(original) failed\n");
goto test_cleanup;
}
duplicated properly, it should cause a valgrind error. */
res = curl_easy_perform(easy2);
if(res != CURLE_OK) {
- fprintf(stderr, "curl_easy_perform(duplicated) failed\n");
+ curl_mfprintf(stderr, "curl_easy_perform(duplicated) failed\n");
goto test_cleanup;
}
easy2 = NULL; /* Already cleaned up. */
if(pooh.freecount != 2) {
- fprintf(stderr, "free_callback() called %d times instead of 2\n",
+ curl_mfprintf(stderr, "free_callback() called %d times instead of 2\n",
pooh.freecount);
res = TEST_ERR_FAILURE;
goto test_cleanup;
cb_count++;
if(strcmp(userdata, TEST_DATA_STRING)) {
- fprintf(stderr, "Invalid test data received");
+ curl_mfprintf(stderr, "Invalid test data received");
exit(1);
}
cb_count++;
if(strcmp(userdata, TEST_DATA_STRING)) {
- fprintf(stderr, "Invalid test data received");
+ curl_mfprintf(stderr, "Invalid test data received");
exit(1);
}
CURLcode res = CURLE_OK;
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
- fprintf(stderr, "curl_global_init() failed\n");
+ curl_mfprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
curl = curl_easy_init();
if(!curl) {
- fprintf(stderr, "curl_easy_init() failed\n");
+ curl_mfprintf(stderr, "curl_easy_init() failed\n");
res = TEST_ERR_MAJOR_BAD;
goto test_cleanup;
}
/* this should fail */
res = curl_easy_perform(curl);
if(res != CURLE_COULDNT_RESOLVE_HOST) {
- fprintf(stderr, "curl_easy_perform should have returned "
+ curl_mfprintf(stderr, "curl_easy_perform should have returned "
"CURLE_COULDNT_RESOLVE_HOST but instead returned error %d\n", res);
if(res == CURLE_OK)
res = TEST_ERR_FAILURE;
/* this should succeed */
res = curl_easy_perform(curl);
if(res) {
- fprintf(stderr, "curl_easy_perform failed.\n");
+ curl_mfprintf(stderr, "curl_easy_perform failed.\n");
goto test_cleanup;
}
if(cb_count != 2) {
- fprintf(stderr, "Unexpected number of callbacks: %d\n", cb_count);
+ curl_mfprintf(stderr, "Unexpected number of callbacks: %d\n", cb_count);
res = TEST_ERR_FAILURE;
goto test_cleanup;
}
urlp = curl_url();
if(!urlp) {
- fprintf(stderr, "problem init URL api.");
+ curl_mfprintf(stderr, "problem init URL api.");
goto test_cleanup;
}
uc = curl_url_set(urlp, CURLUPART_URL, URL, 0);
if(uc) {
- fprintf(stderr, "problem setting CURLUPART_URL: %s.",
+ curl_mfprintf(stderr, "problem setting CURLUPART_URL: %s.",
curl_url_strerror(uc));
goto test_cleanup;
}
res = curl_easy_perform(handle);
if(res) {
- fprintf(stderr, "%s:%d curl_easy_perform() failed with code %d (%s)\n",
- __FILE__, __LINE__, res, curl_easy_strerror(res));
+ curl_mfprintf(stderr, "%s:%d curl_easy_perform() failed "
+ "with code %d (%s)\n",
+ __FILE__, __LINE__, res, curl_easy_strerror(res));
goto test_cleanup;
}
urlp = curl_url();
if(!urlp) {
- fprintf(stderr, "problem init URL api.");
+ curl_mfprintf(stderr, "problem init URL api.");
goto test_cleanup;
}
if(curl_url_set(urlp, CURLUPART_HOST, "www.example.com", 0) ||
curl_url_set(urlp, CURLUPART_SCHEME, "http", 0) ||
curl_url_set(urlp, CURLUPART_PORT, "80", 0)) {
- fprintf(stderr, "problem setting CURLUPART");
+ curl_mfprintf(stderr, "problem setting CURLUPART");
goto test_cleanup;
}
res = curl_easy_perform(handle);
if(res) {
- fprintf(stderr, "%s:%d curl_easy_perform() failed with code %d (%s)\n",
- __FILE__, __LINE__, res, curl_easy_strerror(res));
+ curl_mfprintf(stderr, "%s:%d curl_easy_perform() failed "
+ "with code %d (%s)\n",
+ __FILE__, __LINE__, res, curl_easy_strerror(res));
goto test_cleanup;
}
struct curl_slist *slist = NULL;
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
- fprintf(stderr, "curl_global_init() failed\n");
+ curl_mfprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
curl = curl_easy_init();
if(!curl) {
- fprintf(stderr, "curl_easy_init() failed\n");
+ curl_mfprintf(stderr, "curl_easy_init() failed\n");
res = TEST_ERR_MAJOR_BAD;
goto test_cleanup;
}
/* test: CURLFTPMETHOD_SINGLECWD with absolute path should
skip CWD to entry path */
- newURL = aprintf("%s/folderA/661", URL);
+ newURL = curl_maprintf("%s/folderA/661", URL);
test_setopt(curl, CURLOPT_URL, newURL);
test_setopt(curl, CURLOPT_VERBOSE, 1L);
test_setopt(curl, CURLOPT_IGNORE_CONTENT_LENGTH, 1L);
goto test_cleanup;
curl_free(newURL);
- newURL = aprintf("%s/folderB/661", URL);
+ newURL = curl_maprintf("%s/folderB/661", URL);
test_setopt(curl, CURLOPT_URL, newURL);
res = curl_easy_perform(curl);
if(res != CURLE_REMOTE_FILE_NOT_FOUND)
curl_easy_cleanup(curl);
curl = curl_easy_init();
if(!curl) {
- fprintf(stderr, "curl_easy_init() failed\n");
+ curl_mfprintf(stderr, "curl_easy_init() failed\n");
res = TEST_ERR_MAJOR_BAD;
goto test_cleanup;
}
curl_free(newURL);
- newURL = aprintf("%s/folderA/661", URL);
+ newURL = curl_maprintf("%s/folderA/661", URL);
test_setopt(curl, CURLOPT_URL, newURL);
test_setopt(curl, CURLOPT_VERBOSE, 1L);
test_setopt(curl, CURLOPT_IGNORE_CONTENT_LENGTH, 1L);
/* curve ball: CWD /folderB before reusing connection with _NOCWD */
curl_free(newURL);
- newURL = aprintf("%s/folderB/661", URL);
+ newURL = curl_maprintf("%s/folderB/661", URL);
test_setopt(curl, CURLOPT_URL, newURL);
test_setopt(curl, CURLOPT_FTP_FILEMETHOD, (long) CURLFTPMETHOD_SINGLECWD);
res = curl_easy_perform(curl);
goto test_cleanup;
curl_free(newURL);
- newURL = aprintf("%s/folderA/661", URL);
+ newURL = curl_maprintf("%s/folderA/661", URL);
test_setopt(curl, CURLOPT_URL, newURL);
test_setopt(curl, CURLOPT_FTP_FILEMETHOD, (long) CURLFTPMETHOD_NOCWD);
res = curl_easy_perform(curl);
curl_easy_cleanup(curl);
curl = curl_easy_init();
if(!curl) {
- fprintf(stderr, "curl_easy_init() failed\n");
+ curl_mfprintf(stderr, "curl_easy_init() failed\n");
res = TEST_ERR_MAJOR_BAD;
goto test_cleanup;
}
slist = curl_slist_append(NULL, "SYST");
if(!slist) {
- fprintf(stderr, "curl_slist_append() failed\n");
+ curl_mfprintf(stderr, "curl_slist_append() failed\n");
res = TEST_ERR_MAJOR_BAD;
goto test_cleanup;
}
curl_easy_cleanup(curl);
curl = curl_easy_init();
if(!curl) {
- fprintf(stderr, "curl_easy_init() failed\n");
+ curl_mfprintf(stderr, "curl_easy_init() failed\n");
res = TEST_ERR_MAJOR_BAD;
goto test_cleanup;
}
test_cleanup:
if(res)
- fprintf(stderr, "test encountered error %d\n", res);
+ curl_mfprintf(stderr, "test encountered error %d\n", res);
curl_slist_free_all(slist);
curl_free(newURL);
curl_easy_cleanup(curl);
testbuf[i] = (char) (0x41 + i % 26); /* A...Z */
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
- fprintf(stderr, "curl_global_init() failed\n");
+ curl_mfprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
curl = curl_easy_init();
if(!curl) {
- fprintf(stderr, "curl_easy_init() failed\n");
+ curl_mfprintf(stderr, "curl_easy_init() failed\n");
res = TEST_ERR_MAJOR_BAD;
goto test_cleanup;
}
/* Build mime structure. */
mime = curl_mime_init(curl);
if(!mime) {
- fprintf(stderr, "curl_mime_init() failed\n");
+ curl_mfprintf(stderr, "curl_mime_init() failed\n");
res = TEST_ERR_MAJOR_BAD;
goto test_cleanup;
}
part = curl_mime_addpart(mime);
if(!part) {
- fprintf(stderr, "curl_mime_addpart() failed\n");
+ curl_mfprintf(stderr, "curl_mime_addpart() failed\n");
res = TEST_ERR_MAJOR_BAD;
goto test_cleanup;
}
res = curl_mime_name(part, "upfile");
if(res) {
- fprintf(stderr, "curl_mime_name() failed\n");
+ curl_mfprintf(stderr, "curl_mime_name() failed\n");
goto test_cleanup;
}
res = curl_mime_filename(part, "myfile.txt");
if(res) {
- fprintf(stderr, "curl_mime_filename() failed\n");
+ curl_mfprintf(stderr, "curl_mime_filename() failed\n");
goto test_cleanup;
}
res = curl_mime_data(part, testbuf, sizeof(testbuf));
if(res) {
- fprintf(stderr, "curl_mime_data() failed\n");
+ curl_mfprintf(stderr, "curl_mime_data() failed\n");
goto test_cleanup;
}
res = curl_mime_encoder(part, "binary");
if(res) {
- fprintf(stderr, "curl_mime_encoder() failed\n");
+ curl_mfprintf(stderr, "curl_mime_encoder() failed\n");
goto test_cleanup;
}
*/
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
- fprintf(stderr, "curl_global_init() failed\n");
+ curl_mfprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
/* Send data. */
res = curl_easy_perform(easy);
if(res != CURLE_OK) {
- fprintf(stderr, "curl_easy_perform() failed\n");
+ curl_mfprintf(stderr, "curl_easy_perform() failed\n");
}
test_cleanup:
*/
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
- fprintf(stderr, "curl_global_init() failed\n");
+ curl_mfprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
/* Send data. */
res = curl_easy_perform(easy);
if(res != CURLE_OK) {
- fprintf(stderr, "curl_easy_perform() failed\n");
+ curl_mfprintf(stderr, "curl_easy_perform() failed\n");
}
test_cleanup:
case 3:
return 0;
}
- fprintf(stderr, "Read callback called after EOF\n");
+ curl_mfprintf(stderr, "Read callback called after EOF\n");
exit(1);
}
time_t delta = time(NULL) - pooh->origin;
if(delta >= 4 * PAUSE_TIME) {
- fprintf(stderr, "unpausing failed: drain problem?\n");
+ curl_mfprintf(stderr, "unpausing failed: drain problem?\n");
return CURLE_ABORTED_BY_CALLBACK;
}
*/
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
- fprintf(stderr, "curl_global_init() failed\n");
+ curl_mfprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
part = curl_mime_addpart(mime);
res = curl_mime_name(part, testname);
if(res != CURLE_OK) {
- fprintf(stderr,
+ curl_mfprintf(stderr,
"Something went wrong when building the mime structure: %d\n",
res);
goto test_cleanup;
CURLFORM_END);
)
if(formrc) {
- fprintf(stderr, "curl_formadd() = %d\n", (int) formrc);
+ curl_mfprintf(stderr, "curl_formadd() = %d\n", (int) formrc);
goto test_cleanup;
}
time_t delta = time(NULL) - pooh.origin;
if(delta >= 4 * PAUSE_TIME) {
- fprintf(stderr, "unpausing failed: drain problem?\n");
+ curl_mfprintf(stderr, "unpausing failed: drain problem?\n");
res = CURLE_OPERATION_TIMEDOUT;
break;
}
#endif
rc = select(maxfd + 1, &fdread, &fdwrite, &fdexcept, &timeout);
if(rc == -1) {
- fprintf(stderr, "Select error\n");
+ curl_mfprintf(stderr, "Select error\n");
break;
}
}
urlp = curl_url();
if(!urlp) {
- fprintf(stderr, "problem init URL api.");
+ curl_mfprintf(stderr, "problem init URL api.");
goto test_cleanup;
}
uc = curl_url_set(urlp, CURLUPART_URL, URL, 0);
if(uc) {
- fprintf(stderr, "problem setting CURLUPART_URL: %s.",
+ curl_mfprintf(stderr, "problem setting CURLUPART_URL: %s.",
curl_url_strerror(uc));
goto test_cleanup;
}
res = curl_easy_perform(handle);
if(res) {
- fprintf(stderr, "%s:%d curl_easy_perform() failed with code %d (%s)\n",
- __FILE__, __LINE__, res, curl_easy_strerror(res));
+ curl_mfprintf(stderr, "%s:%d curl_easy_perform() failed "
+ "with code %d (%s)\n",
+ __FILE__, __LINE__, res, curl_easy_strerror(res));
goto test_cleanup;
}
CURL *curl;
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
- fprintf(stderr, "curl_global_init() failed\n");
+ curl_mfprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
curl = curl_easy_init();
if(!curl) {
- fprintf(stderr, "curl_easy_init() failed\n");
+ curl_mfprintf(stderr, "curl_easy_init() failed\n");
curl_global_cleanup();
return TEST_ERR_MAJOR_BAD;
}
res = curl_easy_perform(curl);
if(res) {
- fprintf(stderr, "retrieve 1 failed\n");
+ curl_mfprintf(stderr, "retrieve 1 failed\n");
goto test_cleanup;
}
res = curl_easy_perform(curl);
if(res)
- fprintf(stderr, "retrieve 2 failed\n");
+ curl_mfprintf(stderr, "retrieve 2 failed\n");
test_cleanup:
curl_easy_getinfo(curl, CURLINFO_ACTIVESOCKET, &sock);
if(sock == CURL_SOCKET_BAD)
goto test_cleanup;
- printf("Connected fine, extracted socket. Moving on\n");
+ curl_mprintf("Connected fine, extracted socket. Moving on\n");
}
}
continue;
}
else if(ec) {
- fprintf(stderr, "curl_easy_send() failed, with code %d (%s)\n",
+ curl_mfprintf(stderr, "curl_easy_send() failed, with code %d (%s)\n",
(int)ec, curl_easy_strerror(ec));
res = ec;
goto test_cleanup;
continue;
}
else if(ec) {
- fprintf(stderr, "curl_easy_recv() failed, with code %d (%s)\n",
+ curl_mfprintf(stderr, "curl_easy_recv() failed, with code %d (%s)\n",
(int)ec, curl_easy_strerror(ec));
res = ec;
goto test_cleanup;
curl = curl_easy_init();
if(!curl) {
- fprintf(stderr, "curl_easy_init() failed\n");
+ curl_mfprintf(stderr, "curl_easy_init() failed\n");
return CURLE_FAILED_INIT;
}
if(e) {
w = curl_easy_setopt(e, CURLOPT_CAINFO_BLOB, &blob);
if(w)
- printf("CURLOPT_CAINFO_BLOB is not supported\n");
+ curl_mprintf("CURLOPT_CAINFO_BLOB is not supported\n");
curl_easy_cleanup(e);
}
res = w;
int count = 0;
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
- fprintf(stderr, "curl_global_init() failed\n");
+ curl_mfprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
curl = curl_easy_init();
if(!curl) {
- fprintf(stderr, "curl_easy_init() failed\n");
+ curl_mfprintf(stderr, "curl_easy_init() failed\n");
curl_global_cleanup();
return TEST_ERR_MAJOR_BAD;
}
if(res)
goto test_cleanup;
if(CURLAUTH_NTLM != usedauth) {
- printf("CURLINFO_HTTPAUTH_USED did not say NTLM\n");
+ curl_mprintf("CURLINFO_HTTPAUTH_USED did not say NTLM\n");
}
/* set a new URL for the second, so that we don't restart NTLM */
*/
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
- fprintf(stderr, "curl_global_init() failed\n");
+ curl_mfprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
/* Check for errors */
if(res != CURLE_OK)
- fprintf(stderr, "curl_easy_perform() 1 failed: %s\n",
+ curl_mfprintf(stderr, "curl_easy_perform() 1 failed: %s\n",
curl_easy_strerror(res));
else {
/* phase two, create a mime struct using the mime1 handle */
res = curl_mime_subparts(part, mime1);
if(res != CURLE_OK)
- fprintf(stderr, "curl_mime_subparts() failed: %sn",
+ curl_mfprintf(stderr, "curl_mime_subparts() failed: %sn",
curl_easy_strerror(res));
else {
mime1 = NULL;
/* Check for errors */
if(res != CURLE_OK)
- fprintf(stderr, "curl_easy_perform() 2 failed: %s\n",
+ curl_mfprintf(stderr, "curl_easy_perform() 2 failed: %s\n",
curl_easy_strerror(res));
}
}
size_t len = strlen(url) + 4 + 1;
char *full_url = malloc(len);
if(!full_url) {
- fprintf(stderr, "Not enough memory for full url\n");
+ curl_mfprintf(stderr, "Not enough memory for full url\n");
return CURLE_OUT_OF_MEMORY;
}
- msnprintf(full_url, len, "%s%04d", url, seq);
- fprintf(stderr, "Sending new request %d to %s with credential %s "
+ curl_msnprintf(full_url, len, "%s%04d", url, seq);
+ curl_mfprintf(stderr, "Sending new request %d to %s with credential %s "
"(auth %ld)\n", seq, full_url, userpwd, auth_scheme);
test_setopt(curl, CURLOPT_URL, full_url);
test_setopt(curl, CURLOPT_VERBOSE, 1L);
if(main_auth_scheme == CURLAUTH_NONE ||
fallback_auth_scheme == CURLAUTH_NONE) {
- fprintf(stderr, "auth schemes not found on commandline\n");
+ curl_mfprintf(stderr, "auth schemes not found on commandline\n");
return TEST_ERR_MAJOR_BAD;
}
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
- fprintf(stderr, "curl_global_init() failed\n");
+ curl_mfprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
curl = curl_easy_init();
if(!curl) {
- fprintf(stderr, "curl_easy_init() failed\n");
+ curl_mfprintf(stderr, "curl_easy_init() failed\n");
curl_global_cleanup();
return TEST_ERR_MAJOR_BAD;
}
/* Send wrong password twice, then right password */
curl = curl_easy_init();
if(!curl) {
- fprintf(stderr, "curl_easy_init() failed\n");
+ curl_mfprintf(stderr, "curl_easy_init() failed\n");
curl_global_cleanup();
return TEST_ERR_MAJOR_BAD;
}
code = curl_easy_getinfo(ntlm_easy[idx], CURLINFO_LASTSOCKET, &longdata);
)
if(CURLE_OK != code) {
- fprintf(stderr, "%s:%d curl_easy_getinfo() failed, "
+ curl_mfprintf(stderr, "%s:%d curl_easy_getinfo() failed, "
"with code %d (%s)\n",
__FILE__, __LINE__, (int)code, curl_easy_strerror(code));
ntlmcb_res = TEST_ERR_MAJOR_BAD;
else if(sock != ntlm_sockets[idx]) {
/* An easy handle with a socket different to previously
tracked one, log and fail right away. Known bug #37. */
- fprintf(stderr, "Handle %d started on socket %d and moved to %d\n",
+ curl_mfprintf(stderr, "Handle %d started on socket %d and moved to %d\n",
curlx_sztosi(idx), (int)ntlm_sockets[idx], (int)sock);
ntlmcb_res = TEST_ERR_MAJOR_BAD;
return failure;
start_test_timing();
if(!full_url) {
- fprintf(stderr, "Not enough memory for full url\n");
+ curl_mfprintf(stderr, "Not enough memory for full url\n");
return TEST_ERR_MAJOR_BAD;
}
easy_init(ntlm_easy[num_handles]);
if(num_handles % 3 == 2) {
- msnprintf(full_url, urllen, "%s0200", url);
+ curl_msnprintf(full_url, urllen, "%s0200", url);
easy_setopt(ntlm_easy[num_handles], CURLOPT_HTTPAUTH, CURLAUTH_NTLM);
}
else {
- msnprintf(full_url, urllen, "%s0100", url);
+ curl_msnprintf(full_url, urllen, "%s0100", url);
easy_setopt(ntlm_easy[num_handles], CURLOPT_HTTPAUTH, CURLAUTH_BASIC);
}
easy_setopt(ntlm_easy[num_handles], CURLOPT_FRESH_CONNECT, 1L);
multi_perform(multi, &running);
- fprintf(stderr, "%s:%d running %d state %d\n",
+ curl_mfprintf(stderr, "%s:%d running %d state %d\n",
__FILE__, __LINE__, running, state);
abort_on_test_timeout();
if(state == NeedSocketForNewHandle) {
if(maxfd != -1 && !found_new_socket) {
- fprintf(stderr, "Warning: socket did not open immediately for new "
- "handle (trying again)\n");
+ curl_mfprintf(stderr,
+ "Warning: socket did not open immediately for new "
+ "handle (trying again)\n");
continue;
}
state = num_handles < MAX_EASY_HANDLES ? ReadyForNewHandle
: NoMoreHandles;
- fprintf(stderr, "%s:%d new state %d\n",
- __FILE__, __LINE__, state);
+ curl_mfprintf(stderr, "%s:%d new state %d\n",
+ __FILE__, __LINE__, state);
}
multi_timeout(multi, &timeout);
/* At this point, timeout is guaranteed to be greater or equal than -1. */
- fprintf(stderr, "%s:%d num_handles %d timeout %ld running %d\n",
- __FILE__, __LINE__, num_handles, timeout, running);
+ curl_mfprintf(stderr, "%s:%d num_handles %d timeout %ld running %d\n",
+ __FILE__, __LINE__, num_handles, timeout, running);
if(timeout != -1L) {
int itimeout;
/* proper cleanup sequence - type PB */
for(i = 0; i < MAX_EASY_HANDLES; i++) {
- printf("Data connection %d: %d\n", i, ntlm_counter[i]);
+ curl_mprintf("Data connection %d: %d\n", i, ntlm_counter[i]);
curl_multi_remove_handle(multi, ntlm_easy[i]);
curl_easy_cleanup(ntlm_easy[i]);
}
PRCS *prereq_cb = (PRCS *)clientp;
if(prereq_cb->ipv6) {
- printf("Connected to [%s]\n", conn_primary_ip);
- printf("Connected from [%s]\n", conn_local_ip);
+ curl_mprintf("Connected to [%s]\n", conn_primary_ip);
+ curl_mprintf("Connected from [%s]\n", conn_local_ip);
}
else {
- printf("Connected to %s\n", conn_primary_ip);
- printf("Connected from %s\n", conn_local_ip);
+ curl_mprintf("Connected to %s\n", conn_primary_ip);
+ curl_mprintf("Connected from %s\n", conn_local_ip);
}
- printf("Remote port = %d\n", conn_primary_port);
- printf("Local port = %d\n", conn_local_port);
- printf("Returning = %d\n", prereq_cb->prereq_retcode);
+ curl_mprintf("Remote port = %d\n", conn_primary_port);
+ curl_mprintf("Local port = %d\n", conn_local_port);
+ curl_mprintf("Returning = %d\n", prereq_cb->prereq_retcode);
return prereq_cb->prereq_retcode;
}
ret = curl_easy_perform(curl);
if(ret) {
- fprintf(stderr, "%s:%d curl_easy_perform() failed with code %d (%s)\n",
- __FILE__, __LINE__, ret, curl_easy_strerror(ret));
+ curl_mfprintf(stderr,
+ "%s:%d curl_easy_perform() failed with code %d (%s)\n",
+ __FILE__, __LINE__, ret, curl_easy_strerror(ret));
goto test_cleanup;
}
}
--- /dev/null
+/***************************************************************************
+ * _ _ ____ _
+ * Project ___| | | | _ \| |
+ * / __| | | | |_) | |
+ * | (__| |_| | _ <| |___
+ * \___|\___/|_| \_\_____|
+ *
+ * Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al.
+ *
+ * This software is licensed as described in the file COPYING, which
+ * you should have received as part of this distribution. The terms
+ * are also available at https://curl.se/docs/copyright.html.
+ *
+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
+ * copies of the Software, and permit persons to whom the Software is
+ * furnished to do so, under the terms of the COPYING file.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ * SPDX-License-Identifier: curl
+ *
+ ***************************************************************************/
+#include "test.h"
+#include "curl_memory.h"
+
+#ifndef CURL_STATICLIB
+
+#if defined(_MSC_VER) && defined(_DLL)
+# pragma warning(push)
+# pragma warning(disable:4232) /* MSVC extension, dllimport identity */
+#endif
+
+/* when libcurl is *not* static and we build libtests, the global pointers in
+ curl_memory.c is not available unless we provide them like this */
+
+curl_malloc_callback Curl_cmalloc = (curl_malloc_callback)malloc;
+curl_free_callback Curl_cfree = (curl_free_callback)free;
+curl_realloc_callback Curl_crealloc = (curl_realloc_callback)realloc;
+curl_strdup_callback Curl_cstrdup = (curl_strdup_callback)strdup;
+curl_calloc_callback Curl_ccalloc = (curl_calloc_callback)calloc;
+#if defined(_WIN32) && defined(UNICODE)
+curl_wcsdup_callback Curl_cwcsdup = wcsdup;
+#endif
+
+#if defined(_MSC_VER) && defined(_DLL)
+# pragma warning(pop)
+#endif
+
+#endif /* !CURL_STATICLIB */
#define exe_easy_init(A,Y,Z) do { \
if(((A) = curl_easy_init()) == NULL) { \
- fprintf(stderr, "%s:%d curl_easy_init() failed\n", (Y), (Z)); \
+ curl_mfprintf(stderr, "%s:%d curl_easy_init() failed\n", (Y), (Z)); \
res = TEST_ERR_EASY_INIT; \
} \
} while(0)
#define exe_multi_init(A,Y,Z) do { \
if(((A) = curl_multi_init()) == NULL) { \
- fprintf(stderr, "%s:%d curl_multi_init() failed\n", (Y), (Z)); \
+ curl_mfprintf(stderr, "%s:%d curl_multi_init() failed\n", (Y), (Z)); \
res = TEST_ERR_MULTI; \
} \
} while(0)
#define exe_easy_setopt(A,B,C,Y,Z) do { \
CURLcode ec; \
if((ec = curl_easy_setopt((A), (B), (C))) != CURLE_OK) { \
- fprintf(stderr, "%s:%d curl_easy_setopt() failed, " \
+ curl_mfprintf(stderr, "%s:%d curl_easy_setopt() failed, " \
"with code %d (%s)\n", \
(Y), (Z), (int)ec, curl_easy_strerror(ec)); \
res = ec; \
#define exe_multi_setopt(A, B, C, Y, Z) do { \
CURLMcode ec; \
if((ec = curl_multi_setopt((A), (B), (C))) != CURLM_OK) { \
- fprintf(stderr, "%s:%d curl_multi_setopt() failed, " \
+ curl_mfprintf(stderr, "%s:%d curl_multi_setopt() failed, " \
"with code %d (%s)\n", \
(Y), (Z), (int)ec, curl_multi_strerror(ec)); \
res = TEST_ERR_MULTI; \
#define exe_multi_add_handle(A,B,Y,Z) do { \
CURLMcode ec; \
if((ec = curl_multi_add_handle((A), (B))) != CURLM_OK) { \
- fprintf(stderr, "%s:%d curl_multi_add_handle() failed, " \
+ curl_mfprintf(stderr, "%s:%d curl_multi_add_handle() failed, " \
"with code %d (%s)\n", \
(Y), (Z), (int)ec, curl_multi_strerror(ec)); \
res = TEST_ERR_MULTI; \
#define exe_multi_remove_handle(A,B,Y,Z) do { \
CURLMcode ec; \
if((ec = curl_multi_remove_handle((A), (B))) != CURLM_OK) { \
- fprintf(stderr, "%s:%d curl_multi_remove_handle() failed, " \
+ curl_mfprintf(stderr, "%s:%d curl_multi_remove_handle() failed, " \
"with code %d (%s)\n", \
(Y), (Z), (int)ec, curl_multi_strerror(ec)); \
res = TEST_ERR_MULTI; \
#define exe_multi_perform(A,B,Y,Z) do { \
CURLMcode ec; \
if((ec = curl_multi_perform((A), (B))) != CURLM_OK) { \
- fprintf(stderr, "%s:%d curl_multi_perform() failed, " \
+ curl_mfprintf(stderr, "%s:%d curl_multi_perform() failed, " \
"with code %d (%s)\n", \
(Y), (Z), (int)ec, curl_multi_strerror(ec)); \
res = TEST_ERR_MULTI; \
} \
else if(*((B)) < 0) { \
- fprintf(stderr, "%s:%d curl_multi_perform() succeeded, " \
+ curl_mfprintf(stderr, "%s:%d curl_multi_perform() succeeded, " \
"but returned invalid running_handles value (%d)\n", \
(Y), (Z), (int)*((B))); \
res = TEST_ERR_NUM_HANDLES; \
#define exe_multi_fdset(A, B, C, D, E, Y, Z) do { \
CURLMcode ec; \
if((ec = curl_multi_fdset((A), (B), (C), (D), (E))) != CURLM_OK) { \
- fprintf(stderr, "%s:%d curl_multi_fdset() failed, " \
+ curl_mfprintf(stderr, "%s:%d curl_multi_fdset() failed, " \
"with code %d (%s)\n", \
(Y), (Z), (int)ec, curl_multi_strerror(ec)); \
res = TEST_ERR_MULTI; \
} \
else if(*((E)) < -1) { \
- fprintf(stderr, "%s:%d curl_multi_fdset() succeeded, " \
+ curl_mfprintf(stderr, "%s:%d curl_multi_fdset() succeeded, " \
"but returned invalid max_fd value (%d)\n", \
(Y), (Z), (int)*((E))); \
res = TEST_ERR_NUM_HANDLES; \
#define exe_multi_timeout(A,B,Y,Z) do { \
CURLMcode ec; \
if((ec = curl_multi_timeout((A), (B))) != CURLM_OK) { \
- fprintf(stderr, "%s:%d curl_multi_timeout() failed, " \
+ curl_mfprintf(stderr, "%s:%d curl_multi_timeout() failed, " \
"with code %d (%s)\n", \
(Y), (Z), (int)ec, curl_multi_strerror(ec)); \
res = TEST_ERR_BAD_TIMEOUT; \
} \
else if(*((B)) < -1L) { \
- fprintf(stderr, "%s:%d curl_multi_timeout() succeeded, " \
+ curl_mfprintf(stderr, "%s:%d curl_multi_timeout() succeeded, " \
"but returned invalid timeout value (%ld)\n", \
(Y), (Z), (long)*((B))); \
res = TEST_ERR_BAD_TIMEOUT; \
#define exe_multi_poll(A,B,C,D,E,Y,Z) do { \
CURLMcode ec; \
if((ec = curl_multi_poll((A), (B), (C), (D), (E))) != CURLM_OK) { \
- fprintf(stderr, "%s:%d curl_multi_poll() failed, " \
+ curl_mfprintf(stderr, "%s:%d curl_multi_poll() failed, " \
"with code %d (%s)\n", \
(Y), (Z), (int)ec, curl_multi_strerror(ec)); \
res = TEST_ERR_MULTI; \
} \
else if(*((E)) < 0) { \
- fprintf(stderr, "%s:%d curl_multi_poll() succeeded, " \
+ curl_mfprintf(stderr, "%s:%d curl_multi_poll() succeeded, " \
"but returned invalid numfds value (%d)\n", \
(Y), (Z), (int)*((E))); \
res = TEST_ERR_NUM_HANDLES; \
#define exe_multi_wakeup(A,Y,Z) do { \
CURLMcode ec; \
if((ec = curl_multi_wakeup((A))) != CURLM_OK) { \
- fprintf(stderr, "%s:%d curl_multi_wakeup() failed, " \
+ curl_mfprintf(stderr, "%s:%d curl_multi_wakeup() failed, " \
"with code %d (%s)\n", \
(Y), (Z), (int)ec, curl_multi_strerror(ec)); \
res = TEST_ERR_MULTI; \
int ec; \
if(select_wrapper((A), (B), (C), (D), (E)) == -1) { \
ec = SOCKERRNO; \
- fprintf(stderr, "%s:%d select() failed, with " \
+ curl_mfprintf(stderr, "%s:%d select() failed, with " \
"errno %d (%s)\n", \
(Y), (Z), ec, strerror(ec)); \
res = TEST_ERR_SELECT; \
#define exe_test_timedout(Y,Z) do { \
long timediff = tutil_tvdiff(tutil_tvnow(), tv_test_start); \
if(timediff > (TEST_HANG_TIMEOUT)) { \
- fprintf(stderr, "%s:%d ABORTING TEST, since it seems " \
+ curl_mfprintf(stderr, "%s:%d ABORTING TEST, since it seems " \
"that it would have run forever (%ld ms > %ld ms)\n", \
(Y), (Z), timediff, (long) (TEST_HANG_TIMEOUT)); \
res = TEST_ERR_RUNS_FOREVER; \
#define exe_global_init(A,Y,Z) do { \
CURLcode ec; \
if((ec = curl_global_init((A))) != CURLE_OK) { \
- fprintf(stderr, "%s:%d curl_global_init() failed, " \
+ curl_mfprintf(stderr, "%s:%d curl_global_init() failed, " \
"with code %d (%s)\n", \
(Y), (Z), (int)ec, curl_easy_strerror(ec)); \
res = ec; \
CURLcode test(char *URL) \
{ \
(void)URL; \
- fprintf(stderr, "Missing support\n"); \
+ curl_mfprintf(stderr, "Missing support\n"); \
return CURLE_UNSUPPORTED_PROTOCOL; \
}
#endif
CURLcode test(char *URL) \
{ \
(void)URL; \
- fprintf(stderr, "Missing support\n"); \
+ curl_mfprintf(stderr, "Missing support\n"); \
return CURLE_UNSUPPORTED_PROTOCOL; \
}
#endif
/* without the hex output, we can fit more on screen */
width = 0x40;
- fprintf(stream, "%s%s, %zu bytes (0x%zx)\n", timebuf, text,
- size, size);
+ curl_mfprintf(stream, "%s%s, %zu bytes (0x%zx)\n", timebuf, text,
+ size, size);
for(i = 0; i < size; i += width) {
- fprintf(stream, "%04zx: ", i);
+ curl_mfprintf(stream, "%04zx: ", i);
if(!nohex) {
/* hex not disabled, show it */
for(c = 0; c < width; c++)
if(i + c < size)
- fprintf(stream, "%02x ", ptr[i + c]);
+ curl_mfprintf(stream, "%02x ", ptr[i + c]);
else
fputs(" ", stream);
}
i += (c + 2 - width);
break;
}
- fprintf(stream, "%c", ((ptr[i + c] >= 0x20) && (ptr[i + c] < 0x80)) ?
- ptr[i + c] : '.');
+ curl_mfprintf(stream, "%c",
+ ((ptr[i + c] >= 0x20) && (ptr[i + c] < 0x80)) ?
+ ptr[i + c] : '.');
/* check again for 0D0A, to avoid an extra \n if it's at width */
if(nohex &&
(i + c + 2 < size) && (ptr[i + c + 1] == 0x0D) &&
}
secs = epoch_offset + tv.tv_sec;
now = localtime(&secs); /* not thread safe but we don't care */
- msnprintf(timebuf, sizeof(timebuf), "%02d:%02d:%02d.%06ld ",
- now->tm_hour, now->tm_min, now->tm_sec, (long)tv.tv_usec);
+ curl_msnprintf(timebuf, sizeof(timebuf), "%02d:%02d:%02d.%06ld ",
+ now->tm_hour, now->tm_min, now->tm_sec, (long)tv.tv_usec);
}
switch(type) {
case CURLINFO_TEXT:
- fprintf(stderr, "%s== Info: %s", timestr, (char *)data);
+ curl_mfprintf(stderr, "%s== Info: %s", timestr, (char *)data);
return 0;
case CURLINFO_HEADER_OUT:
text = "=> Send header";
target_include_directories(${_target_name} PRIVATE
"${PROJECT_BINARY_DIR}/lib" # for "curl_config.h"
"${PROJECT_SOURCE_DIR}/lib" # for "curl_setup.h"
+ "${PROJECT_SOURCE_DIR}/lib/curlx" # for curlx
"${PROJECT_SOURCE_DIR}/src" # for "tool_binmode.h", "tool_xattr.h"
"${PROJECT_SOURCE_DIR}/tests/server" # for "first.h"
)
AM_CPPFLAGS = -I$(top_srcdir)/include \
-I$(top_builddir)/lib \
-I$(top_srcdir)/lib \
+ -I$(top_srcdir)/lib/curlx \
-I$(top_srcdir)/src \
-I$(top_srcdir)/tests/server
CURLX_SRCS = \
../../lib/mprintf.c \
../../lib/nonblock.c \
- ../../lib/strparse.c \
+ ../../lib/curlx/strparse.c \
../../lib/strequal.c \
- ../../lib/warnless.c \
- ../../lib/timediff.c \
- ../../lib/timeval.c \
- ../../lib/dynbuf.c \
+ ../../lib/curlx/warnless.c \
+ ../../lib/curlx/timediff.c \
+ ../../lib/curlx/timeval.c \
+ ../../lib/curlx/dynbuf.c \
../../lib/strcase.c \
../../lib/strdup.c \
../../lib/curl_get_line.c \
../../lib/version_win32.c
CURLX_HDRS = \
- ../../lib/curlx.h \
+ ../../lib/curlx/curlx.h \
../../lib/curl_ctype.h \
../../lib/nonblock.h \
../../lib/strcase.h \
- ../../lib/warnless.h \
- ../../lib/timediff.h \
- ../../lib/timeval.h \
- ../../lib/dynbuf.h \
+ ../../lib/curlx/warnless.h \
+ ../../lib/curlx/timediff.h \
+ ../../lib/curlx/timeval.h \
+ ../../lib/curlx/dynbuf.h \
../../lib/strcase.h \
../../lib/strdup.h \
../../lib/curl_get_line.h \
util.c \
util.h \
server_setup.h \
- ../../lib/base64.c \
- ../../lib/curl_base64.h \
+ ../../lib/curlx/base64.c \
+ ../../lib/curlx/base64.h \
../../lib/strerror.c \
../../lib/strerror.h
#include <ctype.h>
-#include "curlx.h" /* from the private lib dir */
+#include <curlx.h> /* from the private lib dir */
#include "getpart.h"
#include "util.h"
#include "server_sockaddr.h"
#include "curl/curl.h"
#include "warnless.h"
#else
-#include "curlx.h" /* from the private lib dir */
+#include <curlx.h> /* from the private lib dir */
#endif
-#include "curl_base64.h"
#include "curl_memory.h"
#ifndef TEST
#include <netdb.h>
#endif
-#include "curlx.h" /* from the private lib dir */
+#include <curlx.h> /* from the private lib dir */
#include "getpart.h"
#include "server_sockaddr.h"
-#include "warnless.h"
#include "tool_binmode.h"
#include <netinet/tcp.h> /* for TCP_NODELAY */
#endif
-#include "curlx.h" /* from the private lib dir */
+#include <curlx.h> /* from the private lib dir */
#include "getpart.h"
#include "util.h"
#include "server_sockaddr.h"
if(got_exit_signal)
return 1; /* done */
- if((req->cl == 0) && strncasecompare("Content-Length:", line, 15)) {
+ if((req->cl == 0) && curl_strnequal("Content-Length:", line, 15)) {
/* If we don't ignore content-length, we read it and we read the whole
request including the body before we return. If we've been told to
ignore the content-length, we will return as soon as all headers
logmsg("... but will abort after %zu bytes", req->cl);
break;
}
- else if(strncasecompare("Transfer-Encoding: chunked", line,
+ else if(curl_strnequal("Transfer-Encoding: chunked", line,
strlen("Transfer-Encoding: chunked"))) {
/* chunked data coming in */
chunked = TRUE;
#include <netdb.h>
#endif
-#include "curlx.h" /* from the private lib dir */
+#include <curlx.h> /* from the private lib dir */
#include "inet_pton.h"
#include "util.h"
#include "server_sockaddr.h"
#include "timediff.h"
-#include "warnless.h"
#include "tool_binmode.h"
#include <netdb.h>
#endif
-#include "curlx.h" /* from the private lib dir */
+#include <curlx.h> /* from the private lib dir */
#include "inet_pton.h"
#include "util.h"
#include "server_sockaddr.h"
-#include "warnless.h"
-
#include "tool_binmode.h"
/* include memdebug.h last */
#include <netinet/tcp.h> /* for TCP_NODELAY */
#endif
-#include "curlx.h" /* from the private lib dir */
+#include <curlx.h> /* from the private lib dir */
#include "getpart.h"
#include "inet_pton.h"
#include "util.h"
if(got_exit_signal)
return 1; /* done */
- if((req->cl == 0) && strncasecompare("Content-Length:", line, 15)) {
+ if((req->cl == 0) && curl_strnequal("Content-Length:", line, 15)) {
/* If we don't ignore content-length, we read it and we read the whole
request including the body before we return. If we've been told to
ignore the content-length, we will return as soon as all headers
if(req->skip)
logmsg("... but will abort after %zu bytes", req->cl);
}
- else if(strncasecompare("Transfer-Encoding: chunked", line,
+ else if(curl_strnequal("Transfer-Encoding: chunked", line,
strlen("Transfer-Encoding: chunked"))) {
/* chunked data coming in */
chunked = TRUE;
}
else if(req->noexpect &&
- strncasecompare("Expect: 100-continue", line,
+ curl_strnequal("Expect: 100-continue", line,
strlen("Expect: 100-continue"))) {
if(req->cl)
req->cl = 0;
#include <ctype.h>
-#include "curlx.h" /* from the private lib dir */
+#include <curlx.h> /* from the private lib dir */
#include "getpart.h"
#include "util.h"
#include "server_sockaddr.h"
#include "strerror.h"
#endif
-#include "curlx.h" /* from the private lib dir */
+#include <curlx.h> /* from the private lib dir */
#include "util.h"
/* need init from main() */
***************************************************************************/
#include "server_setup.h"
+#include <curl/mprintf.h>
+
+/* make the test servers use the libcurl *printf family */
+# undef printf
+# undef fprintf
+# undef msnprintf
+# undef vprintf
+# undef vfprintf
+# undef mvsnprintf
+# undef aprintf
+# undef vaprintf
+# define printf curl_mprintf
+# define fprintf curl_mfprintf
+# define msnprintf curl_msnprintf
+# define vprintf curl_mvprintf
+# define vfprintf curl_mvfprintf
+# define mvsnprintf curl_mvsnprintf
+# define aprintf curl_maprintf
+# define vaprintf curl_mvaprintf
+
enum {
DOCNUMBER_NOTHING = -7,
DOCNUMBER_QUIT = -6,
target_include_directories(${_target_name} PRIVATE
"${PROJECT_BINARY_DIR}/lib" # for "curl_config.h"
"${PROJECT_SOURCE_DIR}/lib" # for "curl_setup.h"
+ "${PROJECT_SOURCE_DIR}/lib/curlx" # for curlx
"${PROJECT_SOURCE_DIR}/src"
"${PROJECT_SOURCE_DIR}/tests/libtest"
"${PROJECT_SOURCE_DIR}/tests/unit" # for curlcheck.h
AM_CPPFLAGS = -I$(top_srcdir)/include \
-I$(top_builddir)/lib \
-I$(top_srcdir)/lib \
+ -I$(top_srcdir)/lib/curlx \
-I$(top_srcdir)/src \
-I$(top_srcdir)/tests/libtest \
-I$(top_srcdir)/tests/unit \
LIBS = $(BLANK_AT_MAKETIME)
LDADD = $(top_builddir)/src/libcurltool.la \
- $(top_builddir)/lib/libcurlu.la \
+ $(top_builddir)/lib/libcurl.la \
@LIBCURL_PC_LDFLAGS_PRIVATE@ @LIBCURL_PC_LIBS_PRIVATE@
AM_CPPFLAGS += -DCURL_STATICLIB -DUNITTESTS
target_include_directories(${_target_name} PRIVATE
"${PROJECT_BINARY_DIR}/lib" # for "curl_config.h"
"${PROJECT_SOURCE_DIR}/lib" # for "curl_setup.h"
+ "${PROJECT_SOURCE_DIR}/lib/curlx" # for curlx
"${PROJECT_SOURCE_DIR}/src"
"${PROJECT_SOURCE_DIR}/tests/libtest"
)
AM_CPPFLAGS = -I$(top_srcdir)/include \
-I$(top_builddir)/lib \
-I$(top_srcdir)/lib \
+ -I$(top_srcdir)/lib/curlx \
-I$(top_srcdir)/src \
-I$(top_srcdir)/tests/libtest \
-I$(top_srcdir)/tests/unit
#include "test.h"
/* The fail macros mark the current test step as failed, and continue */
-#define fail_if(expr, msg) \
+#define fail_if(expr, msg) \
+ do { \
+ if(expr) { \
+ curl_mfprintf(stderr, "%s:%d FAILED Assertion '%s' met: %s\n", \
+ __FILE__, __LINE__, #expr, msg); \
+ unitfail++; \
+ } \
+ } while(0)
+
+#define fail_unless(expr, msg) \
do { \
- if(expr) { \
- fprintf(stderr, "%s:%d FAILED Assertion '%s' met: %s\n", \
- __FILE__, __LINE__, #expr, msg); \
+ if(!(expr)) { \
+ curl_mfprintf(stderr, "%s:%d Assertion '%s' FAILED: %s\n", \
+ __FILE__, __LINE__, #expr, msg); \
unitfail++; \
} \
} while(0)
-#define fail_unless(expr, msg) \
- do { \
- if(!(expr)) { \
- fprintf(stderr, "%s:%d Assertion '%s' FAILED: %s\n", \
- __FILE__, __LINE__, #expr, msg); \
- unitfail++; \
- } \
- } while(0)
-
#define verify_memory(dynamic, check, len) \
do { \
if(dynamic && memcmp(dynamic, check, len)) { \
- fprintf(stderr, "%s:%d Memory buffer FAILED match size %d. " \
- "'%s' is not\n", __FILE__, __LINE__, len, \
- hexdump((const unsigned char *)check, len)); \
- fprintf(stderr, "%s:%d the same as '%s'\n", __FILE__, __LINE__, \
- hexdump((const unsigned char *)dynamic, len)); \
+ curl_mfprintf(stderr, "%s:%d Memory buffer FAILED match size %d. " \
+ "'%s' is not\n", __FILE__, __LINE__, len, \
+ hexdump((const unsigned char *)check, len)); \
+ curl_mfprintf(stderr, "%s:%d the same as '%s'\n", __FILE__, __LINE__, \
+ hexdump((const unsigned char *)dynamic, len)); \
unitfail++; \
} \
} while(0)
/* fail() is for when the test case figured out by itself that a check
proved a failure */
-#define fail(msg) do { \
- fprintf(stderr, "%s:%d test FAILED: '%s'\n", \
- __FILE__, __LINE__, msg); \
- unitfail++; \
+#define fail(msg) do { \
+ curl_mfprintf(stderr, "%s:%d test FAILED: '%s'\n", \
+ __FILE__, __LINE__, msg); \
+ unitfail++; \
} while(0)
-
/* The abort macros mark the current test step as failed, and exit the test */
-#define abort_if(expr, msg) \
- do { \
- if(expr) { \
- fprintf(stderr, "%s:%d ABORT assertion '%s' met: %s\n", \
- __FILE__, __LINE__, #expr, msg); \
- unitfail++; \
- goto unit_test_abort; \
- } \
+#define abort_if(expr, msg) \
+ do { \
+ if(expr) { \
+ curl_mfprintf(stderr, "%s:%d ABORT assertion '%s' met: %s\n", \
+ __FILE__, __LINE__, #expr, msg); \
+ unitfail++; \
+ goto unit_test_abort; \
+ } \
} while(0)
#define abort_unless(expr, msg) \
do { \
if(!(expr)) { \
- fprintf(stderr, "%s:%d ABORT assertion '%s' failed: %s\n", \
- __FILE__, __LINE__, #expr, msg); \
+ curl_mfprintf(stderr, "%s:%d ABORT assertion '%s' failed: %s\n", \
+ __FILE__, __LINE__, #expr, msg); \
unitfail++; \
goto unit_test_abort; \
} \
} while(0)
-#define unittest_abort(msg) \
- do { \
- fprintf(stderr, "%s:%d test ABORTED: '%s'\n", \
- __FILE__, __LINE__, msg); \
- unitfail++; \
- goto unit_test_abort; \
+#define unittest_abort(msg) \
+ do { \
+ curl_mfprintf(stderr, "%s:%d test ABORTED: '%s'\n", \
+ __FILE__, __LINE__, msg); \
+ unitfail++; \
+ goto unit_test_abort; \
} while(0)
#include "urldata.h"
#include "url.h" /* for Curl_safefree */
-#include "curl_base64.h"
+#include "curlx/base64.h"
#include "memdebug.h" /* LAST include file */
static struct Curl_easy *testdata;
unsigned char anychar = 'x';
CURLcode rc;
-rc = Curl_base64_encode("i", 1, &output, &size);
+rc = curlx_base64_encode("i", 1, &output, &size);
fail_unless(rc == CURLE_OK, "return code should be CURLE_OK");
fail_unless(size == 4, "size should be 4");
verify_memory(output, "aQ==", 4);
Curl_safefree(output);
-rc = Curl_base64_encode("ii", 2, &output, &size);
+rc = curlx_base64_encode("ii", 2, &output, &size);
fail_unless(rc == CURLE_OK, "return code should be CURLE_OK");
fail_unless(size == 4, "size should be 4");
verify_memory(output, "aWk=", 4);
Curl_safefree(output);
-rc = Curl_base64_encode("iii", 3, &output, &size);
+rc = curlx_base64_encode("iii", 3, &output, &size);
fail_unless(rc == CURLE_OK, "return code should be CURLE_OK");
fail_unless(size == 4, "size should be 4");
verify_memory(output, "aWlp", 4);
Curl_safefree(output);
-rc = Curl_base64_encode("iiii", 4, &output, &size);
+rc = curlx_base64_encode("iiii", 4, &output, &size);
fail_unless(rc == CURLE_OK, "return code should be CURLE_OK");
fail_unless(size == 8, "size should be 8");
verify_memory(output, "aWlpaQ==", 8);
Curl_safefree(output);
-rc = Curl_base64_encode("\xff\x01\xfe\x02", 4, &output, &size);
+rc = curlx_base64_encode("\xff\x01\xfe\x02", 4, &output, &size);
fail_unless(rc == CURLE_OK, "return code should be CURLE_OK");
fail_unless(size == 8, "size should be 8");
verify_memory(output, "/wH+Ag==", 8);
Curl_safefree(output);
-rc = Curl_base64url_encode("\xff\x01\xfe\x02", 4, &output, &size);
+rc = curlx_base64url_encode("\xff\x01\xfe\x02", 4, &output, &size);
fail_unless(rc == CURLE_OK, "return code should be CURLE_OK");
fail_unless(size == 6, "size should be 6");
verify_memory(output, "_wH-Ag", 6);
Curl_safefree(output);
-rc = Curl_base64url_encode("iiii", 4, &output, &size);
+rc = curlx_base64url_encode("iiii", 4, &output, &size);
fail_unless(rc == CURLE_OK, "return code should be CURLE_OK");
fail_unless(size == 6, "size should be 6");
verify_memory(output, "aWlpaQ", 6);
Curl_safefree(output);
/* 0 length makes it do strlen() */
-rc = Curl_base64_encode("iiii", 0, &output, &size);
+rc = curlx_base64_encode("iiii", 0, &output, &size);
fail_unless(rc == CURLE_OK, "return code should be CURLE_OK");
fail_unless(size == 8, "size should be 8");
verify_memory(output, "aWlpaQ==", 8);
Curl_safefree(output);
-rc = Curl_base64_encode("", 0, &output, &size);
+rc = curlx_base64_encode("", 0, &output, &size);
fail_unless(rc == CURLE_OK, "return code should be CURLE_OK");
fail_unless(size == 0, "size should be 0");
fail_unless(output && !output[0], "output should be a zero-length string");
Curl_safefree(output);
-rc = Curl_base64url_encode("", 0, &output, &size);
+rc = curlx_base64url_encode("", 0, &output, &size);
fail_unless(rc == CURLE_OK, "return code should be CURLE_OK");
fail_unless(size == 0, "size should be 0");
fail_unless(output && !output[0], "output should be a zero-length string");
Curl_safefree(output);
-rc = Curl_base64_decode("aWlpaQ==", &decoded, &size);
+rc = curlx_base64_decode("aWlpaQ==", &decoded, &size);
fail_unless(rc == CURLE_OK, "return code should be CURLE_OK");
fail_unless(size == 4, "size should be 4");
verify_memory(decoded, "iiii", 4);
Curl_safefree(decoded);
-rc = Curl_base64_decode("aWlp", &decoded, &size);
+rc = curlx_base64_decode("aWlp", &decoded, &size);
fail_unless(rc == CURLE_OK, "return code should be CURLE_OK");
fail_unless(size == 3, "size should be 3");
verify_memory(decoded, "iii", 3);
Curl_safefree(decoded);
-rc = Curl_base64_decode("aWk=", &decoded, &size);
+rc = curlx_base64_decode("aWk=", &decoded, &size);
fail_unless(rc == CURLE_OK, "return code should be CURLE_OK");
fail_unless(size == 2, "size should be 2");
verify_memory(decoded, "ii", 2);
Curl_safefree(decoded);
-rc = Curl_base64_decode("aQ==", &decoded, &size);
+rc = curlx_base64_decode("aQ==", &decoded, &size);
fail_unless(rc == CURLE_OK, "return code should be CURLE_OK");
fail_unless(size == 1, "size should be 1");
verify_memory(decoded, "i", 2);
/* This is illegal input as the data is too short */
size = 1; /* not zero */
decoded = &anychar; /* not NULL */
-rc = Curl_base64_decode("aQ", &decoded, &size);
+rc = curlx_base64_decode("aQ", &decoded, &size);
fail_unless(rc == CURLE_BAD_CONTENT_ENCODING,
"return code should be CURLE_BAD_CONTENT_ENCODING");
fail_unless(size == 0, "size should be 0");
/* This is illegal input as it contains three padding characters */
size = 1; /* not zero */
decoded = &anychar; /* not NULL */
-rc = Curl_base64_decode("a===", &decoded, &size);
+rc = curlx_base64_decode("a===", &decoded, &size);
fail_unless(rc == CURLE_BAD_CONTENT_ENCODING,
"return code should be CURLE_BAD_CONTENT_ENCODING");
fail_unless(size == 0, "size should be 0");
/* This is illegal input as it contains a padding character mid input */
size = 1; /* not zero */
decoded = &anychar; /* not NULL */
-rc = Curl_base64_decode("a=Q=", &decoded, &size);
+rc = curlx_base64_decode("a=Q=", &decoded, &size);
fail_unless(rc == CURLE_BAD_CONTENT_ENCODING,
"return code should be CURLE_BAD_CONTENT_ENCODING");
fail_unless(size == 0, "size should be 0");
/* This is also illegal input as it contains a padding character mid input */
size = 1; /* not zero */
decoded = &anychar; /* not NULL */
-rc = Curl_base64_decode("aWlpa=Q=", &decoded, &size);
+rc = curlx_base64_decode("aWlpa=Q=", &decoded, &size);
fail_unless(rc == CURLE_BAD_CONTENT_ENCODING,
"return code should be CURLE_BAD_CONTENT_ENCODING");
fail_unless(size == 0, "size should be 0");
/* This is garbage input as it contains an illegal base64 character */
size = 1; /* not zero */
decoded = &anychar; /* not NULL */
-rc = Curl_base64_decode("a\x1f==", &decoded, &size);
+rc = curlx_base64_decode("a\x1f==", &decoded, &size);
fail_unless(rc == CURLE_BAD_CONTENT_ENCODING,
"return code should be CURLE_BAD_CONTENT_ENCODING");
fail_unless(size == 0, "size should be 0");
# include <arpa/inet.h>
#endif
-#include "curlx.h"
+#include <curlx.h>
#include "hash.h"
#include "hostip.h"
static CURLcode create_node(void)
{
- data_key = aprintf("%s:%d", "dummy", 0);
+ data_key = curl_maprintf("%s:%d", "dummy", 0);
if(!data_key)
return CURLE_OUT_OF_MEMORY;
int rem = (i + 7)%NUM_NODES;
printf("Tree look:\n");
splayprint(root, 0, 1);
- printf("remove pointer %d, payload %zu\n", rem,
- *(size_t *)Curl_splayget(&nodes[rem]));
+ curl_mprintf("remove pointer %d, payload %zu\n", rem,
+ *(size_t *)Curl_splayget(&nodes[rem]));
rc = Curl_splayremove(root, &nodes[rem], &root);
if(rc) {
/* failed! */
tv_now.tv_usec = i;
root = Curl_splaygetbest(tv_now, root, &removed);
while(removed) {
- printf("removed payload %zu[%zu]\n",
- *(size_t *)Curl_splayget(removed) / 10,
- *(size_t *)Curl_splayget(removed) % 10);
+ curl_mprintf("removed payload %zu[%zu]\n",
+ *(size_t *)Curl_splayget(removed) / 10,
+ *(size_t *)Curl_splayget(removed) % 10);
root = Curl_splaygetbest(tv_now, root, &removed);
}
}
size_t i;
for(i = 0; i < CURL_ARRAYSIZE(tests); i++) {
- timediff_t result = Curl_timediff(tests[i].first, tests[i].second);
+ timediff_t result = curlx_timediff(tests[i].first, tests[i].second);
if(result != tests[i].result) {
printf("%ld.%06u to %ld.%06u got %d, but expected %ld\n",
(long)tests[i].first.tv_sec,
abort_if(err && out, "returned error with output");
if(out && pairs[i].output && strcmp(out, pairs[i].output)) {
- fprintf(stderr, "Test %u: '%s' gave '%s' instead of '%s'\n",
- i, pairs[i].input, out, pairs[i].output);
+ curl_mfprintf(stderr, "Test %u: '%s' gave '%s' instead of '%s'\n",
+ i, pairs[i].input, out, pairs[i].output);
fail("Test case output mismatched");
fails++;
}
else if((!out && pairs[i].output) ||
(out && !pairs[i].output)) {
- fprintf(stderr, "Test %u: '%s' gave '%s' instead of '%s'\n",
- i, pairs[i].input, out ? out : "(null)",
- pairs[i].output ? pairs[i].output : "(null)");
+ curl_mfprintf(stderr, "Test %u: '%s' gave '%s' instead of '%s'\n",
+ i, pairs[i].input, out ? out : "(null)",
+ pairs[i].output ? pairs[i].output : "(null)");
fail("Test case output mismatched");
fails++;
}
else
- fprintf(stderr, "Test %u: OK\n", i);
+ curl_mfprintf(stderr, "Test %u: OK\n", i);
free(out);
}
strlen(tests[i].pattern),
tests[i].host,
strlen(tests[i].host))) {
- fprintf(stderr,
- "HOST: %s\n"
- "PTRN: %s\n"
- "did %sMATCH\n",
- tests[i].host,
- tests[i].pattern,
- tests[i].match ? "NOT ": "");
+ curl_mfprintf(stderr,
+ "HOST: %s\n"
+ "PTRN: %s\n"
+ "did %sMATCH\n",
+ tests[i].host,
+ tests[i].pattern,
+ tests[i].match ? "NOT ": "");
unitfail++;
}
}
{
int time_sec = (int)(time_usec / usec_magnitude);
bool same = (time_sec == expected_seconds);
- fprintf(stderr, "is %d us same as %d seconds? %s\n",
- (int)time_usec, expected_seconds,
- same ? "Yes" : "No");
+ curl_mfprintf(stderr, "is %d us same as %d seconds? %s\n",
+ (int)time_usec, expected_seconds,
+ same ? "Yes" : "No");
return same;
}
static void expect_timer_seconds(struct Curl_easy *data, int seconds)
{
char msg[64];
- msnprintf(msg, sizeof(msg), "about %d seconds should have passed", seconds);
+ curl_msnprintf(msg, sizeof(msg), "about %d seconds should have passed",
+ seconds);
fail_unless(usec_matches_seconds(data->progress.t_nslookup, seconds), msg);
fail_unless(usec_matches_seconds(data->progress.t_connect, seconds), msg);
fail_unless(usec_matches_seconds(data->progress.t_appconnect, seconds), msg);
* be 3 seconds. */
UNITTEST_START
struct Curl_easy data;
- struct curltime now = Curl_now();
+ struct curltime now = curlx_now();
data.progress.t_nslookup = 0;
data.progress.t_connect = 0;
***************************************************************************/
#include "curlcheck.h"
-#include "curlx.h"
+#include <curlx.h>
#include "hash.h"
-#include "memdebug.h" /* LAST include file */
+#include <memdebug.h> /* LAST include file */
static struct Curl_hash hash_static;
static CURLcode unit_setup(void)
{
Curl_hash_init(&hash_static, 7, Curl_hash_str,
- Curl_str_key_compare, mydtor);
+ curlx_str_key_compare, mydtor);
return CURLE_OK;
}
***************************************************************************/
#include "curlcheck.h"
-#include "curlx.h"
-
+#include <curlx.h>
#include "hash.h"
-
-#include "memdebug.h" /* LAST include file */
+#include <memdebug.h> /* LAST include file */
static struct Curl_hash hash_static;
static const size_t slots = 3;
static CURLcode unit_setup(void)
{
Curl_hash_init(&hash_static, slots, Curl_hash_str,
- Curl_str_key_compare, mydtor);
+ curlx_str_key_compare, mydtor);
return CURLE_OK;
}
Curl_hash_str(key2, strlen(key2), slots) != 0 ||
Curl_hash_str(key3, strlen(key3), slots) != 2 ||
Curl_hash_str(key4, strlen(key4), slots) != 1)
- fprintf(stderr, "Warning: hashes are not computed as expected on this "
- "architecture; test coverage will be less comprehensive\n");
+ curl_mfprintf(stderr,
+ "Warning: hashes are not computed as expected on this "
+ "architecture; test coverage will be less comprehensive\n");
nodep = Curl_hash_add(&hash_static, &key1, strlen(key1), &key1);
fail_unless(nodep, "insertion into hash failed");
Curl_loadhostpairs(easy);
- entry_id = (void *)aprintf("%s:%d", tests[i].host, tests[i].port);
+ entry_id = (void *)curl_maprintf("%s:%d", tests[i].host, tests[i].port);
if(!entry_id)
goto error;
dns = Curl_hash_pick(&multi->dnscache.entries,
if(addr && !Curl_addr2string(addr->ai_addr, addr->ai_addrlen,
ipaddress, &port)) {
- fprintf(stderr, "%s:%d tests[%d] failed. getaddressinfo failed.\n",
- __FILE__, __LINE__, i);
+ curl_mfprintf(stderr, "%s:%d tests[%d] failed. "
+ "getaddressinfo failed.\n",
+ __FILE__, __LINE__, i);
problem = true;
break;
}
if(addr && !tests[i].address[j]) {
- fprintf(stderr, "%s:%d tests[%d] failed. the retrieved addr "
- "is %s but tests[%d].address[%d] is NULL.\n",
- __FILE__, __LINE__, i, ipaddress, i, j);
+ curl_mfprintf(stderr, "%s:%d tests[%d] failed. the retrieved addr "
+ "is %s but tests[%d].address[%d] is NULL.\n",
+ __FILE__, __LINE__, i, ipaddress, i, j);
problem = true;
break;
}
if(!addr && tests[i].address[j]) {
- fprintf(stderr, "%s:%d tests[%d] failed. the retrieved addr "
- "is NULL but tests[%d].address[%d] is %s.\n",
- __FILE__, __LINE__, i, i, j, tests[i].address[j]);
+ curl_mfprintf(stderr, "%s:%d tests[%d] failed. the retrieved addr "
+ "is NULL but tests[%d].address[%d] is %s.\n",
+ __FILE__, __LINE__, i, i, j, tests[i].address[j]);
problem = true;
break;
}
if(!curl_strequal(ipaddress, tests[i].address[j])) {
- fprintf(stderr, "%s:%d tests[%d] failed. the retrieved addr "
- "%s is not equal to tests[%d].address[%d] %s.\n",
- __FILE__, __LINE__, i, ipaddress, i, j, tests[i].address[j]);
+ curl_mfprintf(stderr, "%s:%d tests[%d] failed. the retrieved addr "
+ "%s is not equal to tests[%d].address[%d] %s.\n",
+ __FILE__, __LINE__, i, ipaddress, i, j,
+ tests[i].address[j]);
problem = true;
break;
}
if(port != tests[i].port) {
- fprintf(stderr, "%s:%d tests[%d] failed. the retrieved port "
- "for tests[%d].address[%d] is %d but tests[%d].port is %d.\n",
- __FILE__, __LINE__, i, i, j, port, i, tests[i].port);
+ curl_mfprintf(stderr, "%s:%d tests[%d] failed. the retrieved port "
+ "for tests[%d].address[%d] is %d "
+ "but tests[%d].port is %d.\n",
+ __FILE__, __LINE__, i, i, j, port, i, tests[i].port);
problem = true;
break;
}
if(dns->timestamp && tests[i].permanent) {
- fprintf(stderr, "%s:%d tests[%d] failed. the timestamp is not zero "
- "but tests[%d].permanent is TRUE\n",
- __FILE__, __LINE__, i, i);
+ curl_mfprintf(stderr,
+ "%s:%d tests[%d] failed. the timestamp is not zero "
+ "but tests[%d].permanent is TRUE\n",
+ __FILE__, __LINE__, i, i);
problem = true;
break;
}
if(dns->timestamp == 0 && !tests[i].permanent) {
- fprintf(stderr, "%s:%d tests[%d] failed. the timestamp is zero "
- "but tests[%d].permanent is FALSE\n",
- __FILE__, __LINE__, i, i);
+ curl_mfprintf(stderr, "%s:%d tests[%d] failed. the timestamp is zero "
+ "but tests[%d].permanent is FALSE\n",
+ __FILE__, __LINE__, i, i);
problem = true;
break;
}
if(Curl_loadhostpairs(easy))
goto error;
- entry_id = (void *)aprintf("%s:%d", tests[i].host, tests[i].port);
+ entry_id = (void *)curl_maprintf("%s:%d", tests[i].host, tests[i].port);
if(!entry_id)
goto error;
if(addr && !Curl_addr2string(addr->ai_addr, addr->ai_addrlen,
ipaddress, &port)) {
- fprintf(stderr, "%s:%d tests[%d] failed. Curl_addr2string failed.\n",
- __FILE__, __LINE__, i);
+ curl_mfprintf(stderr,
+ "%s:%d tests[%d] failed. Curl_addr2string failed.\n",
+ __FILE__, __LINE__, i);
problem = true;
break;
}
if(addr && !tests[i].address[j]) {
- fprintf(stderr, "%s:%d tests[%d] failed. the retrieved addr "
- "is %s but tests[%d].address[%d] is NULL.\n",
- __FILE__, __LINE__, i, ipaddress, i, j);
+ curl_mfprintf(stderr, "%s:%d tests[%d] failed. the retrieved addr "
+ "is %s but tests[%d].address[%d] is NULL.\n",
+ __FILE__, __LINE__, i, ipaddress, i, j);
problem = true;
break;
}
if(!addr && tests[i].address[j]) {
- fprintf(stderr, "%s:%d tests[%d] failed. the retrieved addr "
- "is NULL but tests[%d].address[%d] is %s.\n",
- __FILE__, __LINE__, i, i, j, tests[i].address[j]);
+ curl_mfprintf(stderr, "%s:%d tests[%d] failed. the retrieved addr "
+ "is NULL but tests[%d].address[%d] is %s.\n",
+ __FILE__, __LINE__, i, i, j, tests[i].address[j]);
problem = true;
break;
}
if(!curl_strequal(ipaddress, tests[i].address[j])) {
- fprintf(stderr, "%s:%d tests[%d] failed. the retrieved addr "
- "%s is not equal to tests[%d].address[%d] %s.\n",
- __FILE__, __LINE__, i, ipaddress, i, j, tests[i].address[j]);
+ curl_mfprintf(stderr, "%s:%d tests[%d] failed. the retrieved addr "
+ "%s is not equal to tests[%d].address[%d] %s.\n",
+ __FILE__, __LINE__, i, ipaddress, i, j,
+ tests[i].address[j]);
problem = true;
break;
}
if(port != tests[i].port) {
- fprintf(stderr, "%s:%d tests[%d] failed. the retrieved port "
- "for tests[%d].address[%d] is %d but tests[%d].port is %d.\n",
- __FILE__, __LINE__, i, i, j, port, i, tests[i].port);
+ curl_mfprintf(stderr, "%s:%d tests[%d] failed. the retrieved port "
+ "for tests[%d].address[%d] is %d "
+ "but tests[%d].port is %d.\n",
+ __FILE__, __LINE__, i, i, j, port, i, tests[i].port);
problem = true;
break;
}
for(i = 0; list4[i].a; i++) {
bool match = Curl_cidr4_match(list4[i].a, list4[i].n, list4[i].bits);
if(match != list4[i].match) {
- fprintf(stderr, "%s in %s/%u should %smatch\n",
- list4[i].a, list4[i].n, list4[i].bits,
- list4[i].match ? "": "not ");
+ curl_mfprintf(stderr, "%s in %s/%u should %smatch\n",
+ list4[i].a, list4[i].n, list4[i].bits,
+ list4[i].match ? "": "not ");
err++;
}
}
for(i = 0; list6[i].a; i++) {
bool match = Curl_cidr6_match(list6[i].a, list6[i].n, list6[i].bits);
if(match != list6[i].match) {
- fprintf(stderr, "%s in %s/%u should %smatch\n",
- list6[i].a, list6[i].n, list6[i].bits,
- list6[i].match ? "": "not ");
+ curl_mfprintf(stderr, "%s in %s/%u should %smatch\n",
+ list6[i].a, list6[i].n, list6[i].bits,
+ list6[i].match ? "": "not ");
err++;
}
}
for(i = 0; list[i].a; i++) {
bool match = Curl_check_noproxy(list[i].a, list[i].n);
if(match != list[i].match) {
- fprintf(stderr, "%s in %s should %smatch\n",
- list[i].a, list[i].n,
- list[i].match ? "": "not ");
+ curl_mfprintf(stderr, "%s in %s should %smatch\n",
+ list[i].a, list[i].n,
+ list[i].match ? "": "not ");
err++;
}
}
***************************************************************************/
#include "curlcheck.h"
-#include "curlx.h"
-
-#include "uint-hash.h"
-
-#include "memdebug.h" /* LAST include file */
+#include <curlx.h>
+#include <uint-hash.h>
+#include <memdebug.h> /* LAST include file */
static struct uint_hash hash_static;
DOHcode rc = doh_req_encode(req[i].name, req[i].type,
buffer, sizeof(buffer), &size);
if(rc != req[i].rc) {
- fprintf(stderr, "req %zu: Expected return code %d got %d\n", i,
- req[i].rc, rc);
+ curl_mfprintf(stderr, "req %zu: Expected return code %d got %d\n", i,
+ req[i].rc, rc);
abort_if(rc != req[i].rc, "return code");
}
if(size != req[i].size) {
- fprintf(stderr, "req %zu: Expected size %zu got %zu\n", i,
- req[i].size, size);
- fprintf(stderr, "DNS encode made: %s\n", hexdump(buffer, size));
+ curl_mfprintf(stderr, "req %zu: Expected size %zu got %zu\n", i,
+ req[i].size, size);
+ curl_mfprintf(stderr, "DNS encode made: %s\n", hexdump(buffer, size));
abort_if(size != req[i].size, "size");
}
if(req[i].packet && memcmp(req[i].packet, buffer, size)) {
- fprintf(stderr, "DNS encode made: %s\n", hexdump(buffer, size));
- fprintf(stderr, "... instead of: %s\n",
- hexdump((const unsigned char *)req[i].packet, size));
+ curl_mfprintf(stderr, "DNS encode made: %s\n", hexdump(buffer, size));
+ curl_mfprintf(stderr, "... instead of: %s\n",
+ hexdump((const unsigned char *)req[i].packet, size));
abort_if(req[i].packet && memcmp(req[i].packet, buffer, size),
"contents");
}
rc = doh_resp_decode((const unsigned char *)resp[i].packet, resp[i].size,
resp[i].type, &d);
if(rc != resp[i].rc) {
- fprintf(stderr, "resp %zu: Expected return code %d got %d\n", i,
- resp[i].rc, rc);
+ curl_mfprintf(stderr, "resp %zu: Expected return code %d got %d\n", i,
+ resp[i].rc, rc);
abort_if(rc != resp[i].rc, "return code");
}
len = sizeof(buffer);
a = &d.addr[u];
if(resp[i].type == DNS_TYPE_A) {
p = &a->ip.v4[0];
- msnprintf(ptr, len, "%u.%u.%u.%u ", p[0], p[1], p[2], p[3]);
+ curl_msnprintf(ptr, len, "%u.%u.%u.%u ", p[0], p[1], p[2], p[3]);
o = strlen(ptr);
len -= o;
ptr += o;
int j;
for(j = 0; j < 16; j += 2) {
size_t l;
- msnprintf(ptr, len, "%s%02x%02x", j?":":"", a->ip.v6[j],
- a->ip.v6[j + 1]);
+ curl_msnprintf(ptr, len, "%s%02x%02x", j?":":"", a->ip.v6[j],
+ a->ip.v6[j + 1]);
l = strlen(ptr);
len -= l;
ptr += l;
}
- msnprintf(ptr, len, " ");
+ curl_msnprintf(ptr, len, " ");
len--;
ptr++;
}
}
for(u = 0; u < d.numcname; u++) {
size_t o;
- msnprintf(ptr, len, "%s ", Curl_dyn_ptr(&d.cname[u]));
+ curl_msnprintf(ptr, len, "%s ", curlx_dyn_ptr(&d.cname[u]));
o = strlen(ptr);
len -= o;
ptr += o;
}
de_cleanup(&d);
if(resp[i].out && strcmp((char *)buffer, resp[i].out)) {
- fprintf(stderr, "resp %zu: Expected %s got %s\n", i,
- resp[i].out, buffer);
+ curl_mfprintf(stderr, "resp %zu: Expected %s got %s\n", i,
+ resp[i].out, buffer);
abort_if(resp[i].out && strcmp((char *)buffer, resp[i].out), "content");
}
}
rc = doh_resp_decode((const unsigned char *)full49, i, DNS_TYPE_A, &d);
if(!rc) {
/* none of them should work */
- fprintf(stderr, "%zu: %d\n", i, rc);
+ curl_mfprintf(stderr, "%zu: %d\n", i, rc);
abort_if(!rc, "error rc");
}
}
DNS_TYPE_A, &d);
if(!rc) {
/* none of them should work */
- fprintf(stderr, "2 %zu: %d\n", i, rc);
+ curl_mfprintf(stderr, "2 %zu: %d\n", i, rc);
abort_if(!rc, "error rc");
}
}
fail_if(d.numaddr != 1, "missing address");
a = &d.addr[0];
p = &a->ip.v4[0];
- msnprintf((char *)buffer, sizeof(buffer),
- "%u.%u.%u.%u", p[0], p[1], p[2], p[3]);
+ curl_msnprintf((char *)buffer, sizeof(buffer),
+ "%u.%u.%u.%u", p[0], p[1], p[2], p[3]);
if(rc || strcmp((char *)buffer, "127.0.0.1")) {
- fprintf(stderr, "bad address decoded: %s, rc == %d\n", buffer, rc);
+ curl_mfprintf(stderr, "bad address decoded: %s, rc == %d\n", buffer, rc);
abort_if(rc || strcmp((char *)buffer, "127.0.0.1"), "bad address");
}
fail_if(d.numcname, "bad cname counter");
int byte;
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
- fprintf(stderr, "curl_global_init() failed\n");
+ curl_mfprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
#endif
/* Injecting a simple short string via a format */
-msnprintf(input, sizeof(input), "Simple Test");
+curl_msnprintf(input, sizeof(input), "Simple Test");
Curl_infof(testdata, "%s", input);
fail_unless(verify(output, input) == 0, "Simple string test");
{
struct dynbuf host;
CURLUcode ret;
- Curl_dyn_init(&host, 10000);
- if(Curl_dyn_add(&host, h))
+ curlx_dyn_init(&host, 10000);
+ if(curlx_dyn_add(&host, h))
return CURLUE_OUT_OF_MEMORY;
ret = Curl_parse_port(url, &host, has_scheme);
- Curl_dyn_free(&host);
+ curlx_dyn_free(&host);
return ret;
}
goto fail;
}
fail_unless(Curl_llist_count(&asi->list) == 4, "wrong number of entries");
- msnprintf(outname, sizeof(outname), "%s-out", arg);
+ curl_msnprintf(outname, sizeof(outname), "%s-out", arg);
result = Curl_altsvc_parse(curl, asi, "h2=\"example.com:8080\"\r\n",
ALPN_h1, "example.org", 8080);
CURLcode result;
const char *in = spec->input;
- Curl_dyn_reset(dbuf);
+ curlx_dyn_reset(dbuf);
result = Curl_x509_GTime2str(dbuf, in, in + strlen(in));
if(result != spec->exp_result) {
- fprintf(stderr, "test %zu: expect result %d, got %d\n",
- i, spec->exp_result, result);
+ curl_mfprintf(stderr, "test %zu: expect result %d, got %d\n",
+ i, spec->exp_result, result);
return FALSE;
}
- else if(!result && strcmp(spec->exp_output, Curl_dyn_ptr(dbuf))) {
- fprintf(stderr, "test %zu: input '%s', expected output '%s', got '%s'\n",
- i, in, spec->exp_output, Curl_dyn_ptr(dbuf));
+ else if(!result && strcmp(spec->exp_output, curlx_dyn_ptr(dbuf))) {
+ curl_mfprintf(stderr,
+ "test %zu: input '%s', expected output '%s', got '%s'\n",
+ i, in, spec->exp_output, curlx_dyn_ptr(dbuf));
return FALSE;
}
struct dynbuf dbuf;
bool all_ok = TRUE;
- Curl_dyn_init(&dbuf, 32*1024);
+ curlx_dyn_init(&dbuf, 32*1024);
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
- fprintf(stderr, "curl_global_init() failed\n");
+ curl_mfprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
}
fail_unless(all_ok, "some tests of Curl_x509_GTime2str() fails");
- Curl_dyn_free(&dbuf);
+ curlx_dyn_free(&dbuf);
curl_global_cleanup();
}
UNITTEST_STOP
unsigned char close_undef[] = { 0x00, 0x00 };
for(i = 0; i < spec->n; ++i) {
- r = Curl_dyn_addn(buf, open_undef, sizeof(open_undef));
+ r = curlx_dyn_addn(buf, open_undef, sizeof(open_undef));
if(r)
return r;
}
for(i = 0; i < spec->n; ++i) {
- r = Curl_dyn_addn(buf, close_undef, sizeof(close_undef));
+ r = curlx_dyn_addn(buf, close_undef, sizeof(close_undef));
if(r)
return r;
}
const char *in;
memset(&elem, 0, sizeof(elem));
- Curl_dyn_reset(buf);
+ curlx_dyn_reset(buf);
result = spec->setbuf(spec, buf);
if(result) {
- fprintf(stderr, "test %zu: error setting buf %d\n", i, result);
+ curl_mfprintf(stderr, "test %zu: error setting buf %d\n", i, result);
return FALSE;
}
- in = Curl_dyn_ptr(buf);
- result = Curl_x509_getASN1Element(&elem, in, in + Curl_dyn_len(buf));
+ in = curlx_dyn_ptr(buf);
+ result = Curl_x509_getASN1Element(&elem, in, in + curlx_dyn_len(buf));
if(result != spec->exp_result) {
- fprintf(stderr, "test %zu: expect result %d, got %d\n",
- i, spec->exp_result, result);
+ curl_mfprintf(stderr, "test %zu: expect result %d, got %d\n",
+ i, spec->exp_result, result);
return FALSE;
}
return TRUE;
bool all_ok = TRUE;
struct dynbuf dbuf;
- Curl_dyn_init(&dbuf, 32*1024);
+ curlx_dyn_init(&dbuf, 32*1024);
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
- fprintf(stderr, "curl_global_init() failed\n");
+ curl_mfprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
}
fail_unless(all_ok, "some tests of Curl_x509_getASN1Element() fails");
- Curl_dyn_free(&dbuf);
+ curlx_dyn_free(&dbuf);
curl_global_cleanup();
}
UNITTEST_STOP
{
char *p = rrbuffer;
char *pend = rrbuffer + sizeof(rrbuffer);
- msnprintf(rrbuffer, sizeof(rrbuffer), "r:%d|", (int)result);
+ curl_msnprintf(rrbuffer, sizeof(rrbuffer), "r:%d|", (int)result);
p += strlen(rrbuffer);
if(rr) {
unsigned int i;
- msnprintf(p, pend - p, "p:%d|", rr->priority);
+ curl_msnprintf(p, pend - p, "p:%d|", rr->priority);
p += strlen(p);
- msnprintf(p, pend - p, "%s|", rr->target ? rr->target : "-");
+ curl_msnprintf(p, pend - p, "%s|", rr->target ? rr->target : "-");
p += strlen(p);
for(i = 0; i < MAX_HTTPSRR_ALPNS && rr->alpns[i] != ALPN_none; i++) {
- msnprintf(p, pend - p, "alpn:%x|", rr->alpns[i]);
+ curl_msnprintf(p, pend - p, "alpn:%x|", rr->alpns[i]);
p += strlen(p);
}
if(rr->no_def_alpn) {
- msnprintf(p, pend - p, "no-def-alpn|");
+ curl_msnprintf(p, pend - p, "no-def-alpn|");
p += strlen(p);
}
if(rr->port >= 0) {
- msnprintf(p, pend - p, "port:%d|", rr->port);
+ curl_msnprintf(p, pend - p, "port:%d|", rr->port);
p += strlen(p);
}
if(rr->ipv4hints) {
for(i = 0; i < rr->ipv4hints_len; i += 4) {
- msnprintf(p, pend - p, "ipv4:%d.%d.%d.%d|",
- rr->ipv4hints[i],
- rr->ipv4hints[i + 1],
- rr->ipv4hints[i + 2],
- rr->ipv4hints[i + 3]);
+ curl_msnprintf(p, pend - p, "ipv4:%d.%d.%d.%d|",
+ rr->ipv4hints[i],
+ rr->ipv4hints[i + 1],
+ rr->ipv4hints[i + 2],
+ rr->ipv4hints[i + 3]);
p += strlen(p);
}
}
if(rr->echconfiglist) {
- msnprintf(p, pend - p, "ech:");
+ curl_msnprintf(p, pend - p, "ech:");
p += strlen(p);
for(i = 0; i < rr->echconfiglist_len; i++) {
- msnprintf(p, pend - p, "%02x", rr->echconfiglist[i]);
+ curl_msnprintf(p, pend - p, "%02x", rr->echconfiglist[i]);
p += strlen(p);
}
- msnprintf(p, pend - p, "|");
+ curl_msnprintf(p, pend - p, "|");
p += strlen(p);
}
if(rr->ipv6hints) {
for(i = 0; i < rr->ipv6hints_len; i += 16) {
int x;
- msnprintf(p, pend - p, "ipv6:");
+ curl_msnprintf(p, pend - p, "ipv6:");
p += strlen(p);
for(x = 0; x < 16; x += 2) {
- msnprintf(p, pend - p, "%s%02x%02x",
- x ? ":" : "",
- rr->ipv6hints[i + x],
- rr->ipv6hints[i + x + 1]);
+ curl_msnprintf(p, pend - p, "%s%02x%02x",
+ x ? ":" : "",
+ rr->ipv6hints[i + x],
+ rr->ipv6hints[i + x + 1]);
p += strlen(p);
}
- msnprintf(p, pend - p, "|");
+ curl_msnprintf(p, pend - p, "|");
p += strlen(p);
}
}
/* is the output the expected? */
if(strcmp(rrbuffer, t[i].expect)) {
- fprintf(stderr, "Test %s (%i) failed\n"
- "Expected: %s\n"
- "Received: %s\n", t[i].name, i, t[i].expect, rrbuffer);
+ curl_mfprintf(stderr, "Test %s (%i) failed\n"
+ "Expected: %s\n"
+ "Received: %s\n", t[i].name, i, t[i].expect, rrbuffer);
unitfail++;
}
if(!e)
printf("'%s' is not HSTS\n", chost);
else {
- printf("%s [%s]: %" CURL_FORMAT_CURL_OFF_T "%s\n",
- chost, e->host, e->expires,
- e->includeSubDomains ? " includeSubDomains" : "");
+ curl_mprintf("%s [%s]: %" CURL_FORMAT_CURL_OFF_T "%s\n",
+ chost, e->host, e->expires,
+ e->includeSubDomains ? " includeSubDomains" : "");
}
}
result = Curl_hsts_parse(h, headers[i].host, headers[i].hdr);
if(result != headers[i].result) {
- fprintf(stderr, "Curl_hsts_parse(%s) failed: %d\n",
- headers[i].hdr, result);
+ curl_mfprintf(stderr, "Curl_hsts_parse(%s) failed: %d\n",
+ headers[i].hdr, result);
unitfail++;
continue;
}
showsts(e, chost);
}
- printf("Number of entries: %zu\n", Curl_llist_count(&h->list));
+ curl_mprintf("Number of entries: %zu\n", Curl_llist_count(&h->list));
/* verify that it is exists for 7 seconds */
chost = "expire.example";
deltatime++; /* another second passed */
}
- msnprintf(savename, sizeof(savename), "%s.save", arg);
+ curl_msnprintf(savename, sizeof(savename), "%s.save", arg);
(void)Curl_hsts_save(easy, h, savename);
Curl_hsts_cleanup(&h);
curl_easy_cleanup(easy);
#include <curl/curl.h>
-#include "strparse.h"
+#include "curlx/strparse.h"
#include "memdebug.h" /* LAST include file */
};
int i;
- printf("Curl_str_word\n");
+ printf("curlx_str_word\n");
for(i = 0; wordparse[i]; i++) {
struct Curl_str out;
const char *line = wordparse[i];
const char *orgline = line;
- int rc = Curl_str_word(&line, &out, 7);
+ int rc = curlx_str_word(&line, &out, 7);
printf("%u: (\"%s\") %d, \"%.*s\" [%d], line %d\n",
i, orgline, rc, (int)out.len, out.str, (int)out.len,
(int)(line - orgline));
}
- printf("Curl_str_until\n");
+ printf("curlx_str_until\n");
for(i = 0; wordparse[i]; i++) {
struct Curl_str out;
const char *line = wordparse[i];
const char *orgline = line;
- int rc = Curl_str_until(&line, &out, 7, 'd');
+ int rc = curlx_str_until(&line, &out, 7, 'd');
printf("%u: (\"%s\") %d, \"%.*s\" [%d], line %d\n",
i, orgline, rc, (int)out.len, out.str, (int)out.len,
(int)(line - orgline));
NULL
};
- printf("Curl_str_quotedword\n");
+ printf("curlx_str_quotedword\n");
for(i = 0; qwords[i]; i++) {
struct Curl_str out;
const char *line = qwords[i];
const char *orgline = line;
- int rc = Curl_str_quotedword(&line, &out, 7);
+ int rc = curlx_str_quotedword(&line, &out, 7);
printf("%u: (\"%s\") %d, \"%.*s\" [%d], line %d\n",
i, orgline, rc, (int)out.len, out.str, (int)out.len,
(int)(line - orgline));
"",
NULL
};
- printf("Curl_str_single\n");
+ printf("curlx_str_single\n");
for(i = 0; single[i]; i++) {
const char *line = single[i];
const char *orgline = line;
- int rc = Curl_str_single(&line, 'a');
+ int rc = curlx_str_single(&line, 'a');
printf("%u: (\"%s\") %d, line %d\n",
i, orgline, rc, (int)(line - orgline));
}
"",
NULL
};
- printf("Curl_str_singlespace\n");
+ printf("curlx_str_singlespace\n");
for(i = 0; single[i]; i++) {
const char *line = single[i];
const char *orgline = line;
- int rc = Curl_str_singlespace(&line);
+ int rc = curlx_str_singlespace(&line);
printf("%u: (\"%s\") %d, line %d\n",
i, orgline, rc, (int)(line - orgline));
}
"",
NULL
};
- printf("Curl_str_single\n");
+ printf("curlx_str_single\n");
for(i = 0; single[i]; i++) {
const char *line = single[i];
const char *orgline = line;
- int rc = Curl_str_single(&line, 'a');
+ int rc = curlx_str_single(&line, 'a');
printf("%u: (\"%s\") %d, line %d\n",
i, orgline, rc, (int)(line - orgline));
}
"",
NULL
};
- printf("Curl_str_number\n");
+ printf("curlx_str_number\n");
for(i = 0; nums[i]; i++) {
curl_off_t num;
const char *line = nums[i];
const char *orgline = line;
- int rc = Curl_str_number(&line, &num, 1235);
+ int rc = curlx_str_number(&line, &num, 1235);
printf("%u: (\"%s\") %d, [%u] line %d\n",
i, orgline, rc, (int)num, (int)(line - orgline));
}
{ "12", 10},
{NULL, 0}
};
- printf("Curl_str_number varying max\n");
+ printf("curlx_str_number varying max\n");
for(i = 0; nums[i].str; i++) {
curl_off_t num;
const char *line = nums[i].str;
const char *orgline = line;
- int rc = Curl_str_number(&line, &num, nums[i].max);
- printf("%u: (\"%s\") max %" CURL_FORMAT_CURL_OFF_T
- " == %d, [%" CURL_FORMAT_CURL_OFF_T "]\n",
- i, orgline, nums[i].max, rc, num);
+ int rc = curlx_str_number(&line, &num, nums[i].max);
+ curl_mprintf("%u: (\"%s\") max %" CURL_FORMAT_CURL_OFF_T
+ " == %d, [%" CURL_FORMAT_CURL_OFF_T "]\n",
+ i, orgline, nums[i].max, rc, num);
}
}
{ "12", 16},
{NULL, 0}
};
- printf("Curl_str_hex varying max\n");
+ printf("curlx_str_hex varying max\n");
for(i = 0; nums[i].str; i++) {
curl_off_t num;
const char *line = nums[i].str;
const char *orgline = line;
- int rc = Curl_str_hex(&line, &num, nums[i].max);
- printf("%u: (\"%s\") max %" CURL_FORMAT_CURL_OFF_T
- " == %d, [%" CURL_FORMAT_CURL_OFF_T "]\n",
- i, orgline, nums[i].max, rc, num);
+ int rc = curlx_str_hex(&line, &num, nums[i].max);
+ curl_mprintf("%u: (\"%s\") max %" CURL_FORMAT_CURL_OFF_T
+ " == %d, [%" CURL_FORMAT_CURL_OFF_T "]\n",
+ i, orgline, nums[i].max, rc, num);
}
}
{ "8", 10},
{NULL, 0}
};
- printf("Curl_str_octal varying max\n");
+ printf("curlx_str_octal varying max\n");
for(i = 0; nums[i].str; i++) {
curl_off_t num;
const char *line = nums[i].str;
const char *orgline = line;
- int rc = Curl_str_octal(&line, &num, nums[i].max);
- printf("%u: (\"%s\") max %" CURL_FORMAT_CURL_OFF_T
- " == %d, [%" CURL_FORMAT_CURL_OFF_T "]\n",
- i, orgline, nums[i].max, rc, num);
+ int rc = curlx_str_octal(&line, &num, nums[i].max);
+ curl_mprintf("%u: (\"%s\") max %" CURL_FORMAT_CURL_OFF_T
+ " == %d, [%" CURL_FORMAT_CURL_OFF_T "]\n",
+ i, orgline, nums[i].max, rc, num);
}
}
"999999999999999999",
NULL
};
- printf("Curl_str_number / max\n");
+ printf("curlx_str_number / max\n");
for(i = 0; nums[i]; i++) {
curl_off_t num;
const char *line = nums[i];
const char *orgline = line;
- int rc = Curl_str_number(&line, &num, CURL_OFF_T_MAX);
- printf("%u: (\"%s\") %d, [%" CURL_FORMAT_CURL_OFF_T "] line %d\n",
- i, orgline, rc, num, (int)(line - orgline));
+ int rc = curlx_str_number(&line, &num, CURL_OFF_T_MAX);
+ curl_mprintf("%u: (\"%s\") %d, [%" CURL_FORMAT_CURL_OFF_T "] line %d\n",
+ i, orgline, rc, num, (int)(line - orgline));
}
}
"",
NULL
};
- printf("Curl_str_newline\n");
+ printf("curlx_str_newline\n");
for(i = 0; newl[i]; i++) {
const char *line = newl[i];
const char *orgline = line;
- int rc = Curl_str_newline(&line);
- printf("%u: (%%%02x) %d, line %d\n",
- i, *orgline, rc, (int)(line - orgline));
+ int rc = curlx_str_newline(&line);
+ curl_mprintf("%u: (%%%02x) %d, line %d\n",
+ i, *orgline, rc, (int)(line - orgline));
}
}
"",
NULL
};
- printf("Curl_str_hex\n");
+ printf("curlx_str_hex\n");
for(i = 0; nums[i]; i++) {
curl_off_t num;
const char *line = nums[i];
const char *orgline = line;
- int rc = Curl_str_hex(&line, &num, 0x1235);
- printf("%u: (\"%s\") %d, [%u] line %d\n",
- i, orgline, rc, (int)num, (int)(line - orgline));
+ int rc = curlx_str_hex(&line, &num, 0x1235);
+ curl_mprintf("%u: (\"%s\") %d, [%u] line %d\n",
+ i, orgline, rc, (int)num, (int)(line - orgline));
}
}
"",
NULL
};
- printf("Curl_str_octal\n");
+ printf("curlx_str_octal\n");
for(i = 0; nums[i]; i++) {
curl_off_t num;
const char *line = nums[i];
const char *orgline = line;
- int rc = Curl_str_octal(&line, &num, 01235);
- printf("%u: (\"%s\") %d, [%u] line %d\n",
- i, orgline, rc, (int)num, (int)(line - orgline));
+ int rc = curlx_str_octal(&line, &num, 01235);
+ curl_mprintf("%u: (\"%s\") %d, [%u] line %d\n",
+ i, orgline, rc, (int)num, (int)(line - orgline));
}
}
"666666666666666666666",
NULL
};
- printf("Curl_str_octal / max\n");
+ printf("curlx_str_octal / max\n");
for(i = 0; nums[i]; i++) {
curl_off_t num;
const char *line = nums[i];
const char *orgline = line;
- int rc = Curl_str_octal(&line, &num, CURL_OFF_T_MAX);
- printf("%u: (\"%s\") %d, [%" CURL_FORMAT_CURL_OFF_T "] line %d\n",
- i, orgline, rc, num, (int)(line - orgline));
+ int rc = curlx_str_octal(&line, &num, CURL_OFF_T_MAX);
+ curl_mprintf("%u: (\"%s\") %d, [%" CURL_FORMAT_CURL_OFF_T "] line %d\n",
+ i, orgline, rc, num, (int)(line - orgline));
}
}
"ABCDEF",
NULL
};
- printf("Curl_str_hex / max\n");
+ printf("curlx_str_hex / max\n");
for(i = 0; nums[i]; i++) {
curl_off_t num;
const char *line = nums[i];
const char *orgline = line;
- int rc = Curl_str_hex(&line, &num, CURL_OFF_T_MAX);
- printf("%u: (\"%s\") %d, [%" CURL_FORMAT_CURL_OFF_T "] line %d\n",
- i, orgline, rc, num, (int)(line - orgline));
+ int rc = curlx_str_hex(&line, &num, CURL_OFF_T_MAX);
+ curl_mprintf("%u: (\"%s\") %d, [%" CURL_FORMAT_CURL_OFF_T "] line %d\n",
+ i, orgline, rc, num, (int)(line - orgline));
}
}
struct cf_test_ctx *ctx = cf->ctx;
#ifndef CURL_DISABLE_VERBOSE_STRINGS
infof(data, "%04dms: cf[%s] destroyed",
- (int)Curl_timediff(Curl_now(), current_tr->started), ctx->id);
+ (int)curlx_timediff(curlx_now(), current_tr->started), ctx->id);
#else
(void)data;
#endif
(void)data;
*done = FALSE;
- duration_ms = Curl_timediff(Curl_now(), ctx->started);
+ duration_ms = curlx_timediff(curlx_now(), ctx->started);
if(duration_ms >= ctx->fail_delay_ms) {
infof(data, "%04dms: cf[%s] fail delay reached",
(int)duration_ms, ctx->id);
}
ctx->ai_family = ai->ai_family;
ctx->transport = transport;
- ctx->started = Curl_now();
+ ctx->started = curlx_now();
#ifdef USE_IPV6
if(ctx->ai_family == AF_INET6) {
ctx->stats = ¤t_tr->cf6;
ctx->stats->creations++;
}
- created_at = Curl_timediff(ctx->started, current_tr->started);
+ created_at = curlx_timediff(ctx->started, current_tr->started);
if(ctx->stats->creations == 1)
ctx->stats->first_created = created_at;
ctx->stats->last_created = created_at;
char msg[256];
timediff_t duration_ms;
- duration_ms = Curl_timediff(tr->ended, tr->started);
- fprintf(stderr, "%d: test case took %dms\n", tc->id, (int)duration_ms);
+ duration_ms = curlx_timediff(tr->ended, tr->started);
+ curl_mfprintf(stderr, "%d: test case took %dms\n", tc->id, (int)duration_ms);
if(tr->result != tc->exp_result
&& CURLE_OPERATION_TIMEDOUT != tr->result) {
fail(msg);
}
- duration_ms = Curl_timediff(tr->ended, tr->started);
+ duration_ms = curlx_timediff(tr->ended, tr->started);
if(duration_ms < tc->min_duration_ms) {
curl_msprintf(msg, "%d: expected min duration of %dms, but took %dms",
tc->id, (int)tc->min_duration_ms, (int)duration_ms);
tr.cf6.family = "v6";
tr.cf4.family = "v4";
- tr.started = Curl_now();
+ tr.started = curlx_now();
tr.result = curl_easy_perform(easy);
- tr.ended = Curl_now();
+ tr.ended = curlx_now();
curl_easy_setopt(easy, CURLOPT_RESOLVE, NULL);
curl_slist_free_all(list);
const char *terr;
size_t n;
- fprintf(stderr, "bufq[chunk_size=%zu, max_chunks=%zu] %s\n",
- q->chunk_size, q->max_chunks, msg);
- fprintf(stderr, "- queue[\n");
+ curl_mfprintf(stderr, "bufq[chunk_size=%zu, max_chunks=%zu] %s\n",
+ q->chunk_size, q->max_chunks, msg);
+ curl_mfprintf(stderr, "- queue[\n");
chunk = q->head;
while(chunk) {
- fprintf(stderr, " chunk[len=%zu, roff=%zu, woff=%zu]\n",
- chunk->dlen, chunk->r_offset, chunk->w_offset);
+ curl_mfprintf(stderr, " chunk[len=%zu, roff=%zu, woff=%zu]\n",
+ chunk->dlen, chunk->r_offset, chunk->w_offset);
chunk = chunk->next;
}
- fprintf(stderr, " ]\n");
+ curl_mfprintf(stderr, " ]\n");
terr = tail_err(q);
- fprintf(stderr, "- tail: %s\n", terr ? terr : "ok");
+ curl_mfprintf(stderr, "- tail: %s\n", terr ? terr : "ok");
n = 0;
chunk = q->spare;
while(chunk) {
++n;
chunk = chunk->next;
}
- fprintf(stderr, "- chunks: %zu\n", q->chunk_count);
- fprintf(stderr, "- spares: %zu\n", n);
+ curl_mfprintf(stderr, "- chunks: %zu\n", q->chunk_count);
+ curl_mfprintf(stderr, "- spares: %zu\n", n);
}
static unsigned char test_data[32*1024];
}
}
if(nwritten != max_len) {
- fprintf(stderr, "%zu bytes written, but max_len=%zu\n",
- nwritten, max_len);
+ curl_mfprintf(stderr, "%zu bytes written, but max_len=%zu\n",
+ nwritten, max_len);
dump_bufq(&q, "after writing full");
fail_if(TRUE, "write: bufq full but nwritten wrong");
}
}
}
if(nread != max_len) {
- fprintf(stderr, "%zu bytes read, but max_len=%zu\n",
- nwritten, max_len);
+ curl_mfprintf(stderr, "%zu bytes read, but max_len=%zu\n",
+ nwritten, max_len);
dump_bufq(&q, "after reading empty");
fail_if(TRUE, "read: bufq empty but nread wrong");
}
nwritten += (size_t)n;
}
if(nwritten < max_len) {
- fprintf(stderr, "%zu bytes written, but max_len=%zu\n",
- nwritten, max_len);
+ curl_mfprintf(stderr, "%zu bytes written, but max_len=%zu\n",
+ nwritten, max_len);
dump_bufq(&q, "after writing full");
fail_if(TRUE, "write: bufq full but nwritten wrong");
}
fail_unless(Curl_bufq_is_empty(&q), "should be last read");
}
if(memcmp(buf, rbuf, n)) {
- fprintf(stderr, "at offset %zu expected '%.*s', got '%.*s'\n",
- roffset, (int)n, buf, (int)n, rbuf);
+ curl_mfprintf(stderr, "at offset %zu expected '%.*s', got '%.*s'\n",
+ roffset, (int)n, buf, (int)n, rbuf);
fail("read buf content wrong");
}
roffset += n;
fail_unless(Curl_dynhds_ccount_name(&hds, "bLABlaBlA") == 0, "should");
fail_if(Curl_dynhds_cadd(&hds, "Bla-Bla", "thingies"), "add failed");
- Curl_dyn_init(&dbuf, 32*1024);
+ curlx_dyn_init(&dbuf, 32*1024);
fail_if(Curl_dynhds_h1_dprint(&hds, &dbuf), "h1 print failed");
- if(Curl_dyn_ptr(&dbuf)) {
- fail_if(strcmp(Curl_dyn_ptr(&dbuf),
+ if(curlx_dyn_ptr(&dbuf)) {
+ fail_if(strcmp(curlx_dyn_ptr(&dbuf),
"test1: 123\r\ntest1: 123\r\nBla-Bla: thingies\r\n"),
"h1 format differs");
}
- Curl_dyn_free(&dbuf);
+ curlx_dyn_free(&dbuf);
}
Curl_dynhds_free(&hds);
fail_if(Curl_dynhds_h1_cadd_line(&hds, "ti3: val1"), "add");
fail_if(Curl_dynhds_h1_cadd_line(&hds, " val2"), "add indent");
- Curl_dyn_init(&dbuf, 32*1024);
+ curlx_dyn_init(&dbuf, 32*1024);
fail_if(Curl_dynhds_h1_dprint(&hds, &dbuf), "h1 print failed");
- if(Curl_dyn_ptr(&dbuf)) {
- fprintf(stderr, "indent concat: %s\n", Curl_dyn_ptr(&dbuf));
- fail_if(strcmp(Curl_dyn_ptr(&dbuf),
+ if(curlx_dyn_ptr(&dbuf)) {
+ curl_mfprintf(stderr, "indent concat: %s\n", curlx_dyn_ptr(&dbuf));
+ fail_if(strcmp(curlx_dyn_ptr(&dbuf),
"ti1: val1 val2\r\nti2: val1 val2\r\nti3: val1 val2\r\n"),
"wrong format");
}
- Curl_dyn_free(&dbuf);
+ curlx_dyn_free(&dbuf);
Curl_dynhds_free(&hds);
{
if(s && exp_s) {
if(strcmp(s, exp_s)) {
- fprintf(stderr, "expected %s: '%s' but got '%s'\n", name, exp_s, s);
+ curl_mfprintf(stderr, "expected %s: '%s' but got '%s'\n",
+ name, exp_s, s);
fail("unexpected req component");
}
}
else if(!s && exp_s) {
- fprintf(stderr, "expected %s: '%s' but got NULL\n", name, exp_s);
+ curl_mfprintf(stderr, "expected %s: '%s' but got NULL\n", name, exp_s);
fail("unexpected req component");
}
else if(s && !exp_s) {
- fprintf(stderr, "expected %s: NULL but got '%s'\n", name, s);
+ curl_mfprintf(stderr, "expected %s: NULL but got '%s'\n", name, s);
fail("unexpected req component");
}
}
nread = Curl_h1_req_parse_read(&p, buf, buflen, t->default_scheme,
0, &err);
if(nread < 0) {
- fprintf(stderr, "got err %d parsing: '%s'\n", err, buf);
+ curl_mfprintf(stderr, "got err %d parsing: '%s'\n", err, buf);
fail("error consuming");
}
in_consumed += (size_t)nread;
if((size_t)nread != buflen) {
if(!p.done) {
- fprintf(stderr, "only %zd/%zu consumed for: '%s'\n",
- nread, buflen, buf);
+ curl_mfprintf(stderr, "only %zd/%zu consumed for: '%s'\n",
+ nread, buflen, buf);
fail("not all consumed");
}
}
fail_if(!p.done, "end not detected");
fail_if(!p.req, "not request created");
if(t->input_remain != (in_len - in_consumed)) {
- fprintf(stderr, "expected %zu input bytes to remain, but got %zu\n",
- t->input_remain, in_len - in_consumed);
+ curl_mfprintf(stderr, "expected %zu input bytes to remain, but got %zu\n",
+ t->input_remain, in_len - in_consumed);
fail("unexpected input consumption");
}
if(p.req) {
check_eq(p.req->authority, t->authority, "authority");
check_eq(p.req->path, t->path, "path");
if(Curl_dynhds_count(&p.req->headers) != t->header_count) {
- fprintf(stderr, "expected %zu headers but got %zu\n", t->header_count,
- Curl_dynhds_count(&p.req->headers));
+ curl_mfprintf(stderr, "expected %zu headers but got %zu\n",
+ t->header_count, Curl_dynhds_count(&p.req->headers));
fail("unexpected req header count");
}
}
struct dynbuf buf;
size_t len = 4096;
char *line;
- Curl_dyn_init(&buf, len);
+ curlx_dyn_init(&buf, len);
fp = fopen(arg, "wb");
abort_unless(fp != NULL, "Cannot open testfile");
fp = fopen(arg, "rb");
abort_unless(fp != NULL, "Cannot open testfile");
- fprintf(stderr, "Test %zd...", i);
+ curl_mfprintf(stderr, "Test %zd...", i);
switch(i) {
case 0:
rc = Curl_get_line(&buf, fp);
- line = Curl_dyn_ptr(&buf);
+ line = curlx_dyn_ptr(&buf);
fail_unless(rc && line && !strcmp("LINE1\n", line),
"First line failed (1)");
rc = Curl_get_line(&buf, fp);
- line = Curl_dyn_ptr(&buf);
+ line = curlx_dyn_ptr(&buf);
fail_unless(rc && line && !strcmp("LINE2 NEWLINE\n", line),
"Second line failed (1)");
rc = Curl_get_line(&buf, fp);
- abort_unless(!Curl_dyn_len(&buf), "Missed EOF (1)");
+ abort_unless(!curlx_dyn_len(&buf), "Missed EOF (1)");
break;
case 1:
rc = Curl_get_line(&buf, fp);
- line = Curl_dyn_ptr(&buf);
+ line = curlx_dyn_ptr(&buf);
fail_unless(rc && line && !strcmp("LINE1\n", line),
"First line failed (2)");
rc = Curl_get_line(&buf, fp);
- line = Curl_dyn_ptr(&buf);
+ line = curlx_dyn_ptr(&buf);
fail_unless(rc && line && !strcmp("LINE2 NONEWLINE\n", line),
"Second line failed (2)");
rc = Curl_get_line(&buf, fp);
- abort_unless(!Curl_dyn_len(&buf), "Missed EOF (2)");
+ abort_unless(!curlx_dyn_len(&buf), "Missed EOF (2)");
break;
case 2:
rc = Curl_get_line(&buf, fp);
- line = Curl_dyn_ptr(&buf);
+ line = curlx_dyn_ptr(&buf);
fail_unless(rc && line && !strcmp("LINE1\n", line),
"First line failed (3)");
rc = Curl_get_line(&buf, fp);
- fail_unless(!Curl_dyn_len(&buf),
+ fail_unless(!curlx_dyn_len(&buf),
"Did not detect max read on EOF (3)");
break;
case 3:
rc = Curl_get_line(&buf, fp);
- line = Curl_dyn_ptr(&buf);
+ line = curlx_dyn_ptr(&buf);
fail_unless(rc && line && !strcmp("LINE1\n", line),
"First line failed (4)");
rc = Curl_get_line(&buf, fp);
- fail_unless(!Curl_dyn_len(&buf),
+ fail_unless(!curlx_dyn_len(&buf),
"Did not ignore partial on EOF (4)");
break;
case 4:
rc = Curl_get_line(&buf, fp);
- line = Curl_dyn_ptr(&buf);
+ line = curlx_dyn_ptr(&buf);
fail_unless(rc && line && !strcmp("LINE1\n", line),
"First line failed (5)");
rc = Curl_get_line(&buf, fp);
- fail_unless(!Curl_dyn_len(&buf),
+ fail_unless(!curlx_dyn_len(&buf),
"Did not bail out on too long line");
break;
case 5:
rc = Curl_get_line(&buf, fp);
- line = Curl_dyn_ptr(&buf);
+ line = curlx_dyn_ptr(&buf);
fail_unless(rc && line && !strcmp("LINE1\x1aTEST\n", line),
"Missed/Misinterpreted ^Z (6)");
rc = Curl_get_line(&buf, fp);
- abort_unless(!Curl_dyn_len(&buf), "Missed EOF (6)");
+ abort_unless(!curlx_dyn_len(&buf), "Missed EOF (6)");
break;
default:
abort_unless(1, "Unknown case");
break;
}
- Curl_dyn_free(&buf);
+ curlx_dyn_free(&buf);
fclose(fp);
- fprintf(stderr, "OK\n");
+ curl_mfprintf(stderr, "OK\n");
}
return (CURLcode)rc;
UNITTEST_STOP
if(test->rfc) {
id = Curl_cipher_suite_lookup_id(test->rfc, strlen(test->rfc));
if(id != test->id) {
- fprintf(stderr, "Curl_cipher_suite_lookup_id FAILED for \"%s\", "
- "result = 0x%04x, expected = 0x%04x\n",
- test->rfc, id, test->id);
+ curl_mfprintf(stderr, "Curl_cipher_suite_lookup_id FAILED for \"%s\", "
+ "result = 0x%04x, expected = 0x%04x\n",
+ test->rfc, id, test->id);
unitfail++;
}
}
if(test->openssl) {
id = Curl_cipher_suite_lookup_id(test->openssl, strlen(test->openssl));
if(id != test->id) {
- fprintf(stderr, "Curl_cipher_suite_lookup_id FAILED for \"%s\", "
- "result = 0x%04x, expected = 0x%04x\n",
- test->openssl, id, test->id);
+ curl_mfprintf(stderr, "Curl_cipher_suite_lookup_id FAILED for \"%s\", "
+ "result = 0x%04x, expected = 0x%04x\n",
+ test->openssl, id, test->id);
unitfail++;
}
}
Curl_cipher_suite_get_str(test->id, buf, sizeof(buf), true);
if(expect && strcmp(buf, expect) != 0) {
- fprintf(stderr, "Curl_cipher_suite_get_str FAILED for 0x%04x, "
- "result = \"%s\", expected = \"%s\"\n",
- test->id, buf, expect);
+ curl_mfprintf(stderr, "Curl_cipher_suite_get_str FAILED for 0x%04x, "
+ "result = \"%s\", expected = \"%s\"\n",
+ test->id, buf, expect);
unitfail++;
}
}
if(expect && strcmp(buf, expect) != 0) {
- fprintf(stderr, "Curl_cipher_suite_get_str FAILED for 0x%04x, "
- "result = \"%s\", expected = \"%s\"\n",
- test->id, buf, expect);
+ curl_mfprintf(stderr, "Curl_cipher_suite_get_str FAILED for 0x%04x, "
+ "result = \"%s\", expected = \"%s\"\n",
+ test->id, buf, expect);
unitfail++;
}
}
len = end - ptr;
if(id != test->id) {
- fprintf(stderr, "Curl_cipher_suite_walk_str FAILED for \"%s\" "
- "unexpected cipher, "
- "result = 0x%04x, expected = 0x%04x\n",
- test->str, id, test->id);
+ curl_mfprintf(stderr, "Curl_cipher_suite_walk_str FAILED for \"%s\" "
+ "unexpected cipher, "
+ "result = 0x%04x, expected = 0x%04x\n",
+ test->str, id, test->id);
unitfail++;
}
if(len > 64 || strncmp(ptr, test->str, len) != 0) {
- fprintf(stderr, "Curl_cipher_suite_walk_str ABORT for \"%s\" "
- "unexpected pointers\n",
- test->str);
+ curl_mfprintf(stderr, "Curl_cipher_suite_walk_str ABORT for \"%s\" "
+ "unexpected pointers\n",
+ test->str);
unitfail++;
goto unit_test_abort;
}
size_t i, j;
unsigned int n, c;
- fprintf(stderr, "test %s, capacity=%u, %zu numbers\n",
- name, capacity, slen);
+ curl_mfprintf(stderr, "test %s, capacity=%u, %zu numbers\n",
+ name, capacity, slen);
Curl_uint_bset_init(&bset);
fail_unless(!Curl_uint_bset_resize(&bset, capacity), "bset resize failed");
c = Curl_uint_bset_capacity(&bset);
for(i = 1; i < slen; ++i) {
fail_unless(Curl_uint_bset_next(&bset, n, &n), "next failed");
if(n != s[i]) {
- fprintf(stderr, "expected next to be %u, not %u\n", s[i], n);
+ curl_mfprintf(stderr, "expected next to be %u, not %u\n", s[i], n);
fail_unless(n == s[i], "next not correct number");
}
}
size_t i, j;
unsigned int n, c;
- fprintf(stderr, "test %s, %zu numbers\n", name, slen);
+ curl_mfprintf(stderr, "test %s, %zu numbers\n", name, slen);
Curl_uint_spbset_init(&bset);
for(i = 1; i < slen; ++i) {
fail_unless(Curl_uint_spbset_next(&bset, n, &n), "next failed");
if(n != s[i]) {
- fprintf(stderr, "expected next to be %u, not %u\n", s[i], n);
+ curl_mfprintf(stderr, "expected next to be %u, not %u\n", s[i], n);
fail_unless(n == s[i], "next not correct number");
}
}
# CURL Command section
PROGRAM_NAME = curl.exe
-CURL_CFLAGS = /I../lib /I../include /nologo /W4 /EHsc /FD /c
+CURL_CFLAGS = /I../lib /I../lib/curlx /I../include /nologo /W4 /EHsc /FD /c
CURL_LFLAGS = /out:$(DIRDIST)\bin\$(PROGRAM_NAME) /subsystem:console $(LFLAGS)
CURL_RESFLAGS = /i../include
@if not exist "$(LIB_DIROBJ)\vtls" mkdir $(LIB_DIROBJ)\vtls
@if not exist "$(LIB_DIROBJ)\vssh" mkdir $(LIB_DIROBJ)\vssh
@if not exist "$(LIB_DIROBJ)\vquic" mkdir $(LIB_DIROBJ)\vquic
+ @if not exist "$(LIB_DIROBJ)\curlx" mkdir $(LIB_DIROBJ)\curlx
$(CURL_DIROBJ):
@if not exist "$(CURL_DIROBJ)" mkdir $(CURL_DIROBJ)
{$(LIBCURL_SRC_DIR)\vquic\}.c{$(LIB_DIROBJ)\vquic\}.obj::
$(CURL_CC) $(CFLAGS) /Fo"$(LIB_DIROBJ)\vquic\\" $<
+{$(LIBCURL_SRC_DIR)\curlx\}.c{$(LIB_DIROBJ)\curlx\}.obj::
+ $(CURL_CC) $(CFLAGS) /Fo"$(LIB_DIROBJ)\curlx\\" $<
+
$(LIB_DIROBJ)\libcurl.res: $(LIBCURL_SRC_DIR)\libcurl.rc
$(RC) $(RC_FLAGS)
!ENDIF
$(CURL_DIROBJ)\nonblock.obj: ../lib/nonblock.c
$(CURL_CC) $(CURL_CFLAGS) /Fo"$@" ../lib/nonblock.c
-$(CURL_DIROBJ)\strparse.obj: ../lib/strparse.c
- $(CURL_CC) $(CURL_CFLAGS) /Fo"$@" ../lib/strparse.c
+$(CURL_DIROBJ)\strparse.obj: ../lib/curlx/strparse.c
+ $(CURL_CC) $(CURL_CFLAGS) /Fo"$@" ../lib/curlx/strparse.c
$(CURL_DIROBJ)\strcase.obj: ../lib/strcase.c
$(CURL_CC) $(CURL_CFLAGS) /Fo"$@" ../lib/strcase.c
-$(CURL_DIROBJ)\timeval.obj: ../lib/timeval.c
- $(CURL_CC) $(CURL_CFLAGS) /Fo"$@" ../lib/timeval.c
-$(CURL_DIROBJ)\warnless.obj: ../lib/warnless.c
- $(CURL_CC) $(CURL_CFLAGS) /Fo"$@" ../lib/warnless.c
+$(CURL_DIROBJ)\timeval.obj: ../lib/curlx/timeval.c
+ $(CURL_CC) $(CURL_CFLAGS) /Fo"$@" ../lib/curlx/timeval.c
$(CURL_DIROBJ)\curl_get_line.obj: ../lib/curl_get_line.c
$(CURL_CC) $(CURL_CFLAGS) /Fo"$@" ../lib/curl_get_line.c
$(CURL_DIROBJ)\curl_multibyte.obj: ../lib/curl_multibyte.c
$(CURL_CC) $(CURL_CFLAGS) /Fo"$@" ../lib/curl_multibyte.c
$(CURL_DIROBJ)\version_win32.obj: ../lib/version_win32.c
$(CURL_CC) $(CURL_CFLAGS) /Fo"$@" ../lib/version_win32.c
-$(CURL_DIROBJ)\dynbuf.obj: ../lib/dynbuf.c
- $(CURL_CC) $(CURL_CFLAGS) /Fo"$@" ../lib/dynbuf.c
-$(CURL_DIROBJ)\base64.obj: ../lib/base64.c
- $(CURL_CC) $(CURL_CFLAGS) /Fo"$@" ../lib/base64.c
+$(CURL_DIROBJ)\warnless.obj: ../lib/curlx/warnless.c
+ $(CURL_CC) $(CURL_CFLAGS) /Fo"$@" ../lib/curlx/warnless.c
+$(CURL_DIROBJ)\dynbuf.obj: ../lib/curlx/dynbuf.c
+ $(CURL_CC) $(CURL_CFLAGS) /Fo"$@" ../lib/curlx/dynbuf.c
+$(CURL_DIROBJ)\base64.obj: ../lib/curlx/base64.c
+ $(CURL_CC) $(CURL_CFLAGS) /Fo"$@" ../lib/curlx/base64.c
$(CURL_DIROBJ)\curl.res: $(CURL_SRC_DIR)\curl.rc
$(RC) $(CURL_RC_FLAGS)
projects / thirdparty / curl.git / commitdiff
