1: /***************************************************************************
2: * _ _ ____ _
3: * Project ___| | | | _ \| |
4: * / __| | | | |_) | |
5: * | (__| |_| | _ <| |___
6: * \___|\___/|_| \_\_____|
7: *
8: * Copyright (C) 1998 - 2019, Daniel Stenberg, <daniel@haxx.se>, et al.
9: *
10: * This software is licensed as described in the file COPYING, which
11: * you should have received as part of this distribution. The terms
12: * are also available at https://curl.haxx.se/docs/copyright.html.
13: *
14: * You may opt to use, copy, modify, merge, publish, distribute and/or sell
15: * copies of the Software, and permit persons to whom the Software is
16: * furnished to do so, under the terms of the COPYING file.
17: *
18: * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
19: * KIND, either express or implied.
20: *
21: ***************************************************************************/
22:
23: #include "curl_setup.h"
24:
25: #ifdef CURL_DOES_CONVERSIONS
26:
27: #include <curl/curl.h>
28:
29: #include "non-ascii.h"
30: #include "formdata.h"
31: #include "sendf.h"
32: #include "urldata.h"
33: #include "multiif.h"
34:
35: #include "curl_memory.h"
36: /* The last #include file should be: */
37: #include "memdebug.h"
38:
39: #ifdef HAVE_ICONV
40: #include <iconv.h>
41: /* set default codesets for iconv */
42: #ifndef CURL_ICONV_CODESET_OF_NETWORK
43: #define CURL_ICONV_CODESET_OF_NETWORK "ISO8859-1"
44: #endif
45: #ifndef CURL_ICONV_CODESET_FOR_UTF8
46: #define CURL_ICONV_CODESET_FOR_UTF8 "UTF-8"
47: #endif
48: #define ICONV_ERROR (size_t)-1
49: #endif /* HAVE_ICONV */
50:
51: /*
52: * Curl_convert_clone() returns a malloced copy of the source string (if
53: * returning CURLE_OK), with the data converted to network format.
54: */
55: CURLcode Curl_convert_clone(struct Curl_easy *data,
56: const char *indata,
57: size_t insize,
58: char **outbuf)
59: {
60: char *convbuf;
61: CURLcode result;
62:
63: convbuf = malloc(insize);
64: if(!convbuf)
65: return CURLE_OUT_OF_MEMORY;
66:
67: memcpy(convbuf, indata, insize);
68: result = Curl_convert_to_network(data, convbuf, insize);
69: if(result) {
70: free(convbuf);
71: return result;
72: }
73:
74: *outbuf = convbuf; /* return the converted buffer */
75:
76: return CURLE_OK;
77: }
78:
79: /*
80: * Curl_convert_to_network() is an internal function for performing ASCII
81: * conversions on non-ASCII platforms. It converts the buffer _in place_.
82: */
83: CURLcode Curl_convert_to_network(struct Curl_easy *data,
84: char *buffer, size_t length)
85: {
86: if(data && data->set.convtonetwork) {
87: /* use translation callback */
88: CURLcode result;
89: Curl_set_in_callback(data, true);
90: result = data->set.convtonetwork(buffer, length);
91: Curl_set_in_callback(data, false);
92: if(result) {
93: failf(data,
94: "CURLOPT_CONV_TO_NETWORK_FUNCTION callback returned %d: %s",
95: (int)result, curl_easy_strerror(result));
96: }
97:
98: return result;
99: }
100: else {
101: #ifdef HAVE_ICONV
102: /* do the translation ourselves */
103: iconv_t tmpcd = (iconv_t) -1;
104: iconv_t *cd = &tmpcd;
105: char *input_ptr, *output_ptr;
106: size_t in_bytes, out_bytes, rc;
107:
108: /* open an iconv conversion descriptor if necessary */
109: if(data)
110: cd = &data->outbound_cd;
111: if(*cd == (iconv_t)-1) {
112: *cd = iconv_open(CURL_ICONV_CODESET_OF_NETWORK,
113: CURL_ICONV_CODESET_OF_HOST);
114: if(*cd == (iconv_t)-1) {
115: failf(data,
116: "The iconv_open(\"%s\", \"%s\") call failed with errno %i: %s",
117: CURL_ICONV_CODESET_OF_NETWORK,
118: CURL_ICONV_CODESET_OF_HOST,
119: errno, strerror(errno));
120: return CURLE_CONV_FAILED;
121: }
122: }
123: /* call iconv */
124: input_ptr = output_ptr = buffer;
125: in_bytes = out_bytes = length;
126: rc = iconv(*cd, &input_ptr, &in_bytes,
127: &output_ptr, &out_bytes);
128: if(!data)
129: iconv_close(tmpcd);
130: if((rc == ICONV_ERROR) || (in_bytes != 0)) {
131: failf(data,
132: "The Curl_convert_to_network iconv call failed with errno %i: %s",
133: errno, strerror(errno));
134: return CURLE_CONV_FAILED;
135: }
136: #else
137: failf(data, "CURLOPT_CONV_TO_NETWORK_FUNCTION callback required");
138: return CURLE_CONV_REQD;
139: #endif /* HAVE_ICONV */
140: }
141:
142: return CURLE_OK;
143: }
144:
145: /*
146: * Curl_convert_from_network() is an internal function for performing ASCII
147: * conversions on non-ASCII platforms. It converts the buffer _in place_.
148: */
149: CURLcode Curl_convert_from_network(struct Curl_easy *data,
150: char *buffer, size_t length)
151: {
152: if(data && data->set.convfromnetwork) {
153: /* use translation callback */
154: CURLcode result;
155: Curl_set_in_callback(data, true);
156: result = data->set.convfromnetwork(buffer, length);
157: Curl_set_in_callback(data, false);
158: if(result) {
159: failf(data,
160: "CURLOPT_CONV_FROM_NETWORK_FUNCTION callback returned %d: %s",
161: (int)result, curl_easy_strerror(result));
162: }
163:
164: return result;
165: }
166: else {
167: #ifdef HAVE_ICONV
168: /* do the translation ourselves */
169: iconv_t tmpcd = (iconv_t) -1;
170: iconv_t *cd = &tmpcd;
171: char *input_ptr, *output_ptr;
172: size_t in_bytes, out_bytes, rc;
173:
174: /* open an iconv conversion descriptor if necessary */
175: if(data)
176: cd = &data->inbound_cd;
177: if(*cd == (iconv_t)-1) {
178: *cd = iconv_open(CURL_ICONV_CODESET_OF_HOST,
179: CURL_ICONV_CODESET_OF_NETWORK);
180: if(*cd == (iconv_t)-1) {
181: failf(data,
182: "The iconv_open(\"%s\", \"%s\") call failed with errno %i: %s",
183: CURL_ICONV_CODESET_OF_HOST,
184: CURL_ICONV_CODESET_OF_NETWORK,
185: errno, strerror(errno));
186: return CURLE_CONV_FAILED;
187: }
188: }
189: /* call iconv */
190: input_ptr = output_ptr = buffer;
191: in_bytes = out_bytes = length;
192: rc = iconv(*cd, &input_ptr, &in_bytes,
193: &output_ptr, &out_bytes);
194: if(!data)
195: iconv_close(tmpcd);
196: if((rc == ICONV_ERROR) || (in_bytes != 0)) {
197: failf(data,
198: "Curl_convert_from_network iconv call failed with errno %i: %s",
199: errno, strerror(errno));
200: return CURLE_CONV_FAILED;
201: }
202: #else
203: failf(data, "CURLOPT_CONV_FROM_NETWORK_FUNCTION callback required");
204: return CURLE_CONV_REQD;
205: #endif /* HAVE_ICONV */
206: }
207:
208: return CURLE_OK;
209: }
210:
211: /*
212: * Curl_convert_from_utf8() is an internal function for performing UTF-8
213: * conversions on non-ASCII platforms.
214: */
215: CURLcode Curl_convert_from_utf8(struct Curl_easy *data,
216: char *buffer, size_t length)
217: {
218: if(data && data->set.convfromutf8) {
219: /* use translation callback */
220: CURLcode result;
221: Curl_set_in_callback(data, true);
222: result = data->set.convfromutf8(buffer, length);
223: Curl_set_in_callback(data, false);
224: if(result) {
225: failf(data,
226: "CURLOPT_CONV_FROM_UTF8_FUNCTION callback returned %d: %s",
227: (int)result, curl_easy_strerror(result));
228: }
229:
230: return result;
231: }
232: else {
233: #ifdef HAVE_ICONV
234: /* do the translation ourselves */
235: iconv_t tmpcd = (iconv_t) -1;
236: iconv_t *cd = &tmpcd;
237: char *input_ptr;
238: char *output_ptr;
239: size_t in_bytes, out_bytes, rc;
240:
241: /* open an iconv conversion descriptor if necessary */
242: if(data)
243: cd = &data->utf8_cd;
244: if(*cd == (iconv_t)-1) {
245: *cd = iconv_open(CURL_ICONV_CODESET_OF_HOST,
246: CURL_ICONV_CODESET_FOR_UTF8);
247: if(*cd == (iconv_t)-1) {
248: failf(data,
249: "The iconv_open(\"%s\", \"%s\") call failed with errno %i: %s",
250: CURL_ICONV_CODESET_OF_HOST,
251: CURL_ICONV_CODESET_FOR_UTF8,
252: errno, strerror(errno));
253: return CURLE_CONV_FAILED;
254: }
255: }
256: /* call iconv */
257: input_ptr = output_ptr = buffer;
258: in_bytes = out_bytes = length;
259: rc = iconv(*cd, &input_ptr, &in_bytes,
260: &output_ptr, &out_bytes);
261: if(!data)
262: iconv_close(tmpcd);
263: if((rc == ICONV_ERROR) || (in_bytes != 0)) {
264: failf(data,
265: "The Curl_convert_from_utf8 iconv call failed with errno %i: %s",
266: errno, strerror(errno));
267: return CURLE_CONV_FAILED;
268: }
269: if(output_ptr < input_ptr) {
270: /* null terminate the now shorter output string */
271: *output_ptr = 0x00;
272: }
273: #else
274: failf(data, "CURLOPT_CONV_FROM_UTF8_FUNCTION callback required");
275: return CURLE_CONV_REQD;
276: #endif /* HAVE_ICONV */
277: }
278:
279: return CURLE_OK;
280: }
281:
282: /*
283: * Init conversion stuff for a Curl_easy
284: */
285: void Curl_convert_init(struct Curl_easy *data)
286: {
287: #if defined(CURL_DOES_CONVERSIONS) && defined(HAVE_ICONV)
288: /* conversion descriptors for iconv calls */
289: data->outbound_cd = (iconv_t)-1;
290: data->inbound_cd = (iconv_t)-1;
291: data->utf8_cd = (iconv_t)-1;
292: #else
293: (void)data;
294: #endif /* CURL_DOES_CONVERSIONS && HAVE_ICONV */
295: }
296:
297: /*
298: * Setup conversion stuff for a Curl_easy
299: */
300: void Curl_convert_setup(struct Curl_easy *data)
301: {
302: data->inbound_cd = iconv_open(CURL_ICONV_CODESET_OF_HOST,
303: CURL_ICONV_CODESET_OF_NETWORK);
304: data->outbound_cd = iconv_open(CURL_ICONV_CODESET_OF_NETWORK,
305: CURL_ICONV_CODESET_OF_HOST);
306: data->utf8_cd = iconv_open(CURL_ICONV_CODESET_OF_HOST,
307: CURL_ICONV_CODESET_FOR_UTF8);
308: }
309:
310: /*
311: * Close conversion stuff for a Curl_easy
312: */
313:
314: void Curl_convert_close(struct Curl_easy *data)
315: {
316: #ifdef HAVE_ICONV
317: /* close iconv conversion descriptors */
318: if(data->inbound_cd != (iconv_t)-1) {
319: iconv_close(data->inbound_cd);
320: }
321: if(data->outbound_cd != (iconv_t)-1) {
322: iconv_close(data->outbound_cd);
323: }
324: if(data->utf8_cd != (iconv_t)-1) {
325: iconv_close(data->utf8_cd);
326: }
327: #else
328: (void)data;
329: #endif /* HAVE_ICONV */
330: }
331:
332: #endif /* CURL_DOES_CONVERSIONS */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to non-ascii.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / curl / lib