*** empty log message ***
[emacs.git] / src / w32.c
blob98d630529e6001e7f49d556f84f45d74e1b38dfc
1 /* Utility and Unix shadow routines for GNU Emacs on the Microsoft W32 API.
2 Copyright (C) 1994, 1995, 2000, 2001 Free Software Foundation, Inc.
4 This file is part of GNU Emacs.
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 2, or (at your option)
9 any later version.
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.
16 You should have received a copy of the GNU General Public License
17 along with GNU Emacs; see the file COPYING. If not, write to
18 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA.
21 Geoff Voelker (voelker@cs.washington.edu) 7-29-94
25 #include <stddef.h> /* for offsetof */
26 #include <stdlib.h>
27 #include <stdio.h>
28 #include <io.h>
29 #include <errno.h>
30 #include <fcntl.h>
31 #include <ctype.h>
32 #include <signal.h>
33 #include <sys/file.h>
34 #include <sys/time.h>
35 #include <sys/utime.h>
37 /* must include CRT headers *before* config.h */
39 #ifdef HAVE_CONFIG_H
40 #include <config.h>
41 #endif
43 #undef access
44 #undef chdir
45 #undef chmod
46 #undef creat
47 #undef ctime
48 #undef fopen
49 #undef link
50 #undef mkdir
51 #undef mktemp
52 #undef open
53 #undef rename
54 #undef rmdir
55 #undef unlink
57 #undef close
58 #undef dup
59 #undef dup2
60 #undef pipe
61 #undef read
62 #undef write
64 #undef strerror
66 #include "lisp.h"
68 #include <pwd.h>
69 #include <grp.h>
71 #ifdef __GNUC__
72 #define _ANONYMOUS_UNION
73 #define _ANONYMOUS_STRUCT
74 #endif
75 #include <windows.h>
77 #ifdef HAVE_SOCKETS /* TCP connection support, if kernel can do it */
78 #include <sys/socket.h>
79 #undef socket
80 #undef bind
81 #undef connect
82 #undef htons
83 #undef ntohs
84 #undef inet_addr
85 #undef gethostname
86 #undef gethostbyname
87 #undef getservbyname
88 #undef getpeername
89 #undef shutdown
90 #undef setsockopt
91 #undef listen
92 #undef getsockname
93 #undef accept
94 #undef recvfrom
95 #undef sendto
96 #endif
98 #include "w32.h"
99 #include "ndir.h"
100 #include "w32heap.h"
101 #include "systime.h"
103 void globals_of_w32 ();
105 extern Lisp_Object Vw32_downcase_file_names;
106 extern Lisp_Object Vw32_generate_fake_inodes;
107 extern Lisp_Object Vw32_get_true_file_attributes;
108 extern Lisp_Object Vw32_num_mouse_buttons;
112 Initialization states
114 static BOOL g_b_init_is_windows_9x;
115 static BOOL g_b_init_open_process_token;
116 static BOOL g_b_init_get_token_information;
117 static BOOL g_b_init_lookup_account_sid;
118 static BOOL g_b_init_get_sid_identifier_authority;
121 BEGIN: Wrapper functions around OpenProcessToken
122 and other functions in advapi32.dll that are only
123 supported in Windows NT / 2k / XP
125 /* ** Function pointer typedefs ** */
126 typedef BOOL (WINAPI * OpenProcessToken_Proc) (
127 HANDLE ProcessHandle,
128 DWORD DesiredAccess,
129 PHANDLE TokenHandle);
130 typedef BOOL (WINAPI * GetTokenInformation_Proc) (
131 HANDLE TokenHandle,
132 TOKEN_INFORMATION_CLASS TokenInformationClass,
133 LPVOID TokenInformation,
134 DWORD TokenInformationLength,
135 PDWORD ReturnLength);
136 #ifdef _UNICODE
137 const char * const LookupAccountSid_Name = "LookupAccountSidW";
138 #else
139 const char * const LookupAccountSid_Name = "LookupAccountSidA";
140 #endif
141 typedef BOOL (WINAPI * LookupAccountSid_Proc) (
142 LPCTSTR lpSystemName,
143 PSID Sid,
144 LPTSTR Name,
145 LPDWORD cbName,
146 LPTSTR DomainName,
147 LPDWORD cbDomainName,
148 PSID_NAME_USE peUse);
149 typedef PSID_IDENTIFIER_AUTHORITY (WINAPI * GetSidIdentifierAuthority_Proc) (
150 PSID pSid);
152 /* ** A utility function ** */
153 static BOOL is_windows_9x ()
155 static BOOL s_b_ret=0;
156 OSVERSIONINFO os_ver;
157 if (g_b_init_is_windows_9x == 0)
159 g_b_init_is_windows_9x = 1;
160 ZeroMemory(&os_ver, sizeof(OSVERSIONINFO));
161 os_ver.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
162 if (GetVersionEx (&os_ver))
164 s_b_ret = (os_ver.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS);
167 return s_b_ret;
170 /* ** The wrapper functions ** */
172 BOOL WINAPI open_process_token (
173 HANDLE ProcessHandle,
174 DWORD DesiredAccess,
175 PHANDLE TokenHandle)
177 static OpenProcessToken_Proc s_pfn_Open_Process_Token = NULL;
178 HMODULE hm_advapi32 = NULL;
179 if (is_windows_9x () == TRUE)
181 return FALSE;
183 if (g_b_init_open_process_token == 0)
185 g_b_init_open_process_token = 1;
186 hm_advapi32 = LoadLibrary ("Advapi32.dll");
187 s_pfn_Open_Process_Token =
188 (OpenProcessToken_Proc) GetProcAddress (hm_advapi32, "OpenProcessToken");
190 if (s_pfn_Open_Process_Token == NULL)
192 return FALSE;
194 return (
195 s_pfn_Open_Process_Token (
196 ProcessHandle,
197 DesiredAccess,
198 TokenHandle)
202 BOOL WINAPI get_token_information (
203 HANDLE TokenHandle,
204 TOKEN_INFORMATION_CLASS TokenInformationClass,
205 LPVOID TokenInformation,
206 DWORD TokenInformationLength,
207 PDWORD ReturnLength)
209 static GetTokenInformation_Proc s_pfn_Get_Token_Information = NULL;
210 HMODULE hm_advapi32 = NULL;
211 if (is_windows_9x () == TRUE)
213 return FALSE;
215 if (g_b_init_get_token_information == 0)
217 g_b_init_get_token_information = 1;
218 hm_advapi32 = LoadLibrary ("Advapi32.dll");
219 s_pfn_Get_Token_Information =
220 (GetTokenInformation_Proc) GetProcAddress (hm_advapi32, "GetTokenInformation");
222 if (s_pfn_Get_Token_Information == NULL)
224 return FALSE;
226 return (
227 s_pfn_Get_Token_Information (
228 TokenHandle,
229 TokenInformationClass,
230 TokenInformation,
231 TokenInformationLength,
232 ReturnLength)
236 BOOL WINAPI lookup_account_sid (
237 LPCTSTR lpSystemName,
238 PSID Sid,
239 LPTSTR Name,
240 LPDWORD cbName,
241 LPTSTR DomainName,
242 LPDWORD cbDomainName,
243 PSID_NAME_USE peUse)
245 static LookupAccountSid_Proc s_pfn_Lookup_Account_Sid = NULL;
246 HMODULE hm_advapi32 = NULL;
247 if (is_windows_9x () == TRUE)
249 return FALSE;
251 if (g_b_init_lookup_account_sid == 0)
253 g_b_init_lookup_account_sid = 1;
254 hm_advapi32 = LoadLibrary ("Advapi32.dll");
255 s_pfn_Lookup_Account_Sid =
256 (LookupAccountSid_Proc) GetProcAddress (hm_advapi32, LookupAccountSid_Name);
258 if (s_pfn_Lookup_Account_Sid == NULL)
260 return FALSE;
262 return (
263 s_pfn_Lookup_Account_Sid (
264 lpSystemName,
265 Sid,
266 Name,
267 cbName,
268 DomainName,
269 cbDomainName,
270 peUse)
274 PSID_IDENTIFIER_AUTHORITY WINAPI get_sid_identifier_authority (
275 PSID pSid)
277 static GetSidIdentifierAuthority_Proc s_pfn_Get_Sid_Identifier_Authority = NULL;
278 HMODULE hm_advapi32 = NULL;
279 if (is_windows_9x () == TRUE)
281 return NULL;
283 if (g_b_init_get_sid_identifier_authority == 0)
285 g_b_init_get_sid_identifier_authority = 1;
286 hm_advapi32 = LoadLibrary ("Advapi32.dll");
287 s_pfn_Get_Sid_Identifier_Authority =
288 (GetSidIdentifierAuthority_Proc) GetProcAddress (
289 hm_advapi32, "GetSidIdentifierAuthority");
291 if (s_pfn_Get_Sid_Identifier_Authority == NULL)
293 return NULL;
295 return (s_pfn_Get_Sid_Identifier_Authority (pSid));
299 END: Wrapper functions around OpenProcessToken
300 and other functions in advapi32.dll that are only
301 supported in Windows NT / 2k / XP
305 /* Equivalent of strerror for W32 error codes. */
306 char *
307 w32_strerror (int error_no)
309 static char buf[500];
311 if (error_no == 0)
312 error_no = GetLastError ();
314 buf[0] = '\0';
315 if (!FormatMessage (FORMAT_MESSAGE_FROM_SYSTEM, NULL,
316 error_no,
317 0, /* choose most suitable language */
318 buf, sizeof (buf), NULL))
319 sprintf (buf, "w32 error %u", error_no);
320 return buf;
323 static char startup_dir[MAXPATHLEN];
325 /* Get the current working directory. */
326 char *
327 getwd (char *dir)
329 #if 0
330 if (GetCurrentDirectory (MAXPATHLEN, dir) > 0)
331 return dir;
332 return NULL;
333 #else
334 /* Emacs doesn't actually change directory itself, and we want to
335 force our real wd to be where emacs.exe is to avoid unnecessary
336 conflicts when trying to rename or delete directories. */
337 strcpy (dir, startup_dir);
338 return dir;
339 #endif
342 #ifndef HAVE_SOCKETS
343 /* Emulate gethostname. */
345 gethostname (char *buffer, int size)
347 /* NT only allows small host names, so the buffer is
348 certainly large enough. */
349 return !GetComputerName (buffer, &size);
351 #endif /* HAVE_SOCKETS */
353 /* Emulate getloadavg. */
355 getloadavg (double loadavg[], int nelem)
357 int i;
359 /* A faithful emulation is going to have to be saved for a rainy day. */
360 for (i = 0; i < nelem; i++)
362 loadavg[i] = 0.0;
364 return i;
367 /* Emulate getpwuid, getpwnam and others. */
369 #define PASSWD_FIELD_SIZE 256
371 static char the_passwd_name[PASSWD_FIELD_SIZE];
372 static char the_passwd_passwd[PASSWD_FIELD_SIZE];
373 static char the_passwd_gecos[PASSWD_FIELD_SIZE];
374 static char the_passwd_dir[PASSWD_FIELD_SIZE];
375 static char the_passwd_shell[PASSWD_FIELD_SIZE];
377 static struct passwd the_passwd =
379 the_passwd_name,
380 the_passwd_passwd,
384 the_passwd_gecos,
385 the_passwd_dir,
386 the_passwd_shell,
389 static struct group the_group =
391 /* There are no groups on NT, so we just return "root" as the
392 group name. */
393 "root",
397 getuid ()
399 return the_passwd.pw_uid;
403 geteuid ()
405 /* I could imagine arguing for checking to see whether the user is
406 in the Administrators group and returning a UID of 0 for that
407 case, but I don't know how wise that would be in the long run. */
408 return getuid ();
412 getgid ()
414 return the_passwd.pw_gid;
418 getegid ()
420 return getgid ();
423 struct passwd *
424 getpwuid (int uid)
426 if (uid == the_passwd.pw_uid)
427 return &the_passwd;
428 return NULL;
431 struct group *
432 getgrgid (gid_t gid)
434 return &the_group;
437 struct passwd *
438 getpwnam (char *name)
440 struct passwd *pw;
442 pw = getpwuid (getuid ());
443 if (!pw)
444 return pw;
446 if (stricmp (name, pw->pw_name))
447 return NULL;
449 return pw;
452 void
453 init_user_info ()
455 /* Find the user's real name by opening the process token and
456 looking up the name associated with the user-sid in that token.
458 Use the relative portion of the identifier authority value from
459 the user-sid as the user id value (same for group id using the
460 primary group sid from the process token). */
462 char user_sid[256], name[256], domain[256];
463 DWORD length = sizeof (name), dlength = sizeof (domain), trash;
464 HANDLE token = NULL;
465 SID_NAME_USE user_type;
467 if (
468 open_process_token (GetCurrentProcess (), TOKEN_QUERY, &token)
469 && get_token_information (
470 token, TokenUser,
471 (PVOID) user_sid, sizeof (user_sid), &trash)
472 && lookup_account_sid (
473 NULL, *((PSID *) user_sid), name, &length,
474 domain, &dlength, &user_type)
477 strcpy (the_passwd.pw_name, name);
478 /* Determine a reasonable uid value. */
479 if (stricmp ("administrator", name) == 0)
481 the_passwd.pw_uid = 0;
482 the_passwd.pw_gid = 0;
484 else
486 SID_IDENTIFIER_AUTHORITY * pSIA;
488 pSIA = get_sid_identifier_authority (*((PSID *) user_sid));
489 /* I believe the relative portion is the last 4 bytes (of 6)
490 with msb first. */
491 the_passwd.pw_uid = ((pSIA->Value[2] << 24) +
492 (pSIA->Value[3] << 16) +
493 (pSIA->Value[4] << 8) +
494 (pSIA->Value[5] << 0));
495 /* restrict to conventional uid range for normal users */
496 the_passwd.pw_uid = the_passwd.pw_uid % 60001;
498 /* Get group id */
499 if (get_token_information (token, TokenPrimaryGroup,
500 (PVOID) user_sid, sizeof (user_sid), &trash))
502 SID_IDENTIFIER_AUTHORITY * pSIA;
504 pSIA = get_sid_identifier_authority (*((PSID *) user_sid));
505 the_passwd.pw_gid = ((pSIA->Value[2] << 24) +
506 (pSIA->Value[3] << 16) +
507 (pSIA->Value[4] << 8) +
508 (pSIA->Value[5] << 0));
509 /* I don't know if this is necessary, but for safety... */
510 the_passwd.pw_gid = the_passwd.pw_gid % 60001;
512 else
513 the_passwd.pw_gid = the_passwd.pw_uid;
516 /* If security calls are not supported (presumably because we
517 are running under Windows 95), fallback to this. */
518 else if (GetUserName (name, &length))
520 strcpy (the_passwd.pw_name, name);
521 if (stricmp ("administrator", name) == 0)
522 the_passwd.pw_uid = 0;
523 else
524 the_passwd.pw_uid = 123;
525 the_passwd.pw_gid = the_passwd.pw_uid;
527 else
529 strcpy (the_passwd.pw_name, "unknown");
530 the_passwd.pw_uid = 123;
531 the_passwd.pw_gid = 123;
534 /* Ensure HOME and SHELL are defined. */
535 if (getenv ("HOME") == NULL)
536 abort ();
537 if (getenv ("SHELL") == NULL)
538 abort ();
540 /* Set dir and shell from environment variables. */
541 strcpy (the_passwd.pw_dir, getenv ("HOME"));
542 strcpy (the_passwd.pw_shell, getenv ("SHELL"));
544 if (token)
545 CloseHandle (token);
549 random ()
551 /* rand () on NT gives us 15 random bits...hack together 30 bits. */
552 return ((rand () << 15) | rand ());
555 void
556 srandom (int seed)
558 srand (seed);
562 /* Normalize filename by converting all path separators to
563 the specified separator. Also conditionally convert upper
564 case path name components to lower case. */
566 static void
567 normalize_filename (fp, path_sep)
568 register char *fp;
569 char path_sep;
571 char sep;
572 char *elem;
574 /* Always lower-case drive letters a-z, even if the filesystem
575 preserves case in filenames.
576 This is so filenames can be compared by string comparison
577 functions that are case-sensitive. Even case-preserving filesystems
578 do not distinguish case in drive letters. */
579 if (fp[1] == ':' && *fp >= 'A' && *fp <= 'Z')
581 *fp += 'a' - 'A';
582 fp += 2;
585 if (NILP (Vw32_downcase_file_names))
587 while (*fp)
589 if (*fp == '/' || *fp == '\\')
590 *fp = path_sep;
591 fp++;
593 return;
596 sep = path_sep; /* convert to this path separator */
597 elem = fp; /* start of current path element */
599 do {
600 if (*fp >= 'a' && *fp <= 'z')
601 elem = 0; /* don't convert this element */
603 if (*fp == 0 || *fp == ':')
605 sep = *fp; /* restore current separator (or 0) */
606 *fp = '/'; /* after conversion of this element */
609 if (*fp == '/' || *fp == '\\')
611 if (elem && elem != fp)
613 *fp = 0; /* temporary end of string */
614 _strlwr (elem); /* while we convert to lower case */
616 *fp = sep; /* convert (or restore) path separator */
617 elem = fp + 1; /* next element starts after separator */
618 sep = path_sep;
620 } while (*fp++);
623 /* Destructively turn backslashes into slashes. */
624 void
625 dostounix_filename (p)
626 register char *p;
628 normalize_filename (p, '/');
631 /* Destructively turn slashes into backslashes. */
632 void
633 unixtodos_filename (p)
634 register char *p;
636 normalize_filename (p, '\\');
639 /* Remove all CR's that are followed by a LF.
640 (From msdos.c...probably should figure out a way to share it,
641 although this code isn't going to ever change.) */
643 crlf_to_lf (n, buf)
644 register int n;
645 register unsigned char *buf;
647 unsigned char *np = buf;
648 unsigned char *startp = buf;
649 unsigned char *endp = buf + n;
651 if (n == 0)
652 return n;
653 while (buf < endp - 1)
655 if (*buf == 0x0d)
657 if (*(++buf) != 0x0a)
658 *np++ = 0x0d;
660 else
661 *np++ = *buf++;
663 if (buf < endp)
664 *np++ = *buf++;
665 return np - startp;
668 /* Parse the root part of file name, if present. Return length and
669 optionally store pointer to char after root. */
670 static int
671 parse_root (char * name, char ** pPath)
673 char * start = name;
675 if (name == NULL)
676 return 0;
678 /* find the root name of the volume if given */
679 if (isalpha (name[0]) && name[1] == ':')
681 /* skip past drive specifier */
682 name += 2;
683 if (IS_DIRECTORY_SEP (name[0]))
684 name++;
686 else if (IS_DIRECTORY_SEP (name[0]) && IS_DIRECTORY_SEP (name[1]))
688 int slashes = 2;
689 name += 2;
692 if (IS_DIRECTORY_SEP (*name) && --slashes == 0)
693 break;
694 name++;
696 while ( *name );
697 if (IS_DIRECTORY_SEP (name[0]))
698 name++;
701 if (pPath)
702 *pPath = name;
704 return name - start;
707 /* Get long base name for name; name is assumed to be absolute. */
708 static int
709 get_long_basename (char * name, char * buf, int size)
711 WIN32_FIND_DATA find_data;
712 HANDLE dir_handle;
713 int len = 0;
715 /* must be valid filename, no wild cards or other invalid characters */
716 if (strpbrk (name, "*?|<>\""))
717 return 0;
719 dir_handle = FindFirstFile (name, &find_data);
720 if (dir_handle != INVALID_HANDLE_VALUE)
722 if ((len = strlen (find_data.cFileName)) < size)
723 memcpy (buf, find_data.cFileName, len + 1);
724 else
725 len = 0;
726 FindClose (dir_handle);
728 return len;
731 /* Get long name for file, if possible (assumed to be absolute). */
732 BOOL
733 w32_get_long_filename (char * name, char * buf, int size)
735 char * o = buf;
736 char * p;
737 char * q;
738 char full[ MAX_PATH ];
739 int len;
741 len = strlen (name);
742 if (len >= MAX_PATH)
743 return FALSE;
745 /* Use local copy for destructive modification. */
746 memcpy (full, name, len+1);
747 unixtodos_filename (full);
749 /* Copy root part verbatim. */
750 len = parse_root (full, &p);
751 memcpy (o, full, len);
752 o += len;
753 *o = '\0';
754 size -= len;
756 while (p != NULL && *p)
758 q = p;
759 p = strchr (q, '\\');
760 if (p) *p = '\0';
761 len = get_long_basename (full, o, size);
762 if (len > 0)
764 o += len;
765 size -= len;
766 if (p != NULL)
768 *p++ = '\\';
769 if (size < 2)
770 return FALSE;
771 *o++ = '\\';
772 size--;
773 *o = '\0';
776 else
777 return FALSE;
780 return TRUE;
784 is_unc_volume (const char *filename)
786 const char *ptr = filename;
788 if (!IS_DIRECTORY_SEP (ptr[0]) || !IS_DIRECTORY_SEP (ptr[1]) || !ptr[2])
789 return 0;
791 if (strpbrk (ptr + 2, "*?|<>\"\\/"))
792 return 0;
794 return 1;
797 /* Routines that are no-ops on NT but are defined to get Emacs to compile. */
800 sigsetmask (int signal_mask)
802 return 0;
806 sigmask (int sig)
808 return 0;
812 sigblock (int sig)
814 return 0;
818 sigunblock (int sig)
820 return 0;
824 setpgrp (int pid, int gid)
826 return 0;
830 alarm (int seconds)
832 return 0;
835 void
836 unrequest_sigio (void)
838 return;
841 void
842 request_sigio (void)
844 return;
847 #define REG_ROOT "SOFTWARE\\GNU\\Emacs"
849 LPBYTE
850 w32_get_resource (key, lpdwtype)
851 char *key;
852 LPDWORD lpdwtype;
854 LPBYTE lpvalue;
855 HKEY hrootkey = NULL;
856 DWORD cbData;
857 BOOL ok = FALSE;
859 /* Check both the current user and the local machine to see if
860 we have any resources. */
862 if (RegOpenKeyEx (HKEY_CURRENT_USER, REG_ROOT, 0, KEY_READ, &hrootkey) == ERROR_SUCCESS)
864 lpvalue = NULL;
866 if (RegQueryValueEx (hrootkey, key, NULL, NULL, NULL, &cbData) == ERROR_SUCCESS
867 && (lpvalue = (LPBYTE) xmalloc (cbData)) != NULL
868 && RegQueryValueEx (hrootkey, key, NULL, lpdwtype, lpvalue, &cbData) == ERROR_SUCCESS)
870 return (lpvalue);
873 if (lpvalue) xfree (lpvalue);
875 RegCloseKey (hrootkey);
878 if (RegOpenKeyEx (HKEY_LOCAL_MACHINE, REG_ROOT, 0, KEY_READ, &hrootkey) == ERROR_SUCCESS)
880 lpvalue = NULL;
882 if (RegQueryValueEx (hrootkey, key, NULL, NULL, NULL, &cbData) == ERROR_SUCCESS
883 && (lpvalue = (LPBYTE) xmalloc (cbData)) != NULL
884 && RegQueryValueEx (hrootkey, key, NULL, lpdwtype, lpvalue, &cbData) == ERROR_SUCCESS)
886 return (lpvalue);
889 if (lpvalue) xfree (lpvalue);
891 RegCloseKey (hrootkey);
894 return (NULL);
897 char *get_emacs_configuration (void);
898 extern Lisp_Object Vsystem_configuration;
900 void
901 init_environment (char ** argv)
903 static const char * const tempdirs[] = {
904 "$TMPDIR", "$TEMP", "$TMP", "c:/"
906 int i;
907 const int imax = sizeof (tempdirs) / sizeof (tempdirs[0]);
909 /* Make sure they have a usable $TMPDIR. Many Emacs functions use
910 temporary files and assume "/tmp" if $TMPDIR is unset, which
911 will break on DOS/Windows. Refuse to work if we cannot find
912 a directory, not even "c:/", usable for that purpose. */
913 for (i = 0; i < imax ; i++)
915 const char *tmp = tempdirs[i];
917 if (*tmp == '$')
918 tmp = getenv (tmp + 1);
919 /* Note that `access' can lie to us if the directory resides on a
920 read-only filesystem, like CD-ROM or a write-protected floppy.
921 The only way to be really sure is to actually create a file and
922 see if it succeeds. But I think that's too much to ask. */
923 if (tmp && _access (tmp, D_OK) == 0)
925 char * var = alloca (strlen (tmp) + 8);
926 sprintf (var, "TMPDIR=%s", tmp);
927 _putenv (strdup (var));
928 break;
931 if (i >= imax)
932 cmd_error_internal
933 (Fcons (Qerror,
934 Fcons (build_string ("no usable temporary directories found!!"),
935 Qnil)),
936 "While setting TMPDIR: ");
938 /* Check for environment variables and use registry settings if they
939 don't exist. Fallback on default values where applicable. */
941 int i;
942 LPBYTE lpval;
943 DWORD dwType;
944 char locale_name[32];
946 static struct env_entry
948 char * name;
949 char * def_value;
950 } env_vars[] =
952 {"HOME", "C:/"},
953 {"PRELOAD_WINSOCK", NULL},
954 {"emacs_dir", "C:/emacs"},
955 {"EMACSLOADPATH", "%emacs_dir%/site-lisp;%emacs_dir%/../site-lisp;%emacs_dir%/lisp;%emacs_dir%/leim"},
956 {"SHELL", "%emacs_dir%/bin/cmdproxy.exe"},
957 {"EMACSDATA", "%emacs_dir%/etc"},
958 {"EMACSPATH", "%emacs_dir%/bin"},
959 /* We no longer set INFOPATH because Info-default-directory-list
960 is then ignored. */
961 /* {"INFOPATH", "%emacs_dir%/info"}, */
962 {"EMACSDOC", "%emacs_dir%/etc"},
963 {"TERM", "cmd"},
964 {"LANG", NULL},
967 /* Get default locale info and use it for LANG. */
968 if (GetLocaleInfo (LOCALE_USER_DEFAULT,
969 LOCALE_SABBREVLANGNAME | LOCALE_USE_CP_ACP,
970 locale_name, sizeof (locale_name)))
972 for (i = 0; i < (sizeof (env_vars) / sizeof (env_vars[0])); i++)
974 if (strcmp (env_vars[i].name, "LANG") == 0)
976 env_vars[i].def_value = locale_name;
977 break;
982 #define SET_ENV_BUF_SIZE (4 * MAX_PATH) /* to cover EMACSLOADPATH */
984 /* Treat emacs_dir specially: set it unconditionally based on our
985 location, if it appears that we are running from the bin subdir
986 of a standard installation. */
988 char *p;
989 char modname[MAX_PATH];
991 if (!GetModuleFileName (NULL, modname, MAX_PATH))
992 abort ();
993 if ((p = strrchr (modname, '\\')) == NULL)
994 abort ();
995 *p = 0;
997 if ((p = strrchr (modname, '\\')) && stricmp (p, "\\bin") == 0)
999 char buf[SET_ENV_BUF_SIZE];
1001 *p = 0;
1002 for (p = modname; *p; p++)
1003 if (*p == '\\') *p = '/';
1005 _snprintf (buf, sizeof(buf)-1, "emacs_dir=%s", modname);
1006 _putenv (strdup (buf));
1010 for (i = 0; i < (sizeof (env_vars) / sizeof (env_vars[0])); i++)
1012 if (!getenv (env_vars[i].name))
1014 int dont_free = 0;
1016 if ((lpval = w32_get_resource (env_vars[i].name, &dwType)) == NULL)
1018 lpval = env_vars[i].def_value;
1019 dwType = REG_EXPAND_SZ;
1020 dont_free = 1;
1023 if (lpval)
1025 if (dwType == REG_EXPAND_SZ)
1027 char buf1[SET_ENV_BUF_SIZE], buf2[SET_ENV_BUF_SIZE];
1029 ExpandEnvironmentStrings ((LPSTR) lpval, buf1, sizeof(buf1));
1030 _snprintf (buf2, sizeof(buf2)-1, "%s=%s", env_vars[i].name, buf1);
1031 _putenv (strdup (buf2));
1033 else if (dwType == REG_SZ)
1035 char buf[SET_ENV_BUF_SIZE];
1037 _snprintf (buf, sizeof(buf)-1, "%s=%s", env_vars[i].name, lpval);
1038 _putenv (strdup (buf));
1041 if (!dont_free)
1042 xfree (lpval);
1048 /* Rebuild system configuration to reflect invoking system. */
1049 Vsystem_configuration = build_string (EMACS_CONFIGURATION);
1051 /* Another special case: on NT, the PATH variable is actually named
1052 "Path" although cmd.exe (perhaps NT itself) arranges for
1053 environment variable lookup and setting to be case insensitive.
1054 However, Emacs assumes a fully case sensitive environment, so we
1055 need to change "Path" to "PATH" to match the expectations of
1056 various elisp packages. We do this by the sneaky method of
1057 modifying the string in the C runtime environ entry.
1059 The same applies to COMSPEC. */
1061 char ** envp;
1063 for (envp = environ; *envp; envp++)
1064 if (_strnicmp (*envp, "PATH=", 5) == 0)
1065 memcpy (*envp, "PATH=", 5);
1066 else if (_strnicmp (*envp, "COMSPEC=", 8) == 0)
1067 memcpy (*envp, "COMSPEC=", 8);
1070 /* Remember the initial working directory for getwd, then make the
1071 real wd be the location of emacs.exe to avoid conflicts when
1072 renaming or deleting directories. (We also don't call chdir when
1073 running subprocesses for the same reason.) */
1074 if (!GetCurrentDirectory (MAXPATHLEN, startup_dir))
1075 abort ();
1078 char *p;
1079 static char modname[MAX_PATH];
1081 if (!GetModuleFileName (NULL, modname, MAX_PATH))
1082 abort ();
1083 if ((p = strrchr (modname, '\\')) == NULL)
1084 abort ();
1085 *p = 0;
1087 SetCurrentDirectory (modname);
1089 /* Ensure argv[0] has the full path to Emacs. */
1090 *p = '\\';
1091 argv[0] = modname;
1094 /* Determine if there is a middle mouse button, to allow parse_button
1095 to decide whether right mouse events should be mouse-2 or
1096 mouse-3. */
1097 XSETINT (Vw32_num_mouse_buttons, GetSystemMetrics (SM_CMOUSEBUTTONS));
1099 init_user_info ();
1102 char *
1103 emacs_root_dir (void)
1105 static char root_dir[FILENAME_MAX];
1106 const char *p;
1108 p = getenv ("emacs_dir");
1109 if (p == NULL)
1110 abort ();
1111 strcpy (root_dir, p);
1112 root_dir[parse_root (root_dir, NULL)] = '\0';
1113 dostounix_filename (root_dir);
1114 return root_dir;
1117 /* We don't have scripts to automatically determine the system configuration
1118 for Emacs before it's compiled, and we don't want to have to make the
1119 user enter it, so we define EMACS_CONFIGURATION to invoke this runtime
1120 routine. */
1122 char *
1123 get_emacs_configuration (void)
1125 char *arch, *oem, *os;
1126 int build_num;
1127 static char configuration_buffer[32];
1129 /* Determine the processor type. */
1130 switch (get_processor_type ())
1133 #ifdef PROCESSOR_INTEL_386
1134 case PROCESSOR_INTEL_386:
1135 case PROCESSOR_INTEL_486:
1136 case PROCESSOR_INTEL_PENTIUM:
1137 arch = "i386";
1138 break;
1139 #endif
1141 #ifdef PROCESSOR_INTEL_860
1142 case PROCESSOR_INTEL_860:
1143 arch = "i860";
1144 break;
1145 #endif
1147 #ifdef PROCESSOR_MIPS_R2000
1148 case PROCESSOR_MIPS_R2000:
1149 case PROCESSOR_MIPS_R3000:
1150 case PROCESSOR_MIPS_R4000:
1151 arch = "mips";
1152 break;
1153 #endif
1155 #ifdef PROCESSOR_ALPHA_21064
1156 case PROCESSOR_ALPHA_21064:
1157 arch = "alpha";
1158 break;
1159 #endif
1161 default:
1162 arch = "unknown";
1163 break;
1166 /* Use the OEM field to reflect the compiler/library combination. */
1167 #ifdef _MSC_VER
1168 #define COMPILER_NAME "msvc"
1169 #else
1170 #ifdef __GNUC__
1171 #define COMPILER_NAME "mingw"
1172 #else
1173 #define COMPILER_NAME "unknown"
1174 #endif
1175 #endif
1176 oem = COMPILER_NAME;
1178 switch (osinfo_cache.dwPlatformId) {
1179 case VER_PLATFORM_WIN32_NT:
1180 os = "nt";
1181 build_num = osinfo_cache.dwBuildNumber;
1182 break;
1183 case VER_PLATFORM_WIN32_WINDOWS:
1184 if (osinfo_cache.dwMinorVersion == 0) {
1185 os = "windows95";
1186 } else {
1187 os = "windows98";
1189 build_num = LOWORD (osinfo_cache.dwBuildNumber);
1190 break;
1191 case VER_PLATFORM_WIN32s:
1192 /* Not supported, should not happen. */
1193 os = "windows32s";
1194 build_num = LOWORD (osinfo_cache.dwBuildNumber);
1195 break;
1196 default:
1197 os = "unknown";
1198 build_num = 0;
1199 break;
1202 if (osinfo_cache.dwPlatformId == VER_PLATFORM_WIN32_NT) {
1203 sprintf (configuration_buffer, "%s-%s-%s%d.%d.%d", arch, oem, os,
1204 get_w32_major_version (), get_w32_minor_version (), build_num);
1205 } else {
1206 sprintf (configuration_buffer, "%s-%s-%s.%d", arch, oem, os, build_num);
1209 return configuration_buffer;
1212 char *
1213 get_emacs_configuration_options (void)
1215 static char options_buffer[256];
1217 /* Work out the effective configure options for this build. */
1218 #ifdef _MSC_VER
1219 #define COMPILER_VERSION "--with-msvc (%d.%02d)", _MSC_VER / 100, _MSC_VER % 100
1220 #else
1221 #ifdef __GNUC__
1222 #define COMPILER_VERSION "--with-gcc (%d.%d)", __GNUC__, __GNUC_MINOR__
1223 #else
1224 #define COMPILER_VERSION ""
1225 #endif
1226 #endif
1228 sprintf (options_buffer, COMPILER_VERSION);
1229 #ifdef EMACSDEBUG
1230 strcat (options_buffer, " --no-opt");
1231 #endif
1232 #ifdef USER_CFLAGS
1233 strcat (options_buffer, " --cflags");
1234 strcat (options_buffer, USER_CFLAGS);
1235 #endif
1236 #ifdef USER_LDFLAGS
1237 strcat (options_buffer, " --ldflags");
1238 strcat (options_buffer, USER_LDFLAGS);
1239 #endif
1240 return options_buffer;
1244 #include <sys/timeb.h>
1246 /* Emulate gettimeofday (Ulrich Leodolter, 1/11/95). */
1247 void
1248 gettimeofday (struct timeval *tv, struct timezone *tz)
1250 struct timeb tb;
1251 _ftime (&tb);
1253 tv->tv_sec = tb.time;
1254 tv->tv_usec = tb.millitm * 1000L;
1255 if (tz)
1257 tz->tz_minuteswest = tb.timezone; /* minutes west of Greenwich */
1258 tz->tz_dsttime = tb.dstflag; /* type of dst correction */
1262 /* ------------------------------------------------------------------------- */
1263 /* IO support and wrapper functions for W32 API. */
1264 /* ------------------------------------------------------------------------- */
1266 /* Place a wrapper around the MSVC version of ctime. It returns NULL
1267 on network directories, so we handle that case here.
1268 (Ulrich Leodolter, 1/11/95). */
1269 char *
1270 sys_ctime (const time_t *t)
1272 char *str = (char *) ctime (t);
1273 return (str ? str : "Sun Jan 01 00:00:00 1970");
1276 /* Emulate sleep...we could have done this with a define, but that
1277 would necessitate including windows.h in the files that used it.
1278 This is much easier. */
1279 void
1280 sys_sleep (int seconds)
1282 Sleep (seconds * 1000);
1285 /* Internal MSVC functions for low-level descriptor munging */
1286 extern int __cdecl _set_osfhnd (int fd, long h);
1287 extern int __cdecl _free_osfhnd (int fd);
1289 /* parallel array of private info on file handles */
1290 filedesc fd_info [ MAXDESC ];
1292 typedef struct volume_info_data {
1293 struct volume_info_data * next;
1295 /* time when info was obtained */
1296 DWORD timestamp;
1298 /* actual volume info */
1299 char * root_dir;
1300 DWORD serialnum;
1301 DWORD maxcomp;
1302 DWORD flags;
1303 char * name;
1304 char * type;
1305 } volume_info_data;
1307 /* Global referenced by various functions. */
1308 static volume_info_data volume_info;
1310 /* Vector to indicate which drives are local and fixed (for which cached
1311 data never expires). */
1312 static BOOL fixed_drives[26];
1314 /* Consider cached volume information to be stale if older than 10s,
1315 at least for non-local drives. Info for fixed drives is never stale. */
1316 #define DRIVE_INDEX( c ) ( (c) <= 'Z' ? (c) - 'A' : (c) - 'a' )
1317 #define VOLINFO_STILL_VALID( root_dir, info ) \
1318 ( ( isalpha (root_dir[0]) && \
1319 fixed_drives[ DRIVE_INDEX (root_dir[0]) ] ) \
1320 || GetTickCount () - info->timestamp < 10000 )
1322 /* Cache support functions. */
1324 /* Simple linked list with linear search is sufficient. */
1325 static volume_info_data *volume_cache = NULL;
1327 static volume_info_data *
1328 lookup_volume_info (char * root_dir)
1330 volume_info_data * info;
1332 for (info = volume_cache; info; info = info->next)
1333 if (stricmp (info->root_dir, root_dir) == 0)
1334 break;
1335 return info;
1338 static void
1339 add_volume_info (char * root_dir, volume_info_data * info)
1341 info->root_dir = xstrdup (root_dir);
1342 info->next = volume_cache;
1343 volume_cache = info;
1347 /* Wrapper for GetVolumeInformation, which uses caching to avoid
1348 performance penalty (~2ms on 486 for local drives, 7.5ms for local
1349 cdrom drive, ~5-10ms or more for remote drives on LAN). */
1350 volume_info_data *
1351 GetCachedVolumeInformation (char * root_dir)
1353 volume_info_data * info;
1354 char default_root[ MAX_PATH ];
1356 /* NULL for root_dir means use root from current directory. */
1357 if (root_dir == NULL)
1359 if (GetCurrentDirectory (MAX_PATH, default_root) == 0)
1360 return NULL;
1361 parse_root (default_root, &root_dir);
1362 *root_dir = 0;
1363 root_dir = default_root;
1366 /* Local fixed drives can be cached permanently. Removable drives
1367 cannot be cached permanently, since the volume name and serial
1368 number (if nothing else) can change. Remote drives should be
1369 treated as if they are removable, since there is no sure way to
1370 tell whether they are or not. Also, the UNC association of drive
1371 letters mapped to remote volumes can be changed at any time (even
1372 by other processes) without notice.
1374 As a compromise, so we can benefit from caching info for remote
1375 volumes, we use a simple expiry mechanism to invalidate cache
1376 entries that are more than ten seconds old. */
1378 #if 0
1379 /* No point doing this, because WNetGetConnection is even slower than
1380 GetVolumeInformation, consistently taking ~50ms on a 486 (FWIW,
1381 GetDriveType is about the only call of this type which does not
1382 involve network access, and so is extremely quick). */
1384 /* Map drive letter to UNC if remote. */
1385 if ( isalpha( root_dir[0] ) && !fixed[ DRIVE_INDEX( root_dir[0] ) ] )
1387 char remote_name[ 256 ];
1388 char drive[3] = { root_dir[0], ':' };
1390 if (WNetGetConnection (drive, remote_name, sizeof (remote_name))
1391 == NO_ERROR)
1392 /* do something */ ;
1394 #endif
1396 info = lookup_volume_info (root_dir);
1398 if (info == NULL || ! VOLINFO_STILL_VALID (root_dir, info))
1400 char name[ 256 ];
1401 DWORD serialnum;
1402 DWORD maxcomp;
1403 DWORD flags;
1404 char type[ 256 ];
1406 /* Info is not cached, or is stale. */
1407 if (!GetVolumeInformation (root_dir,
1408 name, sizeof (name),
1409 &serialnum,
1410 &maxcomp,
1411 &flags,
1412 type, sizeof (type)))
1413 return NULL;
1415 /* Cache the volume information for future use, overwriting existing
1416 entry if present. */
1417 if (info == NULL)
1419 info = (volume_info_data *) xmalloc (sizeof (volume_info_data));
1420 add_volume_info (root_dir, info);
1422 else
1424 xfree (info->name);
1425 xfree (info->type);
1428 info->name = xstrdup (name);
1429 info->serialnum = serialnum;
1430 info->maxcomp = maxcomp;
1431 info->flags = flags;
1432 info->type = xstrdup (type);
1433 info->timestamp = GetTickCount ();
1436 return info;
1439 /* Get information on the volume where name is held; set path pointer to
1440 start of pathname in name (past UNC header\volume header if present). */
1442 get_volume_info (const char * name, const char ** pPath)
1444 char temp[MAX_PATH];
1445 char *rootname = NULL; /* default to current volume */
1446 volume_info_data * info;
1448 if (name == NULL)
1449 return FALSE;
1451 /* find the root name of the volume if given */
1452 if (isalpha (name[0]) && name[1] == ':')
1454 rootname = temp;
1455 temp[0] = *name++;
1456 temp[1] = *name++;
1457 temp[2] = '\\';
1458 temp[3] = 0;
1460 else if (IS_DIRECTORY_SEP (name[0]) && IS_DIRECTORY_SEP (name[1]))
1462 char *str = temp;
1463 int slashes = 4;
1464 rootname = temp;
1467 if (IS_DIRECTORY_SEP (*name) && --slashes == 0)
1468 break;
1469 *str++ = *name++;
1471 while ( *name );
1473 *str++ = '\\';
1474 *str = 0;
1477 if (pPath)
1478 *pPath = name;
1480 info = GetCachedVolumeInformation (rootname);
1481 if (info != NULL)
1483 /* Set global referenced by other functions. */
1484 volume_info = *info;
1485 return TRUE;
1487 return FALSE;
1490 /* Determine if volume is FAT format (ie. only supports short 8.3
1491 names); also set path pointer to start of pathname in name. */
1493 is_fat_volume (const char * name, const char ** pPath)
1495 if (get_volume_info (name, pPath))
1496 return (volume_info.maxcomp == 12);
1497 return FALSE;
1500 /* Map filename to a legal 8.3 name if necessary. */
1501 const char *
1502 map_w32_filename (const char * name, const char ** pPath)
1504 static char shortname[MAX_PATH];
1505 char * str = shortname;
1506 char c;
1507 char * path;
1508 const char * save_name = name;
1510 if (strlen (name) >= MAX_PATH)
1512 /* Return a filename which will cause callers to fail. */
1513 strcpy (shortname, "?");
1514 return shortname;
1517 if (is_fat_volume (name, (const char **)&path)) /* truncate to 8.3 */
1519 register int left = 8; /* maximum number of chars in part */
1520 register int extn = 0; /* extension added? */
1521 register int dots = 2; /* maximum number of dots allowed */
1523 while (name < path)
1524 *str++ = *name++; /* skip past UNC header */
1526 while ((c = *name++))
1528 switch ( c )
1530 case '\\':
1531 case '/':
1532 *str++ = '\\';
1533 extn = 0; /* reset extension flags */
1534 dots = 2; /* max 2 dots */
1535 left = 8; /* max length 8 for main part */
1536 break;
1537 case ':':
1538 *str++ = ':';
1539 extn = 0; /* reset extension flags */
1540 dots = 2; /* max 2 dots */
1541 left = 8; /* max length 8 for main part */
1542 break;
1543 case '.':
1544 if ( dots )
1546 /* Convert path components of the form .xxx to _xxx,
1547 but leave . and .. as they are. This allows .emacs
1548 to be read as _emacs, for example. */
1550 if (! *name ||
1551 *name == '.' ||
1552 IS_DIRECTORY_SEP (*name))
1554 *str++ = '.';
1555 dots--;
1557 else
1559 *str++ = '_';
1560 left--;
1561 dots = 0;
1564 else if ( !extn )
1566 *str++ = '.';
1567 extn = 1; /* we've got an extension */
1568 left = 3; /* 3 chars in extension */
1570 else
1572 /* any embedded dots after the first are converted to _ */
1573 *str++ = '_';
1575 break;
1576 case '~':
1577 case '#': /* don't lose these, they're important */
1578 if ( ! left )
1579 str[-1] = c; /* replace last character of part */
1580 /* FALLTHRU */
1581 default:
1582 if ( left )
1584 *str++ = tolower (c); /* map to lower case (looks nicer) */
1585 left--;
1586 dots = 0; /* started a path component */
1588 break;
1591 *str = '\0';
1593 else
1595 strcpy (shortname, name);
1596 unixtodos_filename (shortname);
1599 if (pPath)
1600 *pPath = shortname + (path - save_name);
1602 return shortname;
1605 static int
1606 is_exec (const char * name)
1608 char * p = strrchr (name, '.');
1609 return
1610 (p != NULL
1611 && (stricmp (p, ".exe") == 0 ||
1612 stricmp (p, ".com") == 0 ||
1613 stricmp (p, ".bat") == 0 ||
1614 stricmp (p, ".cmd") == 0));
1617 /* Emulate the Unix directory procedures opendir, closedir,
1618 and readdir. We can't use the procedures supplied in sysdep.c,
1619 so we provide them here. */
1621 struct direct dir_static; /* simulated directory contents */
1622 static HANDLE dir_find_handle = INVALID_HANDLE_VALUE;
1623 static int dir_is_fat;
1624 static char dir_pathname[MAXPATHLEN+1];
1625 static WIN32_FIND_DATA dir_find_data;
1627 /* Support shares on a network resource as subdirectories of a read-only
1628 root directory. */
1629 static HANDLE wnet_enum_handle = INVALID_HANDLE_VALUE;
1630 HANDLE open_unc_volume (char *);
1631 char *read_unc_volume (HANDLE, char *, int);
1632 void close_unc_volume (HANDLE);
1634 DIR *
1635 opendir (char *filename)
1637 DIR *dirp;
1639 /* Opening is done by FindFirstFile. However, a read is inherent to
1640 this operation, so we defer the open until read time. */
1642 if (dir_find_handle != INVALID_HANDLE_VALUE)
1643 return NULL;
1644 if (wnet_enum_handle != INVALID_HANDLE_VALUE)
1645 return NULL;
1647 if (is_unc_volume (filename))
1649 wnet_enum_handle = open_unc_volume (filename);
1650 if (wnet_enum_handle == INVALID_HANDLE_VALUE)
1651 return NULL;
1654 if (!(dirp = (DIR *) malloc (sizeof (DIR))))
1655 return NULL;
1657 dirp->dd_fd = 0;
1658 dirp->dd_loc = 0;
1659 dirp->dd_size = 0;
1661 strncpy (dir_pathname, map_w32_filename (filename, NULL), MAXPATHLEN);
1662 dir_pathname[MAXPATHLEN] = '\0';
1663 dir_is_fat = is_fat_volume (filename, NULL);
1665 return dirp;
1668 void
1669 closedir (DIR *dirp)
1671 /* If we have a find-handle open, close it. */
1672 if (dir_find_handle != INVALID_HANDLE_VALUE)
1674 FindClose (dir_find_handle);
1675 dir_find_handle = INVALID_HANDLE_VALUE;
1677 else if (wnet_enum_handle != INVALID_HANDLE_VALUE)
1679 close_unc_volume (wnet_enum_handle);
1680 wnet_enum_handle = INVALID_HANDLE_VALUE;
1682 xfree ((char *) dirp);
1685 struct direct *
1686 readdir (DIR *dirp)
1688 if (wnet_enum_handle != INVALID_HANDLE_VALUE)
1690 if (!read_unc_volume (wnet_enum_handle,
1691 dir_find_data.cFileName,
1692 MAX_PATH))
1693 return NULL;
1695 /* If we aren't dir_finding, do a find-first, otherwise do a find-next. */
1696 else if (dir_find_handle == INVALID_HANDLE_VALUE)
1698 char filename[MAXNAMLEN + 3];
1699 int ln;
1701 strcpy (filename, dir_pathname);
1702 ln = strlen (filename) - 1;
1703 if (!IS_DIRECTORY_SEP (filename[ln]))
1704 strcat (filename, "\\");
1705 strcat (filename, "*");
1707 dir_find_handle = FindFirstFile (filename, &dir_find_data);
1709 if (dir_find_handle == INVALID_HANDLE_VALUE)
1710 return NULL;
1712 else
1714 if (!FindNextFile (dir_find_handle, &dir_find_data))
1715 return NULL;
1718 /* Emacs never uses this value, so don't bother making it match
1719 value returned by stat(). */
1720 dir_static.d_ino = 1;
1722 dir_static.d_reclen = sizeof (struct direct) - MAXNAMLEN + 3 +
1723 dir_static.d_namlen - dir_static.d_namlen % 4;
1725 dir_static.d_namlen = strlen (dir_find_data.cFileName);
1726 strcpy (dir_static.d_name, dir_find_data.cFileName);
1727 if (dir_is_fat)
1728 _strlwr (dir_static.d_name);
1729 else if (!NILP (Vw32_downcase_file_names))
1731 register char *p;
1732 for (p = dir_static.d_name; *p; p++)
1733 if (*p >= 'a' && *p <= 'z')
1734 break;
1735 if (!*p)
1736 _strlwr (dir_static.d_name);
1739 return &dir_static;
1742 HANDLE
1743 open_unc_volume (char *path)
1745 NETRESOURCE nr;
1746 HANDLE henum;
1747 int result;
1749 nr.dwScope = RESOURCE_GLOBALNET;
1750 nr.dwType = RESOURCETYPE_DISK;
1751 nr.dwDisplayType = RESOURCEDISPLAYTYPE_SERVER;
1752 nr.dwUsage = RESOURCEUSAGE_CONTAINER;
1753 nr.lpLocalName = NULL;
1754 nr.lpRemoteName = map_w32_filename (path, NULL);
1755 nr.lpComment = NULL;
1756 nr.lpProvider = NULL;
1758 result = WNetOpenEnum(RESOURCE_GLOBALNET, RESOURCETYPE_DISK,
1759 RESOURCEUSAGE_CONNECTABLE, &nr, &henum);
1761 if (result == NO_ERROR)
1762 return henum;
1763 else
1764 return INVALID_HANDLE_VALUE;
1767 char *
1768 read_unc_volume (HANDLE henum, char *readbuf, int size)
1770 DWORD count;
1771 int result;
1772 DWORD bufsize = 512;
1773 char *buffer;
1774 char *ptr;
1776 count = 1;
1777 buffer = alloca (bufsize);
1778 result = WNetEnumResource (wnet_enum_handle, &count, buffer, &bufsize);
1779 if (result != NO_ERROR)
1780 return NULL;
1782 /* WNetEnumResource returns \\resource\share...skip forward to "share". */
1783 ptr = ((LPNETRESOURCE) buffer)->lpRemoteName;
1784 ptr += 2;
1785 while (*ptr && !IS_DIRECTORY_SEP (*ptr)) ptr++;
1786 ptr++;
1788 strncpy (readbuf, ptr, size);
1789 return readbuf;
1792 void
1793 close_unc_volume (HANDLE henum)
1795 if (henum != INVALID_HANDLE_VALUE)
1796 WNetCloseEnum (henum);
1799 DWORD
1800 unc_volume_file_attributes (char *path)
1802 HANDLE henum;
1803 DWORD attrs;
1805 henum = open_unc_volume (path);
1806 if (henum == INVALID_HANDLE_VALUE)
1807 return -1;
1809 attrs = FILE_ATTRIBUTE_READONLY | FILE_ATTRIBUTE_DIRECTORY;
1811 close_unc_volume (henum);
1813 return attrs;
1817 /* Shadow some MSVC runtime functions to map requests for long filenames
1818 to reasonable short names if necessary. This was originally added to
1819 permit running Emacs on NT 3.1 on a FAT partition, which doesn't support
1820 long file names. */
1823 sys_access (const char * path, int mode)
1825 DWORD attributes;
1827 /* MSVC implementation doesn't recognize D_OK. */
1828 path = map_w32_filename (path, NULL);
1829 if (is_unc_volume (path))
1831 attributes = unc_volume_file_attributes (path);
1832 if (attributes == -1) {
1833 errno = EACCES;
1834 return -1;
1837 else if ((attributes = GetFileAttributes (path)) == -1)
1839 /* Should try mapping GetLastError to errno; for now just indicate
1840 that path doesn't exist. */
1841 errno = EACCES;
1842 return -1;
1844 if ((mode & X_OK) != 0 && !is_exec (path))
1846 errno = EACCES;
1847 return -1;
1849 if ((mode & W_OK) != 0 && (attributes & FILE_ATTRIBUTE_READONLY) != 0)
1851 errno = EACCES;
1852 return -1;
1854 if ((mode & D_OK) != 0 && (attributes & FILE_ATTRIBUTE_DIRECTORY) == 0)
1856 errno = EACCES;
1857 return -1;
1859 return 0;
1863 sys_chdir (const char * path)
1865 return _chdir (map_w32_filename (path, NULL));
1869 sys_chmod (const char * path, int mode)
1871 return _chmod (map_w32_filename (path, NULL), mode);
1875 sys_creat (const char * path, int mode)
1877 return _creat (map_w32_filename (path, NULL), mode);
1880 FILE *
1881 sys_fopen(const char * path, const char * mode)
1883 int fd;
1884 int oflag;
1885 const char * mode_save = mode;
1887 /* Force all file handles to be non-inheritable. This is necessary to
1888 ensure child processes don't unwittingly inherit handles that might
1889 prevent future file access. */
1891 if (mode[0] == 'r')
1892 oflag = O_RDONLY;
1893 else if (mode[0] == 'w' || mode[0] == 'a')
1894 oflag = O_WRONLY | O_CREAT | O_TRUNC;
1895 else
1896 return NULL;
1898 /* Only do simplistic option parsing. */
1899 while (*++mode)
1900 if (mode[0] == '+')
1902 oflag &= ~(O_RDONLY | O_WRONLY);
1903 oflag |= O_RDWR;
1905 else if (mode[0] == 'b')
1907 oflag &= ~O_TEXT;
1908 oflag |= O_BINARY;
1910 else if (mode[0] == 't')
1912 oflag &= ~O_BINARY;
1913 oflag |= O_TEXT;
1915 else break;
1917 fd = _open (map_w32_filename (path, NULL), oflag | _O_NOINHERIT, 0644);
1918 if (fd < 0)
1919 return NULL;
1921 return _fdopen (fd, mode_save);
1924 /* This only works on NTFS volumes, but is useful to have. */
1926 sys_link (const char * old, const char * new)
1928 HANDLE fileh;
1929 int result = -1;
1930 char oldname[MAX_PATH], newname[MAX_PATH];
1932 if (old == NULL || new == NULL)
1934 errno = ENOENT;
1935 return -1;
1938 strcpy (oldname, map_w32_filename (old, NULL));
1939 strcpy (newname, map_w32_filename (new, NULL));
1941 fileh = CreateFile (oldname, 0, 0, NULL, OPEN_EXISTING,
1942 FILE_FLAG_BACKUP_SEMANTICS, NULL);
1943 if (fileh != INVALID_HANDLE_VALUE)
1945 int wlen;
1947 /* Confusingly, the "alternate" stream name field does not apply
1948 when restoring a hard link, and instead contains the actual
1949 stream data for the link (ie. the name of the link to create).
1950 The WIN32_STREAM_ID structure before the cStreamName field is
1951 the stream header, which is then immediately followed by the
1952 stream data. */
1954 struct {
1955 WIN32_STREAM_ID wid;
1956 WCHAR wbuffer[MAX_PATH]; /* extra space for link name */
1957 } data;
1959 wlen = MultiByteToWideChar (CP_ACP, MB_PRECOMPOSED, newname, -1,
1960 data.wid.cStreamName, MAX_PATH);
1961 if (wlen > 0)
1963 LPVOID context = NULL;
1964 DWORD wbytes = 0;
1966 data.wid.dwStreamId = BACKUP_LINK;
1967 data.wid.dwStreamAttributes = 0;
1968 data.wid.Size.LowPart = wlen * sizeof(WCHAR);
1969 data.wid.Size.HighPart = 0;
1970 data.wid.dwStreamNameSize = 0;
1972 if (BackupWrite (fileh, (LPBYTE)&data,
1973 offsetof (WIN32_STREAM_ID, cStreamName)
1974 + data.wid.Size.LowPart,
1975 &wbytes, FALSE, FALSE, &context)
1976 && BackupWrite (fileh, NULL, 0, &wbytes, TRUE, FALSE, &context))
1978 /* succeeded */
1979 result = 0;
1981 else
1983 /* Should try mapping GetLastError to errno; for now just
1984 indicate a general error (eg. links not supported). */
1985 errno = EINVAL; // perhaps EMLINK?
1989 CloseHandle (fileh);
1991 else
1992 errno = ENOENT;
1994 return result;
1998 sys_mkdir (const char * path)
2000 return _mkdir (map_w32_filename (path, NULL));
2003 /* Because of long name mapping issues, we need to implement this
2004 ourselves. Also, MSVC's _mktemp returns NULL when it can't generate
2005 a unique name, instead of setting the input template to an empty
2006 string.
2008 Standard algorithm seems to be use pid or tid with a letter on the
2009 front (in place of the 6 X's) and cycle through the letters to find a
2010 unique name. We extend that to allow any reasonable character as the
2011 first of the 6 X's. */
2012 char *
2013 sys_mktemp (char * template)
2015 char * p;
2016 int i;
2017 unsigned uid = GetCurrentThreadId ();
2018 static char first_char[] = "abcdefghijklmnopqrstuvwyz0123456789!%-_@#";
2020 if (template == NULL)
2021 return NULL;
2022 p = template + strlen (template);
2023 i = 5;
2024 /* replace up to the last 5 X's with uid in decimal */
2025 while (--p >= template && p[0] == 'X' && --i >= 0)
2027 p[0] = '0' + uid % 10;
2028 uid /= 10;
2031 if (i < 0 && p[0] == 'X')
2033 i = 0;
2036 int save_errno = errno;
2037 p[0] = first_char[i];
2038 if (sys_access (template, 0) < 0)
2040 errno = save_errno;
2041 return template;
2044 while (++i < sizeof (first_char));
2047 /* Template is badly formed or else we can't generate a unique name,
2048 so return empty string */
2049 template[0] = 0;
2050 return template;
2054 sys_open (const char * path, int oflag, int mode)
2056 const char* mpath = map_w32_filename (path, NULL);
2057 /* Try to open file without _O_CREAT, to be able to write to hidden
2058 and system files. Force all file handles to be
2059 non-inheritable. */
2060 int res = _open (mpath, (oflag & ~_O_CREAT) | _O_NOINHERIT, mode);
2061 if (res >= 0)
2062 return res;
2063 return _open (mpath, oflag | _O_NOINHERIT, mode);
2067 sys_rename (const char * oldname, const char * newname)
2069 BOOL result;
2070 char temp[MAX_PATH];
2072 /* MoveFile on Windows 95 doesn't correctly change the short file name
2073 alias in a number of circumstances (it is not easy to predict when
2074 just by looking at oldname and newname, unfortunately). In these
2075 cases, renaming through a temporary name avoids the problem.
2077 A second problem on Windows 95 is that renaming through a temp name when
2078 newname is uppercase fails (the final long name ends up in
2079 lowercase, although the short alias might be uppercase) UNLESS the
2080 long temp name is not 8.3.
2082 So, on Windows 95 we always rename through a temp name, and we make sure
2083 the temp name has a long extension to ensure correct renaming. */
2085 strcpy (temp, map_w32_filename (oldname, NULL));
2087 if (os_subtype == OS_WIN95)
2089 char * o;
2090 char * p;
2091 int i = 0;
2093 oldname = map_w32_filename (oldname, NULL);
2094 if (o = strrchr (oldname, '\\'))
2095 o++;
2096 else
2097 o = (char *) oldname;
2099 if (p = strrchr (temp, '\\'))
2100 p++;
2101 else
2102 p = temp;
2106 /* Force temp name to require a manufactured 8.3 alias - this
2107 seems to make the second rename work properly. */
2108 sprintf (p, "_.%s.%u", o, i);
2109 i++;
2110 result = rename (oldname, temp);
2112 /* This loop must surely terminate! */
2113 while (result < 0 && errno == EEXIST);
2114 if (result < 0)
2115 return -1;
2118 /* Emulate Unix behaviour - newname is deleted if it already exists
2119 (at least if it is a file; don't do this for directories).
2121 Since we mustn't do this if we are just changing the case of the
2122 file name (we would end up deleting the file we are trying to
2123 rename!), we let rename detect if the destination file already
2124 exists - that way we avoid the possible pitfalls of trying to
2125 determine ourselves whether two names really refer to the same
2126 file, which is not always possible in the general case. (Consider
2127 all the permutations of shared or subst'd drives, etc.) */
2129 newname = map_w32_filename (newname, NULL);
2130 result = rename (temp, newname);
2132 if (result < 0
2133 && errno == EEXIST
2134 && _chmod (newname, 0666) == 0
2135 && _unlink (newname) == 0)
2136 result = rename (temp, newname);
2138 return result;
2142 sys_rmdir (const char * path)
2144 return _rmdir (map_w32_filename (path, NULL));
2148 sys_unlink (const char * path)
2150 path = map_w32_filename (path, NULL);
2152 /* On Unix, unlink works without write permission. */
2153 _chmod (path, 0666);
2154 return _unlink (path);
2157 static FILETIME utc_base_ft;
2158 static long double utc_base;
2159 static int init = 0;
2161 static time_t
2162 convert_time (FILETIME ft)
2164 long double ret;
2166 if (!init)
2168 /* Determine the delta between 1-Jan-1601 and 1-Jan-1970. */
2169 SYSTEMTIME st;
2171 st.wYear = 1970;
2172 st.wMonth = 1;
2173 st.wDay = 1;
2174 st.wHour = 0;
2175 st.wMinute = 0;
2176 st.wSecond = 0;
2177 st.wMilliseconds = 0;
2179 SystemTimeToFileTime (&st, &utc_base_ft);
2180 utc_base = (long double) utc_base_ft.dwHighDateTime
2181 * 4096 * 1024 * 1024 + utc_base_ft.dwLowDateTime;
2182 init = 1;
2185 if (CompareFileTime (&ft, &utc_base_ft) < 0)
2186 return 0;
2188 ret = (long double) ft.dwHighDateTime * 4096 * 1024 * 1024 + ft.dwLowDateTime;
2189 ret -= utc_base;
2190 return (time_t) (ret * 1e-7);
2193 void
2194 convert_from_time_t (time_t time, FILETIME * pft)
2196 long double tmp;
2198 if (!init)
2200 /* Determine the delta between 1-Jan-1601 and 1-Jan-1970. */
2201 SYSTEMTIME st;
2203 st.wYear = 1970;
2204 st.wMonth = 1;
2205 st.wDay = 1;
2206 st.wHour = 0;
2207 st.wMinute = 0;
2208 st.wSecond = 0;
2209 st.wMilliseconds = 0;
2211 SystemTimeToFileTime (&st, &utc_base_ft);
2212 utc_base = (long double) utc_base_ft.dwHighDateTime
2213 * 4096 * 1024 * 1024 + utc_base_ft.dwLowDateTime;
2214 init = 1;
2217 /* time in 100ns units since 1-Jan-1601 */
2218 tmp = (long double) time * 1e7 + utc_base;
2219 pft->dwHighDateTime = (DWORD) (tmp / (4096.0 * 1024 * 1024));
2220 pft->dwLowDateTime = (DWORD) (tmp - (4096.0 * 1024 * 1024) * pft->dwHighDateTime);
2223 #if 0
2224 /* No reason to keep this; faking inode values either by hashing or even
2225 using the file index from GetInformationByHandle, is not perfect and
2226 so by default Emacs doesn't use the inode values on Windows.
2227 Instead, we now determine file-truename correctly (except for
2228 possible drive aliasing etc). */
2230 /* Modified version of "PJW" algorithm (see the "Dragon" compiler book). */
2231 static unsigned
2232 hashval (const unsigned char * str)
2234 unsigned h = 0;
2235 while (*str)
2237 h = (h << 4) + *str++;
2238 h ^= (h >> 28);
2240 return h;
2243 /* Return the hash value of the canonical pathname, excluding the
2244 drive/UNC header, to get a hopefully unique inode number. */
2245 static DWORD
2246 generate_inode_val (const char * name)
2248 char fullname[ MAX_PATH ];
2249 char * p;
2250 unsigned hash;
2252 /* Get the truly canonical filename, if it exists. (Note: this
2253 doesn't resolve aliasing due to subst commands, or recognise hard
2254 links. */
2255 if (!w32_get_long_filename ((char *)name, fullname, MAX_PATH))
2256 abort ();
2258 parse_root (fullname, &p);
2259 /* Normal W32 filesystems are still case insensitive. */
2260 _strlwr (p);
2261 return hashval (p);
2264 #endif
2266 /* MSVC stat function can't cope with UNC names and has other bugs, so
2267 replace it with our own. This also allows us to calculate consistent
2268 inode values without hacks in the main Emacs code. */
2270 stat (const char * path, struct stat * buf)
2272 char *name, *r;
2273 WIN32_FIND_DATA wfd;
2274 HANDLE fh;
2275 DWORD fake_inode;
2276 int permission;
2277 int len;
2278 int rootdir = FALSE;
2280 if (path == NULL || buf == NULL)
2282 errno = EFAULT;
2283 return -1;
2286 name = (char *) map_w32_filename (path, &path);
2287 /* must be valid filename, no wild cards or other invalid characters */
2288 if (strpbrk (name, "*?|<>\""))
2290 errno = ENOENT;
2291 return -1;
2294 /* If name is "c:/.." or "/.." then stat "c:/" or "/". */
2295 r = IS_DEVICE_SEP (name[1]) ? &name[2] : name;
2296 if (IS_DIRECTORY_SEP (r[0]) && r[1] == '.' && r[2] == '.' && r[3] == '\0')
2298 r[1] = r[2] = '\0';
2301 /* Remove trailing directory separator, unless name is the root
2302 directory of a drive or UNC volume in which case ensure there
2303 is a trailing separator. */
2304 len = strlen (name);
2305 rootdir = (path >= name + len - 1
2306 && (IS_DIRECTORY_SEP (*path) || *path == 0));
2307 name = strcpy (alloca (len + 2), name);
2309 if (is_unc_volume (name))
2311 DWORD attrs = unc_volume_file_attributes (name);
2313 if (attrs == -1)
2314 return -1;
2316 memset (&wfd, 0, sizeof (wfd));
2317 wfd.dwFileAttributes = attrs;
2318 wfd.ftCreationTime = utc_base_ft;
2319 wfd.ftLastAccessTime = utc_base_ft;
2320 wfd.ftLastWriteTime = utc_base_ft;
2321 strcpy (wfd.cFileName, name);
2323 else if (rootdir)
2325 if (!IS_DIRECTORY_SEP (name[len-1]))
2326 strcat (name, "\\");
2327 if (GetDriveType (name) < 2)
2329 errno = ENOENT;
2330 return -1;
2332 memset (&wfd, 0, sizeof (wfd));
2333 wfd.dwFileAttributes = FILE_ATTRIBUTE_DIRECTORY;
2334 wfd.ftCreationTime = utc_base_ft;
2335 wfd.ftLastAccessTime = utc_base_ft;
2336 wfd.ftLastWriteTime = utc_base_ft;
2337 strcpy (wfd.cFileName, name);
2339 else
2341 if (IS_DIRECTORY_SEP (name[len-1]))
2342 name[len - 1] = 0;
2344 /* (This is hacky, but helps when doing file completions on
2345 network drives.) Optimize by using information available from
2346 active readdir if possible. */
2347 len = strlen (dir_pathname);
2348 if (IS_DIRECTORY_SEP (dir_pathname[len-1]))
2349 len--;
2350 if (dir_find_handle != INVALID_HANDLE_VALUE
2351 && strnicmp (name, dir_pathname, len) == 0
2352 && IS_DIRECTORY_SEP (name[len])
2353 && stricmp (name + len + 1, dir_static.d_name) == 0)
2355 /* This was the last entry returned by readdir. */
2356 wfd = dir_find_data;
2358 else
2360 fh = FindFirstFile (name, &wfd);
2361 if (fh == INVALID_HANDLE_VALUE)
2363 errno = ENOENT;
2364 return -1;
2366 FindClose (fh);
2370 if (!NILP (Vw32_get_true_file_attributes)
2371 /* No access rights required to get info. */
2372 && (fh = CreateFile (name, 0, 0, NULL, OPEN_EXISTING,
2373 FILE_FLAG_BACKUP_SEMANTICS, NULL))
2374 != INVALID_HANDLE_VALUE)
2376 /* This is more accurate in terms of gettting the correct number
2377 of links, but is quite slow (it is noticable when Emacs is
2378 making a list of file name completions). */
2379 BY_HANDLE_FILE_INFORMATION info;
2381 if (GetFileInformationByHandle (fh, &info))
2383 buf->st_nlink = info.nNumberOfLinks;
2384 /* Might as well use file index to fake inode values, but this
2385 is not guaranteed to be unique unless we keep a handle open
2386 all the time (even then there are situations where it is
2387 not unique). Reputedly, there are at most 48 bits of info
2388 (on NTFS, presumably less on FAT). */
2389 fake_inode = info.nFileIndexLow ^ info.nFileIndexHigh;
2391 else
2393 buf->st_nlink = 1;
2394 fake_inode = 0;
2397 if (wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
2399 buf->st_mode = _S_IFDIR;
2401 else
2403 switch (GetFileType (fh))
2405 case FILE_TYPE_DISK:
2406 buf->st_mode = _S_IFREG;
2407 break;
2408 case FILE_TYPE_PIPE:
2409 buf->st_mode = _S_IFIFO;
2410 break;
2411 case FILE_TYPE_CHAR:
2412 case FILE_TYPE_UNKNOWN:
2413 default:
2414 buf->st_mode = _S_IFCHR;
2417 CloseHandle (fh);
2419 else
2421 /* Don't bother to make this information more accurate. */
2422 buf->st_mode = (wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) ?
2423 _S_IFDIR : _S_IFREG;
2424 buf->st_nlink = 1;
2425 fake_inode = 0;
2428 #if 0
2429 /* Not sure if there is any point in this. */
2430 if (!NILP (Vw32_generate_fake_inodes))
2431 fake_inode = generate_inode_val (name);
2432 else if (fake_inode == 0)
2434 /* For want of something better, try to make everything unique. */
2435 static DWORD gen_num = 0;
2436 fake_inode = ++gen_num;
2438 #endif
2440 /* MSVC defines _ino_t to be short; other libc's might not. */
2441 if (sizeof (buf->st_ino) == 2)
2442 buf->st_ino = fake_inode ^ (fake_inode >> 16);
2443 else
2444 buf->st_ino = fake_inode;
2446 /* consider files to belong to current user */
2447 buf->st_uid = the_passwd.pw_uid;
2448 buf->st_gid = the_passwd.pw_gid;
2450 /* volume_info is set indirectly by map_w32_filename */
2451 buf->st_dev = volume_info.serialnum;
2452 buf->st_rdev = volume_info.serialnum;
2455 buf->st_size = wfd.nFileSizeLow;
2457 /* Convert timestamps to Unix format. */
2458 buf->st_mtime = convert_time (wfd.ftLastWriteTime);
2459 buf->st_atime = convert_time (wfd.ftLastAccessTime);
2460 if (buf->st_atime == 0) buf->st_atime = buf->st_mtime;
2461 buf->st_ctime = convert_time (wfd.ftCreationTime);
2462 if (buf->st_ctime == 0) buf->st_ctime = buf->st_mtime;
2464 /* determine rwx permissions */
2465 if (wfd.dwFileAttributes & FILE_ATTRIBUTE_READONLY)
2466 permission = _S_IREAD;
2467 else
2468 permission = _S_IREAD | _S_IWRITE;
2470 if (wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
2471 permission |= _S_IEXEC;
2472 else if (is_exec (name))
2473 permission |= _S_IEXEC;
2475 buf->st_mode |= permission | (permission >> 3) | (permission >> 6);
2477 return 0;
2480 /* Provide fstat and utime as well as stat for consistent handling of
2481 file timestamps. */
2483 fstat (int desc, struct stat * buf)
2485 HANDLE fh = (HANDLE) _get_osfhandle (desc);
2486 BY_HANDLE_FILE_INFORMATION info;
2487 DWORD fake_inode;
2488 int permission;
2490 switch (GetFileType (fh) & ~FILE_TYPE_REMOTE)
2492 case FILE_TYPE_DISK:
2493 buf->st_mode = _S_IFREG;
2494 if (!GetFileInformationByHandle (fh, &info))
2496 errno = EACCES;
2497 return -1;
2499 break;
2500 case FILE_TYPE_PIPE:
2501 buf->st_mode = _S_IFIFO;
2502 goto non_disk;
2503 case FILE_TYPE_CHAR:
2504 case FILE_TYPE_UNKNOWN:
2505 default:
2506 buf->st_mode = _S_IFCHR;
2507 non_disk:
2508 memset (&info, 0, sizeof (info));
2509 info.dwFileAttributes = 0;
2510 info.ftCreationTime = utc_base_ft;
2511 info.ftLastAccessTime = utc_base_ft;
2512 info.ftLastWriteTime = utc_base_ft;
2515 if (info.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
2516 buf->st_mode = _S_IFDIR;
2518 buf->st_nlink = info.nNumberOfLinks;
2519 /* Might as well use file index to fake inode values, but this
2520 is not guaranteed to be unique unless we keep a handle open
2521 all the time (even then there are situations where it is
2522 not unique). Reputedly, there are at most 48 bits of info
2523 (on NTFS, presumably less on FAT). */
2524 fake_inode = info.nFileIndexLow ^ info.nFileIndexHigh;
2526 /* MSVC defines _ino_t to be short; other libc's might not. */
2527 if (sizeof (buf->st_ino) == 2)
2528 buf->st_ino = fake_inode ^ (fake_inode >> 16);
2529 else
2530 buf->st_ino = fake_inode;
2532 /* consider files to belong to current user */
2533 buf->st_uid = 0;
2534 buf->st_gid = 0;
2536 buf->st_dev = info.dwVolumeSerialNumber;
2537 buf->st_rdev = info.dwVolumeSerialNumber;
2539 buf->st_size = info.nFileSizeLow;
2541 /* Convert timestamps to Unix format. */
2542 buf->st_mtime = convert_time (info.ftLastWriteTime);
2543 buf->st_atime = convert_time (info.ftLastAccessTime);
2544 if (buf->st_atime == 0) buf->st_atime = buf->st_mtime;
2545 buf->st_ctime = convert_time (info.ftCreationTime);
2546 if (buf->st_ctime == 0) buf->st_ctime = buf->st_mtime;
2548 /* determine rwx permissions */
2549 if (info.dwFileAttributes & FILE_ATTRIBUTE_READONLY)
2550 permission = _S_IREAD;
2551 else
2552 permission = _S_IREAD | _S_IWRITE;
2554 if (info.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
2555 permission |= _S_IEXEC;
2556 else
2558 #if 0 /* no way of knowing the filename */
2559 char * p = strrchr (name, '.');
2560 if (p != NULL &&
2561 (stricmp (p, ".exe") == 0 ||
2562 stricmp (p, ".com") == 0 ||
2563 stricmp (p, ".bat") == 0 ||
2564 stricmp (p, ".cmd") == 0))
2565 permission |= _S_IEXEC;
2566 #endif
2569 buf->st_mode |= permission | (permission >> 3) | (permission >> 6);
2571 return 0;
2575 utime (const char *name, struct utimbuf *times)
2577 struct utimbuf deftime;
2578 HANDLE fh;
2579 FILETIME mtime;
2580 FILETIME atime;
2582 if (times == NULL)
2584 deftime.modtime = deftime.actime = time (NULL);
2585 times = &deftime;
2588 /* Need write access to set times. */
2589 fh = CreateFile (name, GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE,
2590 0, OPEN_EXISTING, 0, NULL);
2591 if (fh)
2593 convert_from_time_t (times->actime, &atime);
2594 convert_from_time_t (times->modtime, &mtime);
2595 if (!SetFileTime (fh, NULL, &atime, &mtime))
2597 CloseHandle (fh);
2598 errno = EACCES;
2599 return -1;
2601 CloseHandle (fh);
2603 else
2605 errno = EINVAL;
2606 return -1;
2608 return 0;
2611 #ifdef HAVE_SOCKETS
2613 /* Wrappers for winsock functions to map between our file descriptors
2614 and winsock's handles; also set h_errno for convenience.
2616 To allow Emacs to run on systems which don't have winsock support
2617 installed, we dynamically link to winsock on startup if present, and
2618 otherwise provide the minimum necessary functionality
2619 (eg. gethostname). */
2621 /* function pointers for relevant socket functions */
2622 int (PASCAL *pfn_WSAStartup) (WORD wVersionRequired, LPWSADATA lpWSAData);
2623 void (PASCAL *pfn_WSASetLastError) (int iError);
2624 int (PASCAL *pfn_WSAGetLastError) (void);
2625 int (PASCAL *pfn_socket) (int af, int type, int protocol);
2626 int (PASCAL *pfn_bind) (SOCKET s, const struct sockaddr *addr, int namelen);
2627 int (PASCAL *pfn_connect) (SOCKET s, const struct sockaddr *addr, int namelen);
2628 int (PASCAL *pfn_ioctlsocket) (SOCKET s, long cmd, u_long *argp);
2629 int (PASCAL *pfn_recv) (SOCKET s, char * buf, int len, int flags);
2630 int (PASCAL *pfn_send) (SOCKET s, const char * buf, int len, int flags);
2631 int (PASCAL *pfn_closesocket) (SOCKET s);
2632 int (PASCAL *pfn_shutdown) (SOCKET s, int how);
2633 int (PASCAL *pfn_WSACleanup) (void);
2635 u_short (PASCAL *pfn_htons) (u_short hostshort);
2636 u_short (PASCAL *pfn_ntohs) (u_short netshort);
2637 unsigned long (PASCAL *pfn_inet_addr) (const char * cp);
2638 int (PASCAL *pfn_gethostname) (char * name, int namelen);
2639 struct hostent * (PASCAL *pfn_gethostbyname) (const char * name);
2640 struct servent * (PASCAL *pfn_getservbyname) (const char * name, const char * proto);
2641 int (PASCAL *pfn_getpeername) (SOCKET s, struct sockaddr *addr, int * namelen);
2642 int (PASCAL *pfn_setsockopt) (SOCKET s, int level, int optname,
2643 const char * optval, int optlen);
2644 int (PASCAL *pfn_listen) (SOCKET s, int backlog);
2645 int (PASCAL *pfn_getsockname) (SOCKET s, struct sockaddr * name,
2646 int * namelen);
2647 SOCKET (PASCAL *pfn_accept) (SOCKET s, struct sockaddr * addr, int * addrlen);
2648 int (PASCAL *pfn_recvfrom) (SOCKET s, char * buf, int len, int flags,
2649 struct sockaddr * from, int * fromlen);
2650 int (PASCAL *pfn_sendto) (SOCKET s, const char * buf, int len, int flags,
2651 const struct sockaddr * to, int tolen);
2653 /* SetHandleInformation is only needed to make sockets non-inheritable. */
2654 BOOL (WINAPI *pfn_SetHandleInformation) (HANDLE object, DWORD mask, DWORD flags);
2655 #ifndef HANDLE_FLAG_INHERIT
2656 #define HANDLE_FLAG_INHERIT 1
2657 #endif
2659 HANDLE winsock_lib;
2660 static int winsock_inuse;
2662 BOOL
2663 term_winsock (void)
2665 if (winsock_lib != NULL && winsock_inuse == 0)
2667 /* Not sure what would cause WSAENETDOWN, or even if it can happen
2668 after WSAStartup returns successfully, but it seems reasonable
2669 to allow unloading winsock anyway in that case. */
2670 if (pfn_WSACleanup () == 0 ||
2671 pfn_WSAGetLastError () == WSAENETDOWN)
2673 if (FreeLibrary (winsock_lib))
2674 winsock_lib = NULL;
2675 return TRUE;
2678 return FALSE;
2681 BOOL
2682 init_winsock (int load_now)
2684 WSADATA winsockData;
2686 if (winsock_lib != NULL)
2687 return TRUE;
2689 pfn_SetHandleInformation = NULL;
2690 pfn_SetHandleInformation
2691 = (void *) GetProcAddress (GetModuleHandle ("kernel32.dll"),
2692 "SetHandleInformation");
2694 winsock_lib = LoadLibrary ("wsock32.dll");
2696 if (winsock_lib != NULL)
2698 /* dynamically link to socket functions */
2700 #define LOAD_PROC(fn) \
2701 if ((pfn_##fn = (void *) GetProcAddress (winsock_lib, #fn)) == NULL) \
2702 goto fail;
2704 LOAD_PROC( WSAStartup );
2705 LOAD_PROC( WSASetLastError );
2706 LOAD_PROC( WSAGetLastError );
2707 LOAD_PROC( socket );
2708 LOAD_PROC( bind );
2709 LOAD_PROC( connect );
2710 LOAD_PROC( ioctlsocket );
2711 LOAD_PROC( recv );
2712 LOAD_PROC( send );
2713 LOAD_PROC( closesocket );
2714 LOAD_PROC( shutdown );
2715 LOAD_PROC( htons );
2716 LOAD_PROC( ntohs );
2717 LOAD_PROC( inet_addr );
2718 LOAD_PROC( gethostname );
2719 LOAD_PROC( gethostbyname );
2720 LOAD_PROC( getservbyname );
2721 LOAD_PROC( getpeername );
2722 LOAD_PROC( WSACleanup );
2723 LOAD_PROC( setsockopt );
2724 LOAD_PROC( listen );
2725 LOAD_PROC( getsockname );
2726 LOAD_PROC( accept );
2727 LOAD_PROC( recvfrom );
2728 LOAD_PROC( sendto );
2729 #undef LOAD_PROC
2731 /* specify version 1.1 of winsock */
2732 if (pfn_WSAStartup (0x101, &winsockData) == 0)
2734 if (winsockData.wVersion != 0x101)
2735 goto fail;
2737 if (!load_now)
2739 /* Report that winsock exists and is usable, but leave
2740 socket functions disabled. I am assuming that calling
2741 WSAStartup does not require any network interaction,
2742 and in particular does not cause or require a dial-up
2743 connection to be established. */
2745 pfn_WSACleanup ();
2746 FreeLibrary (winsock_lib);
2747 winsock_lib = NULL;
2749 winsock_inuse = 0;
2750 return TRUE;
2753 fail:
2754 FreeLibrary (winsock_lib);
2755 winsock_lib = NULL;
2758 return FALSE;
2762 int h_errno = 0;
2764 /* function to set h_errno for compatability; map winsock error codes to
2765 normal system codes where they overlap (non-overlapping definitions
2766 are already in <sys/socket.h> */
2767 static void set_errno ()
2769 if (winsock_lib == NULL)
2770 h_errno = EINVAL;
2771 else
2772 h_errno = pfn_WSAGetLastError ();
2774 switch (h_errno)
2776 case WSAEACCES: h_errno = EACCES; break;
2777 case WSAEBADF: h_errno = EBADF; break;
2778 case WSAEFAULT: h_errno = EFAULT; break;
2779 case WSAEINTR: h_errno = EINTR; break;
2780 case WSAEINVAL: h_errno = EINVAL; break;
2781 case WSAEMFILE: h_errno = EMFILE; break;
2782 case WSAENAMETOOLONG: h_errno = ENAMETOOLONG; break;
2783 case WSAENOTEMPTY: h_errno = ENOTEMPTY; break;
2785 errno = h_errno;
2788 static void check_errno ()
2790 if (h_errno == 0 && winsock_lib != NULL)
2791 pfn_WSASetLastError (0);
2794 /* Extend strerror to handle the winsock-specific error codes. */
2795 struct {
2796 int errnum;
2797 char * msg;
2798 } _wsa_errlist[] = {
2799 WSAEINTR , "Interrupted function call",
2800 WSAEBADF , "Bad file descriptor",
2801 WSAEACCES , "Permission denied",
2802 WSAEFAULT , "Bad address",
2803 WSAEINVAL , "Invalid argument",
2804 WSAEMFILE , "Too many open files",
2806 WSAEWOULDBLOCK , "Resource temporarily unavailable",
2807 WSAEINPROGRESS , "Operation now in progress",
2808 WSAEALREADY , "Operation already in progress",
2809 WSAENOTSOCK , "Socket operation on non-socket",
2810 WSAEDESTADDRREQ , "Destination address required",
2811 WSAEMSGSIZE , "Message too long",
2812 WSAEPROTOTYPE , "Protocol wrong type for socket",
2813 WSAENOPROTOOPT , "Bad protocol option",
2814 WSAEPROTONOSUPPORT , "Protocol not supported",
2815 WSAESOCKTNOSUPPORT , "Socket type not supported",
2816 WSAEOPNOTSUPP , "Operation not supported",
2817 WSAEPFNOSUPPORT , "Protocol family not supported",
2818 WSAEAFNOSUPPORT , "Address family not supported by protocol family",
2819 WSAEADDRINUSE , "Address already in use",
2820 WSAEADDRNOTAVAIL , "Cannot assign requested address",
2821 WSAENETDOWN , "Network is down",
2822 WSAENETUNREACH , "Network is unreachable",
2823 WSAENETRESET , "Network dropped connection on reset",
2824 WSAECONNABORTED , "Software caused connection abort",
2825 WSAECONNRESET , "Connection reset by peer",
2826 WSAENOBUFS , "No buffer space available",
2827 WSAEISCONN , "Socket is already connected",
2828 WSAENOTCONN , "Socket is not connected",
2829 WSAESHUTDOWN , "Cannot send after socket shutdown",
2830 WSAETOOMANYREFS , "Too many references", /* not sure */
2831 WSAETIMEDOUT , "Connection timed out",
2832 WSAECONNREFUSED , "Connection refused",
2833 WSAELOOP , "Network loop", /* not sure */
2834 WSAENAMETOOLONG , "Name is too long",
2835 WSAEHOSTDOWN , "Host is down",
2836 WSAEHOSTUNREACH , "No route to host",
2837 WSAENOTEMPTY , "Buffer not empty", /* not sure */
2838 WSAEPROCLIM , "Too many processes",
2839 WSAEUSERS , "Too many users", /* not sure */
2840 WSAEDQUOT , "Double quote in host name", /* really not sure */
2841 WSAESTALE , "Data is stale", /* not sure */
2842 WSAEREMOTE , "Remote error", /* not sure */
2844 WSASYSNOTREADY , "Network subsystem is unavailable",
2845 WSAVERNOTSUPPORTED , "WINSOCK.DLL version out of range",
2846 WSANOTINITIALISED , "Winsock not initialized successfully",
2847 WSAEDISCON , "Graceful shutdown in progress",
2848 #ifdef WSAENOMORE
2849 WSAENOMORE , "No more operations allowed", /* not sure */
2850 WSAECANCELLED , "Operation cancelled", /* not sure */
2851 WSAEINVALIDPROCTABLE , "Invalid procedure table from service provider",
2852 WSAEINVALIDPROVIDER , "Invalid service provider version number",
2853 WSAEPROVIDERFAILEDINIT , "Unable to initialize a service provider",
2854 WSASYSCALLFAILURE , "System call failured",
2855 WSASERVICE_NOT_FOUND , "Service not found", /* not sure */
2856 WSATYPE_NOT_FOUND , "Class type not found",
2857 WSA_E_NO_MORE , "No more resources available", /* really not sure */
2858 WSA_E_CANCELLED , "Operation already cancelled", /* really not sure */
2859 WSAEREFUSED , "Operation refused", /* not sure */
2860 #endif
2862 WSAHOST_NOT_FOUND , "Host not found",
2863 WSATRY_AGAIN , "Authoritative host not found during name lookup",
2864 WSANO_RECOVERY , "Non-recoverable error during name lookup",
2865 WSANO_DATA , "Valid name, no data record of requested type",
2867 -1, NULL
2870 char *
2871 sys_strerror(int error_no)
2873 int i;
2874 static char unknown_msg[40];
2876 if (error_no >= 0 && error_no < sys_nerr)
2877 return sys_errlist[error_no];
2879 for (i = 0; _wsa_errlist[i].errnum >= 0; i++)
2880 if (_wsa_errlist[i].errnum == error_no)
2881 return _wsa_errlist[i].msg;
2883 sprintf(unknown_msg, "Unidentified error: %d", error_no);
2884 return unknown_msg;
2887 /* [andrewi 3-May-96] I've had conflicting results using both methods,
2888 but I believe the method of keeping the socket handle separate (and
2889 insuring it is not inheritable) is the correct one. */
2891 //#define SOCK_REPLACE_HANDLE
2893 #ifdef SOCK_REPLACE_HANDLE
2894 #define SOCK_HANDLE(fd) ((SOCKET) _get_osfhandle (fd))
2895 #else
2896 #define SOCK_HANDLE(fd) ((SOCKET) fd_info[fd].hnd)
2897 #endif
2899 int socket_to_fd (SOCKET s);
2902 sys_socket(int af, int type, int protocol)
2904 SOCKET s;
2906 if (winsock_lib == NULL)
2908 h_errno = ENETDOWN;
2909 return INVALID_SOCKET;
2912 check_errno ();
2914 /* call the real socket function */
2915 s = pfn_socket (af, type, protocol);
2917 if (s != INVALID_SOCKET)
2918 return socket_to_fd (s);
2920 set_errno ();
2921 return -1;
2924 /* Convert a SOCKET to a file descriptor. */
2926 socket_to_fd (SOCKET s)
2928 int fd;
2929 child_process * cp;
2931 /* Although under NT 3.5 _open_osfhandle will accept a socket
2932 handle, if opened with SO_OPENTYPE == SO_SYNCHRONOUS_NONALERT,
2933 that does not work under NT 3.1. However, we can get the same
2934 effect by using a backdoor function to replace an existing
2935 descriptor handle with the one we want. */
2937 /* allocate a file descriptor (with appropriate flags) */
2938 fd = _open ("NUL:", _O_RDWR);
2939 if (fd >= 0)
2941 #ifdef SOCK_REPLACE_HANDLE
2942 /* now replace handle to NUL with our socket handle */
2943 CloseHandle ((HANDLE) _get_osfhandle (fd));
2944 _free_osfhnd (fd);
2945 _set_osfhnd (fd, s);
2946 /* setmode (fd, _O_BINARY); */
2947 #else
2948 /* Make a non-inheritable copy of the socket handle. Note
2949 that it is possible that sockets aren't actually kernel
2950 handles, which appears to be the case on Windows 9x when
2951 the MS Proxy winsock client is installed. */
2953 /* Apparently there is a bug in NT 3.51 with some service
2954 packs, which prevents using DuplicateHandle to make a
2955 socket handle non-inheritable (causes WSACleanup to
2956 hang). The work-around is to use SetHandleInformation
2957 instead if it is available and implemented. */
2958 if (pfn_SetHandleInformation)
2960 pfn_SetHandleInformation ((HANDLE) s, HANDLE_FLAG_INHERIT, 0);
2962 else
2964 HANDLE parent = GetCurrentProcess ();
2965 HANDLE new_s = INVALID_HANDLE_VALUE;
2967 if (DuplicateHandle (parent,
2968 (HANDLE) s,
2969 parent,
2970 &new_s,
2972 FALSE,
2973 DUPLICATE_SAME_ACCESS))
2975 /* It is possible that DuplicateHandle succeeds even
2976 though the socket wasn't really a kernel handle,
2977 because a real handle has the same value. So
2978 test whether the new handle really is a socket. */
2979 long nonblocking = 0;
2980 if (pfn_ioctlsocket ((SOCKET) new_s, FIONBIO, &nonblocking) == 0)
2982 pfn_closesocket (s);
2983 s = (SOCKET) new_s;
2985 else
2987 CloseHandle (new_s);
2992 fd_info[fd].hnd = (HANDLE) s;
2993 #endif
2995 /* set our own internal flags */
2996 fd_info[fd].flags = FILE_SOCKET | FILE_BINARY | FILE_READ | FILE_WRITE;
2998 cp = new_child ();
2999 if (cp)
3001 cp->fd = fd;
3002 cp->status = STATUS_READ_ACKNOWLEDGED;
3004 /* attach child_process to fd_info */
3005 if (fd_info[ fd ].cp != NULL)
3007 DebPrint (("sys_socket: fd_info[%d] apparently in use!\n", fd));
3008 abort ();
3011 fd_info[ fd ].cp = cp;
3013 /* success! */
3014 winsock_inuse++; /* count open sockets */
3015 return fd;
3018 /* clean up */
3019 _close (fd);
3021 pfn_closesocket (s);
3022 h_errno = EMFILE;
3023 return -1;
3028 sys_bind (int s, const struct sockaddr * addr, int namelen)
3030 if (winsock_lib == NULL)
3032 h_errno = ENOTSOCK;
3033 return SOCKET_ERROR;
3036 check_errno ();
3037 if (fd_info[s].flags & FILE_SOCKET)
3039 int rc = pfn_bind (SOCK_HANDLE (s), addr, namelen);
3040 if (rc == SOCKET_ERROR)
3041 set_errno ();
3042 return rc;
3044 h_errno = ENOTSOCK;
3045 return SOCKET_ERROR;
3050 sys_connect (int s, const struct sockaddr * name, int namelen)
3052 if (winsock_lib == NULL)
3054 h_errno = ENOTSOCK;
3055 return SOCKET_ERROR;
3058 check_errno ();
3059 if (fd_info[s].flags & FILE_SOCKET)
3061 int rc = pfn_connect (SOCK_HANDLE (s), name, namelen);
3062 if (rc == SOCKET_ERROR)
3063 set_errno ();
3064 return rc;
3066 h_errno = ENOTSOCK;
3067 return SOCKET_ERROR;
3070 u_short
3071 sys_htons (u_short hostshort)
3073 return (winsock_lib != NULL) ?
3074 pfn_htons (hostshort) : hostshort;
3077 u_short
3078 sys_ntohs (u_short netshort)
3080 return (winsock_lib != NULL) ?
3081 pfn_ntohs (netshort) : netshort;
3084 unsigned long
3085 sys_inet_addr (const char * cp)
3087 return (winsock_lib != NULL) ?
3088 pfn_inet_addr (cp) : INADDR_NONE;
3092 sys_gethostname (char * name, int namelen)
3094 if (winsock_lib != NULL)
3095 return pfn_gethostname (name, namelen);
3097 if (namelen > MAX_COMPUTERNAME_LENGTH)
3098 return !GetComputerName (name, (DWORD *)&namelen);
3100 h_errno = EFAULT;
3101 return SOCKET_ERROR;
3104 struct hostent *
3105 sys_gethostbyname(const char * name)
3107 struct hostent * host;
3109 if (winsock_lib == NULL)
3111 h_errno = ENETDOWN;
3112 return NULL;
3115 check_errno ();
3116 host = pfn_gethostbyname (name);
3117 if (!host)
3118 set_errno ();
3119 return host;
3122 struct servent *
3123 sys_getservbyname(const char * name, const char * proto)
3125 struct servent * serv;
3127 if (winsock_lib == NULL)
3129 h_errno = ENETDOWN;
3130 return NULL;
3133 check_errno ();
3134 serv = pfn_getservbyname (name, proto);
3135 if (!serv)
3136 set_errno ();
3137 return serv;
3141 sys_getpeername (int s, struct sockaddr *addr, int * namelen)
3143 if (winsock_lib == NULL)
3145 h_errno = ENETDOWN;
3146 return SOCKET_ERROR;
3149 check_errno ();
3150 if (fd_info[s].flags & FILE_SOCKET)
3152 int rc = pfn_getpeername (SOCK_HANDLE (s), addr, namelen);
3153 if (rc == SOCKET_ERROR)
3154 set_errno ();
3155 return rc;
3157 h_errno = ENOTSOCK;
3158 return SOCKET_ERROR;
3163 sys_shutdown (int s, int how)
3165 if (winsock_lib == NULL)
3167 h_errno = ENETDOWN;
3168 return SOCKET_ERROR;
3171 check_errno ();
3172 if (fd_info[s].flags & FILE_SOCKET)
3174 int rc = pfn_shutdown (SOCK_HANDLE (s), how);
3175 if (rc == SOCKET_ERROR)
3176 set_errno ();
3177 return rc;
3179 h_errno = ENOTSOCK;
3180 return SOCKET_ERROR;
3184 sys_setsockopt (int s, int level, int optname, const char * optval, int optlen)
3186 if (winsock_lib == NULL)
3188 h_errno = ENETDOWN;
3189 return SOCKET_ERROR;
3192 check_errno ();
3193 if (fd_info[s].flags & FILE_SOCKET)
3195 int rc = pfn_setsockopt (SOCK_HANDLE (s), level, optname,
3196 optval, optlen);
3197 if (rc == SOCKET_ERROR)
3198 set_errno ();
3199 return rc;
3201 h_errno = ENOTSOCK;
3202 return SOCKET_ERROR;
3206 sys_listen (int s, int backlog)
3208 if (winsock_lib == NULL)
3210 h_errno = ENETDOWN;
3211 return SOCKET_ERROR;
3214 check_errno ();
3215 if (fd_info[s].flags & FILE_SOCKET)
3217 int rc = pfn_listen (SOCK_HANDLE (s), backlog);
3218 if (rc == SOCKET_ERROR)
3219 set_errno ();
3220 return rc;
3222 h_errno = ENOTSOCK;
3223 return SOCKET_ERROR;
3227 sys_getsockname (int s, struct sockaddr * name, int * namelen)
3229 if (winsock_lib == NULL)
3231 h_errno = ENETDOWN;
3232 return SOCKET_ERROR;
3235 check_errno ();
3236 if (fd_info[s].flags & FILE_SOCKET)
3238 int rc = pfn_getsockname (SOCK_HANDLE (s), name, namelen);
3239 if (rc == SOCKET_ERROR)
3240 set_errno ();
3241 return rc;
3243 h_errno = ENOTSOCK;
3244 return SOCKET_ERROR;
3248 sys_accept (int s, struct sockaddr * addr, int * addrlen)
3250 if (winsock_lib == NULL)
3252 h_errno = ENETDOWN;
3253 return -1;
3256 check_errno ();
3257 if (fd_info[s].flags & FILE_SOCKET)
3259 SOCKET t = pfn_accept (SOCK_HANDLE (s), addr, addrlen);
3260 if (t != INVALID_SOCKET)
3261 return socket_to_fd (t);
3263 set_errno ();
3264 return -1;
3266 h_errno = ENOTSOCK;
3267 return -1;
3271 sys_recvfrom (int s, char * buf, int len, int flags,
3272 struct sockaddr * from, int * fromlen)
3274 if (winsock_lib == NULL)
3276 h_errno = ENETDOWN;
3277 return SOCKET_ERROR;
3280 check_errno ();
3281 if (fd_info[s].flags & FILE_SOCKET)
3283 int rc = pfn_recvfrom (SOCK_HANDLE (s), buf, len, flags, from, fromlen);
3284 if (rc == SOCKET_ERROR)
3285 set_errno ();
3286 return rc;
3288 h_errno = ENOTSOCK;
3289 return SOCKET_ERROR;
3293 sys_sendto (int s, const char * buf, int len, int flags,
3294 const struct sockaddr * to, int tolen)
3296 if (winsock_lib == NULL)
3298 h_errno = ENETDOWN;
3299 return SOCKET_ERROR;
3302 check_errno ();
3303 if (fd_info[s].flags & FILE_SOCKET)
3305 int rc = pfn_sendto (SOCK_HANDLE (s), buf, len, flags, to, tolen);
3306 if (rc == SOCKET_ERROR)
3307 set_errno ();
3308 return rc;
3310 h_errno = ENOTSOCK;
3311 return SOCKET_ERROR;
3314 /* Windows does not have an fcntl function. Provide an implementation
3315 solely for making sockets non-blocking. */
3317 fcntl (int s, int cmd, int options)
3319 if (winsock_lib == NULL)
3321 h_errno = ENETDOWN;
3322 return -1;
3325 check_errno ();
3326 if (fd_info[s].flags & FILE_SOCKET)
3328 if (cmd == F_SETFL && options == O_NDELAY)
3330 unsigned long nblock = 1;
3331 int rc = pfn_ioctlsocket (SOCK_HANDLE (s), FIONBIO, &nblock);
3332 if (rc == SOCKET_ERROR)
3333 set_errno();
3334 /* Keep track of the fact that we set this to non-blocking. */
3335 fd_info[s].flags |= FILE_NDELAY;
3336 return rc;
3338 else
3340 h_errno = EINVAL;
3341 return SOCKET_ERROR;
3344 h_errno = ENOTSOCK;
3345 return SOCKET_ERROR;
3348 #endif /* HAVE_SOCKETS */
3351 /* Shadow main io functions: we need to handle pipes and sockets more
3352 intelligently, and implement non-blocking mode as well. */
3355 sys_close (int fd)
3357 int rc;
3359 if (fd < 0 || fd >= MAXDESC)
3361 errno = EBADF;
3362 return -1;
3365 if (fd_info[fd].cp)
3367 child_process * cp = fd_info[fd].cp;
3369 fd_info[fd].cp = NULL;
3371 if (CHILD_ACTIVE (cp))
3373 /* if last descriptor to active child_process then cleanup */
3374 int i;
3375 for (i = 0; i < MAXDESC; i++)
3377 if (i == fd)
3378 continue;
3379 if (fd_info[i].cp == cp)
3380 break;
3382 if (i == MAXDESC)
3384 #ifdef HAVE_SOCKETS
3385 if (fd_info[fd].flags & FILE_SOCKET)
3387 #ifndef SOCK_REPLACE_HANDLE
3388 if (winsock_lib == NULL) abort ();
3390 pfn_shutdown (SOCK_HANDLE (fd), 2);
3391 rc = pfn_closesocket (SOCK_HANDLE (fd));
3392 #endif
3393 winsock_inuse--; /* count open sockets */
3395 #endif
3396 delete_child (cp);
3401 /* Note that sockets do not need special treatment here (at least on
3402 NT and Windows 95 using the standard tcp/ip stacks) - it appears that
3403 closesocket is equivalent to CloseHandle, which is to be expected
3404 because socket handles are fully fledged kernel handles. */
3405 rc = _close (fd);
3407 if (rc == 0)
3408 fd_info[fd].flags = 0;
3410 return rc;
3414 sys_dup (int fd)
3416 int new_fd;
3418 new_fd = _dup (fd);
3419 if (new_fd >= 0)
3421 /* duplicate our internal info as well */
3422 fd_info[new_fd] = fd_info[fd];
3424 return new_fd;
3429 sys_dup2 (int src, int dst)
3431 int rc;
3433 if (dst < 0 || dst >= MAXDESC)
3435 errno = EBADF;
3436 return -1;
3439 /* make sure we close the destination first if it's a pipe or socket */
3440 if (src != dst && fd_info[dst].flags != 0)
3441 sys_close (dst);
3443 rc = _dup2 (src, dst);
3444 if (rc == 0)
3446 /* duplicate our internal info as well */
3447 fd_info[dst] = fd_info[src];
3449 return rc;
3452 /* Unix pipe() has only one arg */
3454 sys_pipe (int * phandles)
3456 int rc;
3457 unsigned flags;
3459 /* make pipe handles non-inheritable; when we spawn a child, we
3460 replace the relevant handle with an inheritable one. Also put
3461 pipes into binary mode; we will do text mode translation ourselves
3462 if required. */
3463 rc = _pipe (phandles, 0, _O_NOINHERIT | _O_BINARY);
3465 if (rc == 0)
3467 /* Protect against overflow, since Windows can open more handles than
3468 our fd_info array has room for. */
3469 if (phandles[0] >= MAXDESC || phandles[1] >= MAXDESC)
3471 _close (phandles[0]);
3472 _close (phandles[1]);
3473 rc = -1;
3475 else
3477 flags = FILE_PIPE | FILE_READ | FILE_BINARY;
3478 fd_info[phandles[0]].flags = flags;
3480 flags = FILE_PIPE | FILE_WRITE | FILE_BINARY;
3481 fd_info[phandles[1]].flags = flags;
3485 return rc;
3488 /* From ntproc.c */
3489 extern Lisp_Object Vw32_pipe_read_delay;
3491 /* Function to do blocking read of one byte, needed to implement
3492 select. It is only allowed on sockets and pipes. */
3494 _sys_read_ahead (int fd)
3496 child_process * cp;
3497 int rc;
3499 if (fd < 0 || fd >= MAXDESC)
3500 return STATUS_READ_ERROR;
3502 cp = fd_info[fd].cp;
3504 if (cp == NULL || cp->fd != fd || cp->status != STATUS_READ_READY)
3505 return STATUS_READ_ERROR;
3507 if ((fd_info[fd].flags & (FILE_PIPE | FILE_SOCKET)) == 0
3508 || (fd_info[fd].flags & FILE_READ) == 0)
3510 DebPrint (("_sys_read_ahead: internal error: fd %d is not a pipe or socket!\n", fd));
3511 abort ();
3514 cp->status = STATUS_READ_IN_PROGRESS;
3516 if (fd_info[fd].flags & FILE_PIPE)
3518 rc = _read (fd, &cp->chr, sizeof (char));
3520 /* Give subprocess time to buffer some more output for us before
3521 reporting that input is available; we need this because Windows 95
3522 connects DOS programs to pipes by making the pipe appear to be
3523 the normal console stdout - as a result most DOS programs will
3524 write to stdout without buffering, ie. one character at a
3525 time. Even some W32 programs do this - "dir" in a command
3526 shell on NT is very slow if we don't do this. */
3527 if (rc > 0)
3529 int wait = XINT (Vw32_pipe_read_delay);
3531 if (wait > 0)
3532 Sleep (wait);
3533 else if (wait < 0)
3534 while (++wait <= 0)
3535 /* Yield remainder of our time slice, effectively giving a
3536 temporary priority boost to the child process. */
3537 Sleep (0);
3540 #ifdef HAVE_SOCKETS
3541 else if (fd_info[fd].flags & FILE_SOCKET)
3543 unsigned long nblock = 0;
3544 /* We always want this to block, so temporarily disable NDELAY. */
3545 if (fd_info[fd].flags & FILE_NDELAY)
3546 pfn_ioctlsocket (SOCK_HANDLE (fd), FIONBIO, &nblock);
3548 rc = pfn_recv (SOCK_HANDLE (fd), &cp->chr, sizeof (char), 0);
3550 if (fd_info[fd].flags & FILE_NDELAY)
3552 nblock = 1;
3553 pfn_ioctlsocket (SOCK_HANDLE (fd), FIONBIO, &nblock);
3556 #endif
3558 if (rc == sizeof (char))
3559 cp->status = STATUS_READ_SUCCEEDED;
3560 else
3561 cp->status = STATUS_READ_FAILED;
3563 return cp->status;
3567 sys_read (int fd, char * buffer, unsigned int count)
3569 int nchars;
3570 int to_read;
3571 DWORD waiting;
3572 char * orig_buffer = buffer;
3574 if (fd < 0 || fd >= MAXDESC)
3576 errno = EBADF;
3577 return -1;
3580 if (fd_info[fd].flags & (FILE_PIPE | FILE_SOCKET))
3582 child_process *cp = fd_info[fd].cp;
3584 if ((fd_info[fd].flags & FILE_READ) == 0)
3586 errno = EBADF;
3587 return -1;
3590 nchars = 0;
3592 /* re-read CR carried over from last read */
3593 if (fd_info[fd].flags & FILE_LAST_CR)
3595 if (fd_info[fd].flags & FILE_BINARY) abort ();
3596 *buffer++ = 0x0d;
3597 count--;
3598 nchars++;
3599 fd_info[fd].flags &= ~FILE_LAST_CR;
3602 /* presence of a child_process structure means we are operating in
3603 non-blocking mode - otherwise we just call _read directly.
3604 Note that the child_process structure might be missing because
3605 reap_subprocess has been called; in this case the pipe is
3606 already broken, so calling _read on it is okay. */
3607 if (cp)
3609 int current_status = cp->status;
3611 switch (current_status)
3613 case STATUS_READ_FAILED:
3614 case STATUS_READ_ERROR:
3615 /* report normal EOF if nothing in buffer */
3616 if (nchars <= 0)
3617 fd_info[fd].flags |= FILE_AT_EOF;
3618 return nchars;
3620 case STATUS_READ_READY:
3621 case STATUS_READ_IN_PROGRESS:
3622 DebPrint (("sys_read called when read is in progress\n"));
3623 errno = EWOULDBLOCK;
3624 return -1;
3626 case STATUS_READ_SUCCEEDED:
3627 /* consume read-ahead char */
3628 *buffer++ = cp->chr;
3629 count--;
3630 nchars++;
3631 cp->status = STATUS_READ_ACKNOWLEDGED;
3632 ResetEvent (cp->char_avail);
3634 case STATUS_READ_ACKNOWLEDGED:
3635 break;
3637 default:
3638 DebPrint (("sys_read: bad status %d\n", current_status));
3639 errno = EBADF;
3640 return -1;
3643 if (fd_info[fd].flags & FILE_PIPE)
3645 PeekNamedPipe ((HANDLE) _get_osfhandle (fd), NULL, 0, NULL, &waiting, NULL);
3646 to_read = min (waiting, (DWORD) count);
3648 if (to_read > 0)
3649 nchars += _read (fd, buffer, to_read);
3651 #ifdef HAVE_SOCKETS
3652 else /* FILE_SOCKET */
3654 if (winsock_lib == NULL) abort ();
3656 /* do the equivalent of a non-blocking read */
3657 pfn_ioctlsocket (SOCK_HANDLE (fd), FIONREAD, &waiting);
3658 if (waiting == 0 && nchars == 0)
3660 h_errno = errno = EWOULDBLOCK;
3661 return -1;
3664 if (waiting)
3666 /* always use binary mode for sockets */
3667 int res = pfn_recv (SOCK_HANDLE (fd), buffer, count, 0);
3668 if (res == SOCKET_ERROR)
3670 DebPrint(("sys_read.recv failed with error %d on socket %ld\n",
3671 pfn_WSAGetLastError (), SOCK_HANDLE (fd)));
3672 set_errno ();
3673 return -1;
3675 nchars += res;
3678 #endif
3680 else
3682 int nread = _read (fd, buffer, count);
3683 if (nread >= 0)
3684 nchars += nread;
3685 else if (nchars == 0)
3686 nchars = nread;
3689 if (nchars <= 0)
3690 fd_info[fd].flags |= FILE_AT_EOF;
3691 /* Perform text mode translation if required. */
3692 else if ((fd_info[fd].flags & FILE_BINARY) == 0)
3694 nchars = crlf_to_lf (nchars, orig_buffer);
3695 /* If buffer contains only CR, return that. To be absolutely
3696 sure we should attempt to read the next char, but in
3697 practice a CR to be followed by LF would not appear by
3698 itself in the buffer. */
3699 if (nchars > 1 && orig_buffer[nchars - 1] == 0x0d)
3701 fd_info[fd].flags |= FILE_LAST_CR;
3702 nchars--;
3706 else
3707 nchars = _read (fd, buffer, count);
3709 return nchars;
3712 /* For now, don't bother with a non-blocking mode */
3714 sys_write (int fd, const void * buffer, unsigned int count)
3716 int nchars;
3718 if (fd < 0 || fd >= MAXDESC)
3720 errno = EBADF;
3721 return -1;
3724 if (fd_info[fd].flags & (FILE_PIPE | FILE_SOCKET))
3726 if ((fd_info[fd].flags & FILE_WRITE) == 0)
3728 errno = EBADF;
3729 return -1;
3732 /* Perform text mode translation if required. */
3733 if ((fd_info[fd].flags & FILE_BINARY) == 0)
3735 char * tmpbuf = alloca (count * 2);
3736 unsigned char * src = (void *)buffer;
3737 unsigned char * dst = tmpbuf;
3738 int nbytes = count;
3740 while (1)
3742 unsigned char *next;
3743 /* copy next line or remaining bytes */
3744 next = _memccpy (dst, src, '\n', nbytes);
3745 if (next)
3747 /* copied one line ending with '\n' */
3748 int copied = next - dst;
3749 nbytes -= copied;
3750 src += copied;
3751 /* insert '\r' before '\n' */
3752 next[-1] = '\r';
3753 next[0] = '\n';
3754 dst = next + 1;
3755 count++;
3757 else
3758 /* copied remaining partial line -> now finished */
3759 break;
3761 buffer = tmpbuf;
3765 #ifdef HAVE_SOCKETS
3766 if (fd_info[fd].flags & FILE_SOCKET)
3768 unsigned long nblock = 0;
3769 if (winsock_lib == NULL) abort ();
3771 /* TODO: implement select() properly so non-blocking I/O works. */
3772 /* For now, make sure the write blocks. */
3773 if (fd_info[fd].flags & FILE_NDELAY)
3774 pfn_ioctlsocket (SOCK_HANDLE (fd), FIONBIO, &nblock);
3776 nchars = pfn_send (SOCK_HANDLE (fd), buffer, count, 0);
3778 /* Set the socket back to non-blocking if it was before,
3779 for other operations that support it. */
3780 if (fd_info[fd].flags & FILE_NDELAY)
3782 nblock = 1;
3783 pfn_ioctlsocket (SOCK_HANDLE (fd), FIONBIO, &nblock);
3786 if (nchars == SOCKET_ERROR)
3788 DebPrint(("sys_write.send failed with error %d on socket %ld\n",
3789 pfn_WSAGetLastError (), SOCK_HANDLE (fd)));
3790 set_errno ();
3793 else
3794 #endif
3795 nchars = _write (fd, buffer, count);
3797 return nchars;
3800 static void
3801 check_windows_init_file ()
3803 extern int noninteractive, inhibit_window_system;
3805 /* A common indication that Emacs is not installed properly is when
3806 it cannot find the Windows installation file. If this file does
3807 not exist in the expected place, tell the user. */
3809 if (!noninteractive && !inhibit_window_system)
3811 extern Lisp_Object Vwindow_system, Vload_path, Qfile_exists_p;
3812 Lisp_Object objs[2];
3813 Lisp_Object full_load_path;
3814 Lisp_Object init_file;
3815 int fd;
3817 objs[0] = Vload_path;
3818 objs[1] = decode_env_path (0, (getenv ("EMACSLOADPATH")));
3819 full_load_path = Fappend (2, objs);
3820 init_file = build_string ("term/w32-win");
3821 fd = openp (full_load_path, init_file, Vload_suffixes, NULL, Qnil);
3822 if (fd < 0)
3824 Lisp_Object load_path_print = Fprin1_to_string (full_load_path, Qnil);
3825 char *init_file_name = SDATA (init_file);
3826 char *load_path = SDATA (load_path_print);
3827 char *buffer = alloca (1024);
3829 sprintf (buffer,
3830 "The Emacs Windows initialization file \"%s.el\" "
3831 "could not be found in your Emacs installation. "
3832 "Emacs checked the following directories for this file:\n"
3833 "\n%s\n\n"
3834 "When Emacs cannot find this file, it usually means that it "
3835 "was not installed properly, or its distribution file was "
3836 "not unpacked properly.\nSee the README.W32 file in the "
3837 "top-level Emacs directory for more information.",
3838 init_file_name, load_path);
3839 MessageBox (NULL,
3840 buffer,
3841 "Emacs Abort Dialog",
3842 MB_OK | MB_ICONEXCLAMATION | MB_TASKMODAL);
3843 /* Use the low-level Emacs abort. */
3844 #undef abort
3845 abort ();
3847 else
3849 _close (fd);
3854 void
3855 term_ntproc ()
3857 #ifdef HAVE_SOCKETS
3858 /* shutdown the socket interface if necessary */
3859 term_winsock ();
3860 #endif
3863 void
3864 init_ntproc ()
3866 #ifdef HAVE_SOCKETS
3867 /* Initialise the socket interface now if available and requested by
3868 the user by defining PRELOAD_WINSOCK; otherwise loading will be
3869 delayed until open-network-stream is called (w32-has-winsock can
3870 also be used to dynamically load or reload winsock).
3872 Conveniently, init_environment is called before us, so
3873 PRELOAD_WINSOCK can be set in the registry. */
3875 /* Always initialize this correctly. */
3876 winsock_lib = NULL;
3878 if (getenv ("PRELOAD_WINSOCK") != NULL)
3879 init_winsock (TRUE);
3880 #endif
3882 /* Initial preparation for subprocess support: replace our standard
3883 handles with non-inheritable versions. */
3885 HANDLE parent;
3886 HANDLE stdin_save = INVALID_HANDLE_VALUE;
3887 HANDLE stdout_save = INVALID_HANDLE_VALUE;
3888 HANDLE stderr_save = INVALID_HANDLE_VALUE;
3890 parent = GetCurrentProcess ();
3892 /* ignore errors when duplicating and closing; typically the
3893 handles will be invalid when running as a gui program. */
3894 DuplicateHandle (parent,
3895 GetStdHandle (STD_INPUT_HANDLE),
3896 parent,
3897 &stdin_save,
3899 FALSE,
3900 DUPLICATE_SAME_ACCESS);
3902 DuplicateHandle (parent,
3903 GetStdHandle (STD_OUTPUT_HANDLE),
3904 parent,
3905 &stdout_save,
3907 FALSE,
3908 DUPLICATE_SAME_ACCESS);
3910 DuplicateHandle (parent,
3911 GetStdHandle (STD_ERROR_HANDLE),
3912 parent,
3913 &stderr_save,
3915 FALSE,
3916 DUPLICATE_SAME_ACCESS);
3918 fclose (stdin);
3919 fclose (stdout);
3920 fclose (stderr);
3922 if (stdin_save != INVALID_HANDLE_VALUE)
3923 _open_osfhandle ((long) stdin_save, O_TEXT);
3924 else
3925 _open ("nul", O_TEXT | O_NOINHERIT | O_RDONLY);
3926 _fdopen (0, "r");
3928 if (stdout_save != INVALID_HANDLE_VALUE)
3929 _open_osfhandle ((long) stdout_save, O_TEXT);
3930 else
3931 _open ("nul", O_TEXT | O_NOINHERIT | O_WRONLY);
3932 _fdopen (1, "w");
3934 if (stderr_save != INVALID_HANDLE_VALUE)
3935 _open_osfhandle ((long) stderr_save, O_TEXT);
3936 else
3937 _open ("nul", O_TEXT | O_NOINHERIT | O_WRONLY);
3938 _fdopen (2, "w");
3941 /* unfortunately, atexit depends on implementation of malloc */
3942 /* atexit (term_ntproc); */
3943 signal (SIGABRT, term_ntproc);
3945 /* determine which drives are fixed, for GetCachedVolumeInformation */
3947 /* GetDriveType must have trailing backslash. */
3948 char drive[] = "A:\\";
3950 /* Loop over all possible drive letters */
3951 while (*drive <= 'Z')
3953 /* Record if this drive letter refers to a fixed drive. */
3954 fixed_drives[DRIVE_INDEX (*drive)] =
3955 (GetDriveType (drive) == DRIVE_FIXED);
3957 (*drive)++;
3960 /* Reset the volume info cache. */
3961 volume_cache = NULL;
3964 /* Check to see if Emacs has been installed correctly. */
3965 check_windows_init_file ();
3969 globals_of_w32 is used to initialize those global variables that
3970 must always be initialized on startup even when the global variable
3971 initialized is non zero (see the function main in emacs.c).
3973 void globals_of_w32 ()
3975 g_b_init_is_windows_9x = 0;
3976 g_b_init_open_process_token = 0;
3977 g_b_init_get_token_information = 0;
3978 g_b_init_lookup_account_sid = 0;
3979 g_b_init_get_sid_identifier_authority = 0;
3982 /* end of nt.c */
3984 /* arch-tag: 90442dd3-37be-482b-b272-ac752e3049f1
3985 (do not change this comment) */