1 /*************************************************************************** 2 * _ _ ____ _ 3 * Project ___| | | | _ \| | 4 * / __| | | | |_) | | 5 * | (__| |_| | _ <| |___ 6 * \___|\___/|_| \_\_____| 7 * 8 * Copyright (C) 1998 - 2016, Daniel Stenberg, <daniel (at) 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 http://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 char *buf = malloc(256); 47 fail_unless(buf, "out of memory"); 48 snprintf(buf, 256, "%s,%s,%s,%s", 49 ((flags & SANITIZE_ALLOW_COLONS) ? "SANITIZE_ALLOW_COLONS" : ""), 50 ((flags & SANITIZE_ALLOW_PATH) ? "SANITIZE_ALLOW_PATH" : ""), 51 ((flags & SANITIZE_ALLOW_RESERVED) ? "SANITIZE_ALLOW_RESERVED" : ""), 52 ((flags & SANITIZE_ALLOW_TRUNCATE) ? "SANITIZE_ALLOW_TRUNCATE" : "")); 53 return buf; 54 } 55 56 static char *getcurlcodestr(int cc) { 57 char *buf = malloc(256); 58 fail_unless(buf, "out of memory"); 59 snprintf(buf, 256, "%s (%d)", 60 (cc == SANITIZE_ERR_OK ? "SANITIZE_ERR_OK" : 61 cc == SANITIZE_ERR_BAD_ARGUMENT ? "SANITIZE_ERR_BAD_ARGUMENT" : 62 cc == SANITIZE_ERR_INVALID_PATH ? "SANITIZE_ERR_INVALID_PATH" : 63 cc == SANITIZE_ERR_OUT_OF_MEMORY ? "SANITIZE_ERR_OUT_OF_MEMORY" : 64 "unexpected error code - add name"), 65 cc); 66 return buf; 67 } 68 69 struct data { 70 const char *input; 71 int flags; 72 const char *expected_output; 73 CURLcode expected_result; 74 }; 75 76 UNITTEST_START 77 78 { /* START sanitize_file_name */ 79 struct data data[] = { 80 { "", 0, 81 "", SANITIZE_ERR_OK 82 }, 83 { "normal filename", 0, 84 "normal filename", SANITIZE_ERR_OK 85 }, 86 { "control\tchar", 0, 87 "control_char", SANITIZE_ERR_OK 88 }, 89 { "banned*char", 0, 90 "banned_char", SANITIZE_ERR_OK 91 }, 92 { "f:foo", 0, 93 "f_foo", SANITIZE_ERR_OK 94 }, 95 { "f:foo", SANITIZE_ALLOW_COLONS, 96 "f:foo", SANITIZE_ERR_OK 97 }, 98 { "f:foo", SANITIZE_ALLOW_PATH, 99 "f:foo", SANITIZE_ERR_OK 100 }, 101 { "f:\\foo", 0, 102 "f__foo", SANITIZE_ERR_OK 103 }, 104 { "f:\\foo", SANITIZE_ALLOW_PATH, 105 "f:\\foo", SANITIZE_ERR_OK 106 }, 107 { "f:/foo", 0, 108 "f__foo", SANITIZE_ERR_OK 109 }, 110 { "f:/foo", SANITIZE_ALLOW_PATH, 111 "f:/foo", SANITIZE_ERR_OK 112 }, 113 #ifndef MSDOS 114 { "\\\\?\\C:\\foo", SANITIZE_ALLOW_PATH, 115 "\\\\?\\C:\\foo", SANITIZE_ERR_OK 116 }, 117 { "\\\\?\\C:\\foo", 0, 118 "____C__foo", SANITIZE_ERR_OK 119 }, 120 #endif 121 { "foo:bar", 0, 122 "foo_bar", SANITIZE_ERR_OK 123 }, 124 { "foo|<>/bar\\\":?*baz", 0, 125 "foo____bar_____baz", SANITIZE_ERR_OK 126 }, 127 { "f:foo::$DATA", 0, 128 "f_foo__$DATA", SANITIZE_ERR_OK 129 }, 130 { "con . air", 0, 131 "con _ air", SANITIZE_ERR_OK 132 }, 133 { "con.air", 0, 134 "con_air", SANITIZE_ERR_OK 135 }, 136 { "con:/x", 0, 137 "con__x", SANITIZE_ERR_OK 138 }, 139 { "file . . . . .. .", 0, 140 "file", SANITIZE_ERR_OK 141 }, 142 { "foo . . ? . . ", 0, 143 "foo . . _", SANITIZE_ERR_OK 144 }, 145 { "com1", 0, 146 "_com1", SANITIZE_ERR_OK 147 }, 148 { "com1", SANITIZE_ALLOW_RESERVED, 149 "com1", SANITIZE_ERR_OK 150 }, 151 { "f:\\com1", 0, 152 "f__com1", SANITIZE_ERR_OK 153 }, 154 { "f:\\com1", SANITIZE_ALLOW_PATH, 155 "f:\\_com1", SANITIZE_ERR_OK 156 }, 157 { "f:\\com1", SANITIZE_ALLOW_RESERVED, 158 "f__com1", SANITIZE_ERR_OK 159 }, 160 { "f:\\com1", SANITIZE_ALLOW_RESERVED | SANITIZE_ALLOW_COLONS, 161 "f:_com1", SANITIZE_ERR_OK 162 }, 163 { "f:\\com1", SANITIZE_ALLOW_RESERVED | SANITIZE_ALLOW_PATH, 164 "f:\\com1", SANITIZE_ERR_OK 165 }, 166 { "com1:\\com1", SANITIZE_ALLOW_PATH, 167 "_com1:\\_com1", SANITIZE_ERR_OK 168 }, 169 { "com1:\\com1", SANITIZE_ALLOW_RESERVED | SANITIZE_ALLOW_PATH, 170 "com1:\\com1", SANITIZE_ERR_OK 171 }, 172 { "com1:\\com1", SANITIZE_ALLOW_RESERVED, 173 "com1__com1", SANITIZE_ERR_OK 174 }, 175 #ifndef MSDOS 176 { "\\com1", SANITIZE_ALLOW_PATH, 177 "\\_com1", SANITIZE_ERR_OK 178 }, 179 { "\\\\com1", SANITIZE_ALLOW_PATH, 180 "\\\\com1", SANITIZE_ERR_OK 181 }, 182 { "\\\\?\\C:\\com1", SANITIZE_ALLOW_PATH, 183 "\\\\?\\C:\\com1", SANITIZE_ERR_OK 184 }, 185 #endif 186 { "CoM1", 0, 187 "_CoM1", SANITIZE_ERR_OK 188 }, 189 { "CoM1", SANITIZE_ALLOW_RESERVED, 190 "CoM1", SANITIZE_ERR_OK 191 }, 192 { "COM56", 0, 193 "COM56", SANITIZE_ERR_OK 194 }, 195 /* At the moment we expect a maximum path length of 259. I assume MSDOS 196 has variable max path lengths depending on compiler that are shorter 197 so currently these "good" truncate tests won't run on MSDOS */ 198 #ifndef MSDOS 199 { "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" 200 "BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB" 201 "CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC" 202 "DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD" 203 "EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE" 204 "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", 205 SANITIZE_ALLOW_TRUNCATE, 206 "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" 207 "BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB" 208 "CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC" 209 "DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD" 210 "EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE" 211 "FFFFF", SANITIZE_ERR_OK 212 }, 213 { "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" 214 "BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB" 215 "CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC" 216 "DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD" 217 "EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE" 218 "FFF\\FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", 219 SANITIZE_ALLOW_TRUNCATE | SANITIZE_ALLOW_PATH, 220 "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" 221 "BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB" 222 "CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC" 223 "DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD" 224 "EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE" 225 "FFF\\FFFFF", SANITIZE_ERR_OK 226 }, 227 { "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" 228 "BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB" 229 "CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC" 230 "DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD" 231 "EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE" 232 "FFF\\FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", 233 SANITIZE_ALLOW_TRUNCATE, 234 "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" 235 "BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB" 236 "CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC" 237 "DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD" 238 "EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE" 239 "FFF_F", SANITIZE_ERR_OK 240 }, 241 #endif /* !MSDOS */ 242 { "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" 243 "BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB" 244 "CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC" 245 "DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD" 246 "EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE" 247 "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", 248 0, 249 NULL, SANITIZE_ERR_INVALID_PATH 250 }, 251 { "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" 252 "BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB" 253 "CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC" 254 "DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD" 255 "EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE" 256 "FFFF\\FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", 257 SANITIZE_ALLOW_TRUNCATE, 258 NULL, SANITIZE_ERR_INVALID_PATH 259 }, 260 { "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" 261 "BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB" 262 "CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC" 263 "DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD" 264 "EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE" 265 "FFFFFFFFFFFFFFFFFFFFFFFFF\\FFFFFFFFFFFFFFFFFFFFFFFF", 266 SANITIZE_ALLOW_TRUNCATE | SANITIZE_ALLOW_PATH, 267 NULL, SANITIZE_ERR_INVALID_PATH 268 }, 269 { "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" 270 "BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB" 271 "CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC" 272 "DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD" 273 "EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE" 274 "FFF\\FFFFFFFFFFFFFFFFFFFFF:FFFFFFFFFFFFFFFFFFFFFFFF", 275 SANITIZE_ALLOW_TRUNCATE | SANITIZE_ALLOW_PATH, 276 NULL, SANITIZE_ERR_INVALID_PATH 277 }, 278 { "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" 279 "BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB" 280 "CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC" 281 "DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD" 282 "EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE" 283 "FF\\F:FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", 284 SANITIZE_ALLOW_TRUNCATE | SANITIZE_ALLOW_PATH, 285 NULL, SANITIZE_ERR_INVALID_PATH 286 }, 287 { NULL, 0, 288 NULL, SANITIZE_ERR_BAD_ARGUMENT 289 }, 290 }; 291 292 size_t i; 293 294 for(i = 0; i < sizeof data / sizeof data[0]; ++i) { 295 char *output = NULL; 296 char *flagstr = NULL; 297 char *received_ccstr = NULL; 298 char *expected_ccstr = NULL; 299 300 CURLcode res = sanitize_file_name(&output, data[i].input, data[i].flags); 301 302 if(res == data[i].expected_result && 303 ((!output && !data[i].expected_output) || 304 (output && data[i].expected_output && 305 !strcmp(output, data[i].expected_output)))) { /* OK */ 306 free(output); 307 continue; 308 } 309 310 flagstr = getflagstr(data[i].flags); 311 received_ccstr = getcurlcodestr(res); 312 expected_ccstr = getcurlcodestr(data[i].expected_result); 313 314 unitfail++; 315 fprintf(stderr, "\n" 316 "%s:%d sanitize_file_name failed.\n" 317 "input: %s\n" 318 "flags: %s\n" 319 "output: %s\n" 320 "result: %s\n" 321 "expected output: %s\n" 322 "expected result: %s\n", 323 __FILE__, __LINE__, 324 data[i].input, 325 flagstr, 326 (output ? output : "(null)"), 327 received_ccstr, 328 (data[i].expected_output ? data[i].expected_output : "(null)"), 329 expected_ccstr); 330 331 free(output); 332 free(flagstr); 333 free(received_ccstr); 334 free(expected_ccstr); 335 } 336 } /* END sanitize_file_name */ 337 338 #else 339 UNITTEST_START 340 341 { 342 fprintf(stderr, "Skipped test not for this platform\n"); 343 } 344 #endif /* MSDOS || WIN32 */ 345 346 UNITTEST_STOP 347
