Mercurial > hgrepos > Python2 > PyMuPDF

comparison mupdf-source/thirdparty/curl/packages/OS400/ccsidcurl.c @ 2:b50eed0cc0ef upstream

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
ADD: MuPDF v1.26.7: the MuPDF source as downloaded by a default build of PyMuPDF 1.26.4. The directory name has changed: no version number in the expanded directory now.
author Franz Glasner <fzglas.hg@dom66.de>
date Mon, 15 Sep 2025 11:43:07 +0200
parents
children
comparison
equal deleted inserted replaced
1:1d09e1dec1d9 2:b50eed0cc0ef
1 /***************************************************************************
2 * _ _ ____ _
3 * Project ___| | | | _ \| |
4 * / __| | | | |_) | |
5 * | (__| |_| | _ <| |___
6 * \___|\___/|_| \_\_____|
7 *
8 * Copyright (C) 1998 - 2019, 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 static char testwarn = 1;
1134
1135 /* Warns if this procedure has not been updated when the dupstring enum
1136 changes.
1137 We (try to) do it only once: there is no need to issue several times
1138 the same message; but since threadsafeness is not handled here,
1139 this may occur (and we don't care!). */
1140
1141 if(testwarn) {
1142 testwarn = 0;
1143
1144 if((int) STRING_LASTZEROTERMINATED != (int) STRING_SASL_AUTHZID + 1 ||
1145 (int) STRING_LAST != (int) STRING_COPYPOSTFIELDS + 1)
1146 curl_mfprintf(stderr,
1147 "*** WARNING: curl_easy_setopt_ccsid() should be reworked ***\n");
1148 }
1149
1150 data = (struct Curl_easy *) curl;
1151 va_start(arg, tag);
1152
1153 switch(tag) {
1154
1155 case CURLOPT_ABSTRACT_UNIX_SOCKET:
1156 case CURLOPT_ALTSVC:
1157 case CURLOPT_CAINFO:
1158 case CURLOPT_CAPATH:
1159 case CURLOPT_COOKIE:
1160 case CURLOPT_COOKIEFILE:
1161 case CURLOPT_COOKIEJAR:
1162 case CURLOPT_COOKIELIST:
1163 case CURLOPT_CRLFILE:
1164 case CURLOPT_CUSTOMREQUEST:
1165 case CURLOPT_DEFAULT_PROTOCOL:
1166 case CURLOPT_DNS_SERVERS:
1167 case CURLOPT_DOH_URL:
1168 case CURLOPT_EGDSOCKET:
1169 case CURLOPT_ENCODING:
1170 case CURLOPT_FTPPORT:
1171 case CURLOPT_FTP_ACCOUNT:
1172 case CURLOPT_FTP_ALTERNATIVE_TO_USER:
1173 case CURLOPT_INTERFACE:
1174 case CURLOPT_ISSUERCERT:
1175 case CURLOPT_KEYPASSWD:
1176 case CURLOPT_KRBLEVEL:
1177 case CURLOPT_LOGIN_OPTIONS:
1178 case CURLOPT_MAIL_AUTH:
1179 case CURLOPT_MAIL_FROM:
1180 case CURLOPT_NETRC_FILE:
1181 case CURLOPT_NOPROXY:
1182 case CURLOPT_PASSWORD:
1183 case CURLOPT_PINNEDPUBLICKEY:
1184 case CURLOPT_PRE_PROXY:
1185 case CURLOPT_PROXY:
1186 case CURLOPT_PROXYPASSWORD:
1187 case CURLOPT_PROXYUSERNAME:
1188 case CURLOPT_PROXYUSERPWD:
1189 case CURLOPT_PROXY_CAINFO:
1190 case CURLOPT_PROXY_CAPATH:
1191 case CURLOPT_PROXY_CRLFILE:
1192 case CURLOPT_PROXY_KEYPASSWD:
1193 case CURLOPT_PROXY_PINNEDPUBLICKEY:
1194 case CURLOPT_PROXY_SERVICE_NAME:
1195 case CURLOPT_PROXY_SSLCERT:
1196 case CURLOPT_PROXY_SSLCERTTYPE:
1197 case CURLOPT_PROXY_SSLKEY:
1198 case CURLOPT_PROXY_SSLKEYTYPE:
1199 case CURLOPT_PROXY_SSL_CIPHER_LIST:
1200 case CURLOPT_PROXY_TLS13_CIPHERS:
1201 case CURLOPT_PROXY_TLSAUTH_PASSWORD:
1202 case CURLOPT_PROXY_TLSAUTH_TYPE:
1203 case CURLOPT_PROXY_TLSAUTH_USERNAME:
1204 case CURLOPT_RANDOM_FILE:
1205 case CURLOPT_RANGE:
1206 case CURLOPT_REFERER:
1207 case CURLOPT_REQUEST_TARGET:
1208 case CURLOPT_RTSP_SESSION_ID:
1209 case CURLOPT_RTSP_STREAM_URI:
1210 case CURLOPT_RTSP_TRANSPORT:
1211 case CURLOPT_SASL_AUTHZID:
1212 case CURLOPT_SERVICE_NAME:
1213 case CURLOPT_SOCKS5_GSSAPI_SERVICE:
1214 case CURLOPT_SSH_HOST_PUBLIC_KEY_MD5:
1215 case CURLOPT_SSH_KNOWNHOSTS:
1216 case CURLOPT_SSH_PRIVATE_KEYFILE:
1217 case CURLOPT_SSH_PUBLIC_KEYFILE:
1218 case CURLOPT_SSLCERT:
1219 case CURLOPT_SSLCERTTYPE:
1220 case CURLOPT_SSLENGINE:
1221 case CURLOPT_SSLKEY:
1222 case CURLOPT_SSLKEYTYPE:
1223 case CURLOPT_SSL_CIPHER_LIST:
1224 case CURLOPT_TLS13_CIPHERS:
1225 case CURLOPT_TLSAUTH_PASSWORD:
1226 case CURLOPT_TLSAUTH_TYPE:
1227 case CURLOPT_TLSAUTH_USERNAME:
1228 case CURLOPT_UNIX_SOCKET_PATH:
1229 case CURLOPT_URL:
1230 case CURLOPT_USERAGENT:
1231 case CURLOPT_USERNAME:
1232 case CURLOPT_USERPWD:
1233 case CURLOPT_XOAUTH2_BEARER:
1234 s = va_arg(arg, char *);
1235 ccsid = va_arg(arg, unsigned int);
1236
1237 if(s) {
1238 s = dynconvert(ASCII_CCSID, s, -1, ccsid);
1239
1240 if(!s) {
1241 result = CURLE_OUT_OF_MEMORY;
1242 break;
1243 }
1244 }
1245
1246 result = curl_easy_setopt(curl, tag, s);
1247 free(s);
1248 break;
1249
1250 case CURLOPT_COPYPOSTFIELDS:
1251 /* Special case: byte count may have been given by CURLOPT_POSTFIELDSIZE
1252 prior to this call. In this case, convert the given byte count and
1253 replace the length according to the conversion result. */
1254 s = va_arg(arg, char *);
1255 ccsid = va_arg(arg, unsigned int);
1256
1257 pfsize = data->set.postfieldsize;
1258
1259 if(!s || !pfsize || ccsid == NOCONV_CCSID || ccsid == ASCII_CCSID) {
1260 result = curl_easy_setopt(curl, CURLOPT_COPYPOSTFIELDS, s);
1261 break;
1262 }
1263
1264 if(pfsize == -1) {
1265 /* Data is null-terminated. */
1266 s = dynconvert(ASCII_CCSID, s, -1, ccsid);
1267
1268 if(!s) {
1269 result = CURLE_OUT_OF_MEMORY;
1270 break;
1271 }
1272 }
1273 else {
1274 /* Data length specified. */
1275 size_t len;
1276
1277 if(pfsize < 0 || pfsize > SIZE_MAX) {
1278 result = CURLE_OUT_OF_MEMORY;
1279 break;
1280 }
1281
1282 len = pfsize;
1283 pfsize = len * MAX_CONV_EXPANSION;
1284
1285 if(pfsize > SIZE_MAX)
1286 pfsize = SIZE_MAX;
1287
1288 cp = malloc(pfsize);
1289
1290 if(!cp) {
1291 result = CURLE_OUT_OF_MEMORY;
1292 break;
1293 }
1294
1295 pfsize = convert(cp, pfsize, ASCII_CCSID, s, len, ccsid);
1296
1297 if(pfsize < 0) {
1298 free(cp);
1299 result = CURLE_OUT_OF_MEMORY;
1300 break;
1301 }
1302
1303 data->set.postfieldsize = pfsize; /* Replace data size. */
1304 s = cp;
1305 }
1306
1307 result = curl_easy_setopt(curl, CURLOPT_POSTFIELDS, s);
1308 data->set.str[STRING_COPYPOSTFIELDS] = s; /* Give to library. */
1309 break;
1310
1311 case CURLOPT_ERRORBUFFER: /* This is an output buffer. */
1312 default:
1313 result = Curl_vsetopt(curl, tag, arg);
1314 break;
1315 }
1316
1317 va_end(arg);
1318 return result;
1319 }
1320
1321
1322 char *
1323 curl_form_long_value(long value)
1324
1325 {
1326 /* ILE/RPG cannot cast an integer to a pointer. This procedure does it. */
1327
1328 return (char *) value;
1329 }
1330
1331
1332 char *
1333 curl_pushheader_bynum_cssid(struct curl_pushheaders *h,
1334 size_t num, unsigned int ccsid)
1335
1336 {
1337 char *d = (char *) NULL;
1338 char *s = curl_pushheader_bynum(h, num);
1339
1340 if(s)
1341 d = dynconvert(ccsid, s, -1, ASCII_CCSID);
1342
1343 return d;
1344 }
1345
1346
1347 char *
1348 curl_pushheader_byname_ccsid(struct curl_pushheaders *h, const char *header,
1349 unsigned int ccsidin, unsigned int ccsidout)
1350
1351 {
1352 char *d = (char *) NULL;
1353
1354 if(header) {
1355 header = dynconvert(ASCII_CCSID, header, -1, ccsidin);
1356
1357 if(header) {
1358 char *s = curl_pushheader_byname(h, header);
1359 free((char *) header);
1360
1361 if(s)
1362 d = dynconvert(ccsidout, s, -1, ASCII_CCSID);
1363 }
1364 }
1365
1366 return d;
1367 }
1368
1369 static CURLcode
1370 mime_string_call(curl_mimepart *part, const char *string, unsigned int ccsid,
1371 CURLcode (*mimefunc)(curl_mimepart *part, const char *string))
1372
1373 {
1374 char *s = (char *) NULL;
1375 CURLcode result;
1376
1377 if(!string)
1378 return mimefunc(part, string);
1379 s = dynconvert(ASCII_CCSID, string, -1, ccsid);
1380 if(!s)
1381 return CURLE_OUT_OF_MEMORY;
1382
1383 result = mimefunc(part, s);
1384 free(s);
1385 return result;
1386 }
1387
1388 CURLcode
1389 curl_mime_name_ccsid(curl_mimepart *part, const char *name, unsigned int ccsid)
1390
1391 {
1392 return mime_string_call(part, name, ccsid, curl_mime_name);
1393 }
1394
1395 CURLcode
1396 curl_mime_filename_ccsid(curl_mimepart *part,
1397 const char *filename, unsigned int ccsid)
1398
1399 {
1400 return mime_string_call(part, filename, ccsid, curl_mime_filename);
1401 }
1402
1403 CURLcode
1404 curl_mime_type_ccsid(curl_mimepart *part,
1405 const char *mimetype, unsigned int ccsid)
1406
1407 {
1408 return mime_string_call(part, mimetype, ccsid, curl_mime_type);
1409 }
1410
1411 CURLcode
1412 curl_mime_encoder_ccsid(curl_mimepart *part,
1413 const char *encoding, unsigned int ccsid)
1414
1415 {
1416 return mime_string_call(part, encoding, ccsid, curl_mime_encoder);
1417 }
1418
1419 CURLcode
1420 curl_mime_filedata_ccsid(curl_mimepart *part,
1421 const char *filename, unsigned int ccsid)
1422
1423 {
1424 return mime_string_call(part, filename, ccsid, curl_mime_filedata);
1425 }
1426
1427 CURLcode
1428 curl_mime_data_ccsid(curl_mimepart *part,
1429 const char *data, size_t datasize, unsigned int ccsid)
1430
1431 {
1432 char *s = (char *) NULL;
1433 CURLcode result;
1434
1435 if(!data)
1436 return curl_mime_data(part, data, datasize);
1437 s = dynconvert(ASCII_CCSID, data, datasize, ccsid);
1438 if(!s)
1439 return CURLE_OUT_OF_MEMORY;
1440
1441 result = curl_mime_data(part, s, datasize);
1442 free(s);
1443 return result;
1444 }
1445
1446 CURLUcode
1447 curl_url_get_ccsid(CURLU *handle, CURLUPart what, char **part,
1448 unsigned int flags, unsigned int ccsid)
1449
1450 {
1451 char *s = (char *)NULL;
1452 CURLUcode result;
1453
1454 if(!part)
1455 return CURLUE_BAD_PARTPOINTER;
1456
1457 *part = (char *)NULL;
1458 result = curl_url_get(handle, what, &s, flags);
1459 if(result == CURLUE_OK) {
1460 if(s) {
1461 *part = dynconvert(ccsid, s, -1, ASCII_CCSID);
1462 if(!*part)
1463 result = CURLUE_OUT_OF_MEMORY;
1464 }
1465 }
1466 if(s)
1467 free(s);
1468 return result;
1469 }
1470
1471 CURLUcode
1472 curl_url_set_ccsid(CURLU *handle, CURLUPart what, const char *part,
1473 unsigned int flags, unsigned int ccsid)
1474
1475 {
1476 char *s = (char *)NULL;
1477 CURLUcode result;
1478
1479 if(part) {
1480 s = dynconvert(ASCII_CCSID, part, -1, ccsid);
1481 if(!s)
1482 return CURLUE_OUT_OF_MEMORY;
1483 }
1484 result = curl_url_set(handle, what, s, flags);
1485 if(s)
1486 free(s);
1487 return result;
1488 }