luna - curl/projects/OS400/ccsidcurl.c

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