packages/OS400/ccsidcurl.c

   1 /***************************************************************************
   2  *                                  _   _ ____  _
   3  *  Project                     ___| | | |  _ \| |
   4  *                             / __| | | | |_) | |
   5  *                            | (__| |_| |  _ <| |___
   6  *                             \___|\___/|_| \_\_____|
   7  *
   8  * Copyright (C) 1998 - 2018, 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     char * cp = dynconvert(dccsid, from->data, -1, sccsid);
 223
 224     if(!cp) {
 225       curl_slist_free_all(to);
 226       return (struct curl_slist *) NULL;
 227     }
 228     to = Curl_slist_append_nodup(to, cp);
 229   }
 230   return to;
 231 }
 232
 233
 234 char *
 235 curl_version_ccsid(unsigned int ccsid)
 236
 237 {
 238   int i;
 239   char * aversion;
 240   char * eversion;
 241
 242   aversion = curl_version();
 243
 244   if(!aversion)
 245     return aversion;
 246
 247   i = strlen(aversion) + 1;
 248   i *= MAX_CONV_EXPANSION;
 249
 250   if(!(eversion = Curl_thread_buffer(LK_CURL_VERSION, i)))
 251     return (char *) NULL;
 252
 253   if(convert(eversion, i, ccsid, aversion, -1, ASCII_CCSID) < 0)
 254     return (char *) NULL;
 255
 256   return eversion;
 257 }
 258
 259
 260 char *
 261 curl_easy_escape_ccsid(CURL * handle, const char * string, int length,
 262                        unsigned int sccsid, unsigned int dccsid)
 263
 264 {
 265   char * s;
 266   char * d;
 267
 268   if(!string) {
 269     errno = EINVAL;
 270     return (char *) NULL;
 271     }
 272
 273   s = dynconvert(ASCII_CCSID, string, length? length: -1, sccsid);
 274
 275   if(!s)
 276     return (char *) NULL;
 277
 278   d = curl_easy_escape(handle, s, 0);
 279   free(s);
 280
 281   if(!d)
 282     return (char *) NULL;
 283
 284   s = dynconvert(dccsid, d, -1, ASCII_CCSID);
 285   free(d);
 286   return s;
 287 }
 288
 289
 290 char *
 291 curl_easy_unescape_ccsid(CURL * handle, const char * string, int length,
 292                          int * outlength,
 293                          unsigned int sccsid, unsigned int dccsid)
 294
 295 {
 296   char * s;
 297   char * d;
 298
 299   if(!string) {
 300     errno = EINVAL;
 301     return (char *) NULL;
 302     }
 303
 304   s = dynconvert(ASCII_CCSID, string, length? length: -1, sccsid);
 305
 306   if(!s)
 307     return (char *) NULL;
 308
 309   d = curl_easy_unescape(handle, s, 0, outlength);
 310   free(s);
 311
 312   if(!d)
 313     return (char *) NULL;
 314
 315   s = dynconvert(dccsid, d, -1, ASCII_CCSID);
 316   free(d);
 317
 318   if(s && outlength)
 319     *outlength = strlen(s);
 320
 321   return s;
 322 }
 323
 324
 325 struct curl_slist *
 326 curl_slist_append_ccsid(struct curl_slist * list,
 327                         const char * data, unsigned int ccsid)
 328
 329 {
 330   char * s;
 331
 332   s = (char *) NULL;
 333
 334   if(!data)
 335     return curl_slist_append(list, data);
 336
 337   s = dynconvert(ASCII_CCSID, data, -1, ccsid);
 338
 339   if(!s)
 340     return (struct curl_slist *) NULL;
 341
 342   list = curl_slist_append(list, s);
 343   free(s);
 344   return list;
 345 }
 346
 347
 348 time_t
 349 curl_getdate_ccsid(const char * p, const time_t * unused, unsigned int ccsid)
 350
 351 {
 352   char * s;
 353   time_t t;
 354
 355   if(!p)
 356     return curl_getdate(p, unused);
 357
 358   s = dynconvert(ASCII_CCSID, p, -1, ccsid);
 359
 360   if(!s)
 361     return (time_t) -1;
 362
 363   t = curl_getdate(s, unused);
 364   free(s);
 365   return t;
 366 }
 367
 368
 369 static int
 370 convert_version_info_string(const char * * stringp,
 371                             char * * bufp, int * left, unsigned int ccsid)
 372
 373 {
 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. */
 378
 379   if(*stringp) {
 380     int l = convert(*bufp, *left, ccsid, *stringp, -1, ASCII_CCSID);
 381
 382     if(l <= 0)
 383       return -1;
 384
 385     *stringp = *bufp;
 386     *bufp += l;
 387     *left -= l;
 388     }
 389
 390   return 0;
 391 }
 392
 393
 394 curl_version_info_data *
 395 curl_version_info_ccsid(CURLversion stamp, unsigned int ccsid)
 396
 397 {
 398   curl_version_info_data * p;
 399   char * cp;
 400   int n;
 401   int nproto;
 402   curl_version_info_data * id;
 403
 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. */
 407
 408 #if CURLVERSION_NOW != CURLVERSION_FOURTH
 409 #error curl_version_info_data structure has changed: upgrade this procedure.
 410 #endif
 411
 412   /* If caller has been compiled with a new version, error. */
 413
 414   if(stamp > CURLVERSION_NOW)
 415     return (curl_version_info_data *) NULL;
 416
 417   p = curl_version_info(stamp);
 418
 419   if(!p)
 420     return p;
 421
 422   /* Measure thread space needed. */
 423
 424   n = 0;
 425   nproto = 0;
 426
 427   if(p->protocols) {
 428     while(p->protocols[nproto])
 429       n += strlen(p->protocols[nproto++]);
 430
 431     n += nproto++;
 432     }
 433
 434   if(p->version)
 435     n += strlen(p->version) + 1;
 436
 437   if(p->host)
 438     n += strlen(p->host) + 1;
 439
 440   if(p->ssl_version)
 441     n += strlen(p->ssl_version) + 1;
 442
 443   if(p->libz_version)
 444     n += strlen(p->libz_version) + 1;
 445
 446   if(p->ares)
 447     n += strlen(p->ares) + 1;
 448
 449   if(p->libidn)
 450     n += strlen(p->libidn) + 1;
 451
 452   if(p->libssh_version)
 453     n += strlen(p->libssh_version) + 1;
 454
 455   /* Allocate thread space. */
 456
 457   n *= MAX_CONV_EXPANSION;
 458
 459   if(nproto)
 460     n += nproto * sizeof(const char *);
 461
 462   cp = Curl_thread_buffer(LK_VERSION_INFO_DATA, n);
 463   id = (curl_version_info_data *) Curl_thread_buffer(LK_VERSION_INFO,
 464                                                      sizeof *id);
 465
 466   if(!id || !cp)
 467     return (curl_version_info_data *) NULL;
 468
 469   /* Copy data and convert strings. */
 470
 471   memcpy((char *) id, (char *) p, sizeof *p);
 472
 473   if(id->protocols) {
 474     int i = nproto * sizeof id->protocols[0];
 475
 476     id->protocols = (const char * const *) cp;
 477     memcpy(cp, (char *) p->protocols, i);
 478     cp += i;
 479     n -= i;
 480
 481     for(i = 0; id->protocols[i]; i++)
 482       if(convert_version_info_string(((const char * *) id->protocols) + i,
 483                                       &cp, &n, ccsid))
 484         return (curl_version_info_data *) NULL;
 485     }
 486
 487   if(convert_version_info_string(&id->version, &cp, &n, ccsid))
 488     return (curl_version_info_data *) NULL;
 489
 490   if(convert_version_info_string(&id->host, &cp, &n, ccsid))
 491     return (curl_version_info_data *) NULL;
 492
 493   if(convert_version_info_string(&id->ssl_version, &cp, &n, ccsid))
 494     return (curl_version_info_data *) NULL;
 495
 496   if(convert_version_info_string(&id->libz_version, &cp, &n, ccsid))
 497     return (curl_version_info_data *) NULL;
 498
 499   if(convert_version_info_string(&id->ares, &cp, &n, ccsid))
 500     return (curl_version_info_data *) NULL;
 501
 502   if(convert_version_info_string(&id->libidn, &cp, &n, ccsid))
 503     return (curl_version_info_data *) NULL;
 504
 505   if(convert_version_info_string(&id->libssh_version, &cp, &n, ccsid))
 506     return (curl_version_info_data *) NULL;
 507
 508   return id;
 509 }
 510
 511
 512 const char *
 513 curl_easy_strerror_ccsid(CURLcode error, unsigned int ccsid)
 514
 515 {
 516   int i;
 517   const char * s;
 518   char * buf;
 519
 520   s = curl_easy_strerror(error);
 521
 522   if(!s)
 523     return s;
 524
 525   i = MAX_CONV_EXPANSION * (strlen(s) + 1);
 526
 527   if(!(buf = Curl_thread_buffer(LK_EASY_STRERROR, i)))
 528     return (const char *) NULL;
 529
 530   if(convert(buf, i, ccsid, s, -1, ASCII_CCSID) < 0)
 531     return (const char *) NULL;
 532
 533   return (const char *) buf;
 534 }
 535
 536
 537 const char *
 538 curl_share_strerror_ccsid(CURLSHcode error, unsigned int ccsid)
 539
 540 {
 541   int i;
 542   const char * s;
 543   char * buf;
 544
 545   s = curl_share_strerror(error);
 546
 547   if(!s)
 548     return s;
 549
 550   i = MAX_CONV_EXPANSION * (strlen(s) + 1);
 551
 552   if(!(buf = Curl_thread_buffer(LK_SHARE_STRERROR, i)))
 553     return (const char *) NULL;
 554
 555   if(convert(buf, i, ccsid, s, -1, ASCII_CCSID) < 0)
 556     return (const char *) NULL;
 557
 558   return (const char *) buf;
 559 }
 560
 561
 562 const char *
 563 curl_multi_strerror_ccsid(CURLMcode error, unsigned int ccsid)
 564
 565 {
 566   int i;
 567   const char * s;
 568   char * buf;
 569
 570   s = curl_multi_strerror(error);
 571
 572   if(!s)
 573     return s;
 574
 575   i = MAX_CONV_EXPANSION * (strlen(s) + 1);
 576
 577   if(!(buf = Curl_thread_buffer(LK_MULTI_STRERROR, i)))
 578     return (const char *) NULL;
 579
 580   if(convert(buf, i, ccsid, s, -1, ASCII_CCSID) < 0)
 581     return (const char *) NULL;
 582
 583   return (const char *) buf;
 584 }
 585
 586
 587 void
 588 curl_certinfo_free_all(struct curl_certinfo *info)
 589
 590 {
 591   /* Free all memory used by certificate info. */
 592   if(info) {
 593     if(info->certinfo) {
 594       int i;
 595
 596       for(i = 0; i < info->num_of_certs; i++)
 597         curl_slist_free_all(info->certinfo[i]);
 598       free((char *) info->certinfo);
 599     }
 600     free((char *) info);
 601   }
 602 }
 603
 604
 605 CURLcode
 606 curl_easy_getinfo_ccsid(CURL * curl, CURLINFO info, ...)
 607
 608 {
 609   va_list arg;
 610   void * paramp;
 611   CURLcode ret;
 612   unsigned int ccsid;
 613   char * * cpp;
 614   struct Curl_easy * data;
 615   struct curl_slist * * slp;
 616   struct curl_certinfo * cipf;
 617   struct curl_certinfo * cipt;
 618
 619   /* WARNING: unlike curl_easy_getinfo(), the strings returned by this
 620      procedure have to be free'ed. */
 621
 622   data = (struct Curl_easy *) curl;
 623   va_start(arg, info);
 624   paramp = va_arg(arg, void *);
 625   ret = Curl_getinfo(data, info, paramp);
 626
 627   if(ret == CURLE_OK)
 628     switch ((int) info & CURLINFO_TYPEMASK) {
 629
 630     case CURLINFO_STRING:
 631       ccsid = va_arg(arg, unsigned int);
 632       cpp = (char * *) paramp;
 633
 634       if(*cpp) {
 635         *cpp = dynconvert(ccsid, *cpp, -1, ASCII_CCSID);
 636
 637         if(!*cpp)
 638           ret = CURLE_OUT_OF_MEMORY;
 639       }
 640
 641       break;
 642
 643     case CURLINFO_SLIST:
 644       ccsid = va_arg(arg, unsigned int);
 645       switch (info) {
 646       case CURLINFO_CERTINFO:
 647         cipf = *(struct curl_certinfo * *) paramp;
 648         if(cipf) {
 649           if(!(cipt = (struct curl_certinfo *) malloc(sizeof *cipt)))
 650             ret = CURLE_OUT_OF_MEMORY;
 651           else {
 652             cipt->certinfo = (struct curl_slist * *)
 653                              calloc(cipf->num_of_certs +
 654                                     1, sizeof(struct curl_slist *));
 655             if(!cipt->certinfo)
 656               ret = CURLE_OUT_OF_MEMORY;
 657             else {
 658               int i;
 659
 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,
 664                                                           cipf->certinfo[i],
 665                                                           ASCII_CCSID))) {
 666                     ret = CURLE_OUT_OF_MEMORY;
 667                     break;
 668                   }
 669               }
 670             }
 671
 672           if(ret != CURLE_OK) {
 673             curl_certinfo_free_all(cipt);
 674             cipt = (struct curl_certinfo *) NULL;
 675           }
 676
 677           *(struct curl_certinfo * *) paramp = cipt;
 678         }
 679
 680         break;
 681
 682       case CURLINFO_TLS_SESSION:
 683       case CURLINFO_TLS_SSL_PTR:
 684       case CURLINFO_SOCKET:
 685         break;
 686
 687       default:
 688         slp = (struct curl_slist * *) paramp;
 689         if(*slp)
 690           if(!(*slp = slist_convert(ccsid, *slp, ASCII_CCSID)))
 691             ret = CURLE_OUT_OF_MEMORY;
 692         break;
 693       }
 694     }
 695
 696   va_end(arg);
 697   return ret;
 698 }
 699
 700
 701 static int
 702 Curl_is_formadd_string(CURLformoption option)
 703
 704 {
 705   switch (option) {
 706
 707   case CURLFORM_FILENAME:
 708   case CURLFORM_CONTENTTYPE:
 709   case CURLFORM_BUFFER:
 710   case CURLFORM_FILE:
 711   case CURLFORM_FILECONTENT:
 712   case CURLFORM_COPYCONTENTS:
 713   case CURLFORM_COPYNAME:
 714     return 1;
 715   }
 716
 717   return 0;
 718 }
 719
 720
 721 static void
 722 Curl_formadd_release_local(struct curl_forms * forms, int nargs, int skip)
 723
 724 {
 725   while(nargs--)
 726     if(nargs != skip)
 727       if(Curl_is_formadd_string(forms[nargs].option))
 728         if(forms[nargs].value)
 729           free((char *) forms[nargs].value);
 730
 731   free((char *) forms);
 732 }
 733
 734
 735 static int
 736 Curl_formadd_convert(struct curl_forms * forms,
 737                      int formx, int lengthx, unsigned int ccsid)
 738
 739 {
 740   int l;
 741   char * cp;
 742   char * cp2;
 743
 744   if(formx < 0 || !forms[formx].value)
 745     return 0;
 746
 747   if(lengthx >= 0)
 748     l = (int) forms[lengthx].value;
 749   else
 750     l = strlen(forms[formx].value) + 1;
 751
 752   cp = malloc(MAX_CONV_EXPANSION * l);
 753
 754   if(!cp)
 755     return -1;
 756
 757   l = convert(cp, MAX_CONV_EXPANSION * l, ASCII_CCSID,
 758               forms[formx].value, l, ccsid);
 759
 760   if(l < 0) {
 761     free(cp);
 762     return -1;
 763     }
 764
 765   cp2 = realloc(cp, l);         /* Shorten buffer to the string size. */
 766
 767   if(cp2)
 768     cp = cp2;
 769
 770   forms[formx].value = cp;
 771
 772   if(lengthx >= 0)
 773     forms[lengthx].value = (char *) l;  /* Update length after conversion. */
 774
 775   return l;
 776 }
 777
 778
 779 CURLFORMcode
 780 curl_formadd_ccsid(struct curl_httppost * * httppost,
 781                    struct curl_httppost * * last_post, ...)
 782
 783 {
 784   va_list arg;
 785   CURLformoption option;
 786   CURLFORMcode result;
 787   struct curl_forms * forms;
 788   struct curl_forms * lforms;
 789   struct curl_forms * tforms;
 790   unsigned int lformlen;
 791   const char * value;
 792   unsigned int ccsid;
 793   int nargs;
 794   int namex;
 795   int namelengthx;
 796   int contentx;
 797   int lengthx;
 798   unsigned int contentccsid;
 799   unsigned int nameccsid;
 800
 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. */
 815
 816   /* Allocate the local curl_forms array. */
 817
 818   lformlen = ALLOC_GRANULE;
 819   lforms = malloc(lformlen * sizeof *lforms);
 820
 821   if(!lforms)
 822     return CURL_FORMADD_MEMORY;
 823
 824   /* Process the arguments, copying them into local array, latching conversion
 825      indexes and converting when needed. */
 826
 827   result = CURL_FORMADD_OK;
 828   nargs = 0;
 829   contentx = -1;
 830   lengthx = -1;
 831   namex = -1;
 832   namelengthx = -1;
 833   forms = (struct curl_forms *) NULL;
 834   va_start(arg, last_post);
 835
 836   for(;;) {
 837     /* Make sure there is still room for an item in local array. */
 838
 839     if(nargs >= lformlen) {
 840       lformlen += ALLOC_GRANULE;
 841       tforms = realloc(lforms, lformlen * sizeof *lforms);
 842
 843       if(!tforms) {
 844         result = CURL_FORMADD_MEMORY;
 845         break;
 846         }
 847
 848       lforms = tforms;
 849       }
 850
 851     /* Get next option. */
 852
 853     if(forms) {
 854       /* Get option from array. */
 855
 856       option = forms->option;
 857       value = forms->value;
 858       forms++;
 859       }
 860     else {
 861       /* Get option from arguments. */
 862
 863       option = va_arg(arg, CURLformoption);
 864
 865       if(option == CURLFORM_END)
 866         break;
 867       }
 868
 869     /* Dispatch by option. */
 870
 871     switch (option) {
 872
 873     case CURLFORM_END:
 874       forms = (struct curl_forms *) NULL;       /* Leave array mode. */
 875       continue;
 876
 877     case CURLFORM_ARRAY:
 878       if(!forms) {
 879         forms = va_arg(arg, struct curl_forms *);
 880         continue;
 881         }
 882
 883       result = CURL_FORMADD_ILLEGAL_ARRAY;
 884       break;
 885
 886     case CURLFORM_COPYNAME:
 887       option = CURLFORM_PTRNAME;                /* Static for now. */
 888
 889     case CURLFORM_PTRNAME:
 890       if(namex >= 0)
 891         result = CURL_FORMADD_OPTION_TWICE;
 892
 893       namex = nargs;
 894
 895       if(!forms) {
 896         value = va_arg(arg, char *);
 897         nameccsid = (unsigned int) va_arg(arg, long);
 898         }
 899       else {
 900         nameccsid = (unsigned int) forms->value;
 901         forms++;
 902         }
 903
 904       break;
 905
 906     case CURLFORM_COPYCONTENTS:
 907       if(contentx >= 0)
 908         result = CURL_FORMADD_OPTION_TWICE;
 909
 910       contentx = nargs;
 911
 912       if(!forms) {
 913         value = va_arg(arg, char *);
 914         contentccsid = (unsigned int) va_arg(arg, long);
 915         }
 916       else {
 917         contentccsid = (unsigned int) forms->value;
 918         forms++;
 919         }
 920
 921       break;
 922
 923     case CURLFORM_PTRCONTENTS:
 924     case CURLFORM_BUFFERPTR:
 925       if(!forms)
 926         value = va_arg(arg, char *);            /* No conversion. */
 927
 928       break;
 929
 930     case CURLFORM_CONTENTSLENGTH:
 931       lengthx = nargs;
 932
 933       if(!forms)
 934         value = (char *) va_arg(arg, long);
 935
 936       break;
 937
 938     case CURLFORM_CONTENTLEN:
 939       lengthx = nargs;
 940
 941       if(!forms)
 942         value = (char *) va_arg(arg, curl_off_t);
 943
 944       break;
 945
 946     case CURLFORM_NAMELENGTH:
 947       namelengthx = nargs;
 948
 949       if(!forms)
 950         value = (char *) va_arg(arg, long);
 951
 952       break;
 953
 954     case CURLFORM_BUFFERLENGTH:
 955       if(!forms)
 956         value = (char *) va_arg(arg, long);
 957
 958       break;
 959
 960     case CURLFORM_CONTENTHEADER:
 961       if(!forms)
 962         value = (char *) va_arg(arg, struct curl_slist *);
 963
 964       break;
 965
 966     case CURLFORM_STREAM:
 967       if(!forms)
 968         value = (char *) va_arg(arg, void *);
 969
 970       break;
 971
 972     case CURLFORM_CONTENTTYPE:
 973       /* If a previous content has been encountered, convert it now. */
 974
 975       if(Curl_formadd_convert(lforms, contentx, lengthx, contentccsid) < 0) {
 976         result = CURL_FORMADD_MEMORY;
 977         break;
 978         }
 979
 980       contentx = -1;
 981       lengthx = -1;
 982       /* Fall into default. */
 983
 984     default:
 985       /* Must be a convertible string. */
 986
 987       if(!Curl_is_formadd_string(option)) {
 988         result = CURL_FORMADD_UNKNOWN_OPTION;
 989         break;
 990         }
 991
 992       if(!forms) {
 993         value = va_arg(arg, char *);
 994         ccsid = (unsigned int) va_arg(arg, long);
 995         }
 996       else {
 997         ccsid = (unsigned int) forms->value;
 998         forms++;
 999         }
1000
1001       /* Do the conversion. */
1002
1003       lforms[nargs].value = value;
1004
1005       if(Curl_formadd_convert(lforms, nargs, -1, ccsid) < 0) {
1006         result = CURL_FORMADD_MEMORY;
1007         break;
1008         }
1009
1010       value = lforms[nargs].value;
1011       }
1012
1013     if(result != CURL_FORMADD_OK)
1014       break;
1015
1016     lforms[nargs].value = value;
1017     lforms[nargs++].option = option;
1018     }
1019
1020   va_end(arg);
1021
1022   /* Convert the name and the last content, now that we know their lengths. */
1023
1024   if(result == CURL_FORMADD_OK && namex >= 0) {
1025     if(Curl_formadd_convert(lforms, namex, namelengthx, nameccsid) < 0)
1026       result = CURL_FORMADD_MEMORY;
1027     else
1028       lforms[namex].option = CURLFORM_COPYNAME;         /* Force copy. */
1029     }
1030
1031   if(result == CURL_FORMADD_OK) {
1032     if(Curl_formadd_convert(lforms, contentx, lengthx, contentccsid) < 0)
1033       result = CURL_FORMADD_MEMORY;
1034     else
1035       contentx = -1;
1036     }
1037
1038   /* Do the formadd with our converted parameters. */
1039
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);
1044     }
1045
1046   /* Terminate. */
1047
1048   Curl_formadd_release_local(lforms, nargs, contentx);
1049   return result;
1050 }
1051
1052
1053 typedef struct {
1054   curl_formget_callback append;
1055   void *                arg;
1056   unsigned int          ccsid;
1057 }   cfcdata;
1058
1059
1060 static size_t
1061 Curl_formget_callback_ccsid(void * arg, const char * buf, size_t len)
1062
1063 {
1064   cfcdata * p;
1065   char * b;
1066   int l;
1067   size_t ret;
1068
1069   p = (cfcdata *) arg;
1070
1071   if((long) len <= 0)
1072     return (*p->append)(p->arg, buf, len);
1073
1074   b = malloc(MAX_CONV_EXPANSION * len);
1075
1076   if(!b)
1077     return (size_t) -1;
1078
1079   l = convert(b, MAX_CONV_EXPANSION * len, p->ccsid, buf, len, ASCII_CCSID);
1080
1081   if(l < 0) {
1082     free(b);
1083     return (size_t) -1;
1084     }
1085
1086   ret = (*p->append)(p->arg, b, l);
1087   free(b);
1088   return ret == l? len: -1;
1089 }
1090
1091
1092 int
1093 curl_formget_ccsid(struct curl_httppost * form, void * arg,
1094                    curl_formget_callback append, unsigned int ccsid)
1095
1096 {
1097   cfcdata lcfc;
1098
1099   lcfc.append = append;
1100   lcfc.arg = arg;
1101   lcfc.ccsid = ccsid;
1102   return curl_formget(form, (void *) &lcfc, Curl_formget_callback_ccsid);
1103 }
1104
1105
1106 CURLcode
1107 curl_easy_setopt_ccsid(CURL * curl, CURLoption tag, ...)
1108
1109 {
1110   CURLcode result;
1111   va_list arg;
1112   struct Curl_easy * data;
1113   char * s;
1114   char * cp;
1115   unsigned int ccsid;
1116   curl_off_t pfsize;
1117   static char testwarn = 1;
1118
1119   /* Warns if this procedure has not been updated when the dupstring enum
1120      changes.
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!). */
1124
1125   if(testwarn) {
1126     testwarn = 0;
1127
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");
1132     }
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_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:
1167   case CURLOPT_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:
1186   case CURLOPT_RANGE:
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:
1208   case CURLOPT_URL:
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);
1215
1216     if(s) {
1217       s = dynconvert(ASCII_CCSID, s, -1, ccsid);
1218
1219       if(!s) {
1220         result = CURLE_OUT_OF_MEMORY;
1221         break;
1222         }
1223       }
1224
1225     result = curl_easy_setopt(curl, tag, s);
1226     free(s);
1227     break;
1228
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);
1235
1236     pfsize = data->set.postfieldsize;
1237
1238     if(!s || !pfsize || ccsid == NOCONV_CCSID || ccsid == ASCII_CCSID) {
1239       result = curl_easy_setopt(curl, CURLOPT_COPYPOSTFIELDS, s);
1240       break;
1241       }
1242
1243     if(pfsize == -1) {
1244       /* Data is null-terminated. */
1245       s = dynconvert(ASCII_CCSID, s, -1, ccsid);
1246
1247       if(!s) {
1248         result = CURLE_OUT_OF_MEMORY;
1249         break;
1250         }
1251       }
1252     else {
1253       /* Data length specified. */
1254       size_t len;
1255
1256       if(pfsize < 0 || pfsize > SIZE_MAX) {
1257         result = CURLE_OUT_OF_MEMORY;
1258         break;
1259         }
1260
1261       len = pfsize;
1262       pfsize = len * MAX_CONV_EXPANSION;
1263
1264       if(pfsize > SIZE_MAX)
1265         pfsize = SIZE_MAX;
1266
1267       cp = malloc(pfsize);
1268
1269       if(!cp) {
1270         result = CURLE_OUT_OF_MEMORY;
1271         break;
1272         }
1273
1274       pfsize = convert(cp, pfsize, ASCII_CCSID, s, len, ccsid);
1275
1276       if(pfsize < 0) {
1277         free(cp);
1278         result = CURLE_OUT_OF_MEMORY;
1279         break;
1280         }
1281
1282       data->set.postfieldsize = pfsize;         /* Replace data size. */
1283       s = cp;
1284       }
1285
1286     result = curl_easy_setopt(curl, CURLOPT_POSTFIELDS, s);
1287     data->set.str[STRING_COPYPOSTFIELDS] = s;   /* Give to library. */
1288     break;
1289
1290   case CURLOPT_ERRORBUFFER:                     /* This is an output buffer. */
1291   default:
1292     result = Curl_vsetopt(data, tag, arg);
1293     break;
1294     }
1295
1296   va_end(arg);
1297   return result;
1298 }
1299
1300
1301 char *
1302 curl_form_long_value(long value)
1303
1304 {
1305   /* ILE/RPG cannot cast an integer to a pointer. This procedure does it. */
1306
1307   return (char *) value;
1308 }
1309
1310
1311 char *
1312 curl_pushheader_bynum_cssid(struct curl_pushheaders *h,
1313                             size_t num, unsigned int ccsid)
1314
1315 {
1316   char *d = (char *) NULL;
1317   char *s = curl_pushheader_bynum(h, num);
1318
1319   if(s)
1320     d = dynconvert(ccsid, s, -1, ASCII_CCSID);
1321
1322   return d;
1323 }
1324
1325
1326 char *
1327 curl_pushheader_byname_ccsid(struct curl_pushheaders *h, const char *header,
1328                              unsigned int ccsidin, unsigned int ccsidout)
1329
1330 {
1331   char *d = (char *) NULL;
1332   char *s;
1333
1334   if(header) {
1335     header = dynconvert(ASCII_CCSID, header, -1, ccsidin);
1336
1337     if(header) {
1338       s = curl_pushheader_byname(h, header);
1339       free((char *) header);
1340
1341       if(s)
1342         d = dynconvert(ccsidout, s, -1, ASCII_CCSID);
1343     }
1344   }
1345
1346   return d;
1347 }