curl-library
[PATCH 1/3] Generate lists and use symbols in --libcurl code output.
From: Colin Hogben <curl_at_pythontech.co.uk>
Date: Thu, 23 Feb 2012 09:43:37 +0000
Date: Thu, 23 Feb 2012 09:43:37 +0000
This patch improves the output of curl's --libcurl option by
generating code which builds curl_httppost and curl_slist lists, and
uses symbolic names for enum and flag values. Variants of the
my_setopt macro in tool_setopt.h are added in order to pass extra type
information to the code-generation step in tool_setopt.c.
If curl is configured with --disable-libcurl-option then the macros
call curl_easy_setopt directly.
---
src/tool_easysrc.c | 162 ++++++++++++++++++---
src/tool_easysrc.h | 18 ++-
src/tool_operate.c | 57 ++++----
src/tool_setopt.c | 403 ++++++++++++++++++++++++++++++++++++++++++++++++----
src/tool_setopt.h | 63 ++++++++-
5 files changed, 615 insertions(+), 88 deletions(-)
diff --git a/src/tool_easysrc.c b/src/tool_easysrc.c
index ba1e78e..f672386 100644
--- a/src/tool_easysrc.c
+++ b/src/tool_easysrc.c
@@ -37,8 +37,13 @@
/* global variable definitions, for easy-interface source code generation */
-struct curl_slist *easysrc = NULL;
-struct curl_slist *easysrc_remarks = NULL;
+struct curl_slist *easysrc_decl = NULL; /* Variable declarations */
+struct curl_slist *easysrc_data = NULL; /* Build slists, forms etc. */
+struct curl_slist *easysrc_code = NULL; /* Setopt calls */
+struct curl_slist *easysrc_toohard = NULL; /* Unconvertible setopt */
+struct curl_slist *easysrc_clean = NULL; /* Clean up allocated data */
+int easysrc_form_count = 0;
+int easysrc_slist_count = 0;
static const char *const srchead[]={
"/********* Sample code generated by the curl command line tool **********",
@@ -50,8 +55,117 @@ static const char *const srchead[]={
"int main(int argc, char *argv[])",
"{",
" CURLcode ret;",
+ " CURL *hnd;",
NULL
};
+/* easysrc_decl declarations come here */
+/* easysrc_data initialisations come here */
+/* easysrc_code statements come here */
+static const char *const srchard[]={
+ "/* Here is a list of options the curl code used that cannot get generated",
+ " as source easily. You may select to either not use them or implement",
+ " them yourself.",
+ "",
+ NULL
+};
+static const char *const srcend[]={
+ "",
+ " return (int)ret;",
+ "}",
+ "/**** End of sample code ****/",
+ NULL
+};
+
+/* Clean up all source code if we run out of memory */
+static void easysrc_free(void)
+{
+ curl_slist_free_all(easysrc_decl);
+ easysrc_decl = NULL;
+ curl_slist_free_all(easysrc_data);
+ easysrc_data = NULL;
+ curl_slist_free_all(easysrc_code);
+ easysrc_code = NULL;
+ curl_slist_free_all(easysrc_toohard);
+ easysrc_toohard = NULL;
+ curl_slist_free_all(easysrc_clean);
+ easysrc_clean = NULL;
+}
+
+/* Add a source line to the main code or remarks */
+CURLcode easysrc_add(struct curl_slist **plist, const char *line)
+{
+ CURLcode ret = CURLE_OK;
+ struct curl_slist *list =
+ curl_slist_append(*plist, line);
+ if(!list) {
+ easysrc_free();
+ ret = CURLE_OUT_OF_MEMORY;
+ }
+ else
+ *plist = list;
+ return ret;
+}
+
+CURLcode easysrc_addf(struct curl_slist **plist, const char *fmt, ...)
+{
+ CURLcode ret;
+ char *bufp;
+ va_list ap;
+ va_start(ap, fmt);
+ bufp = curlx_mvaprintf(fmt, ap);
+ va_end(ap);
+ if(! bufp) {
+ ret = CURLE_OUT_OF_MEMORY;
+ }
+ else {
+ ret = easysrc_add(plist, bufp);
+ curl_free(bufp);
+ }
+ return ret;
+}
+
+#define CHKRET(v) do {CURLcode ret = (v); if(ret) return ret;} while(0)
+
+CURLcode easysrc_init(void)
+{
+ CHKRET(easysrc_add(&easysrc_code,
+ "hnd = curl_easy_init();"));
+ return CURLE_OK;
+}
+
+CURLcode easysrc_perform(void)
+{
+ /* Note any setopt calls which we could not convert */
+ if(easysrc_toohard) {
+ int i;
+ struct curl_slist *ptr;
+ const char *c;
+ CHKRET(easysrc_add(&easysrc_code, ""));
+ /* Preamble comment */
+ for(i=0; ((c = srchard[i]) != '\0'); i++)
+ CHKRET(easysrc_add(&easysrc_code, c));
+ /* Each unconverted option */
+ for(ptr=easysrc_toohard; ptr; ptr = ptr->next)
+ CHKRET(easysrc_add(&easysrc_code, ptr->data));
+ CHKRET(easysrc_add(&easysrc_code, ""));
+ CHKRET(easysrc_add(&easysrc_code, "*/"));
+
+ curl_slist_free_all(easysrc_toohard);
+ easysrc_toohard = NULL;
+ }
+
+ CHKRET(easysrc_add(&easysrc_code, ""));
+ CHKRET(easysrc_add(&easysrc_code, "ret = curl_easy_perform(hnd);"));
+ return CURLE_OK;
+}
+
+CURLcode easysrc_cleanup(void)
+{
+ CHKRET(easysrc_add(&easysrc_code, ""));
+ CHKRET(easysrc_add(&easysrc_code, "curl_easy_cleanup(hnd);"));
+ CHKRET(easysrc_add(&easysrc_code, "hnd = NULL;"));
+ return CURLE_OK;
+}
void dumpeasysrc(struct Configurable *config)
{
@@ -76,40 +190,40 @@ void dumpeasysrc(struct Configurable *config)
for(i=0; ((c = srchead[i]) != '\0'); i++)
fprintf(out, "%s\n", c);
- ptr = easysrc;
- while(ptr) {
+ /* Declare variables used for complex setopt values */
+ for(ptr=easysrc_decl; ptr; ptr = ptr->next)
fprintf(out, " %s\n", ptr->data);
- ptr = ptr->next;
+
+ /* Set up complex values for setopt calls */
+ if(easysrc_data) {
+ fprintf(out, "\n");
+
+ for(ptr=easysrc_data; ptr; ptr = ptr->next)
+ fprintf(out, " %s\n", ptr->data);
}
- ptr = easysrc_remarks;
- if(ptr) {
- fprintf(out,
- "\n /* Here is a list of options the curl code"
- " used that cannot get generated\n"
- " as source easily. You may select to either"
- " not use them or implement\n them yourself.\n"
- "\n");
- while(ptr) {
+ fprintf(out, "\n");
+ for(ptr=easysrc_code; ptr; ptr = ptr->next) {
+ if(ptr->data[0]) {
fprintf(out, " %s\n", ptr->data);
- ptr = ptr->next;
}
- fprintf(out, "\n */\n");
+ else {
+ fprintf(out, "\n");
+ }
}
- fprintf(out,
- " return (int)ret;\n"
- "}\n"
- "/**** End of sample code ****/\n");
+ for(ptr=easysrc_clean; ptr; ptr = ptr->next)
+ fprintf(out, " %s\n", ptr->data);
+
+ for(i=0; ((c = srcend[i]) != '\0'); i++)
+ fprintf(out, "%s\n", c);
+
if(fopened)
fclose(out);
}
}
- curl_slist_free_all(easysrc_remarks);
- curl_slist_free_all(easysrc);
- easysrc_remarks = NULL;
- easysrc = NULL;
+ easysrc_free();
}
#endif /* CURL_DISABLE_LIBCURL_OPTION */
diff --git a/src/tool_easysrc.h b/src/tool_easysrc.h
index 8e81d55..1d2c027 100644
--- a/src/tool_easysrc.h
+++ b/src/tool_easysrc.h
@@ -26,12 +26,22 @@
/* global variable declarations, for easy-interface source code generation */
-extern struct curl_slist *easysrc;
-extern struct curl_slist *easysrc_remarks;
+extern struct curl_slist *easysrc_decl; /* Variable declarations */
+extern struct curl_slist *easysrc_data; /* Build slists, forms etc. */
+extern struct curl_slist *easysrc_code; /* Setopt calls etc. */
+extern struct curl_slist *easysrc_toohard; /* Unconvertible setopt */
+extern struct curl_slist *easysrc_clean; /* Clean up (reverse order) */
+extern int easysrc_form_count; /* Number of curl_httppost variables */
+extern int easysrc_slist_count; /* Number of curl_slist variables */
+
+extern CURLcode easysrc_init(void);
+extern CURLcode easysrc_add(struct curl_slist **plist, const char *bupf);
+extern CURLcode easysrc_addf(struct curl_slist **plist, const char *fmt, ...);
+extern CURLcode easysrc_perform(void);
+extern CURLcode easysrc_cleanup(void);
void dumpeasysrc(struct Configurable *config);
-#endif /* CURL_DISABLE_LIBCIRL_CMD */
+#endif /* CURL_DISABLE_LIBCURL_OPTION */
#endif /* HEADER_CURL_TOOL_EASYSRC_H */
-
diff --git a/src/tool_operate.c b/src/tool_operate.c
index 3e496bf..d070ea6 100644
--- a/src/tool_operate.c
+++ b/src/tool_operate.c
@@ -355,11 +355,9 @@ int operate(struct Configurable *config, int argc, argv_item_t argv[])
}
#ifndef CURL_DISABLE_LIBCURL_OPTION
- /* This is the first entry added to easysrc and it initializes the slist */
- easysrc = curl_slist_append(easysrc, "CURL *hnd = curl_easy_init();");
- if(!easysrc) {
+ res = easysrc_init();
+ if(res) {
helpf(config->errors, "out of memory\n");
- res = CURLE_OUT_OF_MEMORY;
goto quit_curl;
}
#endif
@@ -835,25 +833,25 @@ int operate(struct Configurable *config, int argc, argv_item_t argv[])
/* new in libcurl 7.5 */
if(config->proxy)
- my_setopt(curl, CURLOPT_PROXYTYPE, config->proxyver);
+ my_setopt_enum(curl, CURLOPT_PROXYTYPE, config->proxyver);
/* new in libcurl 7.10 */
if(config->socksproxy) {
my_setopt_str(curl, CURLOPT_PROXY, config->socksproxy);
- my_setopt(curl, CURLOPT_PROXYTYPE, config->socksver);
+ my_setopt_enum(curl, CURLOPT_PROXYTYPE, config->socksver);
}
/* new in libcurl 7.10.6 */
if(config->proxyanyauth)
- my_setopt(curl, CURLOPT_PROXYAUTH, CURLAUTH_ANY);
+ my_setopt_flags(curl, CURLOPT_PROXYAUTH, CURLAUTH_ANY);
else if(config->proxynegotiate)
- my_setopt(curl, CURLOPT_PROXYAUTH, CURLAUTH_GSSNEGOTIATE);
+ my_setopt_flags(curl, CURLOPT_PROXYAUTH, CURLAUTH_GSSNEGOTIATE);
else if(config->proxyntlm)
- my_setopt(curl, CURLOPT_PROXYAUTH, CURLAUTH_NTLM);
+ my_setopt_flags(curl, CURLOPT_PROXYAUTH, CURLAUTH_NTLM);
else if(config->proxydigest)
- my_setopt(curl, CURLOPT_PROXYAUTH, CURLAUTH_DIGEST);
+ my_setopt_flags(curl, CURLOPT_PROXYAUTH, CURLAUTH_DIGEST);
else if(config->proxybasic)
- my_setopt(curl, CURLOPT_PROXYAUTH, CURLAUTH_BASIC);
+ my_setopt_flags(curl, CURLOPT_PROXYAUTH, CURLAUTH_BASIC);
/* new in libcurl 7.19.4 */
my_setopt(curl, CURLOPT_NOPROXY, config->noproxy);
@@ -896,7 +894,7 @@ int operate(struct Configurable *config, int argc, argv_item_t argv[])
config->postfieldsize);
break;
case HTTPREQ_POST:
- my_setopt(curl, CURLOPT_HTTPPOST, config->httppost);
+ my_setopt_httppost(curl, CURLOPT_HTTPPOST, config->httppost);
break;
default:
break;
@@ -905,18 +903,18 @@ int operate(struct Configurable *config, int argc, argv_item_t argv[])
my_setopt_str(curl, CURLOPT_REFERER, config->referer);
my_setopt(curl, CURLOPT_AUTOREFERER, config->autoreferer);
my_setopt_str(curl, CURLOPT_USERAGENT, config->useragent);
- my_setopt(curl, CURLOPT_HTTPHEADER, config->headers);
+ my_setopt_slist(curl, CURLOPT_HTTPHEADER, config->headers);
/* new in libcurl 7.5 */
my_setopt(curl, CURLOPT_MAXREDIRS, config->maxredirs);
/* new in libcurl 7.9.1 */
if(config->httpversion)
- my_setopt(curl, CURLOPT_HTTP_VERSION, config->httpversion);
+ my_setopt_enum(curl, CURLOPT_HTTP_VERSION, config->httpversion);
/* new in libcurl 7.10.6 (default is Basic) */
if(config->authtype)
- my_setopt(curl, CURLOPT_HTTPAUTH, config->authtype);
+ my_setopt_flags(curl, CURLOPT_HTTPAUTH, config->authtype);
/* curl 7.19.1 (the 301 version existed in 7.18.2) */
my_setopt(curl, CURLOPT_POSTREDIR, config->post301 |
@@ -1011,9 +1009,9 @@ int operate(struct Configurable *config, int argc, argv_item_t argv[])
}
my_setopt(curl, CURLOPT_CRLF, config->crlf);
- my_setopt(curl, CURLOPT_QUOTE, config->quote);
- my_setopt(curl, CURLOPT_POSTQUOTE, config->postquote);
- my_setopt(curl, CURLOPT_PREQUOTE, config->prequote);
+ my_setopt_slist(curl, CURLOPT_QUOTE, config->quote);
+ my_setopt_slist(curl, CURLOPT_POSTQUOTE, config->postquote);
+ my_setopt_slist(curl, CURLOPT_PREQUOTE, config->prequote);
#if !defined(CURL_DISABLE_HTTP) && !defined(CURL_DISABLE_COOKIES)
{
@@ -1034,8 +1032,8 @@ int operate(struct Configurable *config, int argc, argv_item_t argv[])
}
#endif
- my_setopt(curl, CURLOPT_SSLVERSION, config->ssl_version);
- my_setopt(curl, CURLOPT_TIMECONDITION, config->timecond);
+ my_setopt_enum(curl, CURLOPT_SSLVERSION, config->ssl_version);
+ my_setopt_enum(curl, CURLOPT_TIMECONDITION, config->timecond);
my_setopt(curl, CURLOPT_TIMEVALUE, config->condtime);
my_setopt_str(curl, CURLOPT_CUSTOMREQUEST, config->customrequest);
my_setopt(curl, CURLOPT_STDERR, config->errors);
@@ -1054,7 +1052,7 @@ int operate(struct Configurable *config, int argc, argv_item_t argv[])
}
/* new in libcurl 7.6.2: */
- my_setopt(curl, CURLOPT_TELNETOPTIONS, config->telnet_options);
+ my_setopt_slist(curl, CURLOPT_TELNETOPTIONS, config->telnet_options);
/* new in libcurl 7.7: */
my_setopt_str(curl, CURLOPT_RANDOM_FILE, config->random_file);
@@ -1118,7 +1116,7 @@ int operate(struct Configurable *config, int argc, argv_item_t argv[])
/* new in curl 7.16.1 */
if(config->ftp_ssl_ccc)
- my_setopt(curl, CURLOPT_FTP_SSL_CCC, config->ftp_ssl_ccc_mode);
+ my_setopt_enum(curl, CURLOPT_FTP_SSL_CCC, config->ftp_ssl_ccc_mode);
#if defined(HAVE_GSSAPI) || defined(USE_WINDOWS_SSPI)
{
@@ -1191,16 +1189,16 @@ int operate(struct Configurable *config, int argc, argv_item_t argv[])
my_setopt_str(curl, CURLOPT_MAIL_FROM, config->mail_from);
if(config->mail_rcpt)
- my_setopt(curl, CURLOPT_MAIL_RCPT, config->mail_rcpt);
+ my_setopt_slist(curl, CURLOPT_MAIL_RCPT, config->mail_rcpt);
/* curl 7.20.x */
if(config->ftp_pret)
my_setopt(curl, CURLOPT_FTP_USE_PRET, TRUE);
if(config->proto_present)
- my_setopt(curl, CURLOPT_PROTOCOLS, config->proto);
+ my_setopt_flags(curl, CURLOPT_PROTOCOLS, config->proto);
if(config->proto_redir_present)
- my_setopt(curl, CURLOPT_REDIR_PROTOCOLS, config->proto_redir);
+ my_setopt_flags(curl, CURLOPT_REDIR_PROTOCOLS, config->proto_redir);
if((urlnode->flags & GETOUT_USEREMOTE)
&& config->content_disposition) {
@@ -1216,7 +1214,7 @@ int operate(struct Configurable *config, int argc, argv_item_t argv[])
if(config->resolve)
/* new in 7.21.3 */
- my_setopt(curl, CURLOPT_RESOLVE, config->resolve);
+ my_setopt_slist(curl, CURLOPT_RESOLVE, config->resolve);
/* new in 7.21.4 */
if(curlinfo->features & CURL_VERSION_TLSAUTH_SRP) {
@@ -1252,8 +1250,8 @@ int operate(struct Configurable *config, int argc, argv_item_t argv[])
retrystart = tvnow();
#ifndef CURL_DISABLE_LIBCURL_OPTION
- if(!curl_slist_append(easysrc, "ret = curl_easy_perform(hnd);")) {
- res = CURLE_OUT_OF_MEMORY;
+ res = easysrc_perform();
+ if(res) {
goto show_error;
}
#endif
@@ -1580,8 +1578,7 @@ int operate(struct Configurable *config, int argc, argv_item_t argv[])
config->easy = curl = NULL;
}
#ifndef CURL_DISABLE_LIBCURL_OPTION
- if(easysrc)
- curl_slist_append(easysrc, "curl_easy_cleanup(hnd);");
+ easysrc_cleanup();
#endif
/* Close function-local opened file descriptors */
diff --git a/src/tool_setopt.c b/src/tool_setopt.c
index 6fc6047..5be4c3b 100644
--- a/src/tool_setopt.c
+++ b/src/tool_setopt.c
@@ -35,43 +35,397 @@
#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. */
+/* For bit masks, put combinations first, then single bits, */
+/* and finally any "NONE" value. */
+
+#define NV(e) {#e, e}
+#define NVEND {NULL, 0} /* sentinel to mark end of list */
+
+const NameValue setopt_nv_CURLPROXY[] = {
+ NV(CURLPROXY_HTTP),
+ NV(CURLPROXY_HTTP_1_0),
+ NV(CURLPROXY_SOCKS4),
+ NV(CURLPROXY_SOCKS5),
+ NV(CURLPROXY_SOCKS4A),
+ NV(CURLPROXY_SOCKS5_HOSTNAME),
+ NVEND,
+};
+
+const NameValue setopt_nv_CURLAUTH[] = {
+ NV(CURLAUTH_ANY), /* combination */
+ NV(CURLAUTH_ANYSAFE), /* combination */
+ NV(CURLAUTH_BASIC),
+ NV(CURLAUTH_DIGEST),
+ NV(CURLAUTH_GSSNEGOTIATE),
+ NV(CURLAUTH_NTLM),
+ NV(CURLAUTH_DIGEST_IE),
+ NV(CURLAUTH_NTLM_WB),
+ NV(CURLAUTH_ONLY),
+ NV(CURLAUTH_NONE),
+ NVEND,
+};
+
+const NameValue setopt_nv_CURL_HTTP_VERSION[] = {
+ NV(CURL_HTTP_VERSION_NONE),
+ NV(CURL_HTTP_VERSION_1_0),
+ NV(CURL_HTTP_VERSION_1_1),
+ NVEND,
+};
+
+const NameValue setopt_nv_CURL_SSLVERSION[] = {
+ NV(CURL_SSLVERSION_DEFAULT),
+ NV(CURL_SSLVERSION_TLSv1),
+ NV(CURL_SSLVERSION_SSLv2),
+ NV(CURL_SSLVERSION_SSLv3),
+ NVEND,
+};
+
+const NameValue setopt_nv_CURL_TIMECOND[] = {
+ NV(CURL_TIMECOND_IFMODSINCE),
+ NV(CURL_TIMECOND_IFUNMODSINCE),
+ NV(CURL_TIMECOND_LASTMOD),
+ NV(CURL_TIMECOND_NONE),
+ NVEND,
+};
+
+const NameValue setopt_nv_CURLFTPSSL_CCC[] = {
+ NV(CURLFTPSSL_CCC_NONE),
+ NV(CURLFTPSSL_CCC_PASSIVE),
+ NV(CURLFTPSSL_CCC_ACTIVE),
+ NVEND,
+};
+
+/* These mappings essentially triplicated - see
+ * tool_libinfo.c and tool_paramhlp.c */
+const NameValue setopt_nv_CURLPROTO[] = {
+ NV(CURLPROTO_ALL), /* combination */
+ NV(CURLPROTO_DICT),
+ NV(CURLPROTO_FILE),
+ NV(CURLPROTO_FTP),
+ NV(CURLPROTO_FTPS),
+ NV(CURLPROTO_GOPHER),
+ NV(CURLPROTO_HTTP),
+ NV(CURLPROTO_HTTPS),
+ NV(CURLPROTO_IMAP),
+ NV(CURLPROTO_IMAPS),
+ NV(CURLPROTO_LDAP),
+ NV(CURLPROTO_LDAPS),
+ NV(CURLPROTO_POP3),
+ NV(CURLPROTO_POP3S),
+ NV(CURLPROTO_RTSP),
+ NV(CURLPROTO_SCP),
+ NV(CURLPROTO_SFTP),
+ NV(CURLPROTO_SMTP),
+ NV(CURLPROTO_SMTPS),
+ NV(CURLPROTO_TELNET),
+ NV(CURLPROTO_TFTP),
+ NVEND,
+};
+
+/* Format and add code; jump to nomem on malloc error */
+#define ADD(args) do { \
+ ret = easysrc_add args; \
+ if(ret) \
+ goto nomem; \
+} while(0)
+#define ADDF(args) do { \
+ ret = easysrc_addf args; \
+ if(ret) \
+ goto nomem; \
+} while(0)
+
+#define DECL0(s) ADD((&easysrc_decl, s))
+#define DECL1(f,a) ADDF((&easysrc_decl, f,a))
+
+#define DATA0(s) ADD((&easysrc_data, s))
+#define DATA1(f,a) ADDF((&easysrc_data, f,a))
+#define DATA2(f,a,b) ADDF((&easysrc_data, f,a,b))
+#define DATA3(f,a,b,c) ADDF((&easysrc_data, f,a,b,c))
+
+#define CODE0(s) ADD((&easysrc_code, s))
+#define CODE1(f,a) ADDF((&easysrc_code, f,a))
+#define CODE2(f,a,b) ADDF((&easysrc_code, f,a,b))
+#define CODE3(f,a,b,c) ADDF((&easysrc_code, f,a,b,c))
+
+#define CLEAN0(s) ADD((&easysrc_clean, s))
+#define CLEAN1(f,a) ADDF((&easysrc_clean, f,a))
+
+#define REM0(s) ADD((&easysrc_toohard, s))
+#define REM1(f,a) ADDF((&easysrc_toohard, f,a))
+#define REM2(f,a,b) ADDF((&easysrc_toohard, f,a,b))
+
+/* Escape string to C string syntax. Return NULL if out of memory.
+ * Is this correct for those wacky EBCDIC guys? */
+static char *c_escape(const char *str)
+{
+ size_t len = 0;
+ const char *s;
+ unsigned char c;
+ char *escaped, *e;
+ /* Allocate space based on worst-case */
+ len = strlen(str);
+ escaped = malloc(4 * len + 1);
+ if(!escaped)
+ return NULL;
+
+ e = escaped;
+ for(s=str; (c=*s) != '\0'; s++) {
+ if(c=='\n') {
+ strcpy(e, "\\n");
+ e += 2;
+ }
+ else if(c=='\r') {
+ strcpy(e, "\\r");
+ e += 2;
+ }
+ else if(c=='\t') {
+ strcpy(e, "\\t");
+ e += 2;
+ }
+ else if(c=='\\') {
+ strcpy(e, "\\\\");
+ e += 2;
+ }
+ else if(c=='"') {
+ strcpy(e, "\\\"");
+ e += 2;
+ }
+ else if(! isprint(c)) {
+ sprintf(e, "\\%03o", c);
+ e += 4;
+ }
+ else
+ *e++ = c;
+ }
+ *e = '\0';
+ return escaped;
+}
+
+/* setopt wrapper for enum types */
+CURLcode tool_setopt_enum(CURL *curl, struct Configurable *config,
+ const char *name, CURLoption tag,
+ const NameValue *nvlist, long lval)
+{
+ CURLcode ret = CURLE_OK;
+ bool skip = FALSE;
+
+ ret = curl_easy_setopt(curl, tag, lval);
+ if(!lval)
+ skip = TRUE;
+
+ if(config->libcurl && !skip && !ret) {
+ /* we only use this for real if --libcurl was used */
+ const NameValue *nv = NULL;
+ for(nv=nvlist; nv->name; nv++) {
+ if(nv->value == lval) break; /* found it */
+ }
+ if(! nv->name) {
+ /* If no definition was found, output an explicit value.
+ * This could happen if new values are defined and used
+ * but the NameValue list is not updated. */
+ CODE2("curl_easy_setopt(hnd, %s, %ldL);", name, lval);
+ }
+ else {
+ CODE2("curl_easy_setopt(hnd, %s, (long)%s);", name, nv->name);
+ }
+ }
+
+ nomem:
+ return ret;
+}
+
+/* setopt wrapper for bit mask */
+CURLcode tool_setopt_flags(CURL *curl, struct Configurable *config,
+ const char *name, CURLoption tag,
+ const NameValue *nvlist, long lval)
+{
+ CURLcode ret = CURLE_OK;
+ bool skip = FALSE;
+
+ ret = curl_easy_setopt(curl, tag, lval);
+ if(!lval)
+ skip = TRUE;
+
+ if(config->libcurl && !skip && !ret) {
+ /* we only use this for real if --libcurl was used */
+ char preamble[80]; /* should accommodate any symbol name */
+ long rest = lval; /* bits not handled yet */
+ const NameValue *nv = NULL;
+ snprintf(preamble, sizeof(preamble),
+ "curl_easy_setopt(hnd, %s, ", name);
+ for(nv=nvlist; nv->name; nv++) {
+ if((nv->value & ~ rest) == 0) {
+ /* all value flags contained in rest */
+ rest &= ~ nv->value; /* remove bits handled here */
+ CODE3("%s(long)%s%s",
+ preamble, nv->name, rest ? " |" : ");");
+ if(!rest)
+ break; /* handled them all */
+ /* replace with all spaces for continuation line */
+ sprintf(preamble, "%*s", strlen(preamble), "");
+ }
+ }
+ /* If any bits have no definition, output an explicit value.
+ * This could happen if new bits are defined and used
+ * but the NameValue list is not updated. */
+ if(rest)
+ CODE2("%s%ldL);", preamble, rest);
+ }
+
+ nomem:
+ return ret;
+}
+
+/* setopt wrapper for CURLOPT_HTTPPOST */
+CURLcode tool_setopt_httppost(CURL *curl, struct Configurable *config,
+ const char *name, CURLoption tag,
+ struct curl_httppost *post)
+{
+ CURLcode ret = CURLE_OK;
+ bool skip = FALSE;
+
+ ret = curl_easy_setopt(curl, tag, post);
+ if(!post)
+ skip = TRUE;
+
+ if(config->libcurl && !skip && !ret) {
+ struct curl_httppost *pp, *p;
+ int i;
+ /* May use several httppost lists, if multiple POST actions */
+ i = ++ easysrc_form_count;
+ DECL1("struct curl_httppost *post%d;", i);
+ DATA1("post%d = NULL;", i);
+ CLEAN1("curl_formfree(post%d);", i);
+ CLEAN1("post%d = NULL;", i);
+ if(i == 1)
+ DECL0("struct curl_httppost *postend;");
+ DATA0("postend = NULL;");
+ for(p=post; p; p=p->next) {
+ DATA1("curl_formadd(&post%d, &postend,", i);
+ DATA1(" CURLFORM_COPYNAME, \"%s\",", p->name);
+ for(pp=p; pp; pp=pp->more) {
+ /* May be several files uploaded for one name;
+ * these are linked through the 'more' pointer */
+ char *e;
+ e = c_escape(pp->contents);
+ if(!e)
+ goto nomem;
+ if(pp->flags & HTTPPOST_FILENAME) {
+ /* file upload as for -F @filename */
+ DATA1(" CURLFORM_FILE, \"%s\",", e);
+ }
+ else if(pp->flags & HTTPPOST_READFILE) {
+ /* content from file as for -F <filename */
+ DATA1(" CURLFORM_FILECONTENT, \"%s\",", e);
+ }
+ else
+ DATA1(" CURLFORM_COPYCONTENTS, \"%s\",", e);
+ free(e);
+ if(pp->showfilename) {
+ e = c_escape(pp->showfilename);
+ if(!e)
+ goto nomem;
+ DATA1(" CURLFORM_FILENAME, \"%s\",", e);
+ free(e);
+ }
+ if(pp->contenttype) {
+ e = c_escape(pp->contenttype);
+ if(!e)
+ goto nomem;
+ DATA1(" CURLFORM_CONTENTTYPE, \"%s\",", e);
+ free(e);
+ }
+ }
+ DATA0(" CURLFORM_END);");
+ }
+ CODE2("curl_easy_setopt(hnd, %s, post%d);", name, i);
+ }
+
+ nomem:
+ return ret;
+}
+
+/* setopt wrapper for curl_slist options */
+CURLcode tool_setopt_slist(CURL *curl, struct Configurable *config,
+ const char *name, CURLoption tag,
+ struct curl_slist *list)
+{
+ CURLcode ret = CURLE_OK;
+ bool skip = FALSE;
+
+ ret = curl_easy_setopt(curl, tag, list);
+ if(!list)
+ skip = TRUE;
+
+ if(config->libcurl && !skip && !ret) {
+ struct curl_slist *s;
+ int i;
+ /* May need several slist variables, so invent name */
+ i = ++ easysrc_slist_count;
+ DECL1("struct curl_slist *slist%d;", i);
+ DATA1("slist%d = NULL;", i);
+ CLEAN1("curl_slist_free_all(slist%d);", i);
+ CLEAN1("slist%d = NULL;", i);
+ for(s=list; s; s=s->next) {
+ char *e = c_escape(s->data);
+ if(!e)
+ goto nomem;
+ DATA3("slist%d = curl_slist_append(slist%d, \"%s\");", i, i, e);
+ free(e);
+ }
+ CODE2("curl_easy_setopt(hnd, %s, slist%d);", name, i);
+ }
+
+ nomem:
+ return ret;
+}
+
+/* generic setopt wrapper for all other options.
+ * Some type information is encoded in the tag value. */
CURLcode tool_setopt(CURL *curl, bool str, struct Configurable *config,
const char *name, CURLoption tag, ...)
{
va_list arg;
- char *bufp;
- char value[256];
+ char buf[256];
+ const char *value;
bool remark = FALSE;
bool skip = FALSE;
+ bool escape = FALSE;
CURLcode ret = CURLE_OK;
va_start(arg, tag);
if(tag < CURLOPTTYPE_OBJECTPOINT) {
+ /* Value is expected to be a long */
long lval = va_arg(arg, long);
- snprintf(value, sizeof(value), "%ldL", lval);
+ snprintf(buf, sizeof(buf), "%ldL", lval);
+ value = buf;
ret = curl_easy_setopt(curl, tag, lval);
if(!lval)
skip = TRUE;
}
else if(tag < CURLOPTTYPE_OFF_T) {
+ /* Value is some sort of object pointer */
void *pval = va_arg(arg, void *);
- unsigned char *ptr = (unsigned char *)pval;
/* function pointers are never printable */
if(tag >= CURLOPTTYPE_FUNCTIONPOINT) {
if(pval) {
- strcpy(value, "functionpointer"); /* 'value' fits 256 bytes */
+ value = "functionpointer";
remark = TRUE;
}
else
skip = TRUE;
}
- else if(pval && str)
- snprintf(value, sizeof(value), "\"%s\"", (char *)ptr);
+ else if(pval && str) {
+ value = (char *)pval;
+ escape = TRUE;
+ }
else if(pval) {
- strcpy(value, "objectpointer"); /* 'value' fits 256 bytes */
+ value = "objectpointer";
remark = TRUE;
}
else
@@ -81,9 +435,11 @@ CURLcode tool_setopt(CURL *curl, bool str, struct Configurable *config,
}
else {
+ /* Value is expected to be curl_off_t */
curl_off_t oval = va_arg(arg, curl_off_t);
- snprintf(value, sizeof(value),
+ snprintf(buf, sizeof(buf),
"(curl_off_t)%" CURL_FORMAT_CURL_OFF_T, oval);
+ value = buf;
ret = curl_easy_setopt(curl, tag, oval);
if(!oval)
@@ -96,32 +452,21 @@ CURLcode tool_setopt(CURL *curl, bool str, struct Configurable *config,
/* we only use this for real if --libcurl was used */
if(remark)
- bufp = curlx_maprintf("%s set to a %s", name, value);
- else
- bufp = curlx_maprintf("curl_easy_setopt(hnd, %s, %s);", name, value);
-
- if(!bufp)
- ret = CURLE_OUT_OF_MEMORY;
+ REM2("%s set to a %s", name, value);
else {
- struct curl_slist *list =
- curl_slist_append(remark?easysrc_remarks:easysrc, bufp);
-
- curl_free(bufp);
-
- if(!list) {
- curl_slist_free_all(easysrc_remarks);
- curl_slist_free_all(easysrc);
- easysrc_remarks = NULL;
- easysrc = NULL;
- ret = CURLE_OUT_OF_MEMORY;
+ if(escape) {
+ char *escaped = c_escape(value);
+ if(!escaped)
+ goto nomem;
+ CODE2("curl_easy_setopt(hnd, %s, \"%s\");", name, escaped);
+ free(escaped);
}
- else if(remark)
- easysrc_remarks = list;
else
- easysrc = list;
+ CODE2("curl_easy_setopt(hnd, %s, %s);", name, value);
}
}
+ nomem:
return ret;
}
diff --git a/src/tool_setopt.h b/src/tool_setopt.h
index fcd60f8..4189add 100644
--- a/src/tool_setopt.h
+++ b/src/tool_setopt.h
@@ -35,8 +35,45 @@
#ifndef CURL_DISABLE_LIBCURL_OPTION
+/* Associate symbolic names with option values */
+typedef struct {
+ const char *name;
+ long value;
+} NameValue;
+
+extern const NameValue setopt_nv_CURLPROXY[];
+extern const NameValue setopt_nv_CURLAUTH[];
+extern const NameValue setopt_nv_CURL_HTTP_VERSION[];
+extern const NameValue setopt_nv_CURL_SSLVERSION[];
+extern const NameValue setopt_nv_CURL_TIMECOND[];
+extern const NameValue setopt_nv_CURLFTPSSL_CCC[];
+extern const NameValue setopt_nv_CURLPROTO[];
+
+/* Map options to NameValue sets */
+#define setopt_nv_CURLOPT_HTTP_VERSION setopt_nv_CURL_HTTP_VERSION
+#define setopt_nv_CURLOPT_HTTPAUTH setopt_nv_CURLAUTH
+#define setopt_nv_CURLOPT_SSLVERSION setopt_nv_CURL_SSLVERSION
+#define setopt_nv_CURLOPT_TIMECONDITION setopt_nv_CURL_TIMECOND
+#define setopt_nv_CURLOPT_FTP_SSL_CCC setopt_nv_CURLFTPSSL_CCC
+#define setopt_nv_CURLOPT_PROTOCOLS setopt_nv_CURLPROTO
+#define setopt_nv_CURLOPT_REDIR_PROTOCOLS setopt_nv_CURLPROTO
+#define setopt_nv_CURLOPT_PROXYTYPE setopt_nv_CURLPROXY
+#define setopt_nv_CURLOPT_PROXYAUTH setopt_nv_CURLAUTH
+
/* Intercept setopt calls for --libcurl */
+CURLcode tool_setopt_enum(CURL *curl, struct Configurable *config,
+ const char *name, CURLoption tag,
+ const NameValue *nv, long lval);
+CURLcode tool_setopt_flags(CURL *curl, struct Configurable *config,
+ const char *name, CURLoption tag,
+ const NameValue *nv, long lval);
+CURLcode tool_setopt_httppost(CURL *curl, struct Configurable *config,
+ const char *name, CURLoption tag,
+ struct curl_httppost *httppost);
+CURLcode tool_setopt_slist(CURL *curl, struct Configurable *config,
+ const char *name, CURLoption tag,
+ struct curl_slist *list);
CURLcode tool_setopt(CURL *curl, bool str, struct Configurable *config,
const char *name, CURLoption tag, ...);
@@ -46,11 +83,23 @@ CURLcode tool_setopt(CURL *curl, bool str, struct Configurable *config,
#define my_setopt_str(x,y,z) \
SETOPT_CHECK(tool_setopt(x, TRUE, config, #y, y, z))
+#define my_setopt_enum(x,y,z) \
+ SETOPT_CHECK(tool_setopt_enum(x, config, #y, y, setopt_nv_ ## y, z))
+
+#define my_setopt_flags(x,y,z) \
+ SETOPT_CHECK(tool_setopt_flags(x, config, #y, y, setopt_nv_ ## y, z))
+
+#define my_setopt_httppost(x,y,z) \
+ SETOPT_CHECK(tool_setopt_httppost(x, config, #y, y, z))
+
+#define my_setopt_slist(x,y,z) \
+ SETOPT_CHECK(tool_setopt_slist(x, config, #y, y, z))
+
#define res_setopt(x,y,z) tool_setopt(x, FALSE, config, #y, y, z)
#define res_setopt_str(x,y,z) tool_setopt(x, TRUE, config, #y, y, z)
-#else
+#else /* CURL_DISABLE_LIBCURL_OPTION */
/* No --libcurl, so pass options directly to library */
@@ -60,6 +109,18 @@ CURLcode tool_setopt(CURL *curl, bool str, struct Configurable *config,
#define my_setopt_str(x,y,z) \
SETOPT_CHECK(curl_easy_setopt(x, y, z))
+#define my_setopt_enum(x,y,z) \
+ SETOPT_CHECK(curl_easy_setopt(x, y, z))
+
+#define my_setopt_flags(x,y,z) \
+ SETOPT_CHECK(curl_easy_setopt(x, y, z))
+
+#define my_setopt_httppost(x,y,z) \
+ SETOPT_CHECK(curl_easy_setopt(x, y, z))
+
+#define my_setopt_slist(x,y,z) \
+ SETOPT_CHECK(curl_easy_setopt(x, y, z))
+
#define res_setopt(x,y,z) curl_easy_setopt(x,y,z)
#define res_setopt_str(x,y,z) curl_easy_setopt(x,y,z)
--
1.6.5.6
--------------060002010004040105020503
Content-Type: text/x-patch;
name="0002-Add-tests-for-curl-s-libcurl-output.patch"
Content-Transfer-Encoding: base64
Content-Disposition: inline;
filename="0002-Add-tests-for-curl-s-libcurl-output.patch"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--------------060002010004040105020503
Content-Type: text/x-patch;
name="0003-Add-helper-script-convsrctest.pl-to-manipulate-libcu.patch"
Content-Transfer-Encoding: 7bit
Content-Disposition: inline;
filename*0="0003-Add-helper-script-convsrctest.pl-to-manipulate-libcu.pa";
filename*1="tch"
Received on 2001-09-17