mirror/curl
2
0
Fork 0
mirror of https://github.com/curl/curl.git synced 2024-12-27 06:59:43 +08:00
Code Issues Packages Projects Releases Wiki Activity
be8d2b037d
curl/packages/OS400/ccsidcurl.c
max.mehl ad9bc5976d
copyright: make repository REUSE compliant 
Add licensing and copyright information for all files in this repository. This
either happens in the file itself as a comment header or in the file
`.reuse/dep5`.

This commit also adds a Github workflow to check pull requests and adapts
copyright.pl to the changes.

Closes #8869
2022-06-13 09:13:00 +02:00

1463 lines
33 KiB
C
Raw Blame History

/***************************************************************************
* _ _ ____ _
* Project ___| | | | _ \| |
* / __| | | | |_) | |
* | (__| |_| | _ <| |___
* \___|\___/|_| \_\_____|
*
* Copyright (C) 1998 - 2022, Daniel Stenberg, <daniel@haxx.se>, et al.
*
* This software is licensed as described in the file COPYING, which
* you should have received as part of this distribution. The terms
* are also available at https://curl.se/docs/copyright.html.
*
* You may opt to use, copy, modify, merge, publish, distribute and/or sell
* copies of the Software, and permit persons to whom the Software is
* furnished to do so, under the terms of the COPYING file.
*
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
* KIND, either express or implied.
*
* SPDX-License-Identifier: curl
*
*
***************************************************************************/
/* CCSID API wrappers for OS/400. */
#include <iconv.h>
#include <string.h>
#include <stdlib.h>
#include <stddef.h>
#include <errno.h>
#include <stdarg.h>
#pragma enum(int)
#include "curl.h"
#include "mprintf.h"
#include "slist.h"
#include "urldata.h"
#include "url.h"
#include "setopt.h"
#include "getinfo.h"
#include "ccsidcurl.h"
#include "os400sys.h"
#ifndef SIZE_MAX
#define SIZE_MAX ((size_t) ~0) /* Is unsigned on OS/400. */
#endif
#define ASCII_CCSID 819 /* Use ISO-8859-1 as ASCII. */
#define NOCONV_CCSID 65535 /* No conversion. */
#define ICONV_ID_SIZE 32 /* Size of iconv_open() code identifier. */
#define ICONV_OPEN_ERROR(t) ((t).return_value == -1)
#define ALLOC_GRANULE 8 /* Alloc. granule for curl_formadd_ccsid(). */
static void
makeOS400IconvCode(char buf[ICONV_ID_SIZE], unsigned int ccsid)
{
/**
*** Convert a CCSID to the corresponding IBM iconv_open() character
*** code identifier.
*** This code is specific to the OS400 implementation of the iconv library.
*** CCSID 65535 (no conversion) is replaced by the ASCII CCSID.
*** CCSID 0 is interpreted by the OS400 as the job's CCSID.
**/
ccsid &= 0xFFFF;
if(ccsid == NOCONV_CCSID)
ccsid = ASCII_CCSID;
memset(buf, 0, ICONV_ID_SIZE);
curl_msprintf(buf, "IBMCCSID%05u0000000", ccsid);
}
static iconv_t
iconv_open_CCSID(unsigned int ccsidout, unsigned int ccsidin,
unsigned int cstr)
{
char fromcode[ICONV_ID_SIZE];
char tocode[ICONV_ID_SIZE];
/**
*** Like iconv_open(), but character codes are given as CCSIDs.
*** If `cstr' is non-zero, conversion is set up to stop whenever a
*** null character is encountered.
*** See iconv_open() IBM description in "National Language Support API".
**/
makeOS400IconvCode(fromcode, ccsidin);
makeOS400IconvCode(tocode, ccsidout);
memset(tocode + 13, 0, sizeof(tocode) - 13); /* Dest. code id format. */
if(cstr)
fromcode[18] = '1'; /* Set null-terminator flag. */
return iconv_open(tocode, fromcode);
}
static int
convert(char *d, size_t dlen, int dccsid,
const char *s, int slen, int sccsid)
{
int i;
iconv_t cd;
size_t lslen;
/**
*** Convert `sccsid'-coded `slen'-data bytes at `s' into `dccsid'-coded
*** data stored in the `dlen'-byte buffer at `d'.
*** If `slen' < 0, source string is null-terminated.
*** CCSID 65535 (no conversion) is replaced by the ASCII CCSID.
*** Return the converted destination byte count, or -1 if error.
**/
if(sccsid == 65535)
sccsid = ASCII_CCSID;
if(dccsid == 65535)
dccsid = ASCII_CCSID;
if(sccsid == dccsid) {
lslen = slen >= 0? slen: strlen(s) + 1;
i = lslen < dlen? lslen: dlen;
if(s != d && i > 0)
memcpy(d, s, i);
return i;
}
if(slen < 0) {
lslen = 0;
cd = iconv_open_CCSID(dccsid, sccsid, 1);
}
else {
lslen = (size_t) slen;
cd = iconv_open_CCSID(dccsid, sccsid, 0);
}
if(ICONV_OPEN_ERROR(cd))
return -1;
i = dlen;
if((int) iconv(cd, (char * *) &s, &lslen, &d, &dlen) < 0)
i = -1;
else
i -= dlen;
iconv_close(cd);
return i;
}
static char *dynconvert(int dccsid, const char *s, int slen, int sccsid)
{
char *d;
char *cp;
size_t dlen;
int l;
static const char nullbyte = 0;
/* Like convert, but the destination is allocated and returned. */
dlen = (size_t) (slen < 0? strlen(s): slen) + 1;
dlen *= MAX_CONV_EXPANSION; /* Allow some expansion. */
d = malloc(dlen);
if(!d)
return (char *) NULL;
l = convert(d, dlen, dccsid, s, slen, sccsid);
if(l < 0) {
free(d);
return (char *) NULL;
}
if(slen < 0) {
/* Need to null-terminate even when source length is given.
Since destination code size is unknown, use a conversion to generate
terminator. */
int l2 = convert(d + l, dlen - l, dccsid, &nullbyte, -1, ASCII_CCSID);
if(l2 < 0) {
free(d);
return (char *) NULL;
}
l += l2;
}
if((size_t) l < dlen) {
cp = realloc(d, l); /* Shorten to minimum needed. */
if(cp)
d = cp;
}
return d;
}
static struct curl_slist *
slist_convert(int dccsid, struct curl_slist *from, int sccsid)
{
struct curl_slist *to = (struct curl_slist *) NULL;
for(; from; from = from->next) {
struct curl_slist *nl;
char *cp = dynconvert(dccsid, from->data, -1, sccsid);
if(!cp) {
curl_slist_free_all(to);
return (struct curl_slist *) NULL;
}
nl = Curl_slist_append_nodup(to, cp);
if(!nl) {
curl_slist_free_all(to);
free(cp);
return NULL;
}
to = nl;
}
return to;
}
char *curl_version_ccsid(unsigned int ccsid)
{
int i;
char *aversion;
char *eversion;
aversion = curl_version();
if(!aversion)
return aversion;
i = strlen(aversion) + 1;
i *= MAX_CONV_EXPANSION;
eversion = Curl_thread_buffer(LK_CURL_VERSION, i);
if(!eversion)
return (char *) NULL;
if(convert(eversion, i, ccsid, aversion, -1, ASCII_CCSID) < 0)
return (char *) NULL;
return eversion;
}
char *
curl_easy_escape_ccsid(CURL *handle, const char *string, int length,
unsigned int sccsid, unsigned int dccsid)
{
char *s;
char *d;
if(!string) {
errno = EINVAL;
return (char *) NULL;
}
s = dynconvert(ASCII_CCSID, string, length? length: -1, sccsid);
if(!s)
return (char *) NULL;
d = curl_easy_escape(handle, s, 0);
free(s);
if(!d)
return (char *) NULL;
s = dynconvert(dccsid, d, -1, ASCII_CCSID);
free(d);
return s;
}
char *
curl_easy_unescape_ccsid(CURL *handle, const char *string, int length,
int *outlength,
unsigned int sccsid, unsigned int dccsid)
{
char *s;
char *d;
if(!string) {
errno = EINVAL;
return (char *) NULL;
}
s = dynconvert(ASCII_CCSID, string, length? length: -1, sccsid);
if(!s)
return (char *) NULL;
d = curl_easy_unescape(handle, s, 0, outlength);
free(s);
if(!d)
return (char *) NULL;
s = dynconvert(dccsid, d, -1, ASCII_CCSID);
free(d);
if(s && outlength)
*outlength = strlen(s);
return s;
}
struct curl_slist *
curl_slist_append_ccsid(struct curl_slist *list,
const char *data, unsigned int ccsid)
{
char *s;
s = (char *) NULL;
if(!data)
return curl_slist_append(list, data);
s = dynconvert(ASCII_CCSID, data, -1, ccsid);
if(!s)
return (struct curl_slist *) NULL;
list = curl_slist_append(list, s);
free(s);
return list;
}
time_t
curl_getdate_ccsid(const char *p, const time_t *unused, unsigned int ccsid)
{
char *s;
time_t t;
if(!p)
return curl_getdate(p, unused);
s = dynconvert(ASCII_CCSID, p, -1, ccsid);
if(!s)
return (time_t) -1;
t = curl_getdate(s, unused);
free(s);
return t;
}
static int
convert_version_info_string(const char **stringp,
char **bufp, int *left, unsigned int ccsid)
{
/* Helper for curl_version_info_ccsid(): convert a string if defined.
Result is stored in the `*left'-byte buffer at `*bufp'.
`*bufp' and `*left' are updated accordingly.
Return 0 if ok, else -1. */
if(*stringp) {
int l = convert(*bufp, *left, ccsid, *stringp, -1, ASCII_CCSID);
if(l <= 0)
return -1;
*stringp = *bufp;
*bufp += l;
*left -= l;
}
return 0;
}
curl_version_info_data *
curl_version_info_ccsid(CURLversion stamp, unsigned int ccsid)
{
curl_version_info_data *p;
char *cp;
int n;
int nproto;
curl_version_info_data *id;
int i;
const char **cpp;
static const size_t charfields[] = {
offsetof(curl_version_info_data, version),
offsetof(curl_version_info_data, host),
offsetof(curl_version_info_data, ssl_version),
offsetof(curl_version_info_data, libz_version),
offsetof(curl_version_info_data, ares),
offsetof(curl_version_info_data, libidn),
offsetof(curl_version_info_data, libssh_version),
offsetof(curl_version_info_data, brotli_version),
offsetof(curl_version_info_data, nghttp2_version),
offsetof(curl_version_info_data, quic_version),
offsetof(curl_version_info_data, cainfo),
offsetof(curl_version_info_data, capath),
offsetof(curl_version_info_data, zstd_version),
offsetof(curl_version_info_data, hyper_version),
offsetof(curl_version_info_data, gsasl_version)
};
/* The assertion below is possible, because although the second operand
is an enum member, the first is a #define. In that case, the OS/400 C
compiler seems to compare string values after substitution. */
#if CURLVERSION_NOW != CURLVERSION_TENTH
#error curl_version_info_data structure has changed: upgrade this procedure.
#endif
/* If caller has been compiled with a new version, error. */
if(stamp > CURLVERSION_NOW)
return (curl_version_info_data *) NULL;
p = curl_version_info(stamp);
if(!p)
return p;
/* Measure thread space needed. */
n = 0;
nproto = 0;
if(p->protocols) {
while(p->protocols[nproto])
n += strlen(p->protocols[nproto++]);
n += nproto++;
}
for(i = 0; i < sizeof(charfields) / sizeof(charfields[0]); i++) {
cpp = (const char **) ((char *) p + charfields[i]);
if(*cpp)
n += strlen(*cpp) + 1;
}
/* Allocate thread space. */
n *= MAX_CONV_EXPANSION;
if(nproto)
n += nproto * sizeof(const char *);
cp = Curl_thread_buffer(LK_VERSION_INFO_DATA, n);
id = (curl_version_info_data *) Curl_thread_buffer(LK_VERSION_INFO,
sizeof(*id));
if(!id || !cp)
return (curl_version_info_data *) NULL;
/* Copy data and convert strings. */
memcpy((char *) id, (char *) p, sizeof(*p));
if(id->protocols) {
int i = nproto * sizeof(id->protocols[0]);
id->protocols = (const char * const *) cp;
memcpy(cp, (char *) p->protocols, i);
cp += i;
n -= i;
for(i = 0; id->protocols[i]; i++)
if(convert_version_info_string(((const char * *) id->protocols) + i,
&cp, &n, ccsid))
return (curl_version_info_data *) NULL;
}
for(i = 0; i < sizeof(charfields) / sizeof(charfields[0]); i++) {
cpp = (const char **) ((char *) p + charfields[i]);
if (*cpp && convert_version_info_string(cpp, &cp, &n, ccsid))
return (curl_version_info_data *) NULL;
}
return id;
}
const char *
curl_easy_strerror_ccsid(CURLcode error, unsigned int ccsid)
{
int i;
const char *s;
char *buf;
s = curl_easy_strerror(error);
if(!s)
return s;
i = MAX_CONV_EXPANSION * (strlen(s) + 1);
buf = Curl_thread_buffer(LK_EASY_STRERROR, i);
if(!buf)
return (const char *) NULL;
if(convert(buf, i, ccsid, s, -1, ASCII_CCSID) < 0)
return (const char *) NULL;
return (const char *) buf;
}
const char *
curl_share_strerror_ccsid(CURLSHcode error, unsigned int ccsid)
{
int i;
const char *s;
char *buf;
s = curl_share_strerror(error);
if(!s)
return s;
i = MAX_CONV_EXPANSION * (strlen(s) + 1);
buf = Curl_thread_buffer(LK_SHARE_STRERROR, i);
if(!buf)
return (const char *) NULL;
if(convert(buf, i, ccsid, s, -1, ASCII_CCSID) < 0)
return (const char *) NULL;
return (const char *) buf;
}
const char *
curl_multi_strerror_ccsid(CURLMcode error, unsigned int ccsid)
{
int i;
const char *s;
char *buf;
s = curl_multi_strerror(error);
if(!s)
return s;
i = MAX_CONV_EXPANSION * (strlen(s) + 1);
buf = Curl_thread_buffer(LK_MULTI_STRERROR, i);
if(!buf)
return (const char *) NULL;
if(convert(buf, i, ccsid, s, -1, ASCII_CCSID) < 0)
return (const char *) NULL;
return (const char *) buf;
}
void
curl_certinfo_free_all(struct curl_certinfo *info)
{
/* Free all memory used by certificate info. */
if(info) {
if(info->certinfo) {
int i;
for(i = 0; i < info->num_of_certs; i++)
curl_slist_free_all(info->certinfo[i]);
free((char *) info->certinfo);
}
free((char *) info);
}
}
CURLcode
curl_easy_getinfo_ccsid(CURL *curl, CURLINFO info, ...)
{
va_list arg;
void *paramp;
CURLcode ret;
struct Curl_easy *data;
/* WARNING: unlike curl_easy_getinfo(), the strings returned by this
procedure have to be free'ed. */
data = (struct Curl_easy *) curl;
va_start(arg, info);
paramp = va_arg(arg, void *);
ret = Curl_getinfo(data, info, paramp);
if(ret == CURLE_OK) {
unsigned int ccsid;
char **cpp;
struct curl_slist **slp;
struct curl_certinfo *cipf;
struct curl_certinfo *cipt;
switch((int) info & CURLINFO_TYPEMASK) {
case CURLINFO_STRING:
ccsid = va_arg(arg, unsigned int);
cpp = (char * *) paramp;
if(*cpp) {
*cpp = dynconvert(ccsid, *cpp, -1, ASCII_CCSID);
if(!*cpp)
ret = CURLE_OUT_OF_MEMORY;
}
break;
case CURLINFO_SLIST:
ccsid = va_arg(arg, unsigned int);
switch(info) {
case CURLINFO_CERTINFO:
cipf = *(struct curl_certinfo * *) paramp;
if(cipf) {
cipt = (struct curl_certinfo *) malloc(sizeof(*cipt));
if(!cipt)
ret = CURLE_OUT_OF_MEMORY;
else {
cipt->certinfo = (struct curl_slist **)
calloc(cipf->num_of_certs +
1, sizeof(struct curl_slist *));
if(!cipt->certinfo)
ret = CURLE_OUT_OF_MEMORY;
else {
int i;
cipt->num_of_certs = cipf->num_of_certs;
for(i = 0; i < cipf->num_of_certs; i++)
if(cipf->certinfo[i])
if(!(cipt->certinfo[i] = slist_convert(ccsid,
cipf->certinfo[i],
ASCII_CCSID))) {
ret = CURLE_OUT_OF_MEMORY;
break;
}
}
}
if(ret != CURLE_OK) {
curl_certinfo_free_all(cipt);
cipt = (struct curl_certinfo *) NULL;
}
*(struct curl_certinfo * *) paramp = cipt;
}
break;
case CURLINFO_TLS_SESSION:
case CURLINFO_TLS_SSL_PTR:
case CURLINFO_SOCKET:
break;
default:
slp = (struct curl_slist **) paramp;
if(*slp) {
*slp = slist_convert(ccsid, *slp, ASCII_CCSID);
if(!*slp)
ret = CURLE_OUT_OF_MEMORY;
}
break;
}
}
}
va_end(arg);
return ret;
}
static int
Curl_is_formadd_string(CURLformoption option)
{
switch(option) {
case CURLFORM_FILENAME:
case CURLFORM_CONTENTTYPE:
case CURLFORM_BUFFER:
case CURLFORM_FILE:
case CURLFORM_FILECONTENT:
case CURLFORM_COPYCONTENTS:
case CURLFORM_COPYNAME:
return 1;
}
return 0;
}
static void
Curl_formadd_release_local(struct curl_forms *forms, int nargs, int skip)
{
while(nargs--)
if(nargs != skip)
if(Curl_is_formadd_string(forms[nargs].option))
if(forms[nargs].value)
free((char *) forms[nargs].value);
free((char *) forms);
}
static int
Curl_formadd_convert(struct curl_forms *forms,
int formx, int lengthx, unsigned int ccsid)
{
int l;
char *cp;
char *cp2;
if(formx < 0 || !forms[formx].value)
return 0;
if(lengthx >= 0)
l = (int) forms[lengthx].value;
else
l = strlen(forms[formx].value) + 1;
cp = malloc(MAX_CONV_EXPANSION * l);
if(!cp)
return -1;
l = convert(cp, MAX_CONV_EXPANSION * l, ASCII_CCSID,
forms[formx].value, l, ccsid);
if(l < 0) {
free(cp);
return -1;
}
cp2 = realloc(cp, l); /* Shorten buffer to the string size. */
if(cp2)
cp = cp2;
forms[formx].value = cp;
if(lengthx >= 0)
forms[lengthx].value = (char *) l; /* Update length after conversion. */
return l;
}
CURLFORMcode
curl_formadd_ccsid(struct curl_httppost **httppost,
struct curl_httppost **last_post, ...)
{
va_list arg;
CURLformoption option;
CURLFORMcode result;
struct curl_forms *forms;
struct curl_forms *lforms;
struct curl_forms *tforms;
unsigned int lformlen;
const char *value;
unsigned int ccsid;
int nargs;
int namex;
int namelengthx;
int contentx;
int lengthx;
unsigned int contentccsid;
unsigned int nameccsid;
/* A single curl_formadd() call cannot be split in several calls to deal
with all parameters: the original parameters are thus copied to a local
curl_forms array and converted to ASCII when needed.
CURLFORM_PTRNAME is processed as if it were CURLFORM_COPYNAME.
CURLFORM_COPYNAME and CURLFORM_NAMELENGTH occurrence order in
parameters is not defined; for this reason, the actual conversion is
delayed to the end of parameter processing. The same applies to
CURLFORM_COPYCONTENTS/CURLFORM_CONTENTSLENGTH, but these may appear
several times in the parameter list; the problem resides here in knowing
which CURLFORM_CONTENTSLENGTH applies to which CURLFORM_COPYCONTENTS and
when we can be sure to have both info for conversion: end of parameter
list is such a point, but CURLFORM_CONTENTTYPE is also used here as a
natural separator between content data definitions; this seems to be
in accordance with FormAdd() behavior. */
/* Allocate the local curl_forms array. */
lformlen = ALLOC_GRANULE;
lforms = malloc(lformlen * sizeof(*lforms));
if(!lforms)
return CURL_FORMADD_MEMORY;
/* Process the arguments, copying them into local array, latching conversion
indexes and converting when needed. */
result = CURL_FORMADD_OK;
nargs = 0;
contentx = -1;
lengthx = -1;
namex = -1;
namelengthx = -1;
forms = (struct curl_forms *) NULL;
va_start(arg, last_post);
for(;;) {
/* Make sure there is still room for an item in local array. */
if(nargs >= lformlen) {
lformlen += ALLOC_GRANULE;
tforms = realloc(lforms, lformlen * sizeof(*lforms));
if(!tforms) {
result = CURL_FORMADD_MEMORY;
break;
}
lforms = tforms;
}
/* Get next option. */
if(forms) {
/* Get option from array. */
option = forms->option;
value = forms->value;
forms++;
}
else {
/* Get option from arguments. */
option = va_arg(arg, CURLformoption);
if(option == CURLFORM_END)
break;
}
/* Dispatch by option. */
switch(option) {
case CURLFORM_END:
forms = (struct curl_forms *) NULL; /* Leave array mode. */
continue;
case CURLFORM_ARRAY:
if(!forms) {
forms = va_arg(arg, struct curl_forms *);
continue;
}
result = CURL_FORMADD_ILLEGAL_ARRAY;
break;
case CURLFORM_COPYNAME:
option = CURLFORM_PTRNAME; /* Static for now. */
case CURLFORM_PTRNAME:
if(namex >= 0)
result = CURL_FORMADD_OPTION_TWICE;
namex = nargs;
if(!forms) {
value = va_arg(arg, char *);
nameccsid = (unsigned int) va_arg(arg, long);
}
else {
nameccsid = (unsigned int) forms->value;
forms++;
}
break;
case CURLFORM_COPYCONTENTS:
if(contentx >= 0)
result = CURL_FORMADD_OPTION_TWICE;
contentx = nargs;
if(!forms) {
value = va_arg(arg, char *);
contentccsid = (unsigned int) va_arg(arg, long);
}
else {
contentccsid = (unsigned int) forms->value;
forms++;
}
break;
case CURLFORM_PTRCONTENTS:
case CURLFORM_BUFFERPTR:
if(!forms)
value = va_arg(arg, char *); /* No conversion. */
break;
case CURLFORM_CONTENTSLENGTH:
lengthx = nargs;
if(!forms)
value = (char *) va_arg(arg, long);
break;
case CURLFORM_CONTENTLEN:
lengthx = nargs;
if(!forms)
value = (char *) va_arg(arg, curl_off_t);
break;
case CURLFORM_NAMELENGTH:
namelengthx = nargs;
if(!forms)
value = (char *) va_arg(arg, long);
break;
case CURLFORM_BUFFERLENGTH:
if(!forms)
value = (char *) va_arg(arg, long);
break;
case CURLFORM_CONTENTHEADER:
if(!forms)
value = (char *) va_arg(arg, struct curl_slist *);
break;
case CURLFORM_STREAM:
if(!forms)
value = (char *) va_arg(arg, void *);
break;
case CURLFORM_CONTENTTYPE:
/* If a previous content has been encountered, convert it now. */
if(Curl_formadd_convert(lforms, contentx, lengthx, contentccsid) < 0) {
result = CURL_FORMADD_MEMORY;
break;
}
contentx = -1;
lengthx = -1;
/* Fall into default. */
default:
/* Must be a convertible string. */
if(!Curl_is_formadd_string(option)) {
result = CURL_FORMADD_UNKNOWN_OPTION;
break;
}
if(!forms) {
value = va_arg(arg, char *);
ccsid = (unsigned int) va_arg(arg, long);
}
else {
ccsid = (unsigned int) forms->value;
forms++;
}
/* Do the conversion. */
lforms[nargs].value = value;
if(Curl_formadd_convert(lforms, nargs, -1, ccsid) < 0) {
result = CURL_FORMADD_MEMORY;
break;
}
value = lforms[nargs].value;
}
if(result != CURL_FORMADD_OK)
break;
lforms[nargs].value = value;
lforms[nargs++].option = option;
}
va_end(arg);
/* Convert the name and the last content, now that we know their lengths. */
if(result == CURL_FORMADD_OK && namex >= 0) {
if(Curl_formadd_convert(lforms, namex, namelengthx, nameccsid) < 0)
result = CURL_FORMADD_MEMORY;
else
lforms[namex].option = CURLFORM_COPYNAME; /* Force copy. */
}
if(result == CURL_FORMADD_OK) {
if(Curl_formadd_convert(lforms, contentx, lengthx, contentccsid) < 0)
result = CURL_FORMADD_MEMORY;
else
contentx = -1;
}
/* Do the formadd with our converted parameters. */
if(result == CURL_FORMADD_OK) {
lforms[nargs].option = CURLFORM_END;
result = curl_formadd(httppost, last_post,
CURLFORM_ARRAY, lforms, CURLFORM_END);
}
/* Terminate. */
Curl_formadd_release_local(lforms, nargs, contentx);
return result;
}
struct cfcdata {
curl_formget_callback append;
void * arg;
unsigned int ccsid;
};
static size_t
Curl_formget_callback_ccsid(void *arg, const char *buf, size_t len)
{
struct cfcdata *p;
char *b;
int l;
size_t ret;
p = (struct cfcdata *) arg;
if((long) len <= 0)
return (*p->append)(p->arg, buf, len);
b = malloc(MAX_CONV_EXPANSION * len);
if(!b)
return (size_t) -1;
l = convert(b, MAX_CONV_EXPANSION * len, p->ccsid, buf, len, ASCII_CCSID);
if(l < 0) {
free(b);
return (size_t) -1;
}
ret = (*p->append)(p->arg, b, l);
free(b);
return ret == l? len: -1;
}
int
curl_formget_ccsid(struct curl_httppost *form, void *arg,
curl_formget_callback append, unsigned int ccsid)
{
struct cfcdata lcfc;
lcfc.append = append;
lcfc.arg = arg;
lcfc.ccsid = ccsid;
return curl_formget(form, (void *) &lcfc, Curl_formget_callback_ccsid);
}
CURLcode
curl_easy_setopt_ccsid(CURL *curl, CURLoption tag, ...)
{
CURLcode result;
va_list arg;
struct Curl_easy *data;
char *s;
char *cp;
unsigned int ccsid;
curl_off_t pfsize;
data = (struct Curl_easy *) curl;
va_start(arg, tag);
switch(tag) {
case CURLOPT_ABSTRACT_UNIX_SOCKET:
case CURLOPT_ALTSVC:
case CURLOPT_AWS_SIGV4:
case CURLOPT_CAINFO:
case CURLOPT_CAPATH:
case CURLOPT_COOKIE:
case CURLOPT_COOKIEFILE:
case CURLOPT_COOKIEJAR:
case CURLOPT_COOKIELIST:
case CURLOPT_CRLFILE:
case CURLOPT_CUSTOMREQUEST:
case CURLOPT_DEFAULT_PROTOCOL:
case CURLOPT_DNS_SERVERS:
case CURLOPT_DNS_INTERFACE:
case CURLOPT_DNS_LOCAL_IP4:
case CURLOPT_DNS_LOCAL_IP6:
case CURLOPT_DOH_URL:
case CURLOPT_EGDSOCKET:
case CURLOPT_ENCODING:
case CURLOPT_FTPPORT:
case CURLOPT_FTP_ACCOUNT:
case CURLOPT_FTP_ALTERNATIVE_TO_USER:
case CURLOPT_HSTS:
case CURLOPT_INTERFACE:
case CURLOPT_ISSUERCERT:
case CURLOPT_KEYPASSWD:
case CURLOPT_KRBLEVEL:
case CURLOPT_LOGIN_OPTIONS:
case CURLOPT_MAIL_AUTH:
case CURLOPT_MAIL_FROM:
case CURLOPT_NETRC_FILE:
case CURLOPT_NOPROXY:
case CURLOPT_PASSWORD:
case CURLOPT_PINNEDPUBLICKEY:
case CURLOPT_PRE_PROXY:
case CURLOPT_PROXY:
case CURLOPT_PROXYPASSWORD:
case CURLOPT_PROXYUSERNAME:
case CURLOPT_PROXYUSERPWD:
case CURLOPT_PROXY_CAINFO:
case CURLOPT_PROXY_CAPATH:
case CURLOPT_PROXY_CRLFILE:
case CURLOPT_PROXY_KEYPASSWD:
case CURLOPT_PROXY_PINNEDPUBLICKEY:
case CURLOPT_PROXY_SERVICE_NAME:
case CURLOPT_PROXY_SSLCERT:
case CURLOPT_PROXY_SSLCERTTYPE:
case CURLOPT_PROXY_SSLKEY:
case CURLOPT_PROXY_SSLKEYTYPE:
case CURLOPT_PROXY_SSL_CIPHER_LIST:
case CURLOPT_PROXY_TLS13_CIPHERS:
case CURLOPT_PROXY_TLSAUTH_PASSWORD:
case CURLOPT_PROXY_TLSAUTH_TYPE:
case CURLOPT_PROXY_TLSAUTH_USERNAME:
case CURLOPT_RANDOM_FILE:
case CURLOPT_RANGE:
case CURLOPT_REFERER:
case CURLOPT_REQUEST_TARGET:
case CURLOPT_RTSP_SESSION_ID:
case CURLOPT_RTSP_STREAM_URI:
case CURLOPT_RTSP_TRANSPORT:
case CURLOPT_SASL_AUTHZID:
case CURLOPT_SERVICE_NAME:
case CURLOPT_SOCKS5_GSSAPI_SERVICE:
case CURLOPT_SSH_HOST_PUBLIC_KEY_MD5:
case CURLOPT_SSH_KNOWNHOSTS:
case CURLOPT_SSH_PRIVATE_KEYFILE:
case CURLOPT_SSH_PUBLIC_KEYFILE:
case CURLOPT_SSLCERT:
case CURLOPT_SSLCERTTYPE:
case CURLOPT_SSLENGINE:
case CURLOPT_SSLKEY:
case CURLOPT_SSLKEYTYPE:
case CURLOPT_SSL_CIPHER_LIST:
case CURLOPT_SSL_EC_CURVES:
case CURLOPT_TLS13_CIPHERS:
case CURLOPT_TLSAUTH_PASSWORD:
case CURLOPT_TLSAUTH_TYPE:
case CURLOPT_TLSAUTH_USERNAME:
case CURLOPT_UNIX_SOCKET_PATH:
case CURLOPT_URL:
case CURLOPT_USERAGENT:
case CURLOPT_USERNAME:
case CURLOPT_USERPWD:
case CURLOPT_XOAUTH2_BEARER:
s = va_arg(arg, char *);
ccsid = va_arg(arg, unsigned int);
if(s) {
s = dynconvert(ASCII_CCSID, s, -1, ccsid);
if(!s) {
result = CURLE_OUT_OF_MEMORY;
break;
}
}
result = curl_easy_setopt(curl, tag, s);
free(s);
break;
case CURLOPT_COPYPOSTFIELDS:
/* Special case: byte count may have been given by CURLOPT_POSTFIELDSIZE
prior to this call. In this case, convert the given byte count and
replace the length according to the conversion result. */
s = va_arg(arg, char *);
ccsid = va_arg(arg, unsigned int);
pfsize = data->set.postfieldsize;
if(!s || !pfsize || ccsid == NOCONV_CCSID || ccsid == ASCII_CCSID) {
result = curl_easy_setopt(curl, CURLOPT_COPYPOSTFIELDS, s);
break;
}
if(pfsize == -1) {
/* Data is null-terminated. */
s = dynconvert(ASCII_CCSID, s, -1, ccsid);
if(!s) {
result = CURLE_OUT_OF_MEMORY;
break;
}
}
else {
/* Data length specified. */
size_t len;
if(pfsize < 0 || pfsize > SIZE_MAX) {
result = CURLE_OUT_OF_MEMORY;
break;
}
len = pfsize;
pfsize = len * MAX_CONV_EXPANSION;
if(pfsize > SIZE_MAX)
pfsize = SIZE_MAX;
cp = malloc(pfsize);
if(!cp) {
result = CURLE_OUT_OF_MEMORY;
break;
}
pfsize = convert(cp, pfsize, ASCII_CCSID, s, len, ccsid);
if(pfsize < 0) {
free(cp);
result = CURLE_OUT_OF_MEMORY;
break;
}
data->set.postfieldsize = pfsize; /* Replace data size. */
s = cp;
}
result = curl_easy_setopt(curl, CURLOPT_POSTFIELDS, s);
data->set.str[STRING_COPYPOSTFIELDS] = s; /* Give to library. */
break;
case CURLOPT_ERRORBUFFER: /* This is an output buffer. */
default:
result = Curl_vsetopt(curl, tag, arg);
break;
}
va_end(arg);
return result;
}
char *
curl_form_long_value(long value)
{
/* ILE/RPG cannot cast an integer to a pointer. This procedure does it. */
return (char *) value;
}
char *
curl_pushheader_bynum_cssid(struct curl_pushheaders *h,
size_t num, unsigned int ccsid)
{
char *d = (char *) NULL;
char *s = curl_pushheader_bynum(h, num);
if(s)
d = dynconvert(ccsid, s, -1, ASCII_CCSID);
return d;
}
char *
curl_pushheader_byname_ccsid(struct curl_pushheaders *h, const char *header,
unsigned int ccsidin, unsigned int ccsidout)
{
char *d = (char *) NULL;
if(header) {
header = dynconvert(ASCII_CCSID, header, -1, ccsidin);
if(header) {
char *s = curl_pushheader_byname(h, header);
free((char *) header);
if(s)
d = dynconvert(ccsidout, s, -1, ASCII_CCSID);
}
}
return d;
}
static CURLcode
mime_string_call(curl_mimepart *part, const char *string, unsigned int ccsid,
CURLcode (*mimefunc)(curl_mimepart *part, const char *string))
{
char *s = (char *) NULL;
CURLcode result;
if(!string)
return mimefunc(part, string);
s = dynconvert(ASCII_CCSID, string, -1, ccsid);
if(!s)
return CURLE_OUT_OF_MEMORY;
result = mimefunc(part, s);
free(s);
return result;
}
CURLcode
curl_mime_name_ccsid(curl_mimepart *part, const char *name, unsigned int ccsid)
{
return mime_string_call(part, name, ccsid, curl_mime_name);
}
CURLcode
curl_mime_filename_ccsid(curl_mimepart *part,
const char *filename, unsigned int ccsid)
{
return mime_string_call(part, filename, ccsid, curl_mime_filename);
}
CURLcode
curl_mime_type_ccsid(curl_mimepart *part,
const char *mimetype, unsigned int ccsid)
{
return mime_string_call(part, mimetype, ccsid, curl_mime_type);
}
CURLcode
curl_mime_encoder_ccsid(curl_mimepart *part,
const char *encoding, unsigned int ccsid)
{
return mime_string_call(part, encoding, ccsid, curl_mime_encoder);
}
CURLcode
curl_mime_filedata_ccsid(curl_mimepart *part,
const char *filename, unsigned int ccsid)
{
return mime_string_call(part, filename, ccsid, curl_mime_filedata);
}
CURLcode
curl_mime_data_ccsid(curl_mimepart *part,
const char *data, size_t datasize, unsigned int ccsid)
{
char *s = (char *) NULL;
CURLcode result;
if(!data)
return curl_mime_data(part, data, datasize);
s = dynconvert(ASCII_CCSID, data, datasize, ccsid);
if(!s)
return CURLE_OUT_OF_MEMORY;
result = curl_mime_data(part, s, datasize);
free(s);
return result;
}
CURLUcode
curl_url_get_ccsid(CURLU *handle, CURLUPart what, char **part,
unsigned int flags, unsigned int ccsid)
{
char *s = (char *)NULL;
CURLUcode result;
if(!part)
return CURLUE_BAD_PARTPOINTER;
*part = (char *)NULL;
result = curl_url_get(handle, what, &s, flags);
if(result == CURLUE_OK) {
if(s) {
*part = dynconvert(ccsid, s, -1, ASCII_CCSID);
if(!*part)
result = CURLUE_OUT_OF_MEMORY;
}
}
if(s)
free(s);
return result;
}
CURLUcode
curl_url_set_ccsid(CURLU *handle, CURLUPart what, const char *part,
unsigned int flags, unsigned int ccsid)
{
char *s = (char *)NULL;
CURLUcode result;
if(part) {
s = dynconvert(ASCII_CCSID, part, -1, ccsid);
if(!s)
return CURLUE_OUT_OF_MEMORY;
}
result = curl_url_set(handle, what, s, flags);
if(s)
free(s);
return result;
}
const struct curl_easyoption *
curl_easy_option_by_name_ccsid(const char *name, unsigned int ccsid)
{
const struct curl_easyoption *option = NULL;
if(name) {
char *s = dynconvert(ASCII_CCSID, name, -1, ccsid);
if(s) {
option = curl_easy_option_by_name(s);
free(s);
}
}
return option;
}
/* Return option name in the given ccsid. */
const char *
curl_easy_option_get_name_ccsid(const struct curl_easyoption *option,
unsigned int ccsid)
{
char *name = NULL;
if(option && option->name)
name = dynconvert(ccsid, option->name, -1, ASCII_CCSID);
return (const char *) name;
}
Reference in New Issue View Git Blame Copy Permalink