tests/unit/unit1604.c

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