src/w32.c

   1 /* Utility and Unix shadow routines for GNU Emacs on Windows NT.
   2    Copyright (C) 1994 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 it
   7    under the terms of the GNU General Public License as published by the
   8    Free Software Foundation; either version 1, or (at your option) any later
   9    version.
  10
  11    GNU Emacs is distributed in the hope that it will be useful, but WITHOUT
  12    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  14    more details.
  15
  16    You should have received a copy of the GNU General Public License along
  17    with GNU Emacs; see the file COPYING.  If not, write to the Free Software
  18    Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  19
  20    Geoff Voelker (voelker@cs.washington.edu)                         7-29-94
  21 */
  22
  23 #include <windows.h>
  24 #include <stdlib.h>
  25 #include <stdio.h>
  26 #include <io.h>
  27 #include <fcntl.h>
  28 #include <ctype.h>
  29
  30 #include "config.h"
  31 #define getwd _getwd
  32 #include "lisp.h"
  33 #undef getwd
  34
  35 #include <pwd.h>
  36
  37 #include "ndir.h"
  38 #include "ntheap.h"
  39
  40 extern int report_file_error (char *, Lisp_Object);
  41
  42 /* Get the current working directory.  */
  43 int
  44 getwd (char *dir)
  45 {
  46   return GetCurrentDirectory (MAXPATHLEN, dir);
  47 }
  48
  49 /* Emulate gethostname.  */
  50 int
  51 gethostname (char *buffer, int size)
  52 {
  53   /* NT only allows small host names, so the buffer is
  54      certainly large enough.  */
  55   return !GetComputerName (buffer, &size);
  56 }
  57
  58 /* Emulate getloadavg.  */
  59 int
  60 getloadavg (double loadavg[], int nelem)
  61 {
  62   int i;
  63
  64   /* A faithful emulation is going to have to be saved for a rainy day.  */
  65   for (i = 0; i < nelem; i++)
  66     {
  67       loadavg[i] = 0.0;
  68     }
  69   return i;
  70 }
  71
  72 /* Emulate sleep...we could have done this with a define, but that
  73    would necessitate including windows.h in the files that used it.
  74    This is much easier.  */
  75 void
  76 nt_sleep (int seconds)
  77 {
  78   Sleep (seconds * 1000);
  79 }
  80
  81 /* Emulate the Unix directory procedures opendir, closedir,
  82    and readdir.  We can't use the procedures supplied in sysdep.c,
  83    so we provide them here.  */
  84
  85 struct direct dir_static;       /* simulated directory contents */
  86 static int    dir_finding;
  87 static HANDLE dir_find_handle;
  88
  89 DIR *
  90 opendir (char *filename)
  91 {
  92   DIR *dirp;
  93
  94   /* Opening is done by FindFirstFile.  However, a read is inherent to
  95      this operation, so we have a flag to handle the open at read
  96      time.  This flag essentially means "there is a find-handle open and
  97      it needs to be closed."  */
  98
  99   if (!(dirp = (DIR *) malloc (sizeof (DIR))))
 100     {
 101       return 0;
 102     }
 103
 104   dirp->dd_fd = 0;
 105   dirp->dd_loc = 0;
 106   dirp->dd_size = 0;
 107
 108   /* This is tacky, but we need the directory name for our
 109      implementation of readdir.  */
 110   strncpy (dirp->dd_buf, filename, DIRBLKSIZ);
 111   return dirp;
 112 }
 113
 114 void
 115 closedir (DIR *dirp)
 116 {
 117   /* If we have a find-handle open, close it.  */
 118   if (dir_finding)
 119     {
 120       FindClose (dir_find_handle);
 121       dir_finding = 0;
 122     }
 123   xfree ((char *) dirp);
 124 }
 125
 126 struct direct *
 127 readdir (DIR *dirp)
 128 {
 129   WIN32_FIND_DATA find_data;
 130
 131   /* If we aren't dir_finding, do a find-first, otherwise do a find-next. */
 132   if (!dir_finding)
 133     {
 134       char filename[MAXNAMLEN + 3];
 135       int ln;
 136
 137       strncpy (filename, dirp->dd_buf, MAXNAMLEN);
 138       ln = strlen (filename)-1;
 139       if (filename[ln] != '\\' && filename[ln] != ':')
 140         strcat (filename, "\\");
 141       strcat (filename, "*.*");
 142
 143       dir_find_handle = FindFirstFile (filename, &find_data);
 144
 145       if (dir_find_handle == INVALID_HANDLE_VALUE)
 146         return NULL;
 147
 148       dir_finding = 1;
 149     }
 150   else
 151     {
 152       if (!FindNextFile (dir_find_handle, &find_data))
 153         return NULL;
 154     }
 155
 156   /* Don't return . or .. since it doesn't look like any of the
 157      readdir calling code expects them.  */
 158   while (strcmp (find_data.cFileName, ".") == 0
 159          || strcmp (find_data.cFileName, "..") == 0)
 160     {
 161       if (!FindNextFile (dir_find_handle, &find_data))
 162         return 0;
 163     }
 164
 165   /* NT's unique ID for a file is 64 bits, so we have to fake it here.
 166      This should work as long as we never use 0.  */
 167   dir_static.d_ino = 1;
 168
 169   dir_static.d_reclen = sizeof (struct direct) - MAXNAMLEN + 3 +
 170     dir_static.d_namlen - dir_static.d_namlen % 4;
 171
 172   dir_static.d_namlen = strlen (find_data.cFileName);
 173   strncpy (dir_static.d_name, find_data.cFileName, MAXNAMLEN);
 174
 175   return &dir_static;
 176 }
 177
 178 /* Emulate getpwuid and getpwnam.  */
 179
 180 int getuid ();  /* forward declaration */
 181
 182 static char the_passwd_name[256];
 183 static char the_passwd_passwd[256];
 184 static char the_passwd_gecos[256];
 185 static char the_passwd_dir[256];
 186 static char the_passwd_shell[256];
 187
 188 static struct passwd the_passwd =
 189 {
 190   the_passwd_name,
 191   the_passwd_passwd,
 192   0,
 193   0,
 194   0,
 195   the_passwd_gecos,
 196   the_passwd_dir,
 197   the_passwd_shell,
 198 };
 199
 200 struct passwd *
 201 getpwuid (int uid)
 202 {
 203   int size = 256;
 204
 205   if (!GetUserName (the_passwd.pw_name, &size))
 206     return NULL;
 207
 208   the_passwd.pw_passwd[0] = '\0';
 209   the_passwd.pw_uid = 0;
 210   the_passwd.pw_gid = 0;
 211   strcpy (the_passwd.pw_gecos, the_passwd.pw_name);
 212   the_passwd.pw_dir[0] = '\0';
 213   the_passwd.pw_shell[0] = '\0';
 214
 215   return &the_passwd;
 216 }
 217
 218 struct passwd *
 219 getpwnam (char *name)
 220 {
 221   struct passwd *pw;
 222
 223   pw = getpwuid (getuid ());
 224   if (!pw)
 225     return pw;
 226
 227   if (strcmp (name, pw->pw_name))
 228     return NULL;
 229
 230   return pw;
 231 }
 232
 233
 234 /* We don't have scripts to automatically determine the system configuration
 235    for Emacs before it's compiled, and we don't want to have to make the
 236    user enter it, so we define EMACS_CONFIGURATION to invoke this runtime
 237    routine.  */
 238
 239 static char configuration_buffer[16];
 240
 241 char *
 242 get_emacs_configuration (void)
 243 {
 244     char *arch, *oem;
 245
 246     /* Determine the processor type.  */
 247     switch (get_processor_type ())
 248       {
 249       case PROCESSOR_INTEL_386:
 250       case PROCESSOR_INTEL_486:
 251       case PROCESSOR_INTEL_PENTIUM:
 252         arch = "i386";
 253         break;
 254       case PROCESSOR_INTEL_860:
 255         arch = "i860";
 256         break;
 257       case PROCESSOR_MIPS_R2000:
 258       case PROCESSOR_MIPS_R3000:
 259       case PROCESSOR_MIPS_R4000:
 260         arch = "mips";
 261         break;
 262       case PROCESSOR_ALPHA_21064:
 263         arch = "alpha";
 264         break;
 265       default:
 266         arch = "unknown";
 267         break;
 268       }
 269
 270     /* Let oem be "*" until we figure out how to decode the OEM field.  */
 271     oem = "*";
 272
 273     sprintf (configuration_buffer, "%s-%s-nt%d.%d", arch, oem,
 274              get_nt_major_version (), get_nt_minor_version ());
 275     return configuration_buffer;
 276 }
 277
 278 /* Conjure up inode and device numbers that will serve the purpose
 279    of Emacs.  Return 1 upon success, 0 upon failure.  */
 280 int
 281 get_inode_and_device_vals (Lisp_Object filename, Lisp_Object *p_inode,
 282                            Lisp_Object *p_device)
 283 {
 284   /* File uids on NT are found using a handle to a file, which
 285      implies that it has been opened.  Since we want to be able
 286      to stat an arbitrary file, we must open it, get the info,
 287      and then close it.
 288
 289      Also, NT file uids are 64-bits.  This is a problem.  */
 290
 291   HANDLE handle;
 292   BOOL result;
 293   BY_HANDLE_FILE_INFORMATION info;
 294
 295   /* FIXME:  It shouldn't be opened without READ access, but NT on x86
 296      doesn't allow GetFileInfo in that case (NT on mips does).  */
 297
 298   handle = CreateFile (XSTRING (filename)->data,
 299                        GENERIC_READ,
 300                        FILE_SHARE_READ | FILE_SHARE_WRITE,
 301                        NULL,
 302                        OPEN_EXISTING,
 303                        FILE_ATTRIBUTE_NORMAL,
 304                        NULL);
 305   if (handle == INVALID_HANDLE_VALUE)
 306     return 0;
 307
 308   result = GetFileInformationByHandle (handle, &info);
 309   CloseHandle (handle);
 310   if (!result)
 311     return 0;
 312
 313   *p_inode = make_number (info.nFileIndexLow);          /* use the low value */
 314   *p_device = make_number (info.dwVolumeSerialNumber);
 315
 316   return 1;
 317 }
 318
 319 /* The following pipe routines are used to support our fork emulation.
 320    Since NT's crt dup always creates inherited handles, we
 321    must be careful in setting up pipes.  First create
 322    non-inherited pipe handles, then create an inherited handle
 323    to the write end by dup-ing it, and then close the non-inherited
 324    end that was just duped.  This gives us one non-inherited handle
 325    on the read end and one inherited handle to the write end.  As
 326    the parent, we close the inherited handle to the write end after
 327    spawning the child.  */
 328
 329 /* From callproc.c  */
 330 extern Lisp_Object Vbinary_process_input;
 331 extern Lisp_Object Vbinary_process_output;
 332
 333 void
 334 pipe_with_inherited_out (int fds[2])
 335 {
 336   int inherit_out;
 337   unsigned int flags = _O_NOINHERIT;
 338
 339   if (!NILP (Vbinary_process_output))
 340     flags |= _O_BINARY;
 341
 342   _pipe (fds, 0, flags);
 343   inherit_out = dup (fds[1]);
 344   close (fds[1]);
 345   fds[1] = inherit_out;
 346 }
 347
 348 void
 349 pipe_with_inherited_in (int fds[2])
 350 {
 351   int inherit_in;
 352   unsigned int flags = _O_NOINHERIT;
 353
 354   if (!NILP (Vbinary_process_input))
 355     flags |= _O_BINARY;
 356
 357   _pipe (fds, 0, flags);
 358   inherit_in = dup (fds[0]);
 359   close (fds[0]);
 360   fds[0] = inherit_in;
 361 }
 362
 363 /* The following two routines are used to manipulate stdin, stdout, and
 364    stderr of our child processes.
 365
 366    Assuming that in, out, and err are inherited, we make them stdin,
 367    stdout, and stderr of the child as follows:
 368
 369    - Save the parent's current standard handles.
 370    - Set the parent's standard handles to the handles being passed in.
 371      (Note that _get_osfhandle is an io.h procedure that
 372      maps crt file descriptors to NT file handles.)
 373    - Spawn the child, which inherits in, out, and err as stdin,
 374      stdout, and stderr. (see Spawnve)
 375    - Reset the parent's standard handles to the saved handles.
 376      (see reset_standard_handles)
 377    We assume that the caller closes in, out, and err after calling us.  */
 378
 379 void
 380 prepare_standard_handles (int in, int out, int err, HANDLE handles[4])
 381 {
 382   HANDLE parent, stdin_save, stdout_save, stderr_save, err_handle;
 383
 384   parent = GetCurrentProcess ();
 385   if (!DuplicateHandle (parent,
 386                        GetStdHandle (STD_INPUT_HANDLE),
 387                        parent,
 388                        &stdin_save,
 389                        0,
 390                        FALSE,
 391                        DUPLICATE_SAME_ACCESS))
 392     report_file_error ("Duplicating parent's input handle", Qnil);
 393
 394   if (!DuplicateHandle (parent,
 395                        GetStdHandle (STD_OUTPUT_HANDLE),
 396                        parent,
 397                        &stdout_save,
 398                        0,
 399                        FALSE,
 400                        DUPLICATE_SAME_ACCESS))
 401     report_file_error ("Duplicating parent's output handle", Qnil);
 402
 403   if (!DuplicateHandle (parent,
 404                        GetStdHandle (STD_ERROR_HANDLE),
 405                        parent,
 406                        &stderr_save,
 407                        0,
 408                        FALSE,
 409                        DUPLICATE_SAME_ACCESS))
 410     report_file_error ("Duplicating parent's error handle", Qnil);
 411
 412   if (!SetStdHandle (STD_INPUT_HANDLE, (HANDLE) _get_osfhandle (in)))
 413     report_file_error ("Changing stdin handle", Qnil);
 414
 415   if (!SetStdHandle (STD_OUTPUT_HANDLE, (HANDLE) _get_osfhandle (out)))
 416     report_file_error ("Changing stdout handle", Qnil);
 417
 418   /* We lose data if we use the same handle to the pipe for stdout and
 419      stderr, so make a duplicate.  This took a while to find.  */
 420   if (out == err)
 421     {
 422       if (!DuplicateHandle (parent,
 423                            (HANDLE) _get_osfhandle (err),
 424                            parent,
 425                            &err_handle,
 426                            0,
 427                            TRUE,
 428                            DUPLICATE_SAME_ACCESS))
 429         report_file_error ("Duplicating out handle to make err handle.",
 430                           Qnil);
 431     }
 432   else
 433     {
 434       err_handle = (HANDLE) _get_osfhandle (err);
 435     }
 436
 437   if (!SetStdHandle (STD_ERROR_HANDLE, err_handle))
 438     report_file_error ("Changing stderr handle", Qnil);
 439
 440   handles[0] = stdin_save;
 441   handles[1] = stdout_save;
 442   handles[2] = stderr_save;
 443   handles[3] = err_handle;
 444 }
 445
 446 void
 447 reset_standard_handles (int in, int out, int err, HANDLE handles[4])
 448 {
 449   HANDLE stdin_save = handles[0];
 450   HANDLE stdout_save = handles[1];
 451   HANDLE stderr_save = handles[2];
 452   HANDLE err_handle = handles[3];
 453
 454   if (!SetStdHandle (STD_INPUT_HANDLE, stdin_save))
 455     report_file_error ("Resetting input handle", Qnil);
 456
 457   if (!SetStdHandle (STD_OUTPUT_HANDLE, stdout_save))
 458     report_file_error ("Resetting output handle", Qnil);
 459
 460   if (!SetStdHandle (STD_ERROR_HANDLE, stderr_save))
 461     report_file_error ("Resetting error handle", Qnil);
 462
 463   if (out == err)
 464     {
 465       /* If out and err are the same handle, then we duplicated out
 466          and stuck it in err_handle.  Close the duplicate to clean up.  */
 467       if (!CloseHandle (err_handle))
 468         report_file_error ("Closing error handle duplicated from out.",
 469                           Qnil);
 470     }
 471 }
 472
 473 /* Destructively turn backslashes into slashes.  */
 474 void
 475 dostounix_filename (p)
 476      register char *p;
 477 {
 478   while (*p)
 479     {
 480       if (*p == '\\')
 481         *p = '/';
 482       p++;
 483     }
 484 }
 485
 486 /* Routines that are no-ops on NT but are defined to get Emacs to compile.  */
 487
 488
 489 int
 490 sigsetmask (int signal_mask)
 491 {
 492   return 0;
 493 }
 494
 495 int
 496 sigblock (int sig)
 497 {
 498   return 0;
 499 }
 500
 501 int
 502 kill (int pid, int signal)
 503 {
 504   return 0;
 505 }
 506
 507 int
 508 setpgrp (int pid, int gid)
 509 {
 510   return 0;
 511 }
 512
 513 int
 514 alarm (int seconds)
 515 {
 516   return 0;
 517 }
 518
 519 int
 520 unrequest_sigio (void)
 521 {
 522   return 0;
 523 }
 524
 525 int
 526 request_sigio (void)
 527 {
 528   return 0;
 529 }
 530
 531 int
 532 getuid ()
 533 {
 534   return 0;
 535 }
 536
 537 int
 538 geteuid ()
 539 {
 540   return 0;
 541 }
 542
 543 /* Remove all CR's that are followed by a LF.
 544    (From msdos.c...probably should figure out a way to share it,
 545    although this code isn't going to ever change.)  */
 546 int
 547 crlf_to_lf (n, buf)
 548      register int n;
 549      register unsigned char *buf;
 550 {
 551   unsigned char *np = buf;
 552   unsigned char *startp = buf;
 553   unsigned char *endp = buf + n;
 554
 555   if (n == 0)
 556     return n;
 557   while (buf < endp - 1)
 558     {
 559       if (*buf == 0x0d)
 560         {
 561           if (*(++buf) != 0x0a)
 562             *np++ = 0x0d;
 563         }
 564       else
 565         *np++ = *buf++;
 566     }
 567   if (buf < endp)
 568     *np++ = *buf++;
 569   return np - startp;
 570 }
 571
 572
 573 #ifdef PIGSFLY
 574 Keep this around...we might need it later.
 575 #ifdef WINDOWSNT
 576 {
 577   /*
 578    * Find the user's real name by opening the process token and looking
 579    * up the name associated with the user-sid in that token.
 580    */
 581
 582   char            b[256], Name[256], RefD[256];
 583   DWORD           length = 256, rlength = 256, trash;
 584   HANDLE          Token;
 585   SID_NAME_USE    User;
 586
 587   if (1)
 588     Vuser_real_name = build_string ("foo");
 589   else if (!OpenProcessToken (GetCurrentProcess (), TOKEN_QUERY, &Token))
 590     {
 591       Vuser_real_name = build_string ("unknown");
 592     }
 593   else if (!GetTokenInformation (Token, TokenUser, (PVOID)b, 256,
 594                                  &trash))
 595     {
 596       CloseHandle (Token);
 597       Vuser_real_name = build_string ("unknown");
 598     }
 599   else if (!LookupAccountSid ((void *)0, (PSID)b, Name, &length, RefD,
 600                               &rlength, &User))
 601     {
 602       CloseHandle (Token);
 603       Vuser_real_name = build_string ("unknown");
 604     }
 605   else
 606     Vuser_real_name = build_string (Name);
 607 }
 608 #else   /* not WINDOWSNT */
 609 #endif  /* not WINDOWSNT */
 610 #endif  /* PIGSFLY */