tool1604.c (7190B)
1 /*************************************************************************** 2 * _ _ ____ _ 3 * Project ___| | | | _ \| | 4 * / __| | | | |_) | | 5 * | (__| |_| | _ <| |___ 6 * \___|\___/|_| \_\_____| 7 * 8 * Copyright (C) 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.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 * SPDX-License-Identifier: curl 22 * 23 ***************************************************************************/ 24 #include "unitcheck.h" 25 26 #include "tool_cfgable.h" 27 #include "tool_doswin.h" 28 29 #include "memdebug.h" /* LAST include file */ 30 31 #if defined(_WIN32) || defined(MSDOS) 32 static char *getflagstr(int flags) 33 { 34 char *buf = malloc(256); 35 if(buf) { 36 msnprintf(buf, 256, "%s,%s", 37 ((flags & SANITIZE_ALLOW_PATH) ? 38 "SANITIZE_ALLOW_PATH" : ""), 39 ((flags & SANITIZE_ALLOW_RESERVED) ? 40 "SANITIZE_ALLOW_RESERVED" : "")); 41 } 42 return buf; 43 } 44 45 static char *getcurlcodestr(int cc) 46 { 47 char *buf = malloc(256); 48 if(buf) { 49 msnprintf(buf, 256, "%s (%d)", 50 (cc == SANITIZE_ERR_OK ? "SANITIZE_ERR_OK" : 51 cc == SANITIZE_ERR_BAD_ARGUMENT ? "SANITIZE_ERR_BAD_ARGUMENT" : 52 cc == SANITIZE_ERR_INVALID_PATH ? "SANITIZE_ERR_INVALID_PATH" : 53 cc == SANITIZE_ERR_OUT_OF_MEMORY ? "SANITIZE_ERR_OUT_OF_MEMORY": 54 "unexpected error code - add name"), 55 cc); 56 } 57 return buf; 58 } 59 #endif 60 61 static CURLcode test_tool1604(char *arg) 62 { 63 UNITTEST_BEGIN_SIMPLE 64 65 #if defined(_WIN32) || defined(MSDOS) 66 struct data { 67 const char *input; 68 int flags; 69 const char *expected_output; 70 SANITIZEcode expected_result; 71 }; 72 73 /* START sanitize_file_name */ 74 struct data data[] = { 75 { "", 0, 76 "", SANITIZE_ERR_OK 77 }, 78 { "normal filename", 0, 79 "normal filename", SANITIZE_ERR_OK 80 }, 81 { "control\tchar", 0, 82 "control_char", SANITIZE_ERR_OK 83 }, 84 { "banned*char", 0, 85 "banned_char", SANITIZE_ERR_OK 86 }, 87 { "f:foo", 0, 88 "f_foo", SANITIZE_ERR_OK 89 }, 90 { "f:foo", SANITIZE_ALLOW_PATH, 91 "f:foo", SANITIZE_ERR_OK 92 }, 93 { "f:\\foo", 0, 94 "f__foo", SANITIZE_ERR_OK 95 }, 96 { "f:\\foo", SANITIZE_ALLOW_PATH, 97 "f:\\foo", SANITIZE_ERR_OK 98 }, 99 { "f:/foo", 0, 100 "f__foo", SANITIZE_ERR_OK 101 }, 102 { "f:/foo", SANITIZE_ALLOW_PATH, 103 "f:/foo", SANITIZE_ERR_OK 104 }, 105 #ifndef MSDOS 106 { "\\\\?\\C:\\foo", SANITIZE_ALLOW_PATH, 107 "\\\\?\\C:\\foo", SANITIZE_ERR_OK 108 }, 109 { "\\\\?\\C:\\foo", 0, 110 "____C__foo", SANITIZE_ERR_OK 111 }, 112 #endif 113 { "foo:bar", 0, 114 "foo_bar", SANITIZE_ERR_OK 115 }, 116 { "foo|<>/bar\\\":?*baz", 0, 117 "foo____bar_____baz", SANITIZE_ERR_OK 118 }, 119 { "f:foo::$DATA", 0, 120 "f_foo__$DATA", SANITIZE_ERR_OK 121 }, 122 { "con . air", 0, 123 "con _ air", SANITIZE_ERR_OK 124 }, 125 { "con.air", 0, 126 "con_air", SANITIZE_ERR_OK 127 }, 128 { "con:/x", 0, 129 "con__x", SANITIZE_ERR_OK 130 }, 131 { "file . . . . .. .", 0, 132 "file", SANITIZE_ERR_OK 133 }, 134 { "foo . . ? . . ", 0, 135 "foo . . _", SANITIZE_ERR_OK 136 }, 137 { "com1", 0, 138 "_com1", SANITIZE_ERR_OK 139 }, 140 { "com1", SANITIZE_ALLOW_RESERVED, 141 "com1", SANITIZE_ERR_OK 142 }, 143 { "f:\\com1", 0, 144 "f__com1", SANITIZE_ERR_OK 145 }, 146 { "f:\\com1", SANITIZE_ALLOW_PATH, 147 "f:\\_com1", SANITIZE_ERR_OK 148 }, 149 { "f:\\com1", SANITIZE_ALLOW_RESERVED, 150 "f__com1", SANITIZE_ERR_OK 151 }, 152 { "f:\\com1", SANITIZE_ALLOW_RESERVED | SANITIZE_ALLOW_PATH, 153 "f:\\com1", SANITIZE_ERR_OK 154 }, 155 { "com1:\\com1", SANITIZE_ALLOW_PATH, 156 "_com1:\\_com1", SANITIZE_ERR_OK 157 }, 158 { "com1:\\com1", SANITIZE_ALLOW_RESERVED | SANITIZE_ALLOW_PATH, 159 "com1:\\com1", SANITIZE_ERR_OK 160 }, 161 { "com1:\\com1", SANITIZE_ALLOW_RESERVED, 162 "com1__com1", SANITIZE_ERR_OK 163 }, 164 #ifndef MSDOS 165 { "\\com1", SANITIZE_ALLOW_PATH, 166 "\\_com1", SANITIZE_ERR_OK 167 }, 168 { "\\\\com1", SANITIZE_ALLOW_PATH, 169 "\\\\com1", SANITIZE_ERR_OK 170 }, 171 { "\\\\?\\C:\\com1", SANITIZE_ALLOW_PATH, 172 "\\\\?\\C:\\com1", SANITIZE_ERR_OK 173 }, 174 #endif 175 { "CoM1", 0, 176 "_CoM1", SANITIZE_ERR_OK 177 }, 178 { "CoM1", SANITIZE_ALLOW_RESERVED, 179 "CoM1", SANITIZE_ERR_OK 180 }, 181 { "COM56", 0, 182 "COM56", SANITIZE_ERR_OK 183 }, 184 /* At the moment we expect a maximum path length of 259. I assume MS-DOS 185 has variable max path lengths depending on compiler that are shorter 186 so currently these "good" truncate tests will not run on MS-DOS */ 187 { "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" 188 "BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB" 189 "CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC" 190 "DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD" 191 "EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE" 192 "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", 193 0, 194 NULL, SANITIZE_ERR_INVALID_PATH 195 }, 196 { NULL, 0, 197 NULL, SANITIZE_ERR_BAD_ARGUMENT 198 }, 199 }; 200 201 size_t i; 202 203 for(i = 0; i < CURL_ARRAYSIZE(data); ++i) { 204 char *output = NULL; 205 char *flagstr = NULL; 206 char *received_ccstr = NULL; 207 char *expected_ccstr = NULL; 208 SANITIZEcode res; 209 210 res = sanitize_file_name(&output, data[i].input, data[i].flags); 211 212 if(res == data[i].expected_result && 213 ((!output && !data[i].expected_output) || 214 (output && data[i].expected_output && 215 !strcmp(output, data[i].expected_output)))) { /* OK */ 216 free(output); 217 continue; 218 } 219 220 flagstr = getflagstr(data[i].flags); 221 abort_unless(flagstr, "out of memory"); 222 received_ccstr = getcurlcodestr(res); 223 abort_unless(received_ccstr, "out of memory"); 224 expected_ccstr = getcurlcodestr(data[i].expected_result); 225 abort_unless(expected_ccstr, "out of memory"); 226 227 unitfail++; 228 fprintf(stderr, "\n" 229 "%s:%d sanitize_file_name failed.\n" 230 "input: %s\n" 231 "flags: %s\n" 232 "output: %s\n" 233 "result: %s\n" 234 "expected output: %s\n" 235 "expected result: %s\n", 236 __FILE__, __LINE__, 237 data[i].input, 238 flagstr, 239 (output ? output : "(null)"), 240 received_ccstr, 241 (data[i].expected_output ? data[i].expected_output : "(null)"), 242 expected_ccstr); 243 244 free(output); 245 free(flagstr); 246 free(received_ccstr); 247 free(expected_ccstr); 248 } 249 /* END sanitize_file_name */ 250 #else 251 fprintf(stderr, "Skipped test not for this platform\n"); 252 #endif /* _WIN32 || MSDOS */ 253 254 UNITTEST_END_SIMPLE 255 }