lib-src/ntlib.c

   1 /* Utility and Unix shadow routines for GNU Emacs support programs on NT.
   2
   3 Copyright (C) 1994, 2001-2012 Free Software Foundation, Inc.
   4
   5 Author: Geoff Voelker (voelker@cs.washington.edu)
   6 Created: 10-8-94
   7
   8 This file is part of GNU Emacs.
   9
  10 GNU Emacs is free software: you can redistribute it and/or modify
  11 it under the terms of the GNU General Public License as published by
  12 the Free Software Foundation, either version 3 of the License, or
  13 (at your option) any later version.
  14
  15 GNU Emacs is distributed in the hope that it will be useful,
  16 but WITHOUT ANY WARRANTY; without even the implied warranty of
  17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18 GNU General Public License for more details.
  19
  20 You should have received a copy of the GNU General Public License
  21 along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
  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 /* FIXME?  This is in config.nt now - is this still needed?  */
 264 #define IS_DIRECTORY_SEP(x) ((x) == '/' || (x) == '\\')
 265
 266 /* We need this because nt/inc/sys/stat.h defines struct stat that is
 267    incompatible with the MS run-time libraries.  */
 268 int
 269 stat (const char * path, struct stat * buf)
 270 {
 271   WIN32_FIND_DATA wfd;
 272   HANDLE fh;
 273   int permission;
 274   int len;
 275   int rootdir = FALSE;
 276   char *name = alloca (FILENAME_MAX);
 277
 278   if (!init)
 279     {
 280       /* Determine the delta between 1-Jan-1601 and 1-Jan-1970. */
 281       SYSTEMTIME st;
 282
 283       st.wYear = 1970;
 284       st.wMonth = 1;
 285       st.wDay = 1;
 286       st.wHour = 0;
 287       st.wMinute = 0;
 288       st.wSecond = 0;
 289       st.wMilliseconds = 0;
 290
 291       SystemTimeToFileTime (&st, &utc_base_ft);
 292       utc_base = (long double) utc_base_ft.dwHighDateTime
 293         * 4096.0L * 1024.0L * 1024.0L + utc_base_ft.dwLowDateTime;
 294       init = 1;
 295     }
 296
 297   if (path == NULL || buf == NULL || *path == '\0')
 298     {
 299       errno = EFAULT;
 300       return -1;
 301     }
 302   if (_mbspbrk (path, "*?|<>\""))
 303     {
 304       errno = ENOENT;
 305       return -1;
 306     }
 307
 308   strcpy (name, path);
 309   /* Remove trailing directory separator, unless name is the root
 310      directory of a drive in which case ensure there is a trailing
 311      separator. */
 312   len = strlen (name);
 313   rootdir = IS_DIRECTORY_SEP (name[0])
 314     || (len == 3 && name[1] == ':' && IS_DIRECTORY_SEP (name[2]));
 315   if (rootdir)
 316     {
 317       if (GetDriveType (name) < 2)
 318         {
 319           errno = ENOENT;
 320           return -1;
 321         }
 322       memset (&wfd, 0, sizeof (wfd));
 323       wfd.dwFileAttributes = FILE_ATTRIBUTE_DIRECTORY;
 324       wfd.ftCreationTime = utc_base_ft;
 325       wfd.ftLastAccessTime = utc_base_ft;
 326       wfd.ftLastWriteTime = utc_base_ft;
 327       strcpy (wfd.cFileName, name);
 328     }
 329   else
 330     {
 331       if (IS_DIRECTORY_SEP (name[len-1]))
 332         name[len - 1] = 0;
 333
 334       fh = FindFirstFile (name, &wfd);
 335       if (fh == INVALID_HANDLE_VALUE)
 336         {
 337           errno = ENOENT;
 338           return -1;
 339         }
 340       FindClose (fh);
 341     }
 342   buf->st_mode = (wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) ?
 343     S_IFDIR : S_IFREG;
 344   buf->st_nlink = 1;
 345   buf->st_ino = 0;
 346
 347   if (name[0] && name[1] == ':')
 348     buf->st_dev = tolower (name[0]) - 'a' + 1;
 349   else
 350     buf->st_dev = _getdrive ();
 351   buf->st_rdev = buf->st_dev;
 352
 353   buf->st_size = wfd.nFileSizeLow;
 354
 355   /* Convert timestamps to Unix format. */
 356   buf->st_mtime = convert_time (wfd.ftLastWriteTime);
 357   buf->st_atime = convert_time (wfd.ftLastAccessTime);
 358   if (buf->st_atime == 0) buf->st_atime = buf->st_mtime;
 359   buf->st_ctime = convert_time (wfd.ftCreationTime);
 360   if (buf->st_ctime == 0) buf->st_ctime = buf->st_mtime;
 361
 362   /* determine rwx permissions */
 363   if (wfd.dwFileAttributes & FILE_ATTRIBUTE_READONLY)
 364     permission = S_IREAD;
 365   else
 366     permission = S_IREAD | S_IWRITE;
 367
 368   if (wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
 369     permission |= S_IEXEC;
 370   else if (is_exec (name))
 371     permission |= S_IEXEC;
 372
 373   buf->st_mode |= permission | (permission >> 3) | (permission >> 6);
 374
 375   return 0;
 376 }
 377
 378 int
 379 lstat (const char * path, struct stat * buf)
 380 {
 381   return stat (path, buf);
 382 }
 383