Annotation of embedaddon/curl/packages/OS400/ccsidcurl.c, revision 1.1.1.1
1.1 misho 1: /***************************************************************************
2: * _ _ ____ _
3: * Project ___| | | | _ \| |
4: * / __| | | | |_) | |
5: * | (__| |_| | _ <| |___
6: * \___|\___/|_| \_\_____|
7: *
8: * Copyright (C) 1998 - 2020, Daniel Stenberg, <daniel@haxx.se>, et al.
9: *
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.
13: *
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.
17: *
18: * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
19: * KIND, either express or implied.
20: *
21: *
22: ***************************************************************************/
23:
24: /* CCSID API wrappers for OS/400. */
25:
26: #include <iconv.h>
27: #include <string.h>
28: #include <stdlib.h>
29: #include <errno.h>
30: #include <stdarg.h>
31:
32: #pragma enum(int)
33:
34: #include "curl.h"
35: #include "mprintf.h"
36: #include "slist.h"
37: #include "urldata.h"
38: #include "url.h"
39: #include "setopt.h"
40: #include "getinfo.h"
41: #include "ccsidcurl.h"
42:
43: #include "os400sys.h"
44:
45: #ifndef SIZE_MAX
46: #define SIZE_MAX ((size_t) ~0) /* Is unsigned on OS/400. */
47: #endif
48:
49:
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)
54:
55: #define ALLOC_GRANULE 8 /* Alloc. granule for curl_formadd_ccsid(). */
56:
57:
58: static void
59: makeOS400IconvCode(char buf[ICONV_ID_SIZE], unsigned int ccsid)
60:
61: {
62: /**
63: *** Convert a CCSID to the corresponding IBM iconv_open() character
64: *** code identifier.
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.
68: **/
69:
70: ccsid &= 0xFFFF;
71:
72: if(ccsid == NOCONV_CCSID)
73: ccsid = ASCII_CCSID;
74:
75: memset(buf, 0, ICONV_ID_SIZE);
76: curl_msprintf(buf, "IBMCCSID%05u0000000", ccsid);
77: }
78:
79:
80: static iconv_t
81: iconv_open_CCSID(unsigned int ccsidout, unsigned int ccsidin,
82: unsigned int cstr)
83:
84: {
85: char fromcode[ICONV_ID_SIZE];
86: char tocode[ICONV_ID_SIZE];
87:
88: /**
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".
93: **/
94:
95: makeOS400IconvCode(fromcode, ccsidin);
96: makeOS400IconvCode(tocode, ccsidout);
97: memset(tocode + 13, 0, sizeof(tocode) - 13); /* Dest. code id format. */
98:
99: if(cstr)
100: fromcode[18] = '1'; /* Set null-terminator flag. */
101:
102: return iconv_open(tocode, fromcode);
103: }
104:
105:
106: static int
107: convert(char *d, size_t dlen, int dccsid,
108: const char *s, int slen, int sccsid)
109:
110: {
111: int i;
112: iconv_t cd;
113: size_t lslen;
114:
115: /**
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.
121: **/
122:
123: if(sccsid == 65535)
124: sccsid = ASCII_CCSID;
125:
126: if(dccsid == 65535)
127: dccsid = ASCII_CCSID;
128:
129: if(sccsid == dccsid) {
130: lslen = slen >= 0? slen: strlen(s) + 1;
131: i = lslen < dlen? lslen: dlen;
132:
133: if(s != d && i > 0)
134: memcpy(d, s, i);
135:
136: return i;
137: }
138:
139: if(slen < 0) {
140: lslen = 0;
141: cd = iconv_open_CCSID(dccsid, sccsid, 1);
142: }
143: else {
144: lslen = (size_t) slen;
145: cd = iconv_open_CCSID(dccsid, sccsid, 0);
146: }
147:
148: if(ICONV_OPEN_ERROR(cd))
149: return -1;
150:
151: i = dlen;
152:
153: if((int) iconv(cd, (char * *) &s, &lslen, &d, &dlen) < 0)
154: i = -1;
155: else
156: i -= dlen;
157:
158: iconv_close(cd);
159: return i;
160: }
161:
162:
163: static char *
164: dynconvert(int dccsid, const char *s, int slen, int sccsid)
165:
166: {
167: char *d;
168: char *cp;
169: size_t dlen;
170: int l;
171: static const char nullbyte = 0;
172:
173: /* Like convert, but the destination is allocated and returned. */
174:
175: dlen = (size_t) (slen < 0? strlen(s): slen) + 1;
176: dlen *= MAX_CONV_EXPANSION; /* Allow some expansion. */
177: d = malloc(dlen);
178:
179: if(!d)
180: return (char *) NULL;
181:
182: l = convert(d, dlen, dccsid, s, slen, sccsid);
183:
184: if(l < 0) {
185: free(d);
186: return (char *) NULL;
187: }
188:
189: if(slen < 0) {
190: /* Need to null-terminate even when source length is given.
191: Since destination code size is unknown, use a conversion to generate
192: terminator. */
193:
194: int l2 = convert(d + l, dlen - l, dccsid, &nullbyte, -1, ASCII_CCSID);
195:
196: if(l2 < 0) {
197: free(d);
198: return (char *) NULL;
199: }
200:
201: l += l2;
202: }
203:
204: if((size_t) l < dlen) {
205: cp = realloc(d, l); /* Shorten to minimum needed. */
206:
207: if(cp)
208: d = cp;
209: }
210:
211: return d;
212: }
213:
214:
215: static struct curl_slist *
216: slist_convert(int dccsid, struct curl_slist *from, int sccsid)
217:
218: {
219: struct curl_slist *to = (struct curl_slist *) NULL;
220:
221: for(; from; from = from->next) {
222: struct curl_slist *nl;
223: char *cp = dynconvert(dccsid, from->data, -1, sccsid);
224:
225: if(!cp) {
226: curl_slist_free_all(to);
227: return (struct curl_slist *) NULL;
228: }
229: nl = Curl_slist_append_nodup(to, cp);
230: if(!nl) {
231: curl_slist_free_all(to);
232: free(cp);
233: return NULL;
234: }
235: to = nl;
236: }
237: return to;
238: }
239:
240:
241: char *
242: curl_version_ccsid(unsigned int ccsid)
243:
244: {
245: int i;
246: char *aversion;
247: char *eversion;
248:
249: aversion = curl_version();
250:
251: if(!aversion)
252: return aversion;
253:
254: i = strlen(aversion) + 1;
255: i *= MAX_CONV_EXPANSION;
256:
257: eversion = Curl_thread_buffer(LK_CURL_VERSION, i);
258: if(!eversion)
259: return (char *) NULL;
260:
261: if(convert(eversion, i, ccsid, aversion, -1, ASCII_CCSID) < 0)
262: return (char *) NULL;
263:
264: return eversion;
265: }
266:
267:
268: char *
269: curl_easy_escape_ccsid(CURL *handle, const char *string, int length,
270: unsigned int sccsid, unsigned int dccsid)
271:
272: {
273: char *s;
274: char *d;
275:
276: if(!string) {
277: errno = EINVAL;
278: return (char *) NULL;
279: }
280:
281: s = dynconvert(ASCII_CCSID, string, length? length: -1, sccsid);
282:
283: if(!s)
284: return (char *) NULL;
285:
286: d = curl_easy_escape(handle, s, 0);
287: free(s);
288:
289: if(!d)
290: return (char *) NULL;
291:
292: s = dynconvert(dccsid, d, -1, ASCII_CCSID);
293: free(d);
294: return s;
295: }
296:
297:
298: char *
299: curl_easy_unescape_ccsid(CURL *handle, const char *string, int length,
300: int *outlength,
301: unsigned int sccsid, unsigned int dccsid)
302:
303: {
304: char *s;
305: char *d;
306:
307: if(!string) {
308: errno = EINVAL;
309: return (char *) NULL;
310: }
311:
312: s = dynconvert(ASCII_CCSID, string, length? length: -1, sccsid);
313:
314: if(!s)
315: return (char *) NULL;
316:
317: d = curl_easy_unescape(handle, s, 0, outlength);
318: free(s);
319:
320: if(!d)
321: return (char *) NULL;
322:
323: s = dynconvert(dccsid, d, -1, ASCII_CCSID);
324: free(d);
325:
326: if(s && outlength)
327: *outlength = strlen(s);
328:
329: return s;
330: }
331:
332:
333: struct curl_slist *
334: curl_slist_append_ccsid(struct curl_slist *list,
335: const char *data, unsigned int ccsid)
336:
337: {
338: char *s;
339:
340: s = (char *) NULL;
341:
342: if(!data)
343: return curl_slist_append(list, data);
344:
345: s = dynconvert(ASCII_CCSID, data, -1, ccsid);
346:
347: if(!s)
348: return (struct curl_slist *) NULL;
349:
350: list = curl_slist_append(list, s);
351: free(s);
352: return list;
353: }
354:
355:
356: time_t
357: curl_getdate_ccsid(const char *p, const time_t * unused, unsigned int ccsid)
358:
359: {
360: char *s;
361: time_t t;
362:
363: if(!p)
364: return curl_getdate(p, unused);
365:
366: s = dynconvert(ASCII_CCSID, p, -1, ccsid);
367:
368: if(!s)
369: return (time_t) -1;
370:
371: t = curl_getdate(s, unused);
372: free(s);
373: return t;
374: }
375:
376:
377: static int
378: convert_version_info_string(const char * * stringp,
379: char * * bufp, int *left, unsigned int ccsid)
380:
381: {
382: /* Helper for curl_version_info_ccsid(): convert a string if defined.
383: Result is stored in the `*left'-byte buffer at `*bufp'.
384: `*bufp' and `*left' are updated accordingly.
385: Return 0 if ok, else -1. */
386:
387: if(*stringp) {
388: int l = convert(*bufp, *left, ccsid, *stringp, -1, ASCII_CCSID);
389:
390: if(l <= 0)
391: return -1;
392:
393: *stringp = *bufp;
394: *bufp += l;
395: *left -= l;
396: }
397:
398: return 0;
399: }
400:
401:
402: curl_version_info_data *
403: curl_version_info_ccsid(CURLversion stamp, unsigned int ccsid)
404:
405: {
406: curl_version_info_data * p;
407: char *cp;
408: int n;
409: int nproto;
410: curl_version_info_data * id;
411:
412: /* The assertion below is possible, because although the second operand
413: is an enum member, the first is a #define. In that case, the OS/400 C
414: compiler seems to compare string values after substitution. */
415:
416: #if CURLVERSION_NOW != CURLVERSION_FOURTH
417: #error curl_version_info_data structure has changed: upgrade this procedure.
418: #endif
419:
420: /* If caller has been compiled with a new version, error. */
421:
422: if(stamp > CURLVERSION_NOW)
423: return (curl_version_info_data *) NULL;
424:
425: p = curl_version_info(stamp);
426:
427: if(!p)
428: return p;
429:
430: /* Measure thread space needed. */
431:
432: n = 0;
433: nproto = 0;
434:
435: if(p->protocols) {
436: while(p->protocols[nproto])
437: n += strlen(p->protocols[nproto++]);
438:
439: n += nproto++;
440: }
441:
442: if(p->version)
443: n += strlen(p->version) + 1;
444:
445: if(p->host)
446: n += strlen(p->host) + 1;
447:
448: if(p->ssl_version)
449: n += strlen(p->ssl_version) + 1;
450:
451: if(p->libz_version)
452: n += strlen(p->libz_version) + 1;
453:
454: if(p->ares)
455: n += strlen(p->ares) + 1;
456:
457: if(p->libidn)
458: n += strlen(p->libidn) + 1;
459:
460: if(p->libssh_version)
461: n += strlen(p->libssh_version) + 1;
462:
463: /* Allocate thread space. */
464:
465: n *= MAX_CONV_EXPANSION;
466:
467: if(nproto)
468: n += nproto * sizeof(const char *);
469:
470: cp = Curl_thread_buffer(LK_VERSION_INFO_DATA, n);
471: id = (curl_version_info_data *) Curl_thread_buffer(LK_VERSION_INFO,
472: sizeof(*id));
473:
474: if(!id || !cp)
475: return (curl_version_info_data *) NULL;
476:
477: /* Copy data and convert strings. */
478:
479: memcpy((char *) id, (char *) p, sizeof(*p));
480:
481: if(id->protocols) {
482: int i = nproto * sizeof(id->protocols[0]);
483:
484: id->protocols = (const char * const *) cp;
485: memcpy(cp, (char *) p->protocols, i);
486: cp += i;
487: n -= i;
488:
489: for(i = 0; id->protocols[i]; i++)
490: if(convert_version_info_string(((const char * *) id->protocols) + i,
491: &cp, &n, ccsid))
492: return (curl_version_info_data *) NULL;
493: }
494:
495: if(convert_version_info_string(&id->version, &cp, &n, ccsid))
496: return (curl_version_info_data *) NULL;
497:
498: if(convert_version_info_string(&id->host, &cp, &n, ccsid))
499: return (curl_version_info_data *) NULL;
500:
501: if(convert_version_info_string(&id->ssl_version, &cp, &n, ccsid))
502: return (curl_version_info_data *) NULL;
503:
504: if(convert_version_info_string(&id->libz_version, &cp, &n, ccsid))
505: return (curl_version_info_data *) NULL;
506:
507: if(convert_version_info_string(&id->ares, &cp, &n, ccsid))
508: return (curl_version_info_data *) NULL;
509:
510: if(convert_version_info_string(&id->libidn, &cp, &n, ccsid))
511: return (curl_version_info_data *) NULL;
512:
513: if(convert_version_info_string(&id->libssh_version, &cp, &n, ccsid))
514: return (curl_version_info_data *) NULL;
515:
516: return id;
517: }
518:
519:
520: const char *
521: curl_easy_strerror_ccsid(CURLcode error, unsigned int ccsid)
522:
523: {
524: int i;
525: const char *s;
526: char *buf;
527:
528: s = curl_easy_strerror(error);
529:
530: if(!s)
531: return s;
532:
533: i = MAX_CONV_EXPANSION * (strlen(s) + 1);
534:
535: buf = Curl_thread_buffer(LK_EASY_STRERROR, i);
536: if(!buf)
537: return (const char *) NULL;
538:
539: if(convert(buf, i, ccsid, s, -1, ASCII_CCSID) < 0)
540: return (const char *) NULL;
541:
542: return (const char *) buf;
543: }
544:
545:
546: const char *
547: curl_share_strerror_ccsid(CURLSHcode error, unsigned int ccsid)
548:
549: {
550: int i;
551: const char *s;
552: char *buf;
553:
554: s = curl_share_strerror(error);
555:
556: if(!s)
557: return s;
558:
559: i = MAX_CONV_EXPANSION * (strlen(s) + 1);
560:
561: buf = Curl_thread_buffer(LK_SHARE_STRERROR, i);
562: if(!buf)
563: return (const char *) NULL;
564:
565: if(convert(buf, i, ccsid, s, -1, ASCII_CCSID) < 0)
566: return (const char *) NULL;
567:
568: return (const char *) buf;
569: }
570:
571:
572: const char *
573: curl_multi_strerror_ccsid(CURLMcode error, unsigned int ccsid)
574:
575: {
576: int i;
577: const char *s;
578: char *buf;
579:
580: s = curl_multi_strerror(error);
581:
582: if(!s)
583: return s;
584:
585: i = MAX_CONV_EXPANSION * (strlen(s) + 1);
586:
587: buf = Curl_thread_buffer(LK_MULTI_STRERROR, i);
588: if(!buf)
589: return (const char *) NULL;
590:
591: if(convert(buf, i, ccsid, s, -1, ASCII_CCSID) < 0)
592: return (const char *) NULL;
593:
594: return (const char *) buf;
595: }
596:
597:
598: void
599: curl_certinfo_free_all(struct curl_certinfo *info)
600:
601: {
602: /* Free all memory used by certificate info. */
603: if(info) {
604: if(info->certinfo) {
605: int i;
606:
607: for(i = 0; i < info->num_of_certs; i++)
608: curl_slist_free_all(info->certinfo[i]);
609: free((char *) info->certinfo);
610: }
611: free((char *) info);
612: }
613: }
614:
615:
616: CURLcode
617: curl_easy_getinfo_ccsid(CURL *curl, CURLINFO info, ...)
618:
619: {
620: va_list arg;
621: void *paramp;
622: CURLcode ret;
623: struct Curl_easy * data;
624:
625: /* WARNING: unlike curl_easy_getinfo(), the strings returned by this
626: procedure have to be free'ed. */
627:
628: data = (struct Curl_easy *) curl;
629: va_start(arg, info);
630: paramp = va_arg(arg, void *);
631: ret = Curl_getinfo(data, info, paramp);
632:
633: if(ret == CURLE_OK) {
634: unsigned int ccsid;
635: char **cpp;
636: struct curl_slist **slp;
637: struct curl_certinfo *cipf;
638: struct curl_certinfo *cipt;
639:
640: switch((int) info & CURLINFO_TYPEMASK) {
641:
642: case CURLINFO_STRING:
643: ccsid = va_arg(arg, unsigned int);
644: cpp = (char * *) paramp;
645:
646: if(*cpp) {
647: *cpp = dynconvert(ccsid, *cpp, -1, ASCII_CCSID);
648:
649: if(!*cpp)
650: ret = CURLE_OUT_OF_MEMORY;
651: }
652:
653: break;
654:
655: case CURLINFO_SLIST:
656: ccsid = va_arg(arg, unsigned int);
657: switch(info) {
658: case CURLINFO_CERTINFO:
659: cipf = *(struct curl_certinfo * *) paramp;
660: if(cipf) {
661: cipt = (struct curl_certinfo *) malloc(sizeof(*cipt));
662: if(!cipt)
663: ret = CURLE_OUT_OF_MEMORY;
664: else {
665: cipt->certinfo = (struct curl_slist **)
666: calloc(cipf->num_of_certs +
667: 1, sizeof(struct curl_slist *));
668: if(!cipt->certinfo)
669: ret = CURLE_OUT_OF_MEMORY;
670: else {
671: int i;
672:
673: cipt->num_of_certs = cipf->num_of_certs;
674: for(i = 0; i < cipf->num_of_certs; i++)
675: if(cipf->certinfo[i])
676: if(!(cipt->certinfo[i] = slist_convert(ccsid,
677: cipf->certinfo[i],
678: ASCII_CCSID))) {
679: ret = CURLE_OUT_OF_MEMORY;
680: break;
681: }
682: }
683: }
684:
685: if(ret != CURLE_OK) {
686: curl_certinfo_free_all(cipt);
687: cipt = (struct curl_certinfo *) NULL;
688: }
689:
690: *(struct curl_certinfo * *) paramp = cipt;
691: }
692:
693: break;
694:
695: case CURLINFO_TLS_SESSION:
696: case CURLINFO_TLS_SSL_PTR:
697: case CURLINFO_SOCKET:
698: break;
699:
700: default:
701: slp = (struct curl_slist **) paramp;
702: if(*slp) {
703: *slp = slist_convert(ccsid, *slp, ASCII_CCSID);
704: if(!*slp)
705: ret = CURLE_OUT_OF_MEMORY;
706: }
707: break;
708: }
709: }
710: }
711:
712: va_end(arg);
713: return ret;
714: }
715:
716:
717: static int
718: Curl_is_formadd_string(CURLformoption option)
719:
720: {
721: switch(option) {
722:
723: case CURLFORM_FILENAME:
724: case CURLFORM_CONTENTTYPE:
725: case CURLFORM_BUFFER:
726: case CURLFORM_FILE:
727: case CURLFORM_FILECONTENT:
728: case CURLFORM_COPYCONTENTS:
729: case CURLFORM_COPYNAME:
730: return 1;
731: }
732:
733: return 0;
734: }
735:
736:
737: static void
738: Curl_formadd_release_local(struct curl_forms * forms, int nargs, int skip)
739:
740: {
741: while(nargs--)
742: if(nargs != skip)
743: if(Curl_is_formadd_string(forms[nargs].option))
744: if(forms[nargs].value)
745: free((char *) forms[nargs].value);
746:
747: free((char *) forms);
748: }
749:
750:
751: static int
752: Curl_formadd_convert(struct curl_forms * forms,
753: int formx, int lengthx, unsigned int ccsid)
754:
755: {
756: int l;
757: char *cp;
758: char *cp2;
759:
760: if(formx < 0 || !forms[formx].value)
761: return 0;
762:
763: if(lengthx >= 0)
764: l = (int) forms[lengthx].value;
765: else
766: l = strlen(forms[formx].value) + 1;
767:
768: cp = malloc(MAX_CONV_EXPANSION * l);
769:
770: if(!cp)
771: return -1;
772:
773: l = convert(cp, MAX_CONV_EXPANSION * l, ASCII_CCSID,
774: forms[formx].value, l, ccsid);
775:
776: if(l < 0) {
777: free(cp);
778: return -1;
779: }
780:
781: cp2 = realloc(cp, l); /* Shorten buffer to the string size. */
782:
783: if(cp2)
784: cp = cp2;
785:
786: forms[formx].value = cp;
787:
788: if(lengthx >= 0)
789: forms[lengthx].value = (char *) l; /* Update length after conversion. */
790:
791: return l;
792: }
793:
794:
795: CURLFORMcode
796: curl_formadd_ccsid(struct curl_httppost * * httppost,
797: struct curl_httppost * * last_post, ...)
798:
799: {
800: va_list arg;
801: CURLformoption option;
802: CURLFORMcode result;
803: struct curl_forms * forms;
804: struct curl_forms * lforms;
805: struct curl_forms * tforms;
806: unsigned int lformlen;
807: const char *value;
808: unsigned int ccsid;
809: int nargs;
810: int namex;
811: int namelengthx;
812: int contentx;
813: int lengthx;
814: unsigned int contentccsid;
815: unsigned int nameccsid;
816:
817: /* A single curl_formadd() call cannot be split in several calls to deal
818: with all parameters: the original parameters are thus copied to a local
819: curl_forms array and converted to ASCII when needed.
820: CURLFORM_PTRNAME is processed as if it were CURLFORM_COPYNAME.
821: CURLFORM_COPYNAME and CURLFORM_NAMELENGTH occurrence order in
822: parameters is not defined; for this reason, the actual conversion is
823: delayed to the end of parameter processing. The same applies to
824: CURLFORM_COPYCONTENTS/CURLFORM_CONTENTSLENGTH, but these may appear
825: several times in the parameter list; the problem resides here in knowing
826: which CURLFORM_CONTENTSLENGTH applies to which CURLFORM_COPYCONTENTS and
827: when we can be sure to have both info for conversion: end of parameter
828: list is such a point, but CURLFORM_CONTENTTYPE is also used here as a
829: natural separator between content data definitions; this seems to be
830: in accordance with FormAdd() behavior. */
831:
832: /* Allocate the local curl_forms array. */
833:
834: lformlen = ALLOC_GRANULE;
835: lforms = malloc(lformlen * sizeof(*lforms));
836:
837: if(!lforms)
838: return CURL_FORMADD_MEMORY;
839:
840: /* Process the arguments, copying them into local array, latching conversion
841: indexes and converting when needed. */
842:
843: result = CURL_FORMADD_OK;
844: nargs = 0;
845: contentx = -1;
846: lengthx = -1;
847: namex = -1;
848: namelengthx = -1;
849: forms = (struct curl_forms *) NULL;
850: va_start(arg, last_post);
851:
852: for(;;) {
853: /* Make sure there is still room for an item in local array. */
854:
855: if(nargs >= lformlen) {
856: lformlen += ALLOC_GRANULE;
857: tforms = realloc(lforms, lformlen * sizeof(*lforms));
858:
859: if(!tforms) {
860: result = CURL_FORMADD_MEMORY;
861: break;
862: }
863:
864: lforms = tforms;
865: }
866:
867: /* Get next option. */
868:
869: if(forms) {
870: /* Get option from array. */
871:
872: option = forms->option;
873: value = forms->value;
874: forms++;
875: }
876: else {
877: /* Get option from arguments. */
878:
879: option = va_arg(arg, CURLformoption);
880:
881: if(option == CURLFORM_END)
882: break;
883: }
884:
885: /* Dispatch by option. */
886:
887: switch(option) {
888:
889: case CURLFORM_END:
890: forms = (struct curl_forms *) NULL; /* Leave array mode. */
891: continue;
892:
893: case CURLFORM_ARRAY:
894: if(!forms) {
895: forms = va_arg(arg, struct curl_forms *);
896: continue;
897: }
898:
899: result = CURL_FORMADD_ILLEGAL_ARRAY;
900: break;
901:
902: case CURLFORM_COPYNAME:
903: option = CURLFORM_PTRNAME; /* Static for now. */
904:
905: case CURLFORM_PTRNAME:
906: if(namex >= 0)
907: result = CURL_FORMADD_OPTION_TWICE;
908:
909: namex = nargs;
910:
911: if(!forms) {
912: value = va_arg(arg, char *);
913: nameccsid = (unsigned int) va_arg(arg, long);
914: }
915: else {
916: nameccsid = (unsigned int) forms->value;
917: forms++;
918: }
919:
920: break;
921:
922: case CURLFORM_COPYCONTENTS:
923: if(contentx >= 0)
924: result = CURL_FORMADD_OPTION_TWICE;
925:
926: contentx = nargs;
927:
928: if(!forms) {
929: value = va_arg(arg, char *);
930: contentccsid = (unsigned int) va_arg(arg, long);
931: }
932: else {
933: contentccsid = (unsigned int) forms->value;
934: forms++;
935: }
936:
937: break;
938:
939: case CURLFORM_PTRCONTENTS:
940: case CURLFORM_BUFFERPTR:
941: if(!forms)
942: value = va_arg(arg, char *); /* No conversion. */
943:
944: break;
945:
946: case CURLFORM_CONTENTSLENGTH:
947: lengthx = nargs;
948:
949: if(!forms)
950: value = (char *) va_arg(arg, long);
951:
952: break;
953:
954: case CURLFORM_CONTENTLEN:
955: lengthx = nargs;
956:
957: if(!forms)
958: value = (char *) va_arg(arg, curl_off_t);
959:
960: break;
961:
962: case CURLFORM_NAMELENGTH:
963: namelengthx = nargs;
964:
965: if(!forms)
966: value = (char *) va_arg(arg, long);
967:
968: break;
969:
970: case CURLFORM_BUFFERLENGTH:
971: if(!forms)
972: value = (char *) va_arg(arg, long);
973:
974: break;
975:
976: case CURLFORM_CONTENTHEADER:
977: if(!forms)
978: value = (char *) va_arg(arg, struct curl_slist *);
979:
980: break;
981:
982: case CURLFORM_STREAM:
983: if(!forms)
984: value = (char *) va_arg(arg, void *);
985:
986: break;
987:
988: case CURLFORM_CONTENTTYPE:
989: /* If a previous content has been encountered, convert it now. */
990:
991: if(Curl_formadd_convert(lforms, contentx, lengthx, contentccsid) < 0) {
992: result = CURL_FORMADD_MEMORY;
993: break;
994: }
995:
996: contentx = -1;
997: lengthx = -1;
998: /* Fall into default. */
999:
1000: default:
1001: /* Must be a convertible string. */
1002:
1003: if(!Curl_is_formadd_string(option)) {
1004: result = CURL_FORMADD_UNKNOWN_OPTION;
1005: break;
1006: }
1007:
1008: if(!forms) {
1009: value = va_arg(arg, char *);
1010: ccsid = (unsigned int) va_arg(arg, long);
1011: }
1012: else {
1013: ccsid = (unsigned int) forms->value;
1014: forms++;
1015: }
1016:
1017: /* Do the conversion. */
1018:
1019: lforms[nargs].value = value;
1020:
1021: if(Curl_formadd_convert(lforms, nargs, -1, ccsid) < 0) {
1022: result = CURL_FORMADD_MEMORY;
1023: break;
1024: }
1025:
1026: value = lforms[nargs].value;
1027: }
1028:
1029: if(result != CURL_FORMADD_OK)
1030: break;
1031:
1032: lforms[nargs].value = value;
1033: lforms[nargs++].option = option;
1034: }
1035:
1036: va_end(arg);
1037:
1038: /* Convert the name and the last content, now that we know their lengths. */
1039:
1040: if(result == CURL_FORMADD_OK && namex >= 0) {
1041: if(Curl_formadd_convert(lforms, namex, namelengthx, nameccsid) < 0)
1042: result = CURL_FORMADD_MEMORY;
1043: else
1044: lforms[namex].option = CURLFORM_COPYNAME; /* Force copy. */
1045: }
1046:
1047: if(result == CURL_FORMADD_OK) {
1048: if(Curl_formadd_convert(lforms, contentx, lengthx, contentccsid) < 0)
1049: result = CURL_FORMADD_MEMORY;
1050: else
1051: contentx = -1;
1052: }
1053:
1054: /* Do the formadd with our converted parameters. */
1055:
1056: if(result == CURL_FORMADD_OK) {
1057: lforms[nargs].option = CURLFORM_END;
1058: result = curl_formadd(httppost, last_post,
1059: CURLFORM_ARRAY, lforms, CURLFORM_END);
1060: }
1061:
1062: /* Terminate. */
1063:
1064: Curl_formadd_release_local(lforms, nargs, contentx);
1065: return result;
1066: }
1067:
1068:
1069: typedef struct {
1070: curl_formget_callback append;
1071: void * arg;
1072: unsigned int ccsid;
1073: } cfcdata;
1074:
1075:
1076: static size_t
1077: Curl_formget_callback_ccsid(void *arg, const char *buf, size_t len)
1078:
1079: {
1080: cfcdata * p;
1081: char *b;
1082: int l;
1083: size_t ret;
1084:
1085: p = (cfcdata *) arg;
1086:
1087: if((long) len <= 0)
1088: return (*p->append)(p->arg, buf, len);
1089:
1090: b = malloc(MAX_CONV_EXPANSION * len);
1091:
1092: if(!b)
1093: return (size_t) -1;
1094:
1095: l = convert(b, MAX_CONV_EXPANSION * len, p->ccsid, buf, len, ASCII_CCSID);
1096:
1097: if(l < 0) {
1098: free(b);
1099: return (size_t) -1;
1100: }
1101:
1102: ret = (*p->append)(p->arg, b, l);
1103: free(b);
1104: return ret == l? len: -1;
1105: }
1106:
1107:
1108: int
1109: curl_formget_ccsid(struct curl_httppost *form, void *arg,
1110: curl_formget_callback append, unsigned int ccsid)
1111:
1112: {
1113: cfcdata lcfc;
1114:
1115: lcfc.append = append;
1116: lcfc.arg = arg;
1117: lcfc.ccsid = ccsid;
1118: return curl_formget(form, (void *) &lcfc, Curl_formget_callback_ccsid);
1119: }
1120:
1121:
1122: CURLcode
1123: curl_easy_setopt_ccsid(CURL *curl, CURLoption tag, ...)
1124:
1125: {
1126: CURLcode result;
1127: va_list arg;
1128: struct Curl_easy *data;
1129: char *s;
1130: char *cp;
1131: unsigned int ccsid;
1132: curl_off_t pfsize;
1133:
1134: data = (struct Curl_easy *) curl;
1135: va_start(arg, tag);
1136:
1137: switch(tag) {
1138:
1139: case CURLOPT_ABSTRACT_UNIX_SOCKET:
1140: case CURLOPT_ALTSVC:
1141: case CURLOPT_CAINFO:
1142: case CURLOPT_CAPATH:
1143: case CURLOPT_COOKIE:
1144: case CURLOPT_COOKIEFILE:
1145: case CURLOPT_COOKIEJAR:
1146: case CURLOPT_COOKIELIST:
1147: case CURLOPT_CRLFILE:
1148: case CURLOPT_CUSTOMREQUEST:
1149: case CURLOPT_DEFAULT_PROTOCOL:
1150: case CURLOPT_DNS_SERVERS:
1151: case CURLOPT_DNS_INTERFACE:
1152: case CURLOPT_DNS_LOCAL_IP4:
1153: case CURLOPT_DNS_LOCAL_IP6:
1154: case CURLOPT_DOH_URL:
1155: case CURLOPT_EGDSOCKET:
1156: case CURLOPT_ENCODING:
1157: case CURLOPT_FTPPORT:
1158: case CURLOPT_FTP_ACCOUNT:
1159: case CURLOPT_FTP_ALTERNATIVE_TO_USER:
1160: case CURLOPT_INTERFACE:
1161: case CURLOPT_ISSUERCERT:
1162: case CURLOPT_KEYPASSWD:
1163: case CURLOPT_KRBLEVEL:
1164: case CURLOPT_LOGIN_OPTIONS:
1165: case CURLOPT_MAIL_AUTH:
1166: case CURLOPT_MAIL_FROM:
1167: case CURLOPT_NETRC_FILE:
1168: case CURLOPT_NOPROXY:
1169: case CURLOPT_PASSWORD:
1170: case CURLOPT_PINNEDPUBLICKEY:
1171: case CURLOPT_PRE_PROXY:
1172: case CURLOPT_PROXY:
1173: case CURLOPT_PROXYPASSWORD:
1174: case CURLOPT_PROXYUSERNAME:
1175: case CURLOPT_PROXYUSERPWD:
1176: case CURLOPT_PROXY_CAINFO:
1177: case CURLOPT_PROXY_CAPATH:
1178: case CURLOPT_PROXY_CRLFILE:
1179: case CURLOPT_PROXY_KEYPASSWD:
1180: case CURLOPT_PROXY_PINNEDPUBLICKEY:
1181: case CURLOPT_PROXY_SERVICE_NAME:
1182: case CURLOPT_PROXY_SSLCERT:
1183: case CURLOPT_PROXY_SSLCERTTYPE:
1184: case CURLOPT_PROXY_SSLKEY:
1185: case CURLOPT_PROXY_SSLKEYTYPE:
1186: case CURLOPT_PROXY_SSL_CIPHER_LIST:
1187: case CURLOPT_PROXY_TLS13_CIPHERS:
1188: case CURLOPT_PROXY_TLSAUTH_PASSWORD:
1189: case CURLOPT_PROXY_TLSAUTH_TYPE:
1190: case CURLOPT_PROXY_TLSAUTH_USERNAME:
1191: case CURLOPT_RANDOM_FILE:
1192: case CURLOPT_RANGE:
1193: case CURLOPT_REFERER:
1194: case CURLOPT_REQUEST_TARGET:
1195: case CURLOPT_RTSP_SESSION_ID:
1196: case CURLOPT_RTSP_STREAM_URI:
1197: case CURLOPT_RTSP_TRANSPORT:
1198: case CURLOPT_SASL_AUTHZID:
1199: case CURLOPT_SERVICE_NAME:
1200: case CURLOPT_SOCKS5_GSSAPI_SERVICE:
1201: case CURLOPT_SSH_HOST_PUBLIC_KEY_MD5:
1202: case CURLOPT_SSH_KNOWNHOSTS:
1203: case CURLOPT_SSH_PRIVATE_KEYFILE:
1204: case CURLOPT_SSH_PUBLIC_KEYFILE:
1205: case CURLOPT_SSLCERT:
1206: case CURLOPT_SSLCERTTYPE:
1207: case CURLOPT_SSLENGINE:
1208: case CURLOPT_SSLKEY:
1209: case CURLOPT_SSLKEYTYPE:
1210: case CURLOPT_SSL_CIPHER_LIST:
1211: case CURLOPT_TLS13_CIPHERS:
1212: case CURLOPT_TLSAUTH_PASSWORD:
1213: case CURLOPT_TLSAUTH_TYPE:
1214: case CURLOPT_TLSAUTH_USERNAME:
1215: case CURLOPT_UNIX_SOCKET_PATH:
1216: case CURLOPT_URL:
1217: case CURLOPT_USERAGENT:
1218: case CURLOPT_USERNAME:
1219: case CURLOPT_USERPWD:
1220: case CURLOPT_XOAUTH2_BEARER:
1221: s = va_arg(arg, char *);
1222: ccsid = va_arg(arg, unsigned int);
1223:
1224: if(s) {
1225: s = dynconvert(ASCII_CCSID, s, -1, ccsid);
1226:
1227: if(!s) {
1228: result = CURLE_OUT_OF_MEMORY;
1229: break;
1230: }
1231: }
1232:
1233: result = curl_easy_setopt(curl, tag, s);
1234: free(s);
1235: break;
1236:
1237: case CURLOPT_COPYPOSTFIELDS:
1238: /* Special case: byte count may have been given by CURLOPT_POSTFIELDSIZE
1239: prior to this call. In this case, convert the given byte count and
1240: replace the length according to the conversion result. */
1241: s = va_arg(arg, char *);
1242: ccsid = va_arg(arg, unsigned int);
1243:
1244: pfsize = data->set.postfieldsize;
1245:
1246: if(!s || !pfsize || ccsid == NOCONV_CCSID || ccsid == ASCII_CCSID) {
1247: result = curl_easy_setopt(curl, CURLOPT_COPYPOSTFIELDS, s);
1248: break;
1249: }
1250:
1251: if(pfsize == -1) {
1252: /* Data is null-terminated. */
1253: s = dynconvert(ASCII_CCSID, s, -1, ccsid);
1254:
1255: if(!s) {
1256: result = CURLE_OUT_OF_MEMORY;
1257: break;
1258: }
1259: }
1260: else {
1261: /* Data length specified. */
1262: size_t len;
1263:
1264: if(pfsize < 0 || pfsize > SIZE_MAX) {
1265: result = CURLE_OUT_OF_MEMORY;
1266: break;
1267: }
1268:
1269: len = pfsize;
1270: pfsize = len * MAX_CONV_EXPANSION;
1271:
1272: if(pfsize > SIZE_MAX)
1273: pfsize = SIZE_MAX;
1274:
1275: cp = malloc(pfsize);
1276:
1277: if(!cp) {
1278: result = CURLE_OUT_OF_MEMORY;
1279: break;
1280: }
1281:
1282: pfsize = convert(cp, pfsize, ASCII_CCSID, s, len, ccsid);
1283:
1284: if(pfsize < 0) {
1285: free(cp);
1286: result = CURLE_OUT_OF_MEMORY;
1287: break;
1288: }
1289:
1290: data->set.postfieldsize = pfsize; /* Replace data size. */
1291: s = cp;
1292: }
1293:
1294: result = curl_easy_setopt(curl, CURLOPT_POSTFIELDS, s);
1295: data->set.str[STRING_COPYPOSTFIELDS] = s; /* Give to library. */
1296: break;
1297:
1298: case CURLOPT_ERRORBUFFER: /* This is an output buffer. */
1299: default:
1300: result = Curl_vsetopt(curl, tag, arg);
1301: break;
1302: }
1303:
1304: va_end(arg);
1305: return result;
1306: }
1307:
1308:
1309: char *
1310: curl_form_long_value(long value)
1311:
1312: {
1313: /* ILE/RPG cannot cast an integer to a pointer. This procedure does it. */
1314:
1315: return (char *) value;
1316: }
1317:
1318:
1319: char *
1320: curl_pushheader_bynum_cssid(struct curl_pushheaders *h,
1321: size_t num, unsigned int ccsid)
1322:
1323: {
1324: char *d = (char *) NULL;
1325: char *s = curl_pushheader_bynum(h, num);
1326:
1327: if(s)
1328: d = dynconvert(ccsid, s, -1, ASCII_CCSID);
1329:
1330: return d;
1331: }
1332:
1333:
1334: char *
1335: curl_pushheader_byname_ccsid(struct curl_pushheaders *h, const char *header,
1336: unsigned int ccsidin, unsigned int ccsidout)
1337:
1338: {
1339: char *d = (char *) NULL;
1340:
1341: if(header) {
1342: header = dynconvert(ASCII_CCSID, header, -1, ccsidin);
1343:
1344: if(header) {
1345: char *s = curl_pushheader_byname(h, header);
1346: free((char *) header);
1347:
1348: if(s)
1349: d = dynconvert(ccsidout, s, -1, ASCII_CCSID);
1350: }
1351: }
1352:
1353: return d;
1354: }
1355:
1356: static CURLcode
1357: mime_string_call(curl_mimepart *part, const char *string, unsigned int ccsid,
1358: CURLcode (*mimefunc)(curl_mimepart *part, const char *string))
1359:
1360: {
1361: char *s = (char *) NULL;
1362: CURLcode result;
1363:
1364: if(!string)
1365: return mimefunc(part, string);
1366: s = dynconvert(ASCII_CCSID, string, -1, ccsid);
1367: if(!s)
1368: return CURLE_OUT_OF_MEMORY;
1369:
1370: result = mimefunc(part, s);
1371: free(s);
1372: return result;
1373: }
1374:
1375: CURLcode
1376: curl_mime_name_ccsid(curl_mimepart *part, const char *name, unsigned int ccsid)
1377:
1378: {
1379: return mime_string_call(part, name, ccsid, curl_mime_name);
1380: }
1381:
1382: CURLcode
1383: curl_mime_filename_ccsid(curl_mimepart *part,
1384: const char *filename, unsigned int ccsid)
1385:
1386: {
1387: return mime_string_call(part, filename, ccsid, curl_mime_filename);
1388: }
1389:
1390: CURLcode
1391: curl_mime_type_ccsid(curl_mimepart *part,
1392: const char *mimetype, unsigned int ccsid)
1393:
1394: {
1395: return mime_string_call(part, mimetype, ccsid, curl_mime_type);
1396: }
1397:
1398: CURLcode
1399: curl_mime_encoder_ccsid(curl_mimepart *part,
1400: const char *encoding, unsigned int ccsid)
1401:
1402: {
1403: return mime_string_call(part, encoding, ccsid, curl_mime_encoder);
1404: }
1405:
1406: CURLcode
1407: curl_mime_filedata_ccsid(curl_mimepart *part,
1408: const char *filename, unsigned int ccsid)
1409:
1410: {
1411: return mime_string_call(part, filename, ccsid, curl_mime_filedata);
1412: }
1413:
1414: CURLcode
1415: curl_mime_data_ccsid(curl_mimepart *part,
1416: const char *data, size_t datasize, unsigned int ccsid)
1417:
1418: {
1419: char *s = (char *) NULL;
1420: CURLcode result;
1421:
1422: if(!data)
1423: return curl_mime_data(part, data, datasize);
1424: s = dynconvert(ASCII_CCSID, data, datasize, ccsid);
1425: if(!s)
1426: return CURLE_OUT_OF_MEMORY;
1427:
1428: result = curl_mime_data(part, s, datasize);
1429: free(s);
1430: return result;
1431: }
1432:
1433: CURLUcode
1434: curl_url_get_ccsid(CURLU *handle, CURLUPart what, char **part,
1435: unsigned int flags, unsigned int ccsid)
1436:
1437: {
1438: char *s = (char *)NULL;
1439: CURLUcode result;
1440:
1441: if(!part)
1442: return CURLUE_BAD_PARTPOINTER;
1443:
1444: *part = (char *)NULL;
1445: result = curl_url_get(handle, what, &s, flags);
1446: if(result == CURLUE_OK) {
1447: if(s) {
1448: *part = dynconvert(ccsid, s, -1, ASCII_CCSID);
1449: if(!*part)
1450: result = CURLUE_OUT_OF_MEMORY;
1451: }
1452: }
1453: if(s)
1454: free(s);
1455: return result;
1456: }
1457:
1458: CURLUcode
1459: curl_url_set_ccsid(CURLU *handle, CURLUPart what, const char *part,
1460: unsigned int flags, unsigned int ccsid)
1461:
1462: {
1463: char *s = (char *)NULL;
1464: CURLUcode result;
1465:
1466: if(part) {
1467: s = dynconvert(ASCII_CCSID, part, -1, ccsid);
1468: if(!s)
1469: return CURLUE_OUT_OF_MEMORY;
1470: }
1471: result = curl_url_set(handle, what, s, flags);
1472: if(s)
1473: free(s);
1474: return result;
1475: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to ccsidcurl.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / curl / packages / OS400