lib-src/ntlib.c

   1 /* Utility and Unix shadow routines for GNU Emacs support programs on NT.
   2    Copyright (C) 1994, 2001-2011  Free Software Foundation, Inc.
   3
   4 This file is part of GNU Emacs.
   5
   6 GNU Emacs is free software: you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation, either version 3 of the License, or
   9 (at your option) any later version.
  10
  11 GNU Emacs is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
  18
  19
  20    Geoff Voelker (voelker@cs.washington.edu)                         10-8-94
  21 */
  22
  23 #include <windows.h>
  24 #include <stdlib.h>
  25 #include <stdio.h>
  26 #include <time.h>
  27 #include <direct.h>
  28 #include <sys/types.h>
  29 #include <sys/stat.h>
  30 #include <errno.h>
  31 #include <ctype.h>
  32
  33 #include "ntlib.h"
  34
  35 #define MAXPATHLEN _MAX_PATH
  36
  37 /* Emulate sleep...we could have done this with a define, but that
  38    would necessitate including windows.h in the files that used it.
  39    This is much easier.  */
  40 void
  41 sleep (unsigned long seconds)
  42 {
  43   Sleep (seconds * 1000);
  44 }
  45
  46 /* Get the current working directory.  */
  47 char *
  48 getwd (char *dir)
  49 {
  50   if (GetCurrentDirectory (MAXPATHLEN, dir) > 0)
  51     return dir;
  52   return NULL;
  53 }
  54
  55 static HANDLE getppid_parent;
  56 static int    getppid_ppid;
  57
  58 int
  59 getppid (void)
  60 {
  61   char *ppid;
  62   DWORD result;
  63
  64   ppid = getenv ("EM_PARENT_PROCESS_ID");
  65   if (!ppid)
  66     {
  67       printf ("no pid.\n");
  68       return 0;
  69     }
  70   else
  71     {
  72       getppid_ppid = atoi (ppid);
  73     }
  74
  75   if (!getppid_parent)
  76     {
  77       getppid_parent = OpenProcess (SYNCHRONIZE, FALSE, atoi (ppid));
  78       if (!getppid_parent)
  79         {
  80           printf ("Failed to open handle to parent process: %d\n",
  81                  GetLastError ());
  82           exit (1);
  83         }
  84     }
  85
  86   result = WaitForSingleObject (getppid_parent, 0);
  87   switch (result)
  88     {
  89     case WAIT_TIMEOUT:
  90       /* The parent is still alive.  */
  91       return getppid_ppid;
  92     case WAIT_OBJECT_0:
  93       /* The parent is gone.  Return the pid of Unix init (1).  */
  94       return 1;
  95     case WAIT_FAILED:
  96     default:
  97       printf ("Checking parent status failed: %d\n", GetLastError ());
  98       exit (1);
  99     }
 100 }
 101
 102 char *
 103 getlogin (void)
 104 {
 105   static char user_name[256];
 106   DWORD  length = sizeof (user_name);
 107
 108   if (GetUserName (user_name, &length))
 109     return user_name;
 110   return NULL;
 111 }
 112
 113 char *
 114 cuserid (char * s)
 115 {
 116   char * name = getlogin ();
 117   if (s)
 118     return strcpy (s, name ? name : "");
 119   return name;
 120 }
 121
 122 unsigned
 123 getuid (void)
 124 {
 125   return 0;
 126 }
 127
 128 unsigned
 129 getgid (void)
 130 {
 131   return 0;
 132 }
 133
 134 unsigned
 135 getegid (void)
 136 {
 137   return 0;
 138 }
 139
 140 int
 141 setuid (unsigned uid)
 142 {
 143   return 0;
 144 }
 145
 146 int
 147 setregid (unsigned rgid, unsigned gid)
 148 {
 149   return 0;
 150 }
 151
 152 struct passwd *
 153 getpwuid (unsigned uid)
 154 {
 155   return NULL;
 156 }
 157
 158 char *
 159 getpass (const char * prompt)
 160 {
 161   static char input[256];
 162   HANDLE in;
 163   HANDLE err;
 164   DWORD  count;
 165
 166   in = GetStdHandle (STD_INPUT_HANDLE);
 167   err = GetStdHandle (STD_ERROR_HANDLE);
 168
 169   if (in == INVALID_HANDLE_VALUE || err == INVALID_HANDLE_VALUE)
 170     return NULL;
 171
 172   if (WriteFile (err, prompt, strlen (prompt), &count, NULL))
 173     {
 174       int istty = (GetFileType (in) == FILE_TYPE_CHAR);
 175       DWORD old_flags;
 176       int rc;
 177
 178       if (istty)
 179         {
 180           if (GetConsoleMode (in, &old_flags))
 181             SetConsoleMode (in, ENABLE_LINE_INPUT | ENABLE_PROCESSED_INPUT);
 182           else
 183             istty = 0;
 184         }
 185       rc = ReadFile (in, input, sizeof (input), &count, NULL);
 186       if (count >= 2 && input[count - 2] == '\r')
 187         input[count - 2] = '\0';
 188       else
 189         {
 190           char buf[256];
 191           while (ReadFile (in, buf, sizeof (buf), &count, NULL) > 0)
 192             if (count >= 2 && buf[count - 2] == '\r')
 193               break;
 194         }
 195       WriteFile (err, "\r\n", 2, &count, NULL);
 196       if (istty)
 197         SetConsoleMode (in, old_flags);
 198       if (rc)
 199         return input;
 200     }
 201
 202   return NULL;
 203 }
 204
 205 int
 206 fchown (int fd, unsigned uid, unsigned gid)
 207 {
 208   return 0;
 209 }
 210
 211 /* Place a wrapper around the MSVC version of ctime.  It returns NULL
 212    on network directories, so we handle that case here.
 213    (Ulrich Leodolter, 1/11/95).  */
 214 char *
 215 sys_ctime (const time_t *t)
 216 {
 217   char *str = (char *) ctime (t);
 218   return (str ? str : "Sun Jan 01 00:00:00 1970");
 219 }
 220
 221 FILE *
 222 sys_fopen (const char * path, const char * mode)
 223 {
 224   return fopen (path, mode);
 225 }
 226
 227 int
 228 sys_chdir (const char * path)
 229 {
 230   return _chdir (path);
 231 }
 232
 233 static FILETIME utc_base_ft;
 234 static long double utc_base;
 235 static int init = 0;
 236
 237 static time_t
 238 convert_time (FILETIME ft)
 239 {
 240   long double ret;
 241
 242   if (CompareFileTime (&ft, &utc_base_ft) < 0)
 243     return 0;
 244
 245   ret = (long double) ft.dwHighDateTime
 246     * 4096.0L * 1024.0L * 1024.0L + ft.dwLowDateTime;
 247   ret -= utc_base;
 248   return (time_t) (ret * 1e-7L);
 249 }
 250
 251 static int
 252 is_exec (const char * name)
 253 {
 254   char * p = strrchr (name, '.');
 255   return
 256     (p != NULL
 257      && (stricmp (p, ".exe") == 0 ||
 258          stricmp (p, ".com") == 0 ||
 259          stricmp (p, ".bat") == 0 ||
 260          stricmp (p, ".cmd") == 0));
 261 }
 262
 263 #define IS_DIRECTORY_SEP(x) ((x) == '/' || (x) == '\\')
 264
 265 /* We need this because nt/inc/sys/stat.h defines struct stat that is
 266    incompatible with the MS run-time libraries.  */
 267 int
 268 stat (const char * path, struct stat * buf)
 269 {
 270   WIN32_FIND_DATA wfd;
 271   HANDLE fh;
 272   int permission;
 273   int len;
 274   int rootdir = FALSE;
 275   char *name = alloca (FILENAME_MAX);
 276
 277   if (!init)
 278     {
 279       /* Determine the delta between 1-Jan-1601 and 1-Jan-1970. */
 280       SYSTEMTIME st;
 281
 282       st.wYear = 1970;
 283       st.wMonth = 1;
 284       st.wDay = 1;
 285       st.wHour = 0;
 286       st.wMinute = 0;
 287       st.wSecond = 0;
 288       st.wMilliseconds = 0;
 289
 290       SystemTimeToFileTime (&st, &utc_base_ft);
 291       utc_base = (long double) utc_base_ft.dwHighDateTime
 292         * 4096.0L * 1024.0L * 1024.0L + utc_base_ft.dwLowDateTime;
 293       init = 1;
 294     }
 295
 296   if (path == NULL || buf == NULL || *path == '\0')
 297     {
 298       errno = EFAULT;
 299       return -1;
 300     }
 301   if (_mbspbrk (path, "*?|<>\""))
 302     {
 303       errno = ENOENT;
 304       return -1;
 305     }
 306
 307   strcpy (name, path);
 308   /* Remove trailing directory separator, unless name is the root
 309      directory of a drive in which case ensure there is a trailing
 310      separator. */
 311   len = strlen (name);
 312   rootdir = IS_DIRECTORY_SEP (name[0])
 313     || (len == 3 && name[1] == ':' && IS_DIRECTORY_SEP (name[2]));
 314   if (rootdir)
 315     {
 316       if (GetDriveType (name) < 2)
 317         {
 318           errno = ENOENT;
 319           return -1;
 320         }
 321       memset (&wfd, 0, sizeof (wfd));
 322       wfd.dwFileAttributes = FILE_ATTRIBUTE_DIRECTORY;
 323       wfd.ftCreationTime = utc_base_ft;
 324       wfd.ftLastAccessTime = utc_base_ft;
 325       wfd.ftLastWriteTime = utc_base_ft;
 326       strcpy (wfd.cFileName, name);
 327     }
 328   else
 329     {
 330       if (IS_DIRECTORY_SEP (name[len-1]))
 331         name[len - 1] = 0;
 332
 333       fh = FindFirstFile (name, &wfd);
 334       if (fh == INVALID_HANDLE_VALUE)
 335         {
 336           errno = ENOENT;
 337           return -1;
 338         }
 339       FindClose (fh);
 340     }
 341   buf->st_mode = (wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) ?
 342     S_IFDIR : S_IFREG;
 343   buf->st_nlink = 1;
 344   buf->st_ino = 0;
 345
 346   if (name[0] && name[1] == ':')
 347     buf->st_dev = tolower (name[0]) - 'a' + 1;
 348   else
 349     buf->st_dev = _getdrive ();
 350   buf->st_rdev = buf->st_dev;
 351
 352   buf->st_size = wfd.nFileSizeLow;
 353
 354   /* Convert timestamps to Unix format. */
 355   buf->st_mtime = convert_time (wfd.ftLastWriteTime);
 356   buf->st_atime = convert_time (wfd.ftLastAccessTime);
 357   if (buf->st_atime == 0) buf->st_atime = buf->st_mtime;
 358   buf->st_ctime = convert_time (wfd.ftCreationTime);
 359   if (buf->st_ctime == 0) buf->st_ctime = buf->st_mtime;
 360
 361   /* determine rwx permissions */
 362   if (wfd.dwFileAttributes & FILE_ATTRIBUTE_READONLY)
 363     permission = S_IREAD;
 364   else
 365     permission = S_IREAD | S_IWRITE;
 366
 367   if (wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
 368     permission |= S_IEXEC;
 369   else if (is_exec (name))
 370     permission |= S_IEXEC;
 371
 372   buf->st_mode |= permission | (permission >> 3) | (permission >> 6);
 373
 374   return 0;
 375 }
 376