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