src/tool_doswin.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 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 "tool_setup.h"
  23
  24 #if defined(MSDOS) || defined(WIN32)
  25
  26 #if defined(HAVE_LIBGEN_H) && defined(HAVE_BASENAME)
  27 #  include <libgen.h>
  28 #endif
  29
  30 #ifdef WIN32
  31 #  include "tool_cfgable.h"
  32 #  include "tool_libinfo.h"
  33 #endif
  34
  35 #include "tool_bname.h"
  36 #include "tool_doswin.h"
  37
  38 #include "memdebug.h" /* keep this as LAST include */
  39
  40 /*
  41  * Macros ALWAYS_TRUE and ALWAYS_FALSE are used to avoid compiler warnings.
  42  */
  43
  44 #define ALWAYS_TRUE   (1)
  45 #define ALWAYS_FALSE  (0)
  46
  47 #if defined(_MSC_VER) && !defined(__POCC__)
  48 #  undef ALWAYS_TRUE
  49 #  undef ALWAYS_FALSE
  50 #  if (_MSC_VER < 1500)
  51 #    define ALWAYS_TRUE   (0, 1)
  52 #    define ALWAYS_FALSE  (1, 0)
  53 #  else
  54 #    define ALWAYS_TRUE \
  55 __pragma(warning(push)) \
  56 __pragma(warning(disable:4127)) \
  57 (1) \
  58 __pragma(warning(pop))
  59 #    define ALWAYS_FALSE \
  60 __pragma(warning(push)) \
  61 __pragma(warning(disable:4127)) \
  62 (0) \
  63 __pragma(warning(pop))
  64 #  endif
  65 #endif
  66
  67 #ifdef WIN32
  68 #  undef  PATH_MAX
  69 #  define PATH_MAX MAX_PATH
  70 #endif
  71
  72 #ifndef S_ISCHR
  73 #  ifdef S_IFCHR
  74 #    define S_ISCHR(m) (((m) & S_IFMT) == S_IFCHR)
  75 #  else
  76 #    define S_ISCHR(m) (0) /* cannot tell if file is a device */
  77 #  endif
  78 #endif
  79
  80 #ifdef WIN32
  81 #  define _use_lfn(f) ALWAYS_TRUE   /* long file names always available */
  82 #elif !defined(__DJGPP__) || (__DJGPP__ < 2)  /* DJGPP 2.0 has _use_lfn() */
  83 #  define _use_lfn(f) ALWAYS_FALSE  /* long file names never available */
  84 #elif defined(__DJGPP__)
  85 #  include <fcntl.h>                /* _use_lfn(f) prototype */
  86 #endif
  87
  88 #ifndef UNITTESTS
  89 static SANITIZEcode truncate_dryrun(const char *path,
  90                                     const size_t truncate_pos);
  91 #ifdef MSDOS
  92 static SANITIZEcode msdosify(char **const sanitized, const char *file_name,
  93                              int flags);
  94 #endif
  95 static SANITIZEcode rename_if_reserved_dos_device_name(char **const sanitized,
  96                                                        const char *file_name,
  97                                                        int flags);
  98 #endif /* !UNITTESTS (static declarations used if no unit tests) */
  99
 100
 101 /*
 102 Sanitize a file or path name.
 103
 104 All banned characters are replaced by underscores, for example:
 105 f?*foo => f__foo
 106 f:foo::$DATA => f_foo__$DATA
 107 f:\foo:bar => f__foo_bar
 108 f:\foo:bar => f:\foo:bar   (flag SANITIZE_ALLOW_PATH)
 109
 110 This function was implemented according to the guidelines in 'Naming Files,
 111 Paths, and Namespaces' section 'Naming Conventions'.
 112 https://msdn.microsoft.com/en-us/library/windows/desktop/aa365247.aspx
 113
 114 Flags
 115 -----
 116 SANITIZE_ALLOW_COLONS:     Allow colons.
 117 Without this flag colons are sanitized.
 118
 119 SANITIZE_ALLOW_PATH:       Allow path separators and colons.
 120 Without this flag path separators and colons are sanitized.
 121
 122 SANITIZE_ALLOW_RESERVED:   Allow reserved device names.
 123 Without this flag a reserved device name is renamed (COM1 => _COM1) unless it's
 124 in a UNC prefixed path.
 125
 126 SANITIZE_ALLOW_TRUNCATE:   Allow truncating a long filename.
 127 Without this flag if the sanitized filename or path will be too long an error
 128 occurs. With this flag the filename --and not any other parts of the path-- may
 129 be truncated to at least a single character. A filename followed by an
 130 alternate data stream (ADS) cannot be truncated in any case.
 131
 132 Success: (SANITIZE_ERR_OK) *sanitized points to a sanitized copy of file_name.
 133 Failure: (!= SANITIZE_ERR_OK) *sanitized is NULL.
 134 */
 135 SANITIZEcode sanitize_file_name(char **const sanitized, const char *file_name,
 136                                 int flags)
 137 {
 138   char *p, *target;
 139   size_t len;
 140   SANITIZEcode sc;
 141   size_t max_sanitized_len;
 142
 143   if(!sanitized)
 144     return SANITIZE_ERR_BAD_ARGUMENT;
 145
 146   *sanitized = NULL;
 147
 148   if(!file_name)
 149     return SANITIZE_ERR_BAD_ARGUMENT;
 150
 151   if((flags & SANITIZE_ALLOW_PATH)) {
 152 #ifndef MSDOS
 153     if(file_name[0] == '\\' && file_name[1] == '\\')
 154       /* UNC prefixed path \\ (eg \\?\C:\foo) */
 155       max_sanitized_len = 32767-1;
 156     else
 157 #endif
 158       max_sanitized_len = PATH_MAX-1;
 159   }
 160   else
 161     /* The maximum length of a filename.
 162        FILENAME_MAX is often the same as PATH_MAX, in other words it is 260 and
 163        does not discount the path information therefore we shouldn't use it. */
 164     max_sanitized_len = (PATH_MAX-1 > 255) ? 255 : PATH_MAX-1;
 165
 166   len = strlen(file_name);
 167   if(len > max_sanitized_len) {
 168     if(!(flags & SANITIZE_ALLOW_TRUNCATE) ||
 169        truncate_dryrun(file_name, max_sanitized_len))
 170       return SANITIZE_ERR_INVALID_PATH;
 171
 172     len = max_sanitized_len;
 173   }
 174
 175   target = malloc(len + 1);
 176   if(!target)
 177     return SANITIZE_ERR_OUT_OF_MEMORY;
 178
 179   strncpy(target, file_name, len);
 180   target[len] = '\0';
 181
 182 #ifndef MSDOS
 183   if((flags & SANITIZE_ALLOW_PATH) && !strncmp(target, "\\\\?\\", 4))
 184     /* Skip the literal path prefix \\?\ */
 185     p = target + 4;
 186   else
 187 #endif
 188     p = target;
 189
 190   /* replace control characters and other banned characters */
 191   for(; *p; ++p) {
 192     const char *banned;
 193
 194     if((1 <= *p && *p <= 31) ||
 195        (!(flags & (SANITIZE_ALLOW_COLONS|SANITIZE_ALLOW_PATH)) && *p == ':') ||
 196        (!(flags & SANITIZE_ALLOW_PATH) && (*p == '/' || *p == '\\'))) {
 197       *p = '_';
 198       continue;
 199     }
 200
 201     for(banned = "|<>\"?*"; *banned; ++banned) {
 202       if(*p == *banned) {
 203         *p = '_';
 204         break;
 205       }
 206     }
 207   }
 208
 209   /* remove trailing spaces and periods if not allowing paths */
 210   if(!(flags & SANITIZE_ALLOW_PATH) && len) {
 211     char *clip = NULL;
 212
 213     p = &target[len];
 214     do {
 215       --p;
 216       if(*p != ' ' && *p != '.')
 217         break;
 218       clip = p;
 219     } while(p != target);
 220
 221     if(clip) {
 222       *clip = '\0';
 223       len = clip - target;
 224     }
 225   }
 226
 227 #ifdef MSDOS
 228   sc = msdosify(&p, target, flags);
 229   free(target);
 230   if(sc)
 231     return sc;
 232   target = p;
 233   len = strlen(target);
 234
 235   if(len > max_sanitized_len) {
 236     free(target);
 237     return SANITIZE_ERR_INVALID_PATH;
 238   }
 239 #endif
 240
 241   if(!(flags & SANITIZE_ALLOW_RESERVED)) {
 242     sc = rename_if_reserved_dos_device_name(&p, target, flags);
 243     free(target);
 244     if(sc)
 245       return sc;
 246     target = p;
 247     len = strlen(target);
 248
 249     if(len > max_sanitized_len) {
 250       free(target);
 251       return SANITIZE_ERR_INVALID_PATH;
 252     }
 253   }
 254
 255   *sanitized = target;
 256   return SANITIZE_ERR_OK;
 257 }
 258
 259
 260 /*
 261 Test if truncating a path to a file will leave at least a single character in
 262 the filename. Filenames suffixed by an alternate data stream can't be
 263 truncated. This performs a dry run, nothing is modified.
 264
 265 Good truncate_pos 9:    C:\foo\bar  =>  C:\foo\ba
 266 Good truncate_pos 6:    C:\foo      =>  C:\foo
 267 Good truncate_pos 5:    C:\foo      =>  C:\fo
 268 Bad* truncate_pos 5:    C:foo       =>  C:foo
 269 Bad truncate_pos 5:     C:\foo:ads  =>  C:\fo
 270 Bad truncate_pos 9:     C:\foo:ads  =>  C:\foo:ad
 271 Bad truncate_pos 5:     C:\foo\bar  =>  C:\fo
 272 Bad truncate_pos 5:     C:\foo\     =>  C:\fo
 273 Bad truncate_pos 7:     C:\foo\     =>  C:\foo\
 274 Error truncate_pos 7:   C:\foo      =>  (pos out of range)
 275 Bad truncate_pos 1:     C:\foo\     =>  C
 276
 277 * C:foo is ambiguous, C could end up being a drive or file therefore something
 278   like C:superlongfilename can't be truncated.
 279
 280 Returns
 281 SANITIZE_ERR_OK: Good -- 'path' can be truncated
 282 SANITIZE_ERR_INVALID_PATH: Bad -- 'path' cannot be truncated
 283 != SANITIZE_ERR_OK && != SANITIZE_ERR_INVALID_PATH: Error
 284 */
 285 SANITIZEcode truncate_dryrun(const char *path, const size_t truncate_pos)
 286 {
 287   size_t len;
 288
 289   if(!path)
 290     return SANITIZE_ERR_BAD_ARGUMENT;
 291
 292   len = strlen(path);
 293
 294   if(truncate_pos > len)
 295     return SANITIZE_ERR_BAD_ARGUMENT;
 296
 297   if(!len || !truncate_pos)
 298     return SANITIZE_ERR_INVALID_PATH;
 299
 300   if(strpbrk(&path[truncate_pos - 1], "\\/:"))
 301     return SANITIZE_ERR_INVALID_PATH;
 302
 303   /* C:\foo can be truncated but C:\foo:ads can't */
 304   if(truncate_pos > 1) {
 305     const char *p = &path[truncate_pos - 1];
 306     do {
 307       --p;
 308       if(*p == ':')
 309         return SANITIZE_ERR_INVALID_PATH;
 310     } while(p != path && *p != '\\' && *p != '/');
 311   }
 312
 313   return SANITIZE_ERR_OK;
 314 }
 315
 316 /* The functions msdosify, rename_if_dos_device_name and __crt0_glob_function
 317  * were taken with modification from the DJGPP port of tar 1.12. They use
 318  * algorithms originally from DJTAR.
 319  */
 320
 321 /*
 322 Extra sanitization MSDOS for file_name.
 323
 324 This is a supporting function for sanitize_file_name.
 325
 326 Warning: This is an MSDOS legacy function and was purposely written in a way
 327 that some path information may pass through. For example drive letter names
 328 (C:, D:, etc) are allowed to pass through. For sanitizing a filename use
 329 sanitize_file_name.
 330
 331 Success: (SANITIZE_ERR_OK) *sanitized points to a sanitized copy of file_name.
 332 Failure: (!= SANITIZE_ERR_OK) *sanitized is NULL.
 333 */
 334 #if defined(MSDOS) || defined(UNITTESTS)
 335 SANITIZEcode msdosify(char **const sanitized, const char *file_name,
 336                       int flags)
 337 {
 338   char dos_name[PATH_MAX];
 339   static const char illegal_chars_dos[] = ".+, ;=[]" /* illegal in DOS */
 340     "|<>/\\\":?*"; /* illegal in DOS & W95 */
 341   static const char *illegal_chars_w95 = &illegal_chars_dos[8];
 342   int idx, dot_idx;
 343   const char *s = file_name;
 344   char *d = dos_name;
 345   const char *const dlimit = dos_name + sizeof(dos_name) - 1;
 346   const char *illegal_aliens = illegal_chars_dos;
 347   size_t len = sizeof(illegal_chars_dos) - 1;
 348
 349   if(!sanitized)
 350     return SANITIZE_ERR_BAD_ARGUMENT;
 351
 352   *sanitized = NULL;
 353
 354   if(!file_name)
 355     return SANITIZE_ERR_BAD_ARGUMENT;
 356
 357   if(strlen(file_name) > PATH_MAX-1 &&
 358      (!(flags & SANITIZE_ALLOW_TRUNCATE) ||
 359       truncate_dryrun(file_name, PATH_MAX-1)))
 360     return SANITIZE_ERR_INVALID_PATH;
 361
 362   /* Support for Windows 9X VFAT systems, when available. */
 363   if(_use_lfn(file_name)) {
 364     illegal_aliens = illegal_chars_w95;
 365     len -= (illegal_chars_w95 - illegal_chars_dos);
 366   }
 367
 368   /* Get past the drive letter, if any. */
 369   if(s[0] >= 'A' && s[0] <= 'z' && s[1] == ':') {
 370     *d++ = *s++;
 371     *d = ((flags & (SANITIZE_ALLOW_COLONS|SANITIZE_ALLOW_PATH))) ? ':' : '_';
 372     ++d, ++s;
 373   }
 374
 375   for(idx = 0, dot_idx = -1; *s && d < dlimit; s++, d++) {
 376     if(memchr(illegal_aliens, *s, len)) {
 377
 378       if((flags & (SANITIZE_ALLOW_COLONS|SANITIZE_ALLOW_PATH)) && *s == ':')
 379         *d = ':';
 380       else if((flags & SANITIZE_ALLOW_PATH) && (*s == '/' || *s == '\\'))
 381         *d = *s;
 382       /* Dots are special: DOS doesn't allow them as the leading character,
 383          and a file name cannot have more than a single dot.  We leave the
 384          first non-leading dot alone, unless it comes too close to the
 385          beginning of the name: we want sh.lex.c to become sh_lex.c, not
 386          sh.lex-c.  */
 387       else if(*s == '.') {
 388         if((flags & SANITIZE_ALLOW_PATH) && idx == 0 &&
 389            (s[1] == '/' || s[1] == '\\' ||
 390             (s[1] == '.' && (s[2] == '/' || s[2] == '\\')))) {
 391           /* Copy "./" and "../" verbatim.  */
 392           *d++ = *s++;
 393           if(d == dlimit)
 394             break;
 395           if(*s == '.') {
 396             *d++ = *s++;
 397             if(d == dlimit)
 398               break;
 399           }
 400           *d = *s;
 401         }
 402         else if(idx == 0)
 403           *d = '_';
 404         else if(dot_idx >= 0) {
 405           if(dot_idx < 5) { /* 5 is a heuristic ad-hoc'ery */
 406             d[dot_idx - idx] = '_'; /* replace previous dot */
 407             *d = '.';
 408           }
 409           else
 410             *d = '-';
 411         }
 412         else
 413           *d = '.';
 414
 415         if(*s == '.')
 416           dot_idx = idx;
 417       }
 418       else if(*s == '+' && s[1] == '+') {
 419         if(idx - 2 == dot_idx) { /* .c++, .h++ etc. */
 420           *d++ = 'x';
 421           if(d == dlimit)
 422             break;
 423           *d   = 'x';
 424         }
 425         else {
 426           /* libg++ etc.  */
 427           if(dlimit - d < 4) {
 428             *d++ = 'x';
 429             if(d == dlimit)
 430               break;
 431             *d   = 'x';
 432           }
 433           else {
 434             memcpy(d, "plus", 4);
 435             d += 3;
 436           }
 437         }
 438         s++;
 439         idx++;
 440       }
 441       else
 442         *d = '_';
 443     }
 444     else
 445       *d = *s;
 446     if(*s == '/' || *s == '\\') {
 447       idx = 0;
 448       dot_idx = -1;
 449     }
 450     else
 451       idx++;
 452   }
 453   *d = '\0';
 454
 455   if(*s) {
 456     /* dos_name is truncated, check that truncation requirements are met,
 457        specifically truncating a filename suffixed by an alternate data stream
 458        or truncating the entire filename is not allowed. */
 459     if(!(flags & SANITIZE_ALLOW_TRUNCATE) || strpbrk(s, "\\/:") ||
 460        truncate_dryrun(dos_name, d - dos_name))
 461       return SANITIZE_ERR_INVALID_PATH;
 462   }
 463
 464   *sanitized = strdup(dos_name);
 465   return (*sanitized ? SANITIZE_ERR_OK : SANITIZE_ERR_OUT_OF_MEMORY);
 466 }
 467 #endif /* MSDOS || UNITTESTS */
 468
 469 /*
 470 Rename file_name if it's a reserved dos device name.
 471
 472 This is a supporting function for sanitize_file_name.
 473
 474 Warning: This is an MSDOS legacy function and was purposely written in a way
 475 that some path information may pass through. For example drive letter names
 476 (C:, D:, etc) are allowed to pass through. For sanitizing a filename use
 477 sanitize_file_name.
 478
 479 Success: (SANITIZE_ERR_OK) *sanitized points to a sanitized copy of file_name.
 480 Failure: (!= SANITIZE_ERR_OK) *sanitized is NULL.
 481 */
 482 SANITIZEcode rename_if_reserved_dos_device_name(char **const sanitized,
 483                                                 const char *file_name,
 484                                                 int flags)
 485 {
 486   /* We could have a file whose name is a device on MS-DOS.  Trying to
 487    * retrieve such a file would fail at best and wedge us at worst.  We need
 488    * to rename such files. */
 489   char *p, *base;
 490   char fname[PATH_MAX];
 491 #ifdef MSDOS
 492   struct_stat st_buf;
 493 #endif
 494
 495   if(!sanitized)
 496     return SANITIZE_ERR_BAD_ARGUMENT;
 497
 498   *sanitized = NULL;
 499
 500   if(!file_name)
 501     return SANITIZE_ERR_BAD_ARGUMENT;
 502
 503   /* Ignore UNC prefixed paths, they are allowed to contain a reserved name. */
 504 #ifndef MSDOS
 505   if((flags & SANITIZE_ALLOW_PATH) &&
 506      file_name[0] == '\\' && file_name[1] == '\\') {
 507     size_t len = strlen(file_name);
 508     *sanitized = malloc(len + 1);
 509     if(!*sanitized)
 510       return SANITIZE_ERR_OUT_OF_MEMORY;
 511     strncpy(*sanitized, file_name, len + 1);
 512     return SANITIZE_ERR_OK;
 513   }
 514 #endif
 515
 516   if(strlen(file_name) > PATH_MAX-1 &&
 517      (!(flags & SANITIZE_ALLOW_TRUNCATE) ||
 518       truncate_dryrun(file_name, PATH_MAX-1)))
 519     return SANITIZE_ERR_INVALID_PATH;
 520
 521   strncpy(fname, file_name, PATH_MAX-1);
 522   fname[PATH_MAX-1] = '\0';
 523   base = basename(fname);
 524
 525   /* Rename reserved device names that are known to be accessible without \\.\
 526      Examples: CON => _CON, CON.EXT => CON_EXT, CON:ADS => CON_ADS
 527      https://support.microsoft.com/en-us/kb/74496
 528      https://msdn.microsoft.com/en-us/library/windows/desktop/aa365247.aspx
 529      */
 530   for(p = fname; p; p = (p == fname && fname != base ? base : NULL)) {
 531     size_t p_len;
 532     int x = (curl_strnequal(p, "CON", 3) ||
 533              curl_strnequal(p, "PRN", 3) ||
 534              curl_strnequal(p, "AUX", 3) ||
 535              curl_strnequal(p, "NUL", 3)) ? 3 :
 536             (curl_strnequal(p, "CLOCK$", 6)) ? 6 :
 537             (curl_strnequal(p, "COM", 3) || curl_strnequal(p, "LPT", 3)) ?
 538               (('1' <= p[3] && p[3] <= '9') ? 4 : 3) : 0;
 539
 540     if(!x)
 541       continue;
 542
 543     /* the devices may be accessible with an extension or ADS, for
 544        example CON.AIR and 'CON . AIR' and CON:AIR access console */
 545
 546     for(; p[x] == ' '; ++x)
 547       ;
 548
 549     if(p[x] == '.') {
 550       p[x] = '_';
 551       continue;
 552     }
 553     else if(p[x] == ':') {
 554       if(!(flags & (SANITIZE_ALLOW_COLONS|SANITIZE_ALLOW_PATH))) {
 555         p[x] = '_';
 556         continue;
 557       }
 558       ++x;
 559     }
 560     else if(p[x]) /* no match */
 561       continue;
 562
 563     /* p points to 'CON' or 'CON ' or 'CON:', etc */
 564     p_len = strlen(p);
 565
 566     /* Prepend a '_' */
 567     if(strlen(fname) == PATH_MAX-1) {
 568       --p_len;
 569       if(!(flags & SANITIZE_ALLOW_TRUNCATE) || truncate_dryrun(p, p_len))
 570         return SANITIZE_ERR_INVALID_PATH;
 571       p[p_len] = '\0';
 572     }
 573     memmove(p + 1, p, p_len + 1);
 574     p[0] = '_';
 575     ++p_len;
 576
 577     /* if fname was just modified then the basename pointer must be updated */
 578     if(p == fname)
 579       base = basename(fname);
 580   }
 581
 582   /* This is the legacy portion from rename_if_dos_device_name that checks for
 583      reserved device names. It only works on MSDOS. On Windows XP the stat
 584      check errors with EINVAL if the device name is reserved. On Windows
 585      Vista/7/8 it sets mode S_IFREG (regular file or device). According to MSDN
 586      stat doc the latter behavior is correct, but that doesn't help us identify
 587      whether it's a reserved device name and not a regular file name. */
 588 #ifdef MSDOS
 589   if(base && ((stat(base, &st_buf)) == 0) && (S_ISCHR(st_buf.st_mode))) {
 590     /* Prepend a '_' */
 591     size_t blen = strlen(base);
 592     if(blen) {
 593       if(strlen(fname) == PATH_MAX-1) {
 594         --blen;
 595         if(!(flags & SANITIZE_ALLOW_TRUNCATE) || truncate_dryrun(base, blen))
 596           return SANITIZE_ERR_INVALID_PATH;
 597         base[blen] = '\0';
 598       }
 599       memmove(base + 1, base, blen + 1);
 600       base[0] = '_';
 601       ++blen;
 602     }
 603   }
 604 #endif
 605
 606   *sanitized = strdup(fname);
 607   return (*sanitized ? SANITIZE_ERR_OK : SANITIZE_ERR_OUT_OF_MEMORY);
 608 }
 609
 610 #if defined(MSDOS) && (defined(__DJGPP__) || defined(__GO32__))
 611
 612 /*
 613  * Disable program default argument globbing. We do it on our own.
 614  */
 615 char **__crt0_glob_function(char *arg)
 616 {
 617   (void)arg;
 618   return (char **)0;
 619 }
 620
 621 #endif /* MSDOS && (__DJGPP__ || __GO32__) */
 622
 623 #ifdef WIN32
 624
 625 /*
 626  * Function to find CACert bundle on a Win32 platform using SearchPath.
 627  * (SearchPath is already declared via inclusions done in setup header file)
 628  * (Use the ASCII version instead of the unicode one!)
 629  * The order of the directories it searches is:
 630  *  1. application's directory
 631  *  2. current working directory
 632  *  3. Windows System directory (e.g. C:\windows\system32)
 633  *  4. Windows Directory (e.g. C:\windows)
 634  *  5. all directories along %PATH%
 635  *
 636  * For WinXP and later search order actually depends on registry value:
 637  * HKLM\SYSTEM\CurrentControlSet\Control\Session Manager\SafeProcessSearchMode
 638  */
 639
 640 CURLcode FindWin32CACert(struct OperationConfig *config,
 641                          const char *bundle_file)
 642 {
 643   CURLcode result = CURLE_OK;
 644
 645   /* search and set cert file only if libcurl supports SSL */
 646   if(curlinfo->features & CURL_VERSION_SSL) {
 647
 648     DWORD res_len;
 649     DWORD buf_tchar_size = PATH_MAX + 1;
 650     DWORD buf_bytes_size = sizeof(TCHAR) * buf_tchar_size;
 651     char *ptr = NULL;
 652
 653     char *buf = malloc(buf_bytes_size);
 654     if(!buf)
 655       return CURLE_OUT_OF_MEMORY;
 656     buf[0] = '\0';
 657
 658     res_len = SearchPathA(NULL, bundle_file, NULL, buf_tchar_size, buf, &ptr);
 659     if(res_len > 0) {
 660       Curl_safefree(config->cacert);
 661       config->cacert = strdup(buf);
 662       if(!config->cacert)
 663         result = CURLE_OUT_OF_MEMORY;
 664     }
 665
 666     Curl_safefree(buf);
 667   }
 668
 669   return result;
 670 }
 671
 672 #endif /* WIN32 */
 673
 674 #endif /* MSDOS || WIN32 */