1: /***************************************************************************
2: * _ _ ____ _
3: * Project ___| | | | _ \| |
4: * / __| | | | |_) | |
5: * | (__| |_| | _ <| |___
6: * \___|\___/|_| \_\_____|
7: *
8: * Copyright (C) 1998 - 2020, 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: #include "server_setup.h"
23:
24: #include "getpart.h"
25:
26: #define ENABLE_CURLX_PRINTF
27: /* make the curlx header define all printf() functions to use the curlx_*
28: versions instead */
29: #include "curlx.h" /* from the private lib dir */
30:
31: /* just to please curl_base64.h we create a fake struct */
32: struct Curl_easy {
33: int fake;
34: };
35:
36: #include "curl_base64.h"
37: #include "curl_memory.h"
38:
39: /* include memdebug.h last */
40: #include "memdebug.h"
41:
42: #define EAT_SPACE(p) while(*(p) && ISSPACE(*(p))) (p)++
43:
44: #define EAT_WORD(p) while(*(p) && !ISSPACE(*(p)) && ('>' != *(p))) (p)++
45:
46: #ifdef DEBUG_GETPART
47: #define show(x) printf x
48: #else
49: #define show(x) Curl_nop_stmt
50: #endif
51:
52: #if defined(_MSC_VER) && defined(_DLL)
53: # pragma warning(disable:4232) /* MSVC extension, dllimport identity */
54: #endif
55:
56: curl_malloc_callback Curl_cmalloc = (curl_malloc_callback)malloc;
57: curl_free_callback Curl_cfree = (curl_free_callback)free;
58: curl_realloc_callback Curl_crealloc = (curl_realloc_callback)realloc;
59: curl_strdup_callback Curl_cstrdup = (curl_strdup_callback)strdup;
60: curl_calloc_callback Curl_ccalloc = (curl_calloc_callback)calloc;
61: #if defined(WIN32) && defined(UNICODE)
62: curl_wcsdup_callback Curl_cwcsdup = (curl_wcsdup_callback)_wcsdup;
63: #endif
64:
65: #if defined(_MSC_VER) && defined(_DLL)
66: # pragma warning(default:4232) /* MSVC extension, dllimport identity */
67: #endif
68:
69:
70: /*
71: * Curl_convert_clone() returns a malloced copy of the source string (if
72: * returning CURLE_OK), with the data converted to network format. This
73: * function is used by base64 code in libcurl built to support data
74: * conversion. This is a DUMMY VERSION that returns data unmodified - for
75: * use by the test server only.
76: */
77: CURLcode Curl_convert_clone(struct Curl_easy *data,
78: const char *indata,
79: size_t insize,
80: char **outbuf);
81: CURLcode Curl_convert_clone(struct Curl_easy *data,
82: const char *indata,
83: size_t insize,
84: char **outbuf)
85: {
86: char *convbuf;
87: (void)data;
88:
89: convbuf = malloc(insize);
90: if(!convbuf)
91: return CURLE_OUT_OF_MEMORY;
92:
93: memcpy(convbuf, indata, insize);
94: *outbuf = convbuf;
95: return CURLE_OK;
96: }
97:
98: /*
99: * readline()
100: *
101: * Reads a complete line from a file into a dynamically allocated buffer.
102: *
103: * Calling function may call this multiple times with same 'buffer'
104: * and 'bufsize' pointers to avoid multiple buffer allocations. Buffer
105: * will be reallocated and 'bufsize' increased until whole line fits in
106: * buffer before returning it.
107: *
108: * Calling function is responsible to free allocated buffer.
109: *
110: * This function may return:
111: * GPE_OUT_OF_MEMORY
112: * GPE_END_OF_FILE
113: * GPE_OK
114: */
115:
116: static int readline(char **buffer, size_t *bufsize, FILE *stream)
117: {
118: size_t offset = 0;
119: char *newptr;
120:
121: if(!*buffer) {
122: *buffer = malloc(128);
123: if(!*buffer)
124: return GPE_OUT_OF_MEMORY;
125: *bufsize = 128;
126: }
127:
128: for(;;) {
129: size_t length;
130: int bytestoread = curlx_uztosi(*bufsize - offset);
131:
132: if(!fgets(*buffer + offset, bytestoread, stream))
133: return (offset != 0) ? GPE_OK : GPE_END_OF_FILE;
134:
135: length = offset + strlen(*buffer + offset);
136: if(*(*buffer + length - 1) == '\n')
137: break;
138: offset = length;
139: if(length < *bufsize - 1)
140: continue;
141:
142: newptr = realloc(*buffer, *bufsize * 2);
143: if(!newptr)
144: return GPE_OUT_OF_MEMORY;
145: *buffer = newptr;
146: *bufsize *= 2;
147: }
148:
149: return GPE_OK;
150: }
151:
152: /*
153: * appenddata()
154: *
155: * This appends data from a given source buffer to the end of the used part of
156: * a destination buffer. Arguments relative to the destination buffer are, the
157: * address of a pointer to the destination buffer 'dst_buf', the length of data
158: * in destination buffer excluding potential null string termination 'dst_len',
159: * the allocated size of destination buffer 'dst_alloc'. All three destination
160: * buffer arguments may be modified by this function. Arguments relative to the
161: * source buffer are, a pointer to the source buffer 'src_buf' and indication
162: * whether the source buffer is base64 encoded or not 'src_b64'.
163: *
164: * If the source buffer is indicated to be base64 encoded, this appends the
165: * decoded data, binary or whatever, to the destination. The source buffer
166: * may not hold binary data, only a null terminated string is valid content.
167: *
168: * Destination buffer will be enlarged and relocated as needed.
169: *
170: * Calling function is responsible to provide preallocated destination
171: * buffer and also to deallocate it when no longer needed.
172: *
173: * This function may return:
174: * GPE_OUT_OF_MEMORY
175: * GPE_OK
176: */
177:
178: static int appenddata(char **dst_buf, /* dest buffer */
179: size_t *dst_len, /* dest buffer data length */
180: size_t *dst_alloc, /* dest buffer allocated size */
181: char *src_buf, /* source buffer */
182: int src_b64) /* != 0 if source is base64 encoded */
183: {
184: size_t need_alloc = 0;
185: size_t src_len = strlen(src_buf);
186:
187: if(!src_len)
188: return GPE_OK;
189:
190: need_alloc = src_len + *dst_len + 1;
191:
192: if(src_b64) {
193: if(src_buf[src_len - 1] == '\r')
194: src_len--;
195:
196: if(src_buf[src_len - 1] == '\n')
197: src_len--;
198: }
199:
200: /* enlarge destination buffer if required */
201: if(need_alloc > *dst_alloc) {
202: size_t newsize = need_alloc * 2;
203: char *newptr = realloc(*dst_buf, newsize);
204: if(!newptr) {
205: return GPE_OUT_OF_MEMORY;
206: }
207: *dst_alloc = newsize;
208: *dst_buf = newptr;
209: }
210:
211: /* memcpy to support binary blobs */
212: memcpy(*dst_buf + *dst_len, src_buf, src_len);
213: *dst_len += src_len;
214: *(*dst_buf + *dst_len) = '\0';
215:
216: return GPE_OK;
217: }
218:
219: static int decodedata(char **buf, /* dest buffer */
220: size_t *len) /* dest buffer data length */
221: {
222: CURLcode error = CURLE_OK;
223: unsigned char *buf64 = NULL;
224: size_t src_len = 0;
225:
226: if(!*len)
227: return GPE_OK;
228:
229: /* base64 decode the given buffer */
230: error = Curl_base64_decode(*buf, &buf64, &src_len);
231: if(error)
232: return GPE_OUT_OF_MEMORY;
233:
234: if(!src_len) {
235: /*
236: ** currently there is no way to tell apart an OOM condition in
237: ** Curl_base64_decode() from zero length decoded data. For now,
238: ** let's just assume it is an OOM condition, currently we have
239: ** no input for this function that decodes to zero length data.
240: */
241: free(buf64);
242:
243: return GPE_OUT_OF_MEMORY;
244: }
245:
246: /* memcpy to support binary blobs */
247: memcpy(*buf, buf64, src_len);
248: *len = src_len;
249: *(*buf + src_len) = '\0';
250:
251: free(buf64);
252:
253: return GPE_OK;
254: }
255:
256: /*
257: * getpart()
258: *
259: * This returns whole contents of specified XML-like section and subsection
260: * from the given file. This is mostly used to retrieve a specific part from
261: * a test definition file for consumption by test suite servers.
262: *
263: * Data is returned in a dynamically allocated buffer, a pointer to this data
264: * and the size of the data is stored at the addresses that caller specifies.
265: *
266: * If the returned data is a string the returned size will be the length of
267: * the string excluding null termination. Otherwise it will just be the size
268: * of the returned binary data.
269: *
270: * Calling function is responsible to free returned buffer.
271: *
272: * This function may return:
273: * GPE_NO_BUFFER_SPACE
274: * GPE_OUT_OF_MEMORY
275: * GPE_OK
276: */
277:
278: int getpart(char **outbuf, size_t *outlen,
279: const char *main, const char *sub, FILE *stream)
280: {
281: # define MAX_TAG_LEN 79
282: char couter[MAX_TAG_LEN + 1]; /* current outermost section */
283: char cmain[MAX_TAG_LEN + 1]; /* current main section */
284: char csub[MAX_TAG_LEN + 1]; /* current sub section */
285: char ptag[MAX_TAG_LEN + 1]; /* potential tag */
286: char patt[MAX_TAG_LEN + 1]; /* potential attributes */
287: char *buffer = NULL;
288: char *ptr;
289: char *end;
290: union {
291: ssize_t sig;
292: size_t uns;
293: } len;
294: size_t bufsize = 0;
295: size_t outalloc = 256;
296: int in_wanted_part = 0;
297: int base64 = 0;
298: int error;
299:
300: enum {
301: STATE_OUTSIDE = 0,
302: STATE_OUTER = 1,
303: STATE_INMAIN = 2,
304: STATE_INSUB = 3,
305: STATE_ILLEGAL = 4
306: } state = STATE_OUTSIDE;
307:
308: *outlen = 0;
309: *outbuf = malloc(outalloc);
310: if(!*outbuf)
311: return GPE_OUT_OF_MEMORY;
312: *(*outbuf) = '\0';
313:
314: couter[0] = cmain[0] = csub[0] = ptag[0] = patt[0] = '\0';
315:
316: while((error = readline(&buffer, &bufsize, stream)) == GPE_OK) {
317:
318: ptr = buffer;
319: EAT_SPACE(ptr);
320:
321: if('<' != *ptr) {
322: if(in_wanted_part) {
323: show(("=> %s", buffer));
324: error = appenddata(outbuf, outlen, &outalloc, buffer, base64);
325: if(error)
326: break;
327: }
328: continue;
329: }
330:
331: ptr++;
332:
333: if('/' == *ptr) {
334: /*
335: ** closing section tag
336: */
337:
338: ptr++;
339: end = ptr;
340: EAT_WORD(end);
341: len.sig = end - ptr;
342: if(len.sig > MAX_TAG_LEN) {
343: error = GPE_NO_BUFFER_SPACE;
344: break;
345: }
346: memcpy(ptag, ptr, len.uns);
347: ptag[len.uns] = '\0';
348:
349: if((STATE_INSUB == state) && !strcmp(csub, ptag)) {
350: /* end of current sub section */
351: state = STATE_INMAIN;
352: csub[0] = '\0';
353: if(in_wanted_part) {
354: /* end of wanted part */
355: in_wanted_part = 0;
356:
357: /* Do we need to base64 decode the data? */
358: if(base64) {
359: error = decodedata(outbuf, outlen);
360: if(error)
361: return error;
362: }
363: break;
364: }
365: }
366: else if((STATE_INMAIN == state) && !strcmp(cmain, ptag)) {
367: /* end of current main section */
368: state = STATE_OUTER;
369: cmain[0] = '\0';
370: if(in_wanted_part) {
371: /* end of wanted part */
372: in_wanted_part = 0;
373:
374: /* Do we need to base64 decode the data? */
375: if(base64) {
376: error = decodedata(outbuf, outlen);
377: if(error)
378: return error;
379: }
380: break;
381: }
382: }
383: else if((STATE_OUTER == state) && !strcmp(couter, ptag)) {
384: /* end of outermost file section */
385: state = STATE_OUTSIDE;
386: couter[0] = '\0';
387: if(in_wanted_part) {
388: /* end of wanted part */
389: in_wanted_part = 0;
390: break;
391: }
392: }
393:
394: }
395: else if(!in_wanted_part) {
396: /*
397: ** opening section tag
398: */
399:
400: /* get potential tag */
401: end = ptr;
402: EAT_WORD(end);
403: len.sig = end - ptr;
404: if(len.sig > MAX_TAG_LEN) {
405: error = GPE_NO_BUFFER_SPACE;
406: break;
407: }
408: memcpy(ptag, ptr, len.uns);
409: ptag[len.uns] = '\0';
410:
411: /* ignore comments, doctypes and xml declarations */
412: if(('!' == ptag[0]) || ('?' == ptag[0])) {
413: show(("* ignoring (%s)", buffer));
414: continue;
415: }
416:
417: /* get all potential attributes */
418: ptr = end;
419: EAT_SPACE(ptr);
420: end = ptr;
421: while(*end && ('>' != *end))
422: end++;
423: len.sig = end - ptr;
424: if(len.sig > MAX_TAG_LEN) {
425: error = GPE_NO_BUFFER_SPACE;
426: break;
427: }
428: memcpy(patt, ptr, len.uns);
429: patt[len.uns] = '\0';
430:
431: if(STATE_OUTSIDE == state) {
432: /* outermost element (<testcase>) */
433: strcpy(couter, ptag);
434: state = STATE_OUTER;
435: continue;
436: }
437: else if(STATE_OUTER == state) {
438: /* start of a main section */
439: strcpy(cmain, ptag);
440: state = STATE_INMAIN;
441: continue;
442: }
443: else if(STATE_INMAIN == state) {
444: /* start of a sub section */
445: strcpy(csub, ptag);
446: state = STATE_INSUB;
447: if(!strcmp(cmain, main) && !strcmp(csub, sub)) {
448: /* start of wanted part */
449: in_wanted_part = 1;
450: if(strstr(patt, "base64="))
451: /* bit rough test, but "mostly" functional, */
452: /* treat wanted part data as base64 encoded */
453: base64 = 1;
454: }
455: continue;
456: }
457:
458: }
459:
460: if(in_wanted_part) {
461: show(("=> %s", buffer));
462: error = appenddata(outbuf, outlen, &outalloc, buffer, base64);
463: if(error)
464: break;
465: }
466:
467: } /* while */
468:
469: free(buffer);
470:
471: if(error != GPE_OK) {
472: if(error == GPE_END_OF_FILE)
473: error = GPE_OK;
474: else {
475: free(*outbuf);
476: *outbuf = NULL;
477: *outlen = 0;
478: }
479: }
480:
481: return error;
482: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to getpart.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 / tests / server