1 /***************************************************************************
3 * Project ___| | | | _ \| |
5 * | (__| |_| | _ <| |___
6 * \___|\___/|_| \_\_____|
8 * Copyright (C) 1998 - 2018, Daniel Stenberg, <daniel@haxx.se>, et al.
10 * This software is licensed as described in the file COPYING, which
11 * you should have received as part of this distribution. The terms
12 * are also available at https://curl.haxx.se/docs/copyright.html.
14 * You may opt to use, copy, modify, merge, publish, distribute and/or sell
15 * copies of the Software, and permit persons to whom the Software is
16 * furnished to do so, under the terms of the COPYING file.
18 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
19 * KIND, either express or implied.
22 ***************************************************************************/
24 /* CCSID API wrappers for OS/400. */
41 #include "ccsidcurl.h"
46 #define SIZE_MAX ((size_t) ~0) /* Is unsigned on OS/400. */
50 #define ASCII_CCSID 819 /* Use ISO-8859-1 as ASCII. */
51 #define NOCONV_CCSID 65535 /* No conversion. */
52 #define ICONV_ID_SIZE 32 /* Size of iconv_open() code identifier. */
53 #define ICONV_OPEN_ERROR(t) ((t).return_value == -1)
55 #define ALLOC_GRANULE 8 /* Alloc. granule for curl_formadd_ccsid(). */
59 makeOS400IconvCode(char buf[ICONV_ID_SIZE], unsigned int ccsid)
63 *** Convert a CCSID to the corresponding IBM iconv_open() character
65 *** This code is specific to the OS400 implementation of the iconv library.
66 *** CCSID 65535 (no conversion) is replaced by the ASCII CCSID.
67 *** CCSID 0 is interpreted by the OS400 as the job's CCSID.
72 if(ccsid == NOCONV_CCSID)
75 memset(buf, 0, ICONV_ID_SIZE);
76 curl_msprintf(buf, "IBMCCSID%05u0000000", ccsid);
81 iconv_open_CCSID(unsigned int ccsidout, unsigned int ccsidin,
85 char fromcode[ICONV_ID_SIZE];
86 char tocode[ICONV_ID_SIZE];
89 *** Like iconv_open(), but character codes are given as CCSIDs.
90 *** If `cstr' is non-zero, conversion is set up to stop whenever a
91 *** null character is encountered.
92 *** See iconv_open() IBM description in "National Language Support API".
95 makeOS400IconvCode(fromcode, ccsidin);
96 makeOS400IconvCode(tocode, ccsidout);
97 memset(tocode + 13, 0, sizeof tocode - 13); /* Dest. code id format. */
100 fromcode[18] = '1'; /* Set null-terminator flag. */
102 return iconv_open(tocode, fromcode);
107 convert(char * d, size_t dlen, int dccsid,
108 const char * s, int slen, int sccsid)
116 *** Convert `sccsid'-coded `slen'-data bytes at `s' into `dccsid'-coded
117 *** data stored in the `dlen'-byte buffer at `d'.
118 *** If `slen' < 0, source string is null-terminated.
119 *** CCSID 65535 (no conversion) is replaced by the ASCII CCSID.
120 *** Return the converted destination byte count, or -1 if error.
124 sccsid = ASCII_CCSID;
127 dccsid = ASCII_CCSID;
129 if(sccsid == dccsid) {
130 lslen = slen >= 0? slen: strlen(s) + 1;
131 i = lslen < dlen? lslen: dlen;
141 cd = iconv_open_CCSID(dccsid, sccsid, 1);
144 lslen = (size_t) slen;
145 cd = iconv_open_CCSID(dccsid, sccsid, 0);
148 if(ICONV_OPEN_ERROR(cd))
153 if((int) iconv(cd, (char * *) &s, &lslen, &d, &dlen) < 0)
164 dynconvert(int dccsid, const char * s, int slen, int sccsid)
171 static const char nullbyte = 0;
173 /* Like convert, but the destination is allocated and returned. */
175 dlen = (size_t) (slen < 0? strlen(s): slen) + 1;
176 dlen *= MAX_CONV_EXPANSION; /* Allow some expansion. */
180 return (char *) NULL;
182 l = convert(d, dlen, dccsid, s, slen, sccsid);
186 return (char *) NULL;
190 /* Need to null-terminate even when source length is given.
191 Since destination code size is unknown, use a conversion to generate
194 int l2 = convert(d + l, dlen - l, dccsid, &nullbyte, -1, ASCII_CCSID);
198 return (char *) NULL;
204 if((size_t) l < dlen) {
205 cp = realloc(d, l); /* Shorten to minimum needed. */
215 static struct curl_slist *
216 slist_convert(int dccsid, struct curl_slist * from, int sccsid)
219 struct curl_slist * to = (struct curl_slist *) NULL;
221 for(; from; from = from->next) {
222 char * cp = dynconvert(dccsid, from->data, -1, sccsid);
225 curl_slist_free_all(to);
226 return (struct curl_slist *) NULL;
228 to = Curl_slist_append_nodup(to, cp);
235 curl_version_ccsid(unsigned int ccsid)
242 aversion = curl_version();
247 i = strlen(aversion) + 1;
248 i *= MAX_CONV_EXPANSION;
250 if(!(eversion = Curl_thread_buffer(LK_CURL_VERSION, i)))
251 return (char *) NULL;
253 if(convert(eversion, i, ccsid, aversion, -1, ASCII_CCSID) < 0)
254 return (char *) NULL;
261 curl_easy_escape_ccsid(CURL * handle, const char * string, int length,
262 unsigned int sccsid, unsigned int dccsid)
270 return (char *) NULL;
273 s = dynconvert(ASCII_CCSID, string, length? length: -1, sccsid);
276 return (char *) NULL;
278 d = curl_easy_escape(handle, s, 0);
282 return (char *) NULL;
284 s = dynconvert(dccsid, d, -1, ASCII_CCSID);
291 curl_easy_unescape_ccsid(CURL * handle, const char * string, int length,
293 unsigned int sccsid, unsigned int dccsid)
301 return (char *) NULL;
304 s = dynconvert(ASCII_CCSID, string, length? length: -1, sccsid);
307 return (char *) NULL;
309 d = curl_easy_unescape(handle, s, 0, outlength);
313 return (char *) NULL;
315 s = dynconvert(dccsid, d, -1, ASCII_CCSID);
319 *outlength = strlen(s);
326 curl_slist_append_ccsid(struct curl_slist * list,
327 const char * data, unsigned int ccsid)
335 return curl_slist_append(list, data);
337 s = dynconvert(ASCII_CCSID, data, -1, ccsid);
340 return (struct curl_slist *) NULL;
342 list = curl_slist_append(list, s);
349 curl_getdate_ccsid(const char * p, const time_t * unused, unsigned int ccsid)
356 return curl_getdate(p, unused);
358 s = dynconvert(ASCII_CCSID, p, -1, ccsid);
363 t = curl_getdate(s, unused);
370 convert_version_info_string(const char * * stringp,
371 char * * bufp, int * left, unsigned int ccsid)
374 /* Helper for curl_version_info_ccsid(): convert a string if defined.
375 Result is stored in the `*left'-byte buffer at `*bufp'.
376 `*bufp' and `*left' are updated accordingly.
377 Return 0 if ok, else -1. */
380 int l = convert(*bufp, *left, ccsid, *stringp, -1, ASCII_CCSID);
394 curl_version_info_data *
395 curl_version_info_ccsid(CURLversion stamp, unsigned int ccsid)
398 curl_version_info_data * p;
402 curl_version_info_data * id;
404 /* The assertion below is possible, because although the second operand
405 is an enum member, the first is a #define. In that case, the OS/400 C
406 compiler seems to compare string values after substitution. */
408 #if CURLVERSION_NOW != CURLVERSION_FOURTH
409 #error curl_version_info_data structure has changed: upgrade this procedure.
412 /* If caller has been compiled with a new version, error. */
414 if(stamp > CURLVERSION_NOW)
415 return (curl_version_info_data *) NULL;
417 p = curl_version_info(stamp);
422 /* Measure thread space needed. */
428 while(p->protocols[nproto])
429 n += strlen(p->protocols[nproto++]);
435 n += strlen(p->version) + 1;
438 n += strlen(p->host) + 1;
441 n += strlen(p->ssl_version) + 1;
444 n += strlen(p->libz_version) + 1;
447 n += strlen(p->ares) + 1;
450 n += strlen(p->libidn) + 1;
452 if(p->libssh_version)
453 n += strlen(p->libssh_version) + 1;
455 /* Allocate thread space. */
457 n *= MAX_CONV_EXPANSION;
460 n += nproto * sizeof(const char *);
462 cp = Curl_thread_buffer(LK_VERSION_INFO_DATA, n);
463 id = (curl_version_info_data *) Curl_thread_buffer(LK_VERSION_INFO,
467 return (curl_version_info_data *) NULL;
469 /* Copy data and convert strings. */
471 memcpy((char *) id, (char *) p, sizeof *p);
474 int i = nproto * sizeof id->protocols[0];
476 id->protocols = (const char * const *) cp;
477 memcpy(cp, (char *) p->protocols, i);
481 for(i = 0; id->protocols[i]; i++)
482 if(convert_version_info_string(((const char * *) id->protocols) + i,
484 return (curl_version_info_data *) NULL;
487 if(convert_version_info_string(&id->version, &cp, &n, ccsid))
488 return (curl_version_info_data *) NULL;
490 if(convert_version_info_string(&id->host, &cp, &n, ccsid))
491 return (curl_version_info_data *) NULL;
493 if(convert_version_info_string(&id->ssl_version, &cp, &n, ccsid))
494 return (curl_version_info_data *) NULL;
496 if(convert_version_info_string(&id->libz_version, &cp, &n, ccsid))
497 return (curl_version_info_data *) NULL;
499 if(convert_version_info_string(&id->ares, &cp, &n, ccsid))
500 return (curl_version_info_data *) NULL;
502 if(convert_version_info_string(&id->libidn, &cp, &n, ccsid))
503 return (curl_version_info_data *) NULL;
505 if(convert_version_info_string(&id->libssh_version, &cp, &n, ccsid))
506 return (curl_version_info_data *) NULL;
513 curl_easy_strerror_ccsid(CURLcode error, unsigned int ccsid)
520 s = curl_easy_strerror(error);
525 i = MAX_CONV_EXPANSION * (strlen(s) + 1);
527 if(!(buf = Curl_thread_buffer(LK_EASY_STRERROR, i)))
528 return (const char *) NULL;
530 if(convert(buf, i, ccsid, s, -1, ASCII_CCSID) < 0)
531 return (const char *) NULL;
533 return (const char *) buf;
538 curl_share_strerror_ccsid(CURLSHcode error, unsigned int ccsid)
545 s = curl_share_strerror(error);
550 i = MAX_CONV_EXPANSION * (strlen(s) + 1);
552 if(!(buf = Curl_thread_buffer(LK_SHARE_STRERROR, i)))
553 return (const char *) NULL;
555 if(convert(buf, i, ccsid, s, -1, ASCII_CCSID) < 0)
556 return (const char *) NULL;
558 return (const char *) buf;
563 curl_multi_strerror_ccsid(CURLMcode error, unsigned int ccsid)
570 s = curl_multi_strerror(error);
575 i = MAX_CONV_EXPANSION * (strlen(s) + 1);
577 if(!(buf = Curl_thread_buffer(LK_MULTI_STRERROR, i)))
578 return (const char *) NULL;
580 if(convert(buf, i, ccsid, s, -1, ASCII_CCSID) < 0)
581 return (const char *) NULL;
583 return (const char *) buf;
588 curl_certinfo_free_all(struct curl_certinfo *info)
591 /* Free all memory used by certificate info. */
596 for(i = 0; i < info->num_of_certs; i++)
597 curl_slist_free_all(info->certinfo[i]);
598 free((char *) info->certinfo);
606 curl_easy_getinfo_ccsid(CURL * curl, CURLINFO info, ...)
614 struct Curl_easy * data;
615 struct curl_slist * * slp;
616 struct curl_certinfo * cipf;
617 struct curl_certinfo * cipt;
619 /* WARNING: unlike curl_easy_getinfo(), the strings returned by this
620 procedure have to be free'ed. */
622 data = (struct Curl_easy *) curl;
624 paramp = va_arg(arg, void *);
625 ret = Curl_getinfo(data, info, paramp);
628 switch ((int) info & CURLINFO_TYPEMASK) {
630 case CURLINFO_STRING:
631 ccsid = va_arg(arg, unsigned int);
632 cpp = (char * *) paramp;
635 *cpp = dynconvert(ccsid, *cpp, -1, ASCII_CCSID);
638 ret = CURLE_OUT_OF_MEMORY;
644 ccsid = va_arg(arg, unsigned int);
646 case CURLINFO_CERTINFO:
647 cipf = *(struct curl_certinfo * *) paramp;
649 if(!(cipt = (struct curl_certinfo *) malloc(sizeof *cipt)))
650 ret = CURLE_OUT_OF_MEMORY;
652 cipt->certinfo = (struct curl_slist * *)
653 calloc(cipf->num_of_certs +
654 1, sizeof(struct curl_slist *));
656 ret = CURLE_OUT_OF_MEMORY;
660 cipt->num_of_certs = cipf->num_of_certs;
661 for(i = 0; i < cipf->num_of_certs; i++)
662 if(cipf->certinfo[i])
663 if(!(cipt->certinfo[i] = slist_convert(ccsid,
666 ret = CURLE_OUT_OF_MEMORY;
672 if(ret != CURLE_OK) {
673 curl_certinfo_free_all(cipt);
674 cipt = (struct curl_certinfo *) NULL;
677 *(struct curl_certinfo * *) paramp = cipt;
682 case CURLINFO_TLS_SESSION:
683 case CURLINFO_TLS_SSL_PTR:
684 case CURLINFO_SOCKET:
688 slp = (struct curl_slist * *) paramp;
690 if(!(*slp = slist_convert(ccsid, *slp, ASCII_CCSID)))
691 ret = CURLE_OUT_OF_MEMORY;
702 Curl_is_formadd_string(CURLformoption option)
707 case CURLFORM_FILENAME:
708 case CURLFORM_CONTENTTYPE:
709 case CURLFORM_BUFFER:
711 case CURLFORM_FILECONTENT:
712 case CURLFORM_COPYCONTENTS:
713 case CURLFORM_COPYNAME:
722 Curl_formadd_release_local(struct curl_forms * forms, int nargs, int skip)
727 if(Curl_is_formadd_string(forms[nargs].option))
728 if(forms[nargs].value)
729 free((char *) forms[nargs].value);
731 free((char *) forms);
736 Curl_formadd_convert(struct curl_forms * forms,
737 int formx, int lengthx, unsigned int ccsid)
744 if(formx < 0 || !forms[formx].value)
748 l = (int) forms[lengthx].value;
750 l = strlen(forms[formx].value) + 1;
752 cp = malloc(MAX_CONV_EXPANSION * l);
757 l = convert(cp, MAX_CONV_EXPANSION * l, ASCII_CCSID,
758 forms[formx].value, l, ccsid);
765 cp2 = realloc(cp, l); /* Shorten buffer to the string size. */
770 forms[formx].value = cp;
773 forms[lengthx].value = (char *) l; /* Update length after conversion. */
780 curl_formadd_ccsid(struct curl_httppost * * httppost,
781 struct curl_httppost * * last_post, ...)
785 CURLformoption option;
787 struct curl_forms * forms;
788 struct curl_forms * lforms;
789 struct curl_forms * tforms;
790 unsigned int lformlen;
798 unsigned int contentccsid;
799 unsigned int nameccsid;
801 /* A single curl_formadd() call cannot be split in several calls to deal
802 with all parameters: the original parameters are thus copied to a local
803 curl_forms array and converted to ASCII when needed.
804 CURLFORM_PTRNAME is processed as if it were CURLFORM_COPYNAME.
805 CURLFORM_COPYNAME and CURLFORM_NAMELENGTH occurrence order in
806 parameters is not defined; for this reason, the actual conversion is
807 delayed to the end of parameter processing. The same applies to
808 CURLFORM_COPYCONTENTS/CURLFORM_CONTENTSLENGTH, but these may appear
809 several times in the parameter list; the problem resides here in knowing
810 which CURLFORM_CONTENTSLENGTH applies to which CURLFORM_COPYCONTENTS and
811 when we can be sure to have both info for conversion: end of parameter
812 list is such a point, but CURLFORM_CONTENTTYPE is also used here as a
813 natural separator between content data definitions; this seems to be
814 in accordance with FormAdd() behavior. */
816 /* Allocate the local curl_forms array. */
818 lformlen = ALLOC_GRANULE;
819 lforms = malloc(lformlen * sizeof *lforms);
822 return CURL_FORMADD_MEMORY;
824 /* Process the arguments, copying them into local array, latching conversion
825 indexes and converting when needed. */
827 result = CURL_FORMADD_OK;
833 forms = (struct curl_forms *) NULL;
834 va_start(arg, last_post);
837 /* Make sure there is still room for an item in local array. */
839 if(nargs >= lformlen) {
840 lformlen += ALLOC_GRANULE;
841 tforms = realloc(lforms, lformlen * sizeof *lforms);
844 result = CURL_FORMADD_MEMORY;
851 /* Get next option. */
854 /* Get option from array. */
856 option = forms->option;
857 value = forms->value;
861 /* Get option from arguments. */
863 option = va_arg(arg, CURLformoption);
865 if(option == CURLFORM_END)
869 /* Dispatch by option. */
874 forms = (struct curl_forms *) NULL; /* Leave array mode. */
879 forms = va_arg(arg, struct curl_forms *);
883 result = CURL_FORMADD_ILLEGAL_ARRAY;
886 case CURLFORM_COPYNAME:
887 option = CURLFORM_PTRNAME; /* Static for now. */
889 case CURLFORM_PTRNAME:
891 result = CURL_FORMADD_OPTION_TWICE;
896 value = va_arg(arg, char *);
897 nameccsid = (unsigned int) va_arg(arg, long);
900 nameccsid = (unsigned int) forms->value;
906 case CURLFORM_COPYCONTENTS:
908 result = CURL_FORMADD_OPTION_TWICE;
913 value = va_arg(arg, char *);
914 contentccsid = (unsigned int) va_arg(arg, long);
917 contentccsid = (unsigned int) forms->value;
923 case CURLFORM_PTRCONTENTS:
924 case CURLFORM_BUFFERPTR:
926 value = va_arg(arg, char *); /* No conversion. */
930 case CURLFORM_CONTENTSLENGTH:
934 value = (char *) va_arg(arg, long);
938 case CURLFORM_CONTENTLEN:
942 value = (char *) va_arg(arg, curl_off_t);
946 case CURLFORM_NAMELENGTH:
950 value = (char *) va_arg(arg, long);
954 case CURLFORM_BUFFERLENGTH:
956 value = (char *) va_arg(arg, long);
960 case CURLFORM_CONTENTHEADER:
962 value = (char *) va_arg(arg, struct curl_slist *);
966 case CURLFORM_STREAM:
968 value = (char *) va_arg(arg, void *);
972 case CURLFORM_CONTENTTYPE:
973 /* If a previous content has been encountered, convert it now. */
975 if(Curl_formadd_convert(lforms, contentx, lengthx, contentccsid) < 0) {
976 result = CURL_FORMADD_MEMORY;
982 /* Fall into default. */
985 /* Must be a convertible string. */
987 if(!Curl_is_formadd_string(option)) {
988 result = CURL_FORMADD_UNKNOWN_OPTION;
993 value = va_arg(arg, char *);
994 ccsid = (unsigned int) va_arg(arg, long);
997 ccsid = (unsigned int) forms->value;
1001 /* Do the conversion. */
1003 lforms[nargs].value = value;
1005 if(Curl_formadd_convert(lforms, nargs, -1, ccsid) < 0) {
1006 result = CURL_FORMADD_MEMORY;
1010 value = lforms[nargs].value;
1013 if(result != CURL_FORMADD_OK)
1016 lforms[nargs].value = value;
1017 lforms[nargs++].option = option;
1022 /* Convert the name and the last content, now that we know their lengths. */
1024 if(result == CURL_FORMADD_OK && namex >= 0) {
1025 if(Curl_formadd_convert(lforms, namex, namelengthx, nameccsid) < 0)
1026 result = CURL_FORMADD_MEMORY;
1028 lforms[namex].option = CURLFORM_COPYNAME; /* Force copy. */
1031 if(result == CURL_FORMADD_OK) {
1032 if(Curl_formadd_convert(lforms, contentx, lengthx, contentccsid) < 0)
1033 result = CURL_FORMADD_MEMORY;
1038 /* Do the formadd with our converted parameters. */
1040 if(result == CURL_FORMADD_OK) {
1041 lforms[nargs].option = CURLFORM_END;
1042 result = curl_formadd(httppost, last_post,
1043 CURLFORM_ARRAY, lforms, CURLFORM_END);
1048 Curl_formadd_release_local(lforms, nargs, contentx);
1054 curl_formget_callback append;
1061 Curl_formget_callback_ccsid(void * arg, const char * buf, size_t len)
1069 p = (cfcdata *) arg;
1072 return (*p->append)(p->arg, buf, len);
1074 b = malloc(MAX_CONV_EXPANSION * len);
1079 l = convert(b, MAX_CONV_EXPANSION * len, p->ccsid, buf, len, ASCII_CCSID);
1086 ret = (*p->append)(p->arg, b, l);
1088 return ret == l? len: -1;
1093 curl_formget_ccsid(struct curl_httppost * form, void * arg,
1094 curl_formget_callback append, unsigned int ccsid)
1099 lcfc.append = append;
1102 return curl_formget(form, (void *) &lcfc, Curl_formget_callback_ccsid);
1107 curl_easy_setopt_ccsid(CURL * curl, CURLoption tag, ...)
1112 struct Curl_easy * data;
1117 static char testwarn = 1;
1119 /* Warns if this procedure has not been updated when the dupstring enum
1121 We (try to) do it only once: there is no need to issue several times
1122 the same message; but since threadsafeness is not handled here,
1123 this may occur (and we don't care!). */
1128 if((int) STRING_LASTZEROTERMINATED != (int) STRING_TARGET + 1 ||
1129 (int) STRING_LAST != (int) STRING_COPYPOSTFIELDS + 1)
1130 curl_mfprintf(stderr,
1131 "*** WARNING: curl_easy_setopt_ccsid() should be reworked ***\n");
1134 data = (struct Curl_easy *) curl;
1139 case CURLOPT_ABSTRACT_UNIX_SOCKET:
1140 case CURLOPT_CAINFO:
1141 case CURLOPT_CAPATH:
1142 case CURLOPT_COOKIE:
1143 case CURLOPT_COOKIEFILE:
1144 case CURLOPT_COOKIEJAR:
1145 case CURLOPT_COOKIELIST:
1146 case CURLOPT_CRLFILE:
1147 case CURLOPT_CUSTOMREQUEST:
1148 case CURLOPT_DEFAULT_PROTOCOL:
1149 case CURLOPT_DNS_SERVERS:
1150 case CURLOPT_EGDSOCKET:
1151 case CURLOPT_ENCODING:
1152 case CURLOPT_FTPPORT:
1153 case CURLOPT_FTP_ACCOUNT:
1154 case CURLOPT_FTP_ALTERNATIVE_TO_USER:
1155 case CURLOPT_INTERFACE:
1156 case CURLOPT_ISSUERCERT:
1157 case CURLOPT_KEYPASSWD:
1158 case CURLOPT_KRBLEVEL:
1159 case CURLOPT_LOGIN_OPTIONS:
1160 case CURLOPT_MAIL_AUTH:
1161 case CURLOPT_MAIL_FROM:
1162 case CURLOPT_NETRC_FILE:
1163 case CURLOPT_NOPROXY:
1164 case CURLOPT_PASSWORD:
1165 case CURLOPT_PINNEDPUBLICKEY:
1166 case CURLOPT_PRE_PROXY:
1168 case CURLOPT_PROXYPASSWORD:
1169 case CURLOPT_PROXYUSERNAME:
1170 case CURLOPT_PROXYUSERPWD:
1171 case CURLOPT_PROXY_CAINFO:
1172 case CURLOPT_PROXY_CAPATH:
1173 case CURLOPT_PROXY_CRLFILE:
1174 case CURLOPT_PROXY_KEYPASSWD:
1175 case CURLOPT_PROXY_PINNEDPUBLICKEY:
1176 case CURLOPT_PROXY_SERVICE_NAME:
1177 case CURLOPT_PROXY_SSLCERT:
1178 case CURLOPT_PROXY_SSLCERTTYPE:
1179 case CURLOPT_PROXY_SSLKEY:
1180 case CURLOPT_PROXY_SSLKEYTYPE:
1181 case CURLOPT_PROXY_SSL_CIPHER_LIST:
1182 case CURLOPT_PROXY_TLSAUTH_PASSWORD:
1183 case CURLOPT_PROXY_TLSAUTH_TYPE:
1184 case CURLOPT_PROXY_TLSAUTH_USERNAME:
1185 case CURLOPT_RANDOM_FILE:
1187 case CURLOPT_REFERER:
1188 case CURLOPT_REQUEST_TARGET:
1189 case CURLOPT_RTSP_SESSION_ID:
1190 case CURLOPT_RTSP_STREAM_URI:
1191 case CURLOPT_RTSP_TRANSPORT:
1192 case CURLOPT_SERVICE_NAME:
1193 case CURLOPT_SOCKS5_GSSAPI_SERVICE:
1194 case CURLOPT_SSH_HOST_PUBLIC_KEY_MD5:
1195 case CURLOPT_SSH_KNOWNHOSTS:
1196 case CURLOPT_SSH_PRIVATE_KEYFILE:
1197 case CURLOPT_SSH_PUBLIC_KEYFILE:
1198 case CURLOPT_SSLCERT:
1199 case CURLOPT_SSLCERTTYPE:
1200 case CURLOPT_SSLENGINE:
1201 case CURLOPT_SSLKEY:
1202 case CURLOPT_SSLKEYTYPE:
1203 case CURLOPT_SSL_CIPHER_LIST:
1204 case CURLOPT_TLSAUTH_PASSWORD:
1205 case CURLOPT_TLSAUTH_TYPE:
1206 case CURLOPT_TLSAUTH_USERNAME:
1207 case CURLOPT_UNIX_SOCKET_PATH:
1209 case CURLOPT_USERAGENT:
1210 case CURLOPT_USERNAME:
1211 case CURLOPT_USERPWD:
1212 case CURLOPT_XOAUTH2_BEARER:
1213 s = va_arg(arg, char *);
1214 ccsid = va_arg(arg, unsigned int);
1217 s = dynconvert(ASCII_CCSID, s, -1, ccsid);
1220 result = CURLE_OUT_OF_MEMORY;
1225 result = curl_easy_setopt(curl, tag, s);
1229 case CURLOPT_COPYPOSTFIELDS:
1230 /* Special case: byte count may have been given by CURLOPT_POSTFIELDSIZE
1231 prior to this call. In this case, convert the given byte count and
1232 replace the length according to the conversion result. */
1233 s = va_arg(arg, char *);
1234 ccsid = va_arg(arg, unsigned int);
1236 pfsize = data->set.postfieldsize;
1238 if(!s || !pfsize || ccsid == NOCONV_CCSID || ccsid == ASCII_CCSID) {
1239 result = curl_easy_setopt(curl, CURLOPT_COPYPOSTFIELDS, s);
1244 /* Data is null-terminated. */
1245 s = dynconvert(ASCII_CCSID, s, -1, ccsid);
1248 result = CURLE_OUT_OF_MEMORY;
1253 /* Data length specified. */
1256 if(pfsize < 0 || pfsize > SIZE_MAX) {
1257 result = CURLE_OUT_OF_MEMORY;
1262 pfsize = len * MAX_CONV_EXPANSION;
1264 if(pfsize > SIZE_MAX)
1267 cp = malloc(pfsize);
1270 result = CURLE_OUT_OF_MEMORY;
1274 pfsize = convert(cp, pfsize, ASCII_CCSID, s, len, ccsid);
1278 result = CURLE_OUT_OF_MEMORY;
1282 data->set.postfieldsize = pfsize; /* Replace data size. */
1286 result = curl_easy_setopt(curl, CURLOPT_POSTFIELDS, s);
1287 data->set.str[STRING_COPYPOSTFIELDS] = s; /* Give to library. */
1290 case CURLOPT_ERRORBUFFER: /* This is an output buffer. */
1292 result = Curl_vsetopt(data, tag, arg);
1302 curl_form_long_value(long value)
1305 /* ILE/RPG cannot cast an integer to a pointer. This procedure does it. */
1307 return (char *) value;
1312 curl_pushheader_bynum_cssid(struct curl_pushheaders *h,
1313 size_t num, unsigned int ccsid)
1316 char *d = (char *) NULL;
1317 char *s = curl_pushheader_bynum(h, num);
1320 d = dynconvert(ccsid, s, -1, ASCII_CCSID);
1327 curl_pushheader_byname_ccsid(struct curl_pushheaders *h, const char *header,
1328 unsigned int ccsidin, unsigned int ccsidout)
1331 char *d = (char *) NULL;
1335 header = dynconvert(ASCII_CCSID, header, -1, ccsidin);
1338 s = curl_pushheader_byname(h, header);
1339 free((char *) header);
1342 d = dynconvert(ccsidout, s, -1, ASCII_CCSID);