QRScanner/mobile/jni/thirdparty/curl/src/tool_doswin.c

   1 /***************************************************************************
   2  *                                  _   _ ____  _
   3  *  Project                     ___| | | |  _ \| |
   4  *                             / __| | | | |_) | |
   5  *                            | (__| |_| |  _ <| |___
   6  *                             \___|\___/|_| \_\_____|
   7  *
   8  * Copyright (C) 1998 - 2012, 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 "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 static const char *msdosify (const char *file_name);
  89 static char *rename_if_dos_device_name (char *file_name);
  90
  91 /*
  92  * sanitize_dos_name: returns a newly allocated string holding a
  93  * valid file name which will be a transformation of given argument
  94  * in case this wasn't already a valid file name.
  95  *
  96  * This function takes ownership of given argument, free'ing it before
  97  * returning. Caller is responsible of free'ing returned string. Upon
  98  * out of memory condition function returns NULL.
  99  */
 100
 101 char *sanitize_dos_name(char *file_name)
 102 {
 103   char new_name[PATH_MAX];
 104
 105   if(!file_name)
 106     return NULL;
 107
 108   if(strlen(file_name) >= PATH_MAX)
 109     file_name[PATH_MAX-1] = '\0'; /* truncate it */
 110
 111   strcpy(new_name, msdosify(file_name));
 112
 113   Curl_safefree(file_name);
 114
 115   return strdup(rename_if_dos_device_name(new_name));
 116 }
 117
 118 /* The following functions are taken with modification from the DJGPP
 119  * port of tar 1.12. They use algorithms originally from DJTAR. */
 120
 121 static const char *msdosify (const char *file_name)
 122 {
 123   static char dos_name[PATH_MAX];
 124   static const char illegal_chars_dos[] = ".+, ;=[]" /* illegal in DOS */
 125     "|<>\\\":?*"; /* illegal in DOS & W95 */
 126   static const char *illegal_chars_w95 = &illegal_chars_dos[8];
 127   int idx, dot_idx;
 128   const char *s = file_name;
 129   char *d = dos_name;
 130   const char *const dlimit = dos_name + sizeof(dos_name) - 1;
 131   const char *illegal_aliens = illegal_chars_dos;
 132   size_t len = sizeof(illegal_chars_dos) - 1;
 133
 134   /* Support for Windows 9X VFAT systems, when available. */
 135   if(_use_lfn(file_name)) {
 136     illegal_aliens = illegal_chars_w95;
 137     len -= (illegal_chars_w95 - illegal_chars_dos);
 138   }
 139
 140   /* Get past the drive letter, if any. */
 141   if(s[0] >= 'A' && s[0] <= 'z' && s[1] == ':') {
 142     *d++ = *s++;
 143     *d++ = *s++;
 144   }
 145
 146   for(idx = 0, dot_idx = -1; *s && d < dlimit; s++, d++) {
 147     if(memchr(illegal_aliens, *s, len)) {
 148       /* Dots are special: DOS doesn't allow them as the leading character,
 149          and a file name cannot have more than a single dot.  We leave the
 150          first non-leading dot alone, unless it comes too close to the
 151          beginning of the name: we want sh.lex.c to become sh_lex.c, not
 152          sh.lex-c.  */
 153       if(*s == '.') {
 154         if(idx == 0 && (s[1] == '/' || (s[1] == '.' && s[2] == '/'))) {
 155           /* Copy "./" and "../" verbatim.  */
 156           *d++ = *s++;
 157           if(*s == '.')
 158             *d++ = *s++;
 159           *d = *s;
 160         }
 161         else if(idx == 0)
 162           *d = '_';
 163         else if(dot_idx >= 0) {
 164           if(dot_idx < 5) { /* 5 is a heuristic ad-hoc'ery */
 165             d[dot_idx - idx] = '_'; /* replace previous dot */
 166             *d = '.';
 167           }
 168           else
 169             *d = '-';
 170         }
 171         else
 172           *d = '.';
 173
 174         if(*s == '.')
 175           dot_idx = idx;
 176       }
 177       else if(*s == '+' && s[1] == '+') {
 178         if(idx - 2 == dot_idx) { /* .c++, .h++ etc. */
 179           *d++ = 'x';
 180           *d   = 'x';
 181         }
 182         else {
 183           /* libg++ etc.  */
 184           memcpy (d, "plus", 4);
 185           d += 3;
 186         }
 187         s++;
 188         idx++;
 189       }
 190       else
 191         *d = '_';
 192     }
 193     else
 194       *d = *s;
 195     if(*s == '/') {
 196       idx = 0;
 197       dot_idx = -1;
 198     }
 199     else
 200       idx++;
 201   }
 202
 203   *d = '\0';
 204   return dos_name;
 205 }
 206
 207 static char *rename_if_dos_device_name (char *file_name)
 208 {
 209   /* We could have a file whose name is a device on MS-DOS.  Trying to
 210    * retrieve such a file would fail at best and wedge us at worst.  We need
 211    * to rename such files. */
 212   char *base;
 213   struct_stat st_buf;
 214   char fname[PATH_MAX];
 215
 216   strncpy(fname, file_name, PATH_MAX-1);
 217   fname[PATH_MAX-1] = '\0';
 218   base = basename(fname);
 219   if(((stat(base, &st_buf)) == 0) && (S_ISCHR(st_buf.st_mode))) {
 220     size_t blen = strlen(base);
 221
 222     if(strlen(fname) >= PATH_MAX-1) {
 223       /* Make room for the '_' */
 224       blen--;
 225       base[blen] = '\0';
 226     }
 227     /* Prepend a '_'.  */
 228     memmove(base + 1, base, blen + 1);
 229     base[0] = '_';
 230     strcpy(file_name, fname);
 231   }
 232   return file_name;
 233 }
 234
 235 #if defined(MSDOS) && (defined(__DJGPP__) || defined(__GO32__))
 236
 237 /*
 238  * Disable program default argument globbing. We do it on our own.
 239  */
 240 char **__crt0_glob_function(char *arg)
 241 {
 242   (void)arg;
 243   return (char**)0;
 244 }
 245
 246 #endif /* MSDOS && (__DJGPP__ || __GO32__) */
 247
 248 #ifdef WIN32
 249
 250 /*
 251  * Function to find CACert bundle on a Win32 platform using SearchPath.
 252  * (SearchPath is already declared via inclusions done in setup header file)
 253  * (Use the ASCII version instead of the unicode one!)
 254  * The order of the directories it searches is:
 255  *  1. application's directory
 256  *  2. current working directory
 257  *  3. Windows System directory (e.g. C:\windows\system32)
 258  *  4. Windows Directory (e.g. C:\windows)
 259  *  5. all directories along %PATH%
 260  *
 261  * For WinXP and later search order actually depends on registry value:
 262  * HKLM\SYSTEM\CurrentControlSet\Control\Session Manager\SafeProcessSearchMode
 263  */
 264
 265 CURLcode FindWin32CACert(struct Configurable *config, const char *bundle_file)
 266 {
 267   CURLcode result = CURLE_OK;
 268
 269   /* search and set cert file only if libcurl supports SSL */
 270   if(curlinfo->features & CURL_VERSION_SSL) {
 271
 272     DWORD res_len;
 273     DWORD buf_tchar_size = PATH_MAX + 1;
 274     DWORD buf_bytes_size = sizeof(TCHAR) * buf_tchar_size;
 275     char *ptr = NULL;
 276
 277     char *buf = malloc(buf_bytes_size);
 278     if(!buf)
 279       return CURLE_OUT_OF_MEMORY;
 280     buf[0] = '\0';
 281
 282     res_len = SearchPathA(NULL, bundle_file, NULL, buf_tchar_size, buf, &ptr);
 283     if(res_len > 0) {
 284       Curl_safefree(config->cacert);
 285       config->cacert = strdup(buf);
 286       if(!config->cacert)
 287         result = CURLE_OUT_OF_MEMORY;
 288     }
 289
 290     Curl_safefree(buf);
 291   }
 292
 293   return result;
 294 }
 295
 296 #endif /* WIN32 */
 297
 298 #endif /* MSDOS || WIN32 */
 299