Annotation of embedaddon/curl/tests/unit/unit1604.c, revision 1.1.1.1
1.1 misho 1: /***************************************************************************
2: * _ _ ____ _
3: * Project ___| | | | _ \| |
4: * / __| | | | |_) | |
5: * | (__| |_| | _ <| |___
6: * \___|\___/|_| \_\_____|
7: *
8: * Copyright (C) 1998 - 2018, Daniel Stenberg, <daniel@haxx.se>, et al.
9: *
10: * This software is licensed as described in the file COPYING, which
11: * you should have received as part of this distribution. The terms
12: * are also available at https://curl.haxx.se/docs/copyright.html.
13: *
14: * You may opt to use, copy, modify, merge, publish, distribute and/or sell
15: * copies of the Software, and permit persons to whom the Software is
16: * furnished to do so, under the terms of the COPYING file.
17: *
18: * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
19: * KIND, either express or implied.
20: *
21: ***************************************************************************/
22: #include "curlcheck.h"
23:
24: #include "tool_cfgable.h"
25: #include "tool_doswin.h"
26:
27: #include <stdio.h>
28: #include <stdlib.h>
29: #include <string.h>
30:
31: #include "memdebug.h" /* LAST include file */
32:
33: static CURLcode unit_setup(void)
34: {
35: return CURLE_OK;
36: }
37:
38: static void unit_stop(void)
39: {
40:
41: }
42:
43: #if defined(MSDOS) || defined(WIN32)
44:
45: static char *getflagstr(int flags)
46: {
47: char *buf = malloc(256);
48: if(buf) {
49: msnprintf(buf, 256, "%s,%s,%s,%s",
50: ((flags & SANITIZE_ALLOW_COLONS) ?
51: "SANITIZE_ALLOW_COLONS" : ""),
52: ((flags & SANITIZE_ALLOW_PATH) ?
53: "SANITIZE_ALLOW_PATH" : ""),
54: ((flags & SANITIZE_ALLOW_RESERVED) ?
55: "SANITIZE_ALLOW_RESERVED" : ""),
56: ((flags & SANITIZE_ALLOW_TRUNCATE) ?
57: "SANITIZE_ALLOW_TRUNCATE" : ""));
58: }
59: return buf;
60: }
61:
62: static char *getcurlcodestr(int cc)
63: {
64: char *buf = malloc(256);
65: if(buf) {
66: msnprintf(buf, 256, "%s (%d)",
67: (cc == SANITIZE_ERR_OK ? "SANITIZE_ERR_OK" :
68: cc == SANITIZE_ERR_BAD_ARGUMENT ? "SANITIZE_ERR_BAD_ARGUMENT" :
69: cc == SANITIZE_ERR_INVALID_PATH ? "SANITIZE_ERR_INVALID_PATH" :
70: cc == SANITIZE_ERR_OUT_OF_MEMORY ? "SANITIZE_ERR_OUT_OF_MEMORY":
71: "unexpected error code - add name"),
72: cc);
73: }
74: return buf;
75: }
76:
77: struct data {
78: const char *input;
79: int flags;
80: const char *expected_output;
81: CURLcode expected_result;
82: };
83:
84: UNITTEST_START
85:
86: { /* START sanitize_file_name */
87: struct data data[] = {
88: { "", 0,
89: "", SANITIZE_ERR_OK
90: },
91: { "normal filename", 0,
92: "normal filename", SANITIZE_ERR_OK
93: },
94: { "control\tchar", 0,
95: "control_char", SANITIZE_ERR_OK
96: },
97: { "banned*char", 0,
98: "banned_char", SANITIZE_ERR_OK
99: },
100: { "f:foo", 0,
101: "f_foo", SANITIZE_ERR_OK
102: },
103: { "f:foo", SANITIZE_ALLOW_COLONS,
104: "f:foo", SANITIZE_ERR_OK
105: },
106: { "f:foo", SANITIZE_ALLOW_PATH,
107: "f:foo", SANITIZE_ERR_OK
108: },
109: { "f:\\foo", 0,
110: "f__foo", SANITIZE_ERR_OK
111: },
112: { "f:\\foo", SANITIZE_ALLOW_PATH,
113: "f:\\foo", SANITIZE_ERR_OK
114: },
115: { "f:/foo", 0,
116: "f__foo", SANITIZE_ERR_OK
117: },
118: { "f:/foo", SANITIZE_ALLOW_PATH,
119: "f:/foo", SANITIZE_ERR_OK
120: },
121: #ifndef MSDOS
122: { "\\\\?\\C:\\foo", SANITIZE_ALLOW_PATH,
123: "\\\\?\\C:\\foo", SANITIZE_ERR_OK
124: },
125: { "\\\\?\\C:\\foo", 0,
126: "____C__foo", SANITIZE_ERR_OK
127: },
128: #endif
129: { "foo:bar", 0,
130: "foo_bar", SANITIZE_ERR_OK
131: },
132: { "foo|<>/bar\\\":?*baz", 0,
133: "foo____bar_____baz", SANITIZE_ERR_OK
134: },
135: { "f:foo::$DATA", 0,
136: "f_foo__$DATA", SANITIZE_ERR_OK
137: },
138: { "con . air", 0,
139: "con _ air", SANITIZE_ERR_OK
140: },
141: { "con.air", 0,
142: "con_air", SANITIZE_ERR_OK
143: },
144: { "con:/x", 0,
145: "con__x", SANITIZE_ERR_OK
146: },
147: { "file . . . . .. .", 0,
148: "file", SANITIZE_ERR_OK
149: },
150: { "foo . . ? . . ", 0,
151: "foo . . _", SANITIZE_ERR_OK
152: },
153: { "com1", 0,
154: "_com1", SANITIZE_ERR_OK
155: },
156: { "com1", SANITIZE_ALLOW_RESERVED,
157: "com1", SANITIZE_ERR_OK
158: },
159: { "f:\\com1", 0,
160: "f__com1", SANITIZE_ERR_OK
161: },
162: { "f:\\com1", SANITIZE_ALLOW_PATH,
163: "f:\\_com1", SANITIZE_ERR_OK
164: },
165: { "f:\\com1", SANITIZE_ALLOW_RESERVED,
166: "f__com1", SANITIZE_ERR_OK
167: },
168: { "f:\\com1", SANITIZE_ALLOW_RESERVED | SANITIZE_ALLOW_COLONS,
169: "f:_com1", SANITIZE_ERR_OK
170: },
171: { "f:\\com1", SANITIZE_ALLOW_RESERVED | SANITIZE_ALLOW_PATH,
172: "f:\\com1", SANITIZE_ERR_OK
173: },
174: { "com1:\\com1", SANITIZE_ALLOW_PATH,
175: "_com1:\\_com1", SANITIZE_ERR_OK
176: },
177: { "com1:\\com1", SANITIZE_ALLOW_RESERVED | SANITIZE_ALLOW_PATH,
178: "com1:\\com1", SANITIZE_ERR_OK
179: },
180: { "com1:\\com1", SANITIZE_ALLOW_RESERVED,
181: "com1__com1", SANITIZE_ERR_OK
182: },
183: #ifndef MSDOS
184: { "\\com1", SANITIZE_ALLOW_PATH,
185: "\\_com1", SANITIZE_ERR_OK
186: },
187: { "\\\\com1", SANITIZE_ALLOW_PATH,
188: "\\\\com1", SANITIZE_ERR_OK
189: },
190: { "\\\\?\\C:\\com1", SANITIZE_ALLOW_PATH,
191: "\\\\?\\C:\\com1", SANITIZE_ERR_OK
192: },
193: #endif
194: { "CoM1", 0,
195: "_CoM1", SANITIZE_ERR_OK
196: },
197: { "CoM1", SANITIZE_ALLOW_RESERVED,
198: "CoM1", SANITIZE_ERR_OK
199: },
200: { "COM56", 0,
201: "COM56", SANITIZE_ERR_OK
202: },
203: /* At the moment we expect a maximum path length of 259. I assume MSDOS
204: has variable max path lengths depending on compiler that are shorter
205: so currently these "good" truncate tests won't run on MSDOS */
206: #ifndef MSDOS
207: { "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
208: "BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB"
209: "CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC"
210: "DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD"
211: "EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE"
212: "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF",
213: SANITIZE_ALLOW_TRUNCATE,
214: "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
215: "BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB"
216: "CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC"
217: "DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD"
218: "EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE"
219: "FFFFF", SANITIZE_ERR_OK
220: },
221: { "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
222: "BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB"
223: "CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC"
224: "DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD"
225: "EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE"
226: "FFF\\FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF",
227: SANITIZE_ALLOW_TRUNCATE | SANITIZE_ALLOW_PATH,
228: "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
229: "BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB"
230: "CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC"
231: "DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD"
232: "EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE"
233: "FFF\\FFFFF", SANITIZE_ERR_OK
234: },
235: { "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
236: "BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB"
237: "CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC"
238: "DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD"
239: "EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE"
240: "FFF\\FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF",
241: SANITIZE_ALLOW_TRUNCATE,
242: "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
243: "BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB"
244: "CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC"
245: "DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD"
246: "EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE"
247: "FFF_F", SANITIZE_ERR_OK
248: },
249: #endif /* !MSDOS */
250: { "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
251: "BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB"
252: "CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC"
253: "DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD"
254: "EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE"
255: "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF",
256: 0,
257: NULL, SANITIZE_ERR_INVALID_PATH
258: },
259: { "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
260: "BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB"
261: "CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC"
262: "DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD"
263: "EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE"
264: "FFFF\\FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF",
265: SANITIZE_ALLOW_TRUNCATE,
266: NULL, SANITIZE_ERR_INVALID_PATH
267: },
268: { "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
269: "BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB"
270: "CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC"
271: "DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD"
272: "EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE"
273: "FFFFFFFFFFFFFFFFFFFFFFFFF\\FFFFFFFFFFFFFFFFFFFFFFFF",
274: SANITIZE_ALLOW_TRUNCATE | SANITIZE_ALLOW_PATH,
275: NULL, SANITIZE_ERR_INVALID_PATH
276: },
277: { "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
278: "BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB"
279: "CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC"
280: "DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD"
281: "EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE"
282: "FFF\\FFFFFFFFFFFFFFFFFFFFF:FFFFFFFFFFFFFFFFFFFFFFFF",
283: SANITIZE_ALLOW_TRUNCATE | SANITIZE_ALLOW_PATH,
284: NULL, SANITIZE_ERR_INVALID_PATH
285: },
286: { "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
287: "BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB"
288: "CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC"
289: "DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD"
290: "EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE"
291: "FF\\F:FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF",
292: SANITIZE_ALLOW_TRUNCATE | SANITIZE_ALLOW_PATH,
293: NULL, SANITIZE_ERR_INVALID_PATH
294: },
295: { NULL, 0,
296: NULL, SANITIZE_ERR_BAD_ARGUMENT
297: },
298: };
299:
300: size_t i;
301:
302: for(i = 0; i < sizeof(data) / sizeof(data[0]); ++i) {
303: char *output = NULL;
304: char *flagstr = NULL;
305: char *received_ccstr = NULL;
306: char *expected_ccstr = NULL;
307:
308: CURLcode res = sanitize_file_name(&output, data[i].input, data[i].flags);
309:
310: if(res == data[i].expected_result &&
311: ((!output && !data[i].expected_output) ||
312: (output && data[i].expected_output &&
313: !strcmp(output, data[i].expected_output)))) { /* OK */
314: free(output);
315: continue;
316: }
317:
318: flagstr = getflagstr(data[i].flags);
319: abort_unless(flagstr, "out of memory");
320: received_ccstr = getcurlcodestr(res);
321: abort_unless(received_ccstr, "out of memory");
322: expected_ccstr = getcurlcodestr(data[i].expected_result);
323: abort_unless(expected_ccstr, "out of memory");
324:
325: unitfail++;
326: fprintf(stderr, "\n"
327: "%s:%d sanitize_file_name failed.\n"
328: "input: %s\n"
329: "flags: %s\n"
330: "output: %s\n"
331: "result: %s\n"
332: "expected output: %s\n"
333: "expected result: %s\n",
334: __FILE__, __LINE__,
335: data[i].input,
336: flagstr,
337: (output ? output : "(null)"),
338: received_ccstr,
339: (data[i].expected_output ? data[i].expected_output : "(null)"),
340: expected_ccstr);
341:
342: free(output);
343: free(flagstr);
344: free(received_ccstr);
345: free(expected_ccstr);
346: }
347: } /* END sanitize_file_name */
348:
349: #else
350: UNITTEST_START
351:
352: {
353: fprintf(stderr, "Skipped test not for this platform\n");
354: }
355: #endif /* MSDOS || WIN32 */
356:
357: UNITTEST_STOP
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to unit1604.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 / unit