text: /***************************************************************************
   *                                  _   _ ____  _
   *  Project                     ___| | | |  _ \| |
   *                             / __| | | | |_) | |
   *                            | (__| |_| |  _ <| |___
   *                             \___|\___/|_| \_\_____|
   *
   * Copyright (C) 1998 - 2020, Daniel Stenberg, <daniel@haxx.se>, et al.
   *
   * This software is licensed as described in the file COPYING, which
   * you should have received as part of this distribution. The terms
   * are also available at https://curl.haxx.se/docs/copyright.html.
   *
   * You may opt to use, copy, modify, merge, publish, distribute and/or sell
   * copies of the Software, and permit persons to whom the Software is
   * furnished to do so, under the terms of the COPYING file.
   *
   * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
   * KIND, either express or implied.
   *
   ***************************************************************************/
  #include "tool_setup.h"
  
  #if defined(MSDOS) || defined(WIN32)
  
  #if defined(HAVE_LIBGEN_H) && defined(HAVE_BASENAME)
  #  include <libgen.h>
  #endif
  
  #ifdef WIN32
  #  include <tlhelp32.h>
  #  include "tool_cfgable.h"
  #  include "tool_libinfo.h"
  #endif
  
  #include "tool_bname.h"
  #include "tool_doswin.h"
  
  #include "memdebug.h" /* keep this as LAST include */
  
  #ifdef WIN32
  #  undef  PATH_MAX
  #  define PATH_MAX MAX_PATH
  #endif
  
  #ifndef S_ISCHR
  #  ifdef S_IFCHR
  #    define S_ISCHR(m) (((m) & S_IFMT) == S_IFCHR)
  #  else
  #    define S_ISCHR(m) (0) /* cannot tell if file is a device */
  #  endif
  #endif
  
  #ifdef WIN32
  #  define _use_lfn(f) (1)   /* long file names always available */
  #elif !defined(__DJGPP__) || (__DJGPP__ < 2)  /* DJGPP 2.0 has _use_lfn() */
  #  define _use_lfn(f) (0)  /* long file names never available */
  #elif defined(__DJGPP__)
  #  include <fcntl.h>                /* _use_lfn(f) prototype */
  #endif
  
  #ifndef UNITTESTS
  static SANITIZEcode truncate_dryrun(const char *path,
                                      const size_t truncate_pos);
  #ifdef MSDOS
  static SANITIZEcode msdosify(char **const sanitized, const char *file_name,
                               int flags);
  #endif
  static SANITIZEcode rename_if_reserved_dos_device_name(char **const sanitized,
                                                         const char *file_name,
                                                         int flags);
  #endif /* !UNITTESTS (static declarations used if no unit tests) */
  
  
  /*
  Sanitize a file or path name.
  
  All banned characters are replaced by underscores, for example:
  f?*foo => f__foo
  f:foo::$DATA => f_foo__$DATA
  f:\foo:bar => f__foo_bar
  f:\foo:bar => f:\foo:bar   (flag SANITIZE_ALLOW_PATH)
  
  This function was implemented according to the guidelines in 'Naming Files,
  Paths, and Namespaces' section 'Naming Conventions'.
  https://msdn.microsoft.com/en-us/library/windows/desktop/aa365247.aspx
  
  Flags
  -----
  SANITIZE_ALLOW_COLONS:     Allow colons.
  Without this flag colons are sanitized.
  
  SANITIZE_ALLOW_PATH:       Allow path separators and colons.
  Without this flag path separators and colons are sanitized.
  
  SANITIZE_ALLOW_RESERVED:   Allow reserved device names.
  Without this flag a reserved device name is renamed (COM1 => _COM1) unless it's
  in a UNC prefixed path.
  
  SANITIZE_ALLOW_TRUNCATE:   Allow truncating a long filename.
  Without this flag if the sanitized filename or path will be too long an error
  occurs. With this flag the filename --and not any other parts of the path-- may
  be truncated to at least a single character. A filename followed by an
  alternate data stream (ADS) cannot be truncated in any case.
  
  Success: (SANITIZE_ERR_OK) *sanitized points to a sanitized copy of file_name.
  Failure: (!= SANITIZE_ERR_OK) *sanitized is NULL.
  */
  SANITIZEcode sanitize_file_name(char **const sanitized, const char *file_name,
                                  int flags)
  {
    char *p, *target;
    size_t len;
    SANITIZEcode sc;
    size_t max_sanitized_len;
  
    if(!sanitized)
      return SANITIZE_ERR_BAD_ARGUMENT;
  
    *sanitized = NULL;
  
    if(!file_name)
      return SANITIZE_ERR_BAD_ARGUMENT;
  
    if((flags & SANITIZE_ALLOW_PATH)) {
  #ifndef MSDOS
      if(file_name[0] == '\\' && file_name[1] == '\\')
        /* UNC prefixed path \\ (eg \\?\C:\foo) */
        max_sanitized_len = 32767-1;
      else
  #endif
        max_sanitized_len = PATH_MAX-1;
    }
    else
      /* The maximum length of a filename.
         FILENAME_MAX is often the same as PATH_MAX, in other words it is 260 and
         does not discount the path information therefore we shouldn't use it. */
      max_sanitized_len = (PATH_MAX-1 > 255) ? 255 : PATH_MAX-1;
  
    len = strlen(file_name);
    if(len > max_sanitized_len) {
      if(!(flags & SANITIZE_ALLOW_TRUNCATE) ||
         truncate_dryrun(file_name, max_sanitized_len))
        return SANITIZE_ERR_INVALID_PATH;
  
      len = max_sanitized_len;
    }
  
    target = malloc(len + 1);
    if(!target)
      return SANITIZE_ERR_OUT_OF_MEMORY;
  
    strncpy(target, file_name, len);
    target[len] = '\0';
  
  #ifndef MSDOS
    if((flags & SANITIZE_ALLOW_PATH) && !strncmp(target, "\\\\?\\", 4))
      /* Skip the literal path prefix \\?\ */
      p = target + 4;
    else
  #endif
      p = target;
  
    /* replace control characters and other banned characters */
    for(; *p; ++p) {
      const char *banned;
  
      if((1 <= *p && *p <= 31) ||
         (!(flags & (SANITIZE_ALLOW_COLONS|SANITIZE_ALLOW_PATH)) && *p == ':') ||
         (!(flags & SANITIZE_ALLOW_PATH) && (*p == '/' || *p == '\\'))) {
        *p = '_';
        continue;
      }
  
      for(banned = "|<>\"?*"; *banned; ++banned) {
        if(*p == *banned) {
          *p = '_';
          break;
        }
      }
    }
  
    /* remove trailing spaces and periods if not allowing paths */
    if(!(flags & SANITIZE_ALLOW_PATH) && len) {
      char *clip = NULL;
  
      p = &target[len];
      do {
        --p;
        if(*p != ' ' && *p != '.')
          break;
        clip = p;
      } while(p != target);
  
      if(clip) {
        *clip = '\0';
        len = clip - target;
      }
    }
  
  #ifdef MSDOS
    sc = msdosify(&p, target, flags);
    free(target);
    if(sc)
      return sc;
    target = p;
    len = strlen(target);
  
    if(len > max_sanitized_len) {
      free(target);
      return SANITIZE_ERR_INVALID_PATH;
    }
  #endif
  
    if(!(flags & SANITIZE_ALLOW_RESERVED)) {
      sc = rename_if_reserved_dos_device_name(&p, target, flags);
      free(target);
      if(sc)
        return sc;
      target = p;
      len = strlen(target);
  
      if(len > max_sanitized_len) {
        free(target);
        return SANITIZE_ERR_INVALID_PATH;
      }
    }
  
    *sanitized = target;
    return SANITIZE_ERR_OK;
  }
  
  
  /*
  Test if truncating a path to a file will leave at least a single character in
  the filename. Filenames suffixed by an alternate data stream can't be
  truncated. This performs a dry run, nothing is modified.
  
  Good truncate_pos 9:    C:\foo\bar  =>  C:\foo\ba
  Good truncate_pos 6:    C:\foo      =>  C:\foo
  Good truncate_pos 5:    C:\foo      =>  C:\fo
  Bad* truncate_pos 5:    C:foo       =>  C:foo
  Bad truncate_pos 5:     C:\foo:ads  =>  C:\fo
  Bad truncate_pos 9:     C:\foo:ads  =>  C:\foo:ad
  Bad truncate_pos 5:     C:\foo\bar  =>  C:\fo
  Bad truncate_pos 5:     C:\foo\     =>  C:\fo
  Bad truncate_pos 7:     C:\foo\     =>  C:\foo\
  Error truncate_pos 7:   C:\foo      =>  (pos out of range)
  Bad truncate_pos 1:     C:\foo\     =>  C
  
  * C:foo is ambiguous, C could end up being a drive or file therefore something
    like C:superlongfilename can't be truncated.
  
  Returns
  SANITIZE_ERR_OK: Good -- 'path' can be truncated
  SANITIZE_ERR_INVALID_PATH: Bad -- 'path' cannot be truncated
  != SANITIZE_ERR_OK && != SANITIZE_ERR_INVALID_PATH: Error
  */
  SANITIZEcode truncate_dryrun(const char *path, const size_t truncate_pos)
  {
    size_t len;
  
    if(!path)
      return SANITIZE_ERR_BAD_ARGUMENT;
  
    len = strlen(path);
  
    if(truncate_pos > len)
      return SANITIZE_ERR_BAD_ARGUMENT;
  
    if(!len || !truncate_pos)
      return SANITIZE_ERR_INVALID_PATH;
  
    if(strpbrk(&path[truncate_pos - 1], "\\/:"))
      return SANITIZE_ERR_INVALID_PATH;
  
    /* C:\foo can be truncated but C:\foo:ads can't */
    if(truncate_pos > 1) {
      const char *p = &path[truncate_pos - 1];
      do {
        --p;
        if(*p == ':')
          return SANITIZE_ERR_INVALID_PATH;
      } while(p != path && *p != '\\' && *p != '/');
    }
  
    return SANITIZE_ERR_OK;
  }
  
  /* The functions msdosify, rename_if_dos_device_name and __crt0_glob_function
   * were taken with modification from the DJGPP port of tar 1.12. They use
   * algorithms originally from DJTAR.
   */
  
  /*
  Extra sanitization MSDOS for file_name.
  
  This is a supporting function for sanitize_file_name.
  
  Warning: This is an MSDOS legacy function and was purposely written in a way
  that some path information may pass through. For example drive letter names
  (C:, D:, etc) are allowed to pass through. For sanitizing a filename use
  sanitize_file_name.
  
  Success: (SANITIZE_ERR_OK) *sanitized points to a sanitized copy of file_name.
  Failure: (!= SANITIZE_ERR_OK) *sanitized is NULL.
  */
  #if defined(MSDOS) || defined(UNITTESTS)
  SANITIZEcode msdosify(char **const sanitized, const char *file_name,
                        int flags)
  {
    char dos_name[PATH_MAX];
    static const char illegal_chars_dos[] = ".+, ;=[]" /* illegal in DOS */
      "|<>/\\\":?*"; /* illegal in DOS & W95 */
    static const char *illegal_chars_w95 = &illegal_chars_dos[8];
    int idx, dot_idx;
    const char *s = file_name;
    char *d = dos_name;
    const char *const dlimit = dos_name + sizeof(dos_name) - 1;
    const char *illegal_aliens = illegal_chars_dos;
    size_t len = sizeof(illegal_chars_dos) - 1;
  
    if(!sanitized)
      return SANITIZE_ERR_BAD_ARGUMENT;
  
    *sanitized = NULL;
  
    if(!file_name)
      return SANITIZE_ERR_BAD_ARGUMENT;
  
    if(strlen(file_name) > PATH_MAX-1 &&
       (!(flags & SANITIZE_ALLOW_TRUNCATE) ||
        truncate_dryrun(file_name, PATH_MAX-1)))
      return SANITIZE_ERR_INVALID_PATH;
  
    /* Support for Windows 9X VFAT systems, when available. */
    if(_use_lfn(file_name)) {
      illegal_aliens = illegal_chars_w95;
      len -= (illegal_chars_w95 - illegal_chars_dos);
    }
  
    /* Get past the drive letter, if any. */
    if(s[0] >= 'A' && s[0] <= 'z' && s[1] == ':') {
      *d++ = *s++;
      *d = ((flags & (SANITIZE_ALLOW_COLONS|SANITIZE_ALLOW_PATH))) ? ':' : '_';
      ++d, ++s;
    }
  
    for(idx = 0, dot_idx = -1; *s && d < dlimit; s++, d++) {
      if(memchr(illegal_aliens, *s, len)) {
  
        if((flags & (SANITIZE_ALLOW_COLONS|SANITIZE_ALLOW_PATH)) && *s == ':')
          *d = ':';
        else if((flags & SANITIZE_ALLOW_PATH) && (*s == '/' || *s == '\\'))
          *d = *s;
        /* Dots are special: DOS doesn't allow them as the leading character,
           and a file name cannot have more than a single dot.  We leave the
           first non-leading dot alone, unless it comes too close to the
           beginning of the name: we want sh.lex.c to become sh_lex.c, not
           sh.lex-c.  */
        else if(*s == '.') {
          if((flags & SANITIZE_ALLOW_PATH) && idx == 0 &&
             (s[1] == '/' || s[1] == '\\' ||
              (s[1] == '.' && (s[2] == '/' || s[2] == '\\')))) {
            /* Copy "./" and "../" verbatim.  */
            *d++ = *s++;
            if(d == dlimit)
              break;
            if(*s == '.') {
              *d++ = *s++;
              if(d == dlimit)
                break;
            }
            *d = *s;
          }
          else if(idx == 0)
            *d = '_';
          else if(dot_idx >= 0) {
            if(dot_idx < 5) { /* 5 is a heuristic ad-hoc'ery */
              d[dot_idx - idx] = '_'; /* replace previous dot */
              *d = '.';
            }
            else
              *d = '-';
          }
          else
            *d = '.';
  
          if(*s == '.')
            dot_idx = idx;
        }
        else if(*s == '+' && s[1] == '+') {
          if(idx - 2 == dot_idx) { /* .c++, .h++ etc. */
            *d++ = 'x';
            if(d == dlimit)
              break;
            *d   = 'x';
          }
          else {
            /* libg++ etc.  */
            if(dlimit - d < 4) {
              *d++ = 'x';
              if(d == dlimit)
                break;
              *d   = 'x';
            }
            else {
              memcpy(d, "plus", 4);
              d += 3;
            }
          }
          s++;
          idx++;
        }
        else
          *d = '_';
      }
      else
        *d = *s;
      if(*s == '/' || *s == '\\') {
        idx = 0;
        dot_idx = -1;
      }
      else
        idx++;
    }
    *d = '\0';
  
    if(*s) {
      /* dos_name is truncated, check that truncation requirements are met,
         specifically truncating a filename suffixed by an alternate data stream
         or truncating the entire filename is not allowed. */
      if(!(flags & SANITIZE_ALLOW_TRUNCATE) || strpbrk(s, "\\/:") ||
         truncate_dryrun(dos_name, d - dos_name))
        return SANITIZE_ERR_INVALID_PATH;
    }
  
    *sanitized = strdup(dos_name);
    return (*sanitized ? SANITIZE_ERR_OK : SANITIZE_ERR_OUT_OF_MEMORY);
  }
  #endif /* MSDOS || UNITTESTS */
  
  /*
  Rename file_name if it's a reserved dos device name.
  
  This is a supporting function for sanitize_file_name.
  
  Warning: This is an MSDOS legacy function and was purposely written in a way
  that some path information may pass through. For example drive letter names
  (C:, D:, etc) are allowed to pass through. For sanitizing a filename use
  sanitize_file_name.
  
  Success: (SANITIZE_ERR_OK) *sanitized points to a sanitized copy of file_name.
  Failure: (!= SANITIZE_ERR_OK) *sanitized is NULL.
  */
  SANITIZEcode rename_if_reserved_dos_device_name(char **const sanitized,
                                                  const char *file_name,
                                                  int flags)
  {
    /* We could have a file whose name is a device on MS-DOS.  Trying to
     * retrieve such a file would fail at best and wedge us at worst.  We need
     * to rename such files. */
    char *p, *base;
    char fname[PATH_MAX];
  #ifdef MSDOS
    struct_stat st_buf;
  #endif
  
    if(!sanitized)
      return SANITIZE_ERR_BAD_ARGUMENT;
  
    *sanitized = NULL;
  
    if(!file_name)
      return SANITIZE_ERR_BAD_ARGUMENT;
  
    /* Ignore UNC prefixed paths, they are allowed to contain a reserved name. */
  #ifndef MSDOS
    if((flags & SANITIZE_ALLOW_PATH) &&
       file_name[0] == '\\' && file_name[1] == '\\') {
      size_t len = strlen(file_name);
      *sanitized = malloc(len + 1);
      if(!*sanitized)
        return SANITIZE_ERR_OUT_OF_MEMORY;
      strncpy(*sanitized, file_name, len + 1);
      return SANITIZE_ERR_OK;
    }
  #endif
  
    if(strlen(file_name) > PATH_MAX-1 &&
       (!(flags & SANITIZE_ALLOW_TRUNCATE) ||
        truncate_dryrun(file_name, PATH_MAX-1)))
      return SANITIZE_ERR_INVALID_PATH;
  
    strncpy(fname, file_name, PATH_MAX-1);
    fname[PATH_MAX-1] = '\0';
    base = basename(fname);
  
    /* Rename reserved device names that are known to be accessible without \\.\
       Examples: CON => _CON, CON.EXT => CON_EXT, CON:ADS => CON_ADS
       https://support.microsoft.com/en-us/kb/74496
       https://msdn.microsoft.com/en-us/library/windows/desktop/aa365247.aspx
       */
    for(p = fname; p; p = (p == fname && fname != base ? base : NULL)) {
      size_t p_len;
      int x = (curl_strnequal(p, "CON", 3) ||
               curl_strnequal(p, "PRN", 3) ||
               curl_strnequal(p, "AUX", 3) ||
               curl_strnequal(p, "NUL", 3)) ? 3 :
              (curl_strnequal(p, "CLOCK$", 6)) ? 6 :
              (curl_strnequal(p, "COM", 3) || curl_strnequal(p, "LPT", 3)) ?
                (('1' <= p[3] && p[3] <= '9') ? 4 : 3) : 0;
  
      if(!x)
        continue;
  
      /* the devices may be accessible with an extension or ADS, for
         example CON.AIR and 'CON . AIR' and CON:AIR access console */
  
      for(; p[x] == ' '; ++x)
        ;
  
      if(p[x] == '.') {
        p[x] = '_';
        continue;
      }
      else if(p[x] == ':') {
        if(!(flags & (SANITIZE_ALLOW_COLONS|SANITIZE_ALLOW_PATH))) {
          p[x] = '_';
          continue;
        }
        ++x;
      }
      else if(p[x]) /* no match */
        continue;
  
      /* p points to 'CON' or 'CON ' or 'CON:', etc */
      p_len = strlen(p);
  
      /* Prepend a '_' */
      if(strlen(fname) == PATH_MAX-1) {
        --p_len;
        if(!(flags & SANITIZE_ALLOW_TRUNCATE) || truncate_dryrun(p, p_len))
          return SANITIZE_ERR_INVALID_PATH;
        p[p_len] = '\0';
      }
      memmove(p + 1, p, p_len + 1);
      p[0] = '_';
      ++p_len;
  
      /* if fname was just modified then the basename pointer must be updated */
      if(p == fname)
        base = basename(fname);
    }
  
    /* This is the legacy portion from rename_if_dos_device_name that checks for
       reserved device names. It only works on MSDOS. On Windows XP the stat
       check errors with EINVAL if the device name is reserved. On Windows
       Vista/7/8 it sets mode S_IFREG (regular file or device). According to MSDN
       stat doc the latter behavior is correct, but that doesn't help us identify
       whether it's a reserved device name and not a regular file name. */
  #ifdef MSDOS
    if(base && ((stat(base, &st_buf)) == 0) && (S_ISCHR(st_buf.st_mode))) {
      /* Prepend a '_' */
      size_t blen = strlen(base);
      if(blen) {
        if(strlen(fname) == PATH_MAX-1) {
          --blen;
          if(!(flags & SANITIZE_ALLOW_TRUNCATE) || truncate_dryrun(base, blen))
            return SANITIZE_ERR_INVALID_PATH;
          base[blen] = '\0';
        }
        memmove(base + 1, base, blen + 1);
        base[0] = '_';
      }
    }
  #endif
  
    *sanitized = strdup(fname);
    return (*sanitized ? SANITIZE_ERR_OK : SANITIZE_ERR_OUT_OF_MEMORY);
  }
  
  #if defined(MSDOS) && (defined(__DJGPP__) || defined(__GO32__))
  
  /*
   * Disable program default argument globbing. We do it on our own.
   */
  char **__crt0_glob_function(char *arg)
  {
    (void)arg;
    return (char **)0;
  }
  
  #endif /* MSDOS && (__DJGPP__ || __GO32__) */
  
  #ifdef WIN32
  
  /*
   * Function to find CACert bundle on a Win32 platform using SearchPath.
   * (SearchPath is already declared via inclusions done in setup header file)
   * (Use the ASCII version instead of the unicode one!)
   * The order of the directories it searches is:
   *  1. application's directory
   *  2. current working directory
   *  3. Windows System directory (e.g. C:\windows\system32)
   *  4. Windows Directory (e.g. C:\windows)
   *  5. all directories along %PATH%
   *
   * For WinXP and later search order actually depends on registry value:
   * HKLM\SYSTEM\CurrentControlSet\Control\Session Manager\SafeProcessSearchMode
   */
  
  CURLcode FindWin32CACert(struct OperationConfig *config,
                           curl_sslbackend backend,
                           const char *bundle_file)
  {
    CURLcode result = CURLE_OK;
  
    /* Search and set cert file only if libcurl supports SSL.
     *
     * If Schannel is the selected SSL backend then these locations are
     * ignored. We allow setting CA location for schannel only when explicitly
     * specified by the user via CURLOPT_CAINFO / --cacert.
     */
    if((curlinfo->features & CURL_VERSION_SSL) &&
       backend != CURLSSLBACKEND_SCHANNEL) {
  
      DWORD res_len;
      char buf[PATH_MAX];
      char *ptr = NULL;
  
      buf[0] = '\0';
  
      res_len = SearchPathA(NULL, bundle_file, NULL, PATH_MAX, buf, &ptr);
      if(res_len > 0) {
        Curl_safefree(config->cacert);
        config->cacert = strdup(buf);
        if(!config->cacert)
          result = CURLE_OUT_OF_MEMORY;
      }
    }
  
    return result;
  }
  
  
  /* Get a list of all loaded modules with full paths.
   * Returns slist on success or NULL on error.
   */
  struct curl_slist *GetLoadedModulePaths(void)
  {
    HANDLE hnd = INVALID_HANDLE_VALUE;
    MODULEENTRY32 mod = {0};
    struct curl_slist *slist = NULL;
  
    mod.dwSize = sizeof(MODULEENTRY32);
  
    do {
      hnd = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, 0);
    } while(hnd == INVALID_HANDLE_VALUE && GetLastError() == ERROR_BAD_LENGTH);
  
    if(hnd == INVALID_HANDLE_VALUE)
      goto error;
  
    if(!Module32First(hnd, &mod))
      goto error;
  
    do {
      char *path; /* points to stack allocated buffer */
      struct curl_slist *temp;
  
  #ifdef UNICODE
      /* sizeof(mod.szExePath) is the max total bytes of wchars. the max total
         bytes of multibyte chars won't be more than twice that. */
      char buffer[sizeof(mod.szExePath) * 2];
      if(!WideCharToMultiByte(CP_ACP, 0, mod.szExePath, -1,
                              buffer, sizeof(buffer), NULL, NULL))
        goto error;
      path = buffer;
  #else
      path = mod.szExePath;
  #endif
      temp = curl_slist_append(slist, path);
      if(!temp)
        goto error;
      slist = temp;
    } while(Module32Next(hnd, &mod));
  
    goto cleanup;
  
  error:
    curl_slist_free_all(slist);
    slist = NULL;
  cleanup:
    if(hnd != INVALID_HANDLE_VALUE)
      CloseHandle(hnd);
    return slist;
  }
  
  LARGE_INTEGER tool_freq;
  bool tool_isVistaOrGreater;
  
  CURLcode win32_init(void)
  {
    OSVERSIONINFOEXA osvi;
    unsigned __int64 mask = 0;
    unsigned char op = VER_GREATER_EQUAL;
  
    memset(&osvi, 0, sizeof(osvi));
    osvi.dwOSVersionInfoSize = sizeof(osvi);
    osvi.dwMajorVersion = 6;
    VER_SET_CONDITION(mask, VER_MAJORVERSION, op);
    VER_SET_CONDITION(mask, VER_MINORVERSION, op);
  
    if(VerifyVersionInfoA(&osvi, (VER_MAJORVERSION | VER_MINORVERSION), mask))
      tool_isVistaOrGreater = true;
    else if(GetLastError() == ERROR_OLD_WIN_VERSION)
      tool_isVistaOrGreater = false;
    else
      return CURLE_FAILED_INIT;
  
    QueryPerformanceFrequency(&tool_freq);
    return CURLE_OK;
  }
  
  #endif /* WIN32 */
  
  #endif /* MSDOS || WIN32 */
  