|
771
|
1 /* Utility and Unix shadow routines under MS Windows (WIN32_NATIVE defined).
|
|
428
|
2 Copyright (C) 1994, 1995 Free Software Foundation, Inc.
|
|
2957
|
3 Copyright (C) 2000, 2001, 2002, 2004, 2005 Ben Wing.
|
|
428
|
4
|
|
|
5 This file is part of XEmacs.
|
|
|
6
|
|
|
7 XEmacs is free software; you can redistribute it and/or modify it
|
|
|
8 under the terms of the GNU General Public License as published by the
|
|
|
9 Free Software Foundation; either version 2, or (at your option) any
|
|
|
10 later version.
|
|
|
11
|
|
|
12 XEmacs is distributed in the hope that it will be useful, but WITHOUT
|
|
|
13 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
|
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
|
15 for more details.
|
|
|
16
|
|
|
17 You should have received a copy of the GNU General Public License
|
|
|
18 along with XEmacs; see the file COPYING. If not, write to the Free
|
|
|
19 Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
|
|
|
20 02111-1307, USA.
|
|
|
21
|
|
771
|
22 */
|
|
428
|
23
|
|
771
|
24 /* Authorship:
|
|
428
|
25
|
|
771
|
26 Geoff Voelker (voelker@cs.washington.edu) 7-29-94
|
|
|
27 Adapted for XEmacs by David Hobley <david@spook-le0.cia.com.au>
|
|
|
28 Sync'ed with Emacs 19.34.6 by Marc Paquette <marcpa@cam.org>
|
|
|
29 (Note: Sync messages from Marc Paquette may indicate
|
|
|
30 incomplete synching, so beware.)
|
|
|
31 Synched (completely!) with Emacs 20.6 by Ben Wing, 6-23-00.
|
|
|
32 Largely rewritten by Ben Wing for XEmacs Mule support.
|
|
2526
|
33 Synched (completely!) with Emacs 21.0.103 by Ben Wing, 6-13-01.
|
|
771
|
34 */
|
|
|
35
|
|
|
36 /* This file Mule-ized by Ben Wing, 6-23-00. */
|
|
428
|
37
|
|
|
38 #include <config.h>
|
|
|
39 #include "lisp.h"
|
|
|
40
|
|
592
|
41 #include "buffer.h"
|
|
872
|
42 #include "process.h"
|
|
592
|
43
|
|
859
|
44 #include "sysdir.h"
|
|
|
45 #include "sysfile.h"
|
|
428
|
46 #include "sysproc.h"
|
|
442
|
47 #include "syspwd.h"
|
|
859
|
48 #include "syssignal.h"
|
|
|
49 #include "systime.h"
|
|
428
|
50
|
|
442
|
51 #include "syswindows.h"
|
|
428
|
52
|
|
771
|
53 /* Control whether stat() attempts to determine file type and link count
|
|
|
54 exactly, at the expense of slower operation. Since true hard links
|
|
|
55 are supported on NTFS volumes, this is only relevant on NT. */
|
|
|
56 Lisp_Object Vmswindows_get_true_file_attributes;
|
|
428
|
57
|
|
771
|
58 /* Vmswindows_generate_fake_inodes; deleted */
|
|
|
59
|
|
|
60 Fixnum mswindows_fake_unix_uid;
|
|
428
|
61
|
|
|
62 /* Emulate getpwuid, getpwnam and others. */
|
|
|
63
|
|
771
|
64 static struct passwd the_passwd =
|
|
428
|
65 {
|
|
771
|
66 "",
|
|
|
67 "",
|
|
428
|
68 0,
|
|
|
69 0,
|
|
|
70 0,
|
|
771
|
71 "",
|
|
|
72 "",
|
|
|
73 "",
|
|
428
|
74 };
|
|
|
75
|
|
|
76 uid_t
|
|
442
|
77 getuid (void)
|
|
440
|
78 {
|
|
771
|
79 return mswindows_fake_unix_uid;
|
|
428
|
80 }
|
|
|
81
|
|
|
82 uid_t
|
|
442
|
83 geteuid (void)
|
|
428
|
84 {
|
|
771
|
85 /* Emacs 20.6 says: [[I could imagine arguing for checking to see
|
|
|
86 whether the user is in the Administrators group and returning a
|
|
|
87 UID of 0 for that case, but I don't know how wise that would be
|
|
|
88 in the long run.]] */
|
|
|
89 return mswindows_fake_unix_uid;
|
|
428
|
90 }
|
|
|
91
|
|
|
92 gid_t
|
|
442
|
93 getgid (void)
|
|
428
|
94 {
|
|
|
95 return the_passwd.pw_gid;
|
|
|
96 }
|
|
|
97
|
|
|
98 gid_t
|
|
442
|
99 getegid (void)
|
|
428
|
100 {
|
|
|
101 return getgid ();
|
|
|
102 }
|
|
|
103
|
|
|
104 struct passwd *
|
|
|
105 getpwuid (uid_t uid)
|
|
|
106 {
|
|
771
|
107 if (uid == mswindows_fake_unix_uid)
|
|
440
|
108 {
|
|
|
109 the_passwd.pw_gid = the_passwd.pw_uid = uid;
|
|
|
110 return &the_passwd;
|
|
|
111 }
|
|
|
112 else
|
|
|
113 return NULL;
|
|
428
|
114 }
|
|
|
115
|
|
|
116 struct passwd *
|
|
867
|
117 getpwnam (const Ibyte *name)
|
|
428
|
118 {
|
|
|
119 struct passwd *pw;
|
|
|
120
|
|
|
121 pw = getpwuid (getuid ());
|
|
|
122 if (!pw)
|
|
|
123 return pw;
|
|
|
124
|
|
1204
|
125 if (qxestrcasecmp_i18n (name, (Ibyte *) pw->pw_name))
|
|
428
|
126 return NULL;
|
|
|
127
|
|
|
128 return pw;
|
|
|
129 }
|
|
|
130
|
|
771
|
131 static void
|
|
442
|
132 init_user_info (void)
|
|
428
|
133 {
|
|
440
|
134 /* This code is pretty much of ad hoc nature. There is no unix-like
|
|
|
135 UIDs under Windows NT. There is no concept of root user, because
|
|
|
136 all security is ACL-based. Instead, let's use a simple variable,
|
|
|
137 nt-fake-unix-uid, which would allow the user to have a uid of
|
|
|
138 choice. --kkm, 02/03/2000 */
|
|
|
139 #if 0
|
|
428
|
140 /* Find the user's real name by opening the process token and
|
|
|
141 looking up the name associated with the user-sid in that token.
|
|
|
142
|
|
|
143 Use the relative portion of the identifier authority value from
|
|
|
144 the user-sid as the user id value (same for group id using the
|
|
|
145 primary group sid from the process token). */
|
|
|
146
|
|
771
|
147 TOKEN_USER sidinfo;
|
|
|
148 Extbyte name[256], domain[256];
|
|
|
149 Charcount length = sizeof (name) / XETCHAR_SIZE;
|
|
|
150 Charcount dlength = sizeof (domain) / XETCHAR_SIZE;
|
|
|
151 DWORD trash;
|
|
|
152 HANDLE token = NULL;
|
|
|
153 SID_NAME_USE user_type;
|
|
428
|
154
|
|
|
155 if (OpenProcessToken (GetCurrentProcess (), TOKEN_QUERY, &token)
|
|
771
|
156 && GetTokenInformation (token, TokenUser, &sidinfo, sizeof (sidinfo),
|
|
|
157 &trash)
|
|
|
158 && qxeLookupAccountSid (NULL, sidinfo.User.Sid, name, &length,
|
|
|
159 domain, &dlength, &user_type))
|
|
428
|
160 {
|
|
771
|
161 TSTR_TO_C_STRING_MALLOC (name, the_passwd.pw_name);
|
|
428
|
162 /* Determine a reasonable uid value. */
|
|
771
|
163 if (qxestrcasecmp ("administrator", the_passwd.pw_name) == 0)
|
|
428
|
164 {
|
|
|
165 the_passwd.pw_uid = 0;
|
|
|
166 the_passwd.pw_gid = 0;
|
|
|
167 }
|
|
|
168 else
|
|
|
169 {
|
|
|
170 SID_IDENTIFIER_AUTHORITY * pSIA;
|
|
771
|
171 TOKEN_PRIMARY_GROUP group;
|
|
428
|
172
|
|
771
|
173 pSIA = GetSidIdentifierAuthority (sidinfo.User.Sid);
|
|
428
|
174 /* I believe the relative portion is the last 4 bytes (of 6)
|
|
|
175 with msb first. */
|
|
|
176 the_passwd.pw_uid = ((pSIA->Value[2] << 24) +
|
|
|
177 (pSIA->Value[3] << 16) +
|
|
|
178 (pSIA->Value[4] << 8) +
|
|
|
179 (pSIA->Value[5] << 0));
|
|
|
180 /* restrict to conventional uid range for normal users */
|
|
|
181 the_passwd.pw_uid = the_passwd.pw_uid % 60001;
|
|
|
182
|
|
|
183 /* Get group id */
|
|
|
184 if (GetTokenInformation (token, TokenPrimaryGroup,
|
|
771
|
185 &group, sizeof (group), &trash))
|
|
428
|
186 {
|
|
|
187 SID_IDENTIFIER_AUTHORITY * pSIA;
|
|
|
188
|
|
771
|
189 pSIA = GetSidIdentifierAuthority (group.PrimaryGroup);
|
|
428
|
190 the_passwd.pw_gid = ((pSIA->Value[2] << 24) +
|
|
|
191 (pSIA->Value[3] << 16) +
|
|
|
192 (pSIA->Value[4] << 8) +
|
|
|
193 (pSIA->Value[5] << 0));
|
|
|
194 /* I don't know if this is necessary, but for safety... */
|
|
|
195 the_passwd.pw_gid = the_passwd.pw_gid % 60001;
|
|
|
196 }
|
|
|
197 else
|
|
|
198 the_passwd.pw_gid = the_passwd.pw_uid;
|
|
|
199 }
|
|
|
200 }
|
|
|
201 /* If security calls are not supported (presumably because we
|
|
|
202 are running under Windows 95), fallback to this. */
|
|
771
|
203 else if (qxeGetUserName (name, &length))
|
|
428
|
204 {
|
|
771
|
205 TSTR_TO_C_STRING_MALLOC (name, the_passwd.pw_name);
|
|
|
206 if (qxestrcasecmp ("administrator", the_passwd.pw_name) == 0)
|
|
428
|
207 the_passwd.pw_uid = 0;
|
|
|
208 else
|
|
|
209 the_passwd.pw_uid = 123;
|
|
|
210 the_passwd.pw_gid = the_passwd.pw_uid;
|
|
|
211 }
|
|
|
212 else
|
|
|
213 {
|
|
771
|
214 the_passwd.pw_name = "unknown";
|
|
428
|
215 the_passwd.pw_uid = 123;
|
|
|
216 the_passwd.pw_gid = 123;
|
|
|
217 }
|
|
|
218
|
|
440
|
219 if (token)
|
|
|
220 CloseHandle (token);
|
|
|
221 #else
|
|
|
222 /* Obtain only logon id here, uid part is moved to getuid */
|
|
771
|
223 DWORD length = UNLEN + 1;
|
|
|
224 Extbyte name[MAX_XETCHAR_SIZE * (UNLEN + 1)];
|
|
|
225 if (qxeGetUserName (name, &length))
|
|
|
226 TSTR_TO_C_STRING_MALLOC (name, the_passwd.pw_name);
|
|
440
|
227 else
|
|
771
|
228 the_passwd.pw_name = "unknown";
|
|
440
|
229 #endif
|
|
|
230
|
|
771
|
231 #if 0
|
|
428
|
232 /* Ensure HOME and SHELL are defined. */
|
|
|
233 /*
|
|
|
234 * With XEmacs, setting $HOME is deprecated.
|
|
|
235 */
|
|
771
|
236 if (egetenv ("HOME") == NULL)
|
|
|
237 eputenv ("HOME=c:/");
|
|
428
|
238 #endif
|
|
|
239
|
|
611
|
240 /* Set dir from environment variables. */
|
|
771
|
241 the_passwd.pw_dir = (char *) qxestrdup (get_home_directory ());
|
|
611
|
242 /* We used to set pw_shell here, but the order is wrong (SHELL gets
|
|
853
|
243 initted in process.c, called later in the init process) and pw_shell
|
|
611
|
244 is not used anywhere. */
|
|
428
|
245 }
|
|
|
246
|
|
771
|
247 /* Parse the root part of file name, if present. Return length and
|
|
867
|
248 optionally store pointer to Ibyte after root. */
|
|
771
|
249 static Bytecount
|
|
867
|
250 parse_root (Ibyte *name, Ibyte **pPath)
|
|
428
|
251 {
|
|
867
|
252 Ibyte *start = name;
|
|
428
|
253
|
|
|
254 if (name == NULL)
|
|
|
255 return 0;
|
|
|
256
|
|
|
257 /* find the root name of the volume if given */
|
|
|
258 if (isalpha (name[0]) && name[1] == ':')
|
|
|
259 {
|
|
|
260 /* skip past drive specifier */
|
|
|
261 name += 2;
|
|
|
262 if (IS_DIRECTORY_SEP (name[0]))
|
|
|
263 name++;
|
|
|
264 }
|
|
|
265 else if (IS_DIRECTORY_SEP (name[0]) && IS_DIRECTORY_SEP (name[1]))
|
|
|
266 {
|
|
|
267 int slashes = 2;
|
|
|
268 name += 2;
|
|
|
269 do
|
|
|
270 {
|
|
|
271 if (IS_DIRECTORY_SEP (*name) && --slashes == 0)
|
|
|
272 break;
|
|
|
273 name++;
|
|
|
274 }
|
|
771
|
275 while (*name);
|
|
428
|
276 if (IS_DIRECTORY_SEP (name[0]))
|
|
|
277 name++;
|
|
|
278 }
|
|
|
279
|
|
|
280 if (pPath)
|
|
|
281 *pPath = name;
|
|
|
282
|
|
|
283 return name - start;
|
|
|
284 }
|
|
|
285
|
|
|
286 /* Get long base name for name; name is assumed to be absolute. */
|
|
867
|
287 static Ibyte *
|
|
|
288 get_long_basename (Ibyte *name)
|
|
428
|
289 {
|
|
771
|
290 WIN32_FIND_DATAW find_data;
|
|
428
|
291 HANDLE dir_handle;
|
|
771
|
292 Extbyte *nameext;
|
|
428
|
293
|
|
771
|
294 /* must be valid filename, no wild cards or other invalid characters */
|
|
|
295 if (qxestrpbrk (name, "*?|<>\""))
|
|
|
296 return 0;
|
|
428
|
297
|
|
2526
|
298 PATHNAME_CONVERT_OUT (name, nameext);
|
|
771
|
299 dir_handle = qxeFindFirstFile (nameext, &find_data);
|
|
428
|
300 if (dir_handle != INVALID_HANDLE_VALUE)
|
|
|
301 {
|
|
867
|
302 Ibyte *fileint;
|
|
771
|
303
|
|
|
304 TSTR_TO_C_STRING_MALLOC (find_data.cFileName, fileint);
|
|
428
|
305 FindClose (dir_handle);
|
|
771
|
306 return fileint;
|
|
428
|
307 }
|
|
771
|
308 return 0;
|
|
428
|
309 }
|
|
|
310
|
|
|
311 /* Get long name for file, if possible (assumed to be absolute). */
|
|
867
|
312 Ibyte *
|
|
|
313 mswindows_get_long_filename (Ibyte *name)
|
|
428
|
314 {
|
|
867
|
315 Ibyte *full = mswindows_canonicalize_filename (name);
|
|
|
316 Ibyte *p;
|
|
|
317 Ibyte *q;
|
|
771
|
318 DECLARE_EISTRING (o);
|
|
|
319 Bytecount len;
|
|
428
|
320
|
|
|
321 /* Copy root part verbatim. */
|
|
|
322 len = parse_root (full, &p);
|
|
771
|
323 eicpy_raw (o, full, len);
|
|
428
|
324
|
|
771
|
325 while (p != NULL && *p)
|
|
428
|
326 {
|
|
867
|
327 Ibyte *component;
|
|
771
|
328
|
|
428
|
329 q = p;
|
|
771
|
330 p = qxestrchr (q, '\\');
|
|
428
|
331 if (p) *p = '\0';
|
|
771
|
332 component = get_long_basename (full);
|
|
|
333 if (component)
|
|
428
|
334 {
|
|
771
|
335 eicat_rawz (o, component);
|
|
428
|
336 if (p != NULL)
|
|
|
337 {
|
|
|
338 *p++ = '\\';
|
|
771
|
339 eicat_ch (o, '\\');
|
|
428
|
340 }
|
|
1726
|
341 xfree (component, Ibyte *);
|
|
428
|
342 }
|
|
|
343 else
|
|
771
|
344 {
|
|
1726
|
345 xfree (full, Ibyte *);
|
|
771
|
346 return 0;
|
|
|
347 }
|
|
428
|
348 }
|
|
|
349
|
|
1726
|
350 xfree (full, Ibyte *);
|
|
771
|
351 return eicpyout_malloc (o, 0);
|
|
428
|
352 }
|
|
|
353
|
|
771
|
354 static int
|
|
867
|
355 is_unc_volume (const Ibyte *filename)
|
|
771
|
356 {
|
|
867
|
357 const Ibyte *ptr = filename;
|
|
428
|
358
|
|
771
|
359 if (!IS_DIRECTORY_SEP (ptr[0]) || !IS_DIRECTORY_SEP (ptr[1]) || !ptr[2])
|
|
|
360 return 0;
|
|
|
361
|
|
|
362 if (qxestrpbrk (ptr + 2, "*?|<>\"\\/"))
|
|
|
363 return 0;
|
|
|
364
|
|
|
365 return 1;
|
|
428
|
366 }
|
|
|
367
|
|
771
|
368 /* NOTE: Value returned is still in external format. Callers need to
|
|
|
369 convert. */
|
|
707
|
370 #define REG_ROOT "SOFTWARE\\XEmacs\\XEmacs"
|
|
428
|
371
|
|
771
|
372 static LPBYTE
|
|
867
|
373 nt_get_resource (Ibyte *key, LPDWORD lpdwtype)
|
|
428
|
374 {
|
|
|
375 LPBYTE lpvalue;
|
|
|
376 HKEY hrootkey = NULL;
|
|
|
377 DWORD cbData;
|
|
771
|
378 Extbyte *keyext;
|
|
|
379
|
|
|
380 C_STRING_TO_TSTR (key, keyext);
|
|
428
|
381
|
|
|
382 /* Check both the current user and the local machine to see if
|
|
|
383 we have any resources. */
|
|
|
384
|
|
771
|
385 if (qxeRegOpenKeyEx (HKEY_CURRENT_USER, XETEXT (REG_ROOT), 0, KEY_READ,
|
|
|
386 &hrootkey) == ERROR_SUCCESS)
|
|
428
|
387 {
|
|
|
388 lpvalue = NULL;
|
|
|
389
|
|
771
|
390 if (qxeRegQueryValueEx (hrootkey, keyext, NULL, NULL, NULL,
|
|
|
391 &cbData) == ERROR_SUCCESS
|
|
2367
|
392 && (lpvalue = xnew_array (BYTE, cbData)) != NULL
|
|
771
|
393 && qxeRegQueryValueEx (hrootkey, keyext, NULL, lpdwtype, lpvalue,
|
|
|
394 &cbData) == ERROR_SUCCESS)
|
|
|
395 return (lpvalue);
|
|
428
|
396
|
|
1726
|
397 if (lpvalue)
|
|
|
398 xfree (lpvalue, LPBYTE);
|
|
428
|
399
|
|
|
400 RegCloseKey (hrootkey);
|
|
|
401 }
|
|
|
402
|
|
771
|
403 if (qxeRegOpenKeyEx (HKEY_LOCAL_MACHINE, XETEXT (REG_ROOT), 0, KEY_READ,
|
|
|
404 &hrootkey) == ERROR_SUCCESS)
|
|
428
|
405 {
|
|
|
406 lpvalue = NULL;
|
|
|
407
|
|
771
|
408 if (qxeRegQueryValueEx (hrootkey, keyext, NULL, NULL, NULL,
|
|
|
409 &cbData) == ERROR_SUCCESS &&
|
|
2367
|
410 (lpvalue = xnew_array (BYTE, cbData)) != NULL &&
|
|
771
|
411 qxeRegQueryValueEx (hrootkey, keyext, NULL, lpdwtype, lpvalue,
|
|
|
412 &cbData) == ERROR_SUCCESS)
|
|
|
413 return (lpvalue);
|
|
428
|
414
|
|
1726
|
415 if (lpvalue)
|
|
|
416 xfree (lpvalue, LPBYTE);
|
|
428
|
417
|
|
|
418 RegCloseKey (hrootkey);
|
|
|
419 }
|
|
|
420
|
|
|
421 return (NULL);
|
|
|
422 }
|
|
|
423
|
|
|
424 void
|
|
814
|
425 init_mswindows_environment (void)
|
|
428
|
426 {
|
|
|
427 /* Check for environment variables and use registry if they don't exist */
|
|
771
|
428 /* Emacs 20.6 sets default values for these; not necessary here because
|
|
|
429 we already supply them. (except SHELL, which is set in init_user_info().)
|
|
|
430 Emacs 20.6 messes with TMPDIR; not necessary here. */
|
|
428
|
431 {
|
|
|
432 int i;
|
|
|
433 LPBYTE lpval;
|
|
|
434 DWORD dwType;
|
|
|
435
|
|
2367
|
436 static Ascbyte *env_vars[] =
|
|
428
|
437 {
|
|
|
438 "HOME",
|
|
|
439 "EMACSLOADPATH",
|
|
|
440 "EMACSDEBUGPATHS",
|
|
|
441 "SHELL",
|
|
|
442 "CMDPROXY",
|
|
|
443 "EMACSDATA",
|
|
|
444 "EMACSPATH",
|
|
|
445 "EMACSPACKAGEPATH",
|
|
3179
|
446 "EMACSEARLYPACKAGES",
|
|
|
447 "EMACSLATEPACKAGES",
|
|
|
448 "EMACSLASTPACKAGES",
|
|
771
|
449 "EMACSLOCKMETHOD",
|
|
428
|
450 "INFOPATH"
|
|
|
451 };
|
|
771
|
452 #if defined (HEAP_IN_DATA) && !defined (PDUMP)
|
|
430
|
453 cache_system_info ();
|
|
|
454 #endif
|
|
771
|
455
|
|
|
456 #if 0 /* FSF 21.1 */
|
|
|
457 /* !!#### i think i already do the equivalent elsewhere.
|
|
|
458 delete when i'm sure i do.
|
|
|
459 (but maybe i should be playing with LANG when the user changes
|
|
|
460 the locale, so that subprocesses get it right.) */
|
|
|
461 /* Get default locale info and use it for LANG. */
|
|
|
462 if (GetLocaleInfo (LOCALE_USER_DEFAULT,
|
|
|
463 LOCALE_SABBREVLANGNAME | LOCALE_USE_CP_ACP,
|
|
|
464 locale_name, sizeof (locale_name)))
|
|
|
465 {
|
|
|
466 for (i = 0; i < (sizeof (env_vars) / sizeof (env_vars[0])); i++)
|
|
|
467 {
|
|
|
468 if (strcmp (env_vars[i].name, "LANG") == 0)
|
|
|
469 {
|
|
|
470 env_vars[i].def_value = locale_name;
|
|
|
471 break;
|
|
|
472 }
|
|
|
473 }
|
|
|
474 }
|
|
|
475 #endif /* 0 */
|
|
|
476
|
|
428
|
477 for (i = 0; i < countof (env_vars); i++)
|
|
|
478 {
|
|
771
|
479 if (!egetenv (env_vars[i]) &&
|
|
1204
|
480 (lpval = nt_get_resource ((Ibyte *) env_vars[i], &dwType)) != NULL)
|
|
428
|
481 {
|
|
|
482 if (dwType == REG_EXPAND_SZ)
|
|
|
483 {
|
|
771
|
484 Extbyte *buf = NULL;
|
|
867
|
485 Ibyte *envval;
|
|
771
|
486 Charcount cch;
|
|
428
|
487
|
|
771
|
488 cch = qxeExpandEnvironmentStrings ((Extbyte *) lpval, buf, 0);
|
|
2367
|
489 buf = alloca_extbytes (cch * XETCHAR_SIZE);
|
|
771
|
490 qxeExpandEnvironmentStrings ((Extbyte *) lpval, buf, cch);
|
|
|
491 TSTR_TO_C_STRING (buf, envval);
|
|
1204
|
492 eputenv (env_vars[i], (CIbyte *) envval);
|
|
428
|
493 }
|
|
|
494 else if (dwType == REG_SZ)
|
|
|
495 {
|
|
867
|
496 Ibyte *envval;
|
|
771
|
497
|
|
|
498 TSTR_TO_C_STRING (lpval, envval);
|
|
1204
|
499 eputenv (env_vars[i], (CIbyte *) envval);
|
|
428
|
500 }
|
|
|
501
|
|
1726
|
502 xfree (lpval, LPBYTE);
|
|
428
|
503 }
|
|
|
504 }
|
|
|
505 }
|
|
|
506
|
|
|
507 /* Another special case: on NT, the PATH variable is actually named
|
|
|
508 "Path" although cmd.exe (perhaps NT itself) arranges for
|
|
|
509 environment variable lookup and setting to be case insensitive.
|
|
|
510 However, Emacs assumes a fully case sensitive environment, so we
|
|
|
511 need to change "Path" to "PATH" to match the expectations of
|
|
771
|
512 various elisp packages.
|
|
428
|
513
|
|
|
514 The same applies to COMSPEC. */
|
|
|
515 {
|
|
2367
|
516 EXTERNAL_LIST_LOOP_2 (str, Vprocess_environment)
|
|
771
|
517 {
|
|
|
518 if (STRINGP (str))
|
|
|
519 {
|
|
867
|
520 Ibyte *dat = XSTRING_DATA (str);
|
|
2367
|
521 if (qxestrncasecmp_ascii (dat, "PATH=", 5) == 0)
|
|
771
|
522 memcpy (dat, "PATH=", 5);
|
|
2367
|
523 else if (qxestrncasecmp_ascii (dat, "COMSPEC=", 8) == 0)
|
|
771
|
524 memcpy (dat, "COMSPEC=", 8);
|
|
|
525 }
|
|
|
526 }
|
|
428
|
527 }
|
|
|
528
|
|
|
529 init_user_info ();
|
|
|
530 }
|
|
|
531
|
|
771
|
532 /* Emacs 20.6 contains a routine get_emacs_configuration() here to set
|
|
|
533 EMACS_CONFIGURATION. */
|
|
428
|
534 #ifndef HAVE_X_WINDOWS
|
|
|
535 /* X11R6 on NT provides the single parameter version of this command. */
|
|
|
536
|
|
|
537 #include <sys/timeb.h>
|
|
|
538
|
|
|
539 /* Emulate gettimeofday (Ulrich Leodolter, 1/11/95). */
|
|
|
540 void
|
|
|
541 gettimeofday (struct timeval *tv, struct timezone *tz)
|
|
|
542 {
|
|
|
543 struct _timeb tb;
|
|
|
544 _ftime (&tb);
|
|
|
545
|
|
|
546 tv->tv_sec = tb.time;
|
|
|
547 tv->tv_usec = tb.millitm * 1000L;
|
|
|
548 if (tz)
|
|
|
549 {
|
|
|
550 tz->tz_minuteswest = tb.timezone; /* minutes west of Greenwich */
|
|
|
551 tz->tz_dsttime = tb.dstflag; /* type of dst correction */
|
|
|
552 }
|
|
|
553 }
|
|
|
554
|
|
|
555 #endif /* HAVE_X_WINDOWS */
|
|
|
556
|
|
771
|
557
|
|
428
|
558 /* ------------------------------------------------------------------------- */
|
|
771
|
559 /* IO support and wrapper functions for Win32 API. */
|
|
428
|
560 /* ------------------------------------------------------------------------- */
|
|
|
561
|
|
771
|
562 typedef struct volume_info_data
|
|
428
|
563 {
|
|
771
|
564 struct volume_info_data *next;
|
|
428
|
565
|
|
|
566 /* time when info was obtained */
|
|
771
|
567 DWORD timestamp;
|
|
428
|
568
|
|
|
569 /* actual volume info */
|
|
867
|
570 Ibyte *root_dir;
|
|
771
|
571 DWORD serialnum;
|
|
|
572 DWORD maxcomp;
|
|
|
573 DWORD flags;
|
|
867
|
574 Ibyte *name;
|
|
|
575 Ibyte *type;
|
|
428
|
576 } volume_info_data;
|
|
|
577
|
|
|
578 /* Global referenced by various functions. */
|
|
|
579 static volume_info_data volume_info;
|
|
|
580
|
|
|
581 /* Vector to indicate which drives are local and fixed (for which cached
|
|
|
582 data never expires). */
|
|
|
583 static BOOL fixed_drives[26];
|
|
|
584
|
|
|
585 /* Consider cached volume information to be stale if older than 10s,
|
|
|
586 at least for non-local drives. Info for fixed drives is never stale. */
|
|
|
587 #define DRIVE_INDEX( c ) ( (c) <= 'Z' ? (c) - 'A' : (c) - 'a' )
|
|
|
588 #define VOLINFO_STILL_VALID( root_dir, info ) \
|
|
|
589 ( ( isalpha (root_dir[0]) && \
|
|
|
590 fixed_drives[ DRIVE_INDEX (root_dir[0]) ] ) \
|
|
|
591 || GetTickCount () - info->timestamp < 10000 )
|
|
|
592
|
|
|
593 /* Cache support functions. */
|
|
|
594
|
|
|
595 /* Simple linked list with linear search is sufficient. */
|
|
|
596 static volume_info_data *volume_cache = NULL;
|
|
|
597
|
|
|
598 static volume_info_data *
|
|
867
|
599 lookup_volume_info (Ibyte *root_dir)
|
|
428
|
600 {
|
|
771
|
601 volume_info_data *info;
|
|
428
|
602
|
|
|
603 for (info = volume_cache; info; info = info->next)
|
|
771
|
604 if (qxestrcasecmp_i18n (info->root_dir, root_dir) == 0)
|
|
428
|
605 break;
|
|
|
606 return info;
|
|
|
607 }
|
|
|
608
|
|
|
609 static void
|
|
867
|
610 add_volume_info (Ibyte *root_dir, volume_info_data *info)
|
|
428
|
611 {
|
|
771
|
612 info->root_dir = qxestrdup (root_dir);
|
|
428
|
613 info->next = volume_cache;
|
|
|
614 volume_cache = info;
|
|
|
615 }
|
|
|
616
|
|
|
617
|
|
|
618 /* Wrapper for GetVolumeInformation, which uses caching to avoid
|
|
|
619 performance penalty (~2ms on 486 for local drives, 7.5ms for local
|
|
|
620 cdrom drive, ~5-10ms or more for remote drives on LAN). */
|
|
771
|
621 static volume_info_data *
|
|
867
|
622 get_cached_volume_information (Ibyte *root_dir)
|
|
428
|
623 {
|
|
771
|
624 volume_info_data *info;
|
|
867
|
625 Ibyte *default_root;
|
|
428
|
626
|
|
|
627 /* NULL for root_dir means use root from current directory. */
|
|
|
628 if (root_dir == NULL)
|
|
|
629 {
|
|
771
|
630 Charcount nchars = qxeGetCurrentDirectory (0, NULL);
|
|
|
631 Extbyte *rootext;
|
|
|
632
|
|
|
633 if (!nchars)
|
|
428
|
634 return NULL;
|
|
771
|
635 rootext = alloca_extbytes (nchars * XETCHAR_SIZE);
|
|
|
636 if (!qxeGetCurrentDirectory (nchars, rootext))
|
|
|
637 return NULL;
|
|
|
638 TSTR_TO_C_STRING (rootext, default_root);
|
|
428
|
639 parse_root (default_root, &root_dir);
|
|
|
640 *root_dir = 0;
|
|
|
641 root_dir = default_root;
|
|
|
642 }
|
|
|
643
|
|
|
644 /* Local fixed drives can be cached permanently. Removable drives
|
|
|
645 cannot be cached permanently, since the volume name and serial
|
|
|
646 number (if nothing else) can change. Remote drives should be
|
|
|
647 treated as if they are removable, since there is no sure way to
|
|
|
648 tell whether they are or not. Also, the UNC association of drive
|
|
|
649 letters mapped to remote volumes can be changed at any time (even
|
|
|
650 by other processes) without notice.
|
|
|
651
|
|
|
652 As a compromise, so we can benefit from caching info for remote
|
|
|
653 volumes, we use a simple expiry mechanism to invalidate cache
|
|
|
654 entries that are more than ten seconds old. */
|
|
|
655
|
|
|
656 #if 0
|
|
|
657 /* No point doing this, because WNetGetConnection is even slower than
|
|
|
658 GetVolumeInformation, consistently taking ~50ms on a 486 (FWIW,
|
|
|
659 GetDriveType is about the only call of this type which does not
|
|
|
660 involve network access, and so is extremely quick). */
|
|
|
661
|
|
|
662 /* Map drive letter to UNC if remote. */
|
|
771
|
663 if (isalpha (root_dir[0]) && !fixed [DRIVE_INDEX (root_dir[0])])
|
|
428
|
664 {
|
|
771
|
665 Extbyte remote_name[256 * XETCHAR_SIZE];
|
|
867
|
666 Ibyte drive[3] = { root_dir[0], ':' };
|
|
771
|
667 Extbyte *driveext;
|
|
428
|
668
|
|
2526
|
669 PATHNAME_CONVERT_OUT (drive, driveext);
|
|
771
|
670 if (qxeWNetGetConnection (driveext, remote_name,
|
|
|
671 sizeof (remote_name) / XETCHAR_SIZE)
|
|
428
|
672 == NO_ERROR)
|
|
|
673 /* do something */ ;
|
|
|
674 }
|
|
|
675 #endif
|
|
|
676
|
|
|
677 info = lookup_volume_info (root_dir);
|
|
|
678
|
|
|
679 if (info == NULL || ! VOLINFO_STILL_VALID (root_dir, info))
|
|
771
|
680 {
|
|
|
681 Extbyte name[256 * MAX_XETCHAR_SIZE];
|
|
|
682 DWORD serialnum;
|
|
|
683 DWORD maxcomp;
|
|
|
684 DWORD flags;
|
|
|
685 Extbyte type[256 * MAX_XETCHAR_SIZE];
|
|
1204
|
686 Extbyte *rootdirext;
|
|
|
687
|
|
2526
|
688 PATHNAME_CONVERT_OUT (root_dir, rootdirext);
|
|
428
|
689
|
|
771
|
690 /* Info is not cached, or is stale. */
|
|
1204
|
691 if (!qxeGetVolumeInformation (rootdirext,
|
|
771
|
692 name, sizeof (name) / XETCHAR_SIZE,
|
|
|
693 &serialnum,
|
|
|
694 &maxcomp,
|
|
|
695 &flags,
|
|
|
696 type, sizeof (type) / XETCHAR_SIZE))
|
|
|
697 return NULL;
|
|
428
|
698
|
|
771
|
699 /* Cache the volume information for future use, overwriting existing
|
|
|
700 entry if present. */
|
|
|
701 if (info == NULL)
|
|
|
702 {
|
|
2367
|
703 info = xnew (volume_info_data);
|
|
771
|
704 add_volume_info (root_dir, info);
|
|
|
705 }
|
|
|
706 else
|
|
|
707 {
|
|
1726
|
708 xfree (info->name, Ibyte *);
|
|
|
709 xfree (info->type, Ibyte *);
|
|
771
|
710 }
|
|
428
|
711
|
|
771
|
712 TSTR_TO_C_STRING_MALLOC (name, info->name);
|
|
|
713 info->serialnum = serialnum;
|
|
|
714 info->maxcomp = maxcomp;
|
|
|
715 info->flags = flags;
|
|
|
716 TSTR_TO_C_STRING_MALLOC (type, info->type);
|
|
|
717 info->timestamp = GetTickCount ();
|
|
|
718 }
|
|
428
|
719
|
|
|
720 return info;
|
|
|
721 }
|
|
|
722
|
|
|
723 /* Get information on the volume where name is held; set path pointer to
|
|
|
724 start of pathname in name (past UNC header\volume header if present). */
|
|
771
|
725 static int
|
|
867
|
726 get_volume_info (const Ibyte *name, const Ibyte **pPath)
|
|
428
|
727 {
|
|
771
|
728 /* We probably only need a couple of bytes, but let's be generous in
|
|
|
729 case this function gets changed */
|
|
2367
|
730 Ibyte *temp = alloca_ibytes (qxestrlen (name) + 10);
|
|
867
|
731 Ibyte *rootname = NULL; /* default to current volume */
|
|
771
|
732 volume_info_data *info;
|
|
428
|
733
|
|
|
734 if (name == NULL)
|
|
|
735 return FALSE;
|
|
|
736
|
|
|
737 /* find the root name of the volume if given */
|
|
|
738 if (isalpha (name[0]) && name[1] == ':')
|
|
|
739 {
|
|
|
740 rootname = temp;
|
|
|
741 temp[0] = *name++;
|
|
|
742 temp[1] = *name++;
|
|
|
743 temp[2] = '\\';
|
|
|
744 temp[3] = 0;
|
|
|
745 }
|
|
|
746 else if (IS_DIRECTORY_SEP (name[0]) && IS_DIRECTORY_SEP (name[1]))
|
|
|
747 {
|
|
867
|
748 Ibyte *str = temp;
|
|
428
|
749 int slashes = 4;
|
|
|
750 rootname = temp;
|
|
|
751 do
|
|
|
752 {
|
|
|
753 if (IS_DIRECTORY_SEP (*name) && --slashes == 0)
|
|
|
754 break;
|
|
|
755 *str++ = *name++;
|
|
|
756 }
|
|
771
|
757 while (*name);
|
|
428
|
758
|
|
|
759 *str++ = '\\';
|
|
|
760 *str = 0;
|
|
|
761 }
|
|
|
762
|
|
|
763 if (pPath)
|
|
|
764 *pPath = name;
|
|
|
765
|
|
771
|
766 info = get_cached_volume_information (rootname);
|
|
428
|
767 if (info != NULL)
|
|
|
768 {
|
|
|
769 /* Set global referenced by other functions. */
|
|
|
770 volume_info = *info;
|
|
|
771 return TRUE;
|
|
|
772 }
|
|
|
773 return FALSE;
|
|
|
774 }
|
|
|
775
|
|
771
|
776 /* XEmacs: Everything referring to map_win32_filename() aka map_w32_filename()
|
|
|
777 removed; it was only for NT 3.1, which we hereby do not support. (NT 3.5
|
|
|
778 predates Windows 95!) */
|
|
428
|
779
|
|
1204
|
780 int
|
|
|
781 mswindows_is_executable (const Ibyte *name)
|
|
771
|
782 {
|
|
867
|
783 Ibyte *p = qxestrrchr (name, '.');
|
|
2367
|
784 return (p != NULL && (qxestrcasecmp_ascii (p, ".exe") == 0 ||
|
|
|
785 qxestrcasecmp_ascii (p, ".com") == 0 ||
|
|
|
786 qxestrcasecmp_ascii (p, ".bat") == 0 ||
|
|
|
787 qxestrcasecmp_ascii (p, ".cmd") == 0));
|
|
428
|
788 }
|
|
|
789
|
|
|
790 /* Emulate the Unix directory procedures opendir, closedir,
|
|
|
791 and readdir. We can't use the procedures supplied in sysdep.c,
|
|
|
792 so we provide them here. */
|
|
|
793
|
|
|
794 struct direct dir_static; /* simulated directory contents */
|
|
|
795 static HANDLE dir_find_handle = INVALID_HANDLE_VALUE;
|
|
771
|
796 /* dir_is_fat deleted */
|
|
867
|
797 static Ibyte *dir_pathname;
|
|
771
|
798 static WIN32_FIND_DATAW dir_find_data;
|
|
|
799
|
|
|
800 /* Support shares on a network resource as subdirectories of a read-only
|
|
|
801 root directory. */
|
|
|
802 static HANDLE wnet_enum_handle = INVALID_HANDLE_VALUE;
|
|
867
|
803 static HANDLE open_unc_volume (const Ibyte *);
|
|
|
804 static Ibyte *read_unc_volume (HANDLE);
|
|
771
|
805 static int close_unc_volume (HANDLE);
|
|
428
|
806
|
|
|
807 DIR *
|
|
867
|
808 mswindows_opendir (const Ibyte *filename)
|
|
428
|
809 {
|
|
|
810 DIR *dirp;
|
|
|
811
|
|
|
812 /* Opening is done by FindFirstFile. However, a read is inherent to
|
|
|
813 this operation, so we defer the open until read time. */
|
|
|
814
|
|
771
|
815 if (dir_find_handle != INVALID_HANDLE_VALUE)
|
|
428
|
816 return NULL;
|
|
771
|
817 if (wnet_enum_handle != INVALID_HANDLE_VALUE)
|
|
428
|
818 return NULL;
|
|
|
819
|
|
771
|
820 if (is_unc_volume (filename))
|
|
|
821 {
|
|
|
822 wnet_enum_handle = open_unc_volume (filename);
|
|
|
823 if (wnet_enum_handle == INVALID_HANDLE_VALUE)
|
|
|
824 return NULL;
|
|
|
825 }
|
|
428
|
826
|
|
771
|
827 if (!(dirp = xnew_and_zero (DIR)))
|
|
|
828 return NULL;
|
|
|
829
|
|
|
830 if (dir_pathname)
|
|
1726
|
831 xfree (dir_pathname, Ibyte *);
|
|
771
|
832 dir_pathname = qxestrdup (filename);
|
|
428
|
833
|
|
|
834 return dirp;
|
|
|
835 }
|
|
|
836
|
|
442
|
837 int
|
|
771
|
838 mswindows_closedir (DIR *dirp)
|
|
428
|
839 {
|
|
2957
|
840 int retval = -1;
|
|
442
|
841
|
|
428
|
842 /* If we have a find-handle open, close it. */
|
|
|
843 if (dir_find_handle != INVALID_HANDLE_VALUE)
|
|
|
844 {
|
|
771
|
845 retval = FindClose (dir_find_handle) ? 0 : -1;
|
|
428
|
846 dir_find_handle = INVALID_HANDLE_VALUE;
|
|
|
847 }
|
|
771
|
848 else if (wnet_enum_handle != INVALID_HANDLE_VALUE)
|
|
|
849 {
|
|
|
850 retval = close_unc_volume (wnet_enum_handle);
|
|
|
851 wnet_enum_handle = INVALID_HANDLE_VALUE;
|
|
|
852 }
|
|
1726
|
853 xfree (dirp, DIR *);
|
|
771
|
854
|
|
|
855 return retval;
|
|
|
856 }
|
|
|
857
|
|
|
858 struct direct *
|
|
2286
|
859 mswindows_readdir (DIR *UNUSED (dirp))
|
|
771
|
860 {
|
|
867
|
861 Ibyte *val;
|
|
771
|
862 int need_to_free = 0;
|
|
|
863
|
|
|
864 if (wnet_enum_handle != INVALID_HANDLE_VALUE)
|
|
|
865 {
|
|
|
866 if (!(val = read_unc_volume (wnet_enum_handle)))
|
|
|
867 return NULL;
|
|
|
868 need_to_free = 1;
|
|
|
869 }
|
|
|
870 /* If we aren't dir_finding, do a find-first, otherwise do a find-next. */
|
|
|
871 else if (dir_find_handle == INVALID_HANDLE_VALUE)
|
|
|
872 {
|
|
|
873 DECLARE_EISTRING (filename);
|
|
867
|
874 Ichar lastch;
|
|
2526
|
875 Extbyte *fileext;
|
|
771
|
876
|
|
|
877 eicpy_rawz (filename, dir_pathname);
|
|
|
878 lastch = eigetch_char (filename, eicharlen (filename) - 1);
|
|
|
879 if (!IS_DIRECTORY_SEP (lastch))
|
|
|
880 eicat_ch (filename, '\\');
|
|
|
881 eicat_ch (filename, '*');
|
|
2526
|
882 PATHNAME_CONVERT_OUT (eidata (filename), fileext);
|
|
771
|
883
|
|
2526
|
884 dir_find_handle = qxeFindFirstFile (fileext, &dir_find_data);
|
|
771
|
885
|
|
|
886 if (dir_find_handle == INVALID_HANDLE_VALUE)
|
|
|
887 return NULL;
|
|
|
888 TSTR_TO_C_STRING (dir_find_data.cFileName, val);
|
|
|
889 }
|
|
|
890 else
|
|
|
891 {
|
|
|
892 if (!qxeFindNextFile (dir_find_handle, &dir_find_data))
|
|
|
893 return NULL;
|
|
|
894 TSTR_TO_C_STRING (dir_find_data.cFileName, val);
|
|
|
895 }
|
|
|
896
|
|
|
897 /* XEmacs never uses this value, so don't bother making it match
|
|
|
898 value returned by qxe_stat(). */
|
|
|
899 dir_static.d_ino = 1;
|
|
|
900
|
|
|
901 dir_static.d_reclen = sizeof (struct direct) - MAXNAMLEN + 3 +
|
|
|
902 dir_static.d_namlen - dir_static.d_namlen % 4;
|
|
|
903
|
|
|
904 {
|
|
|
905 DECLARE_EISTRING (found);
|
|
|
906 Bytecount namlen;
|
|
|
907
|
|
2526
|
908 if (mswindows_shortcuts_are_symlinks)
|
|
|
909 {
|
|
|
910 int len = qxestrlen (val);
|
|
|
911 if (len > 4 && !qxestrcasecmp_ascii (val + len - 4, ".LNK"))
|
|
|
912 {
|
|
|
913 /* If we've found a valid link, then chop off the .LNK ending */
|
|
|
914 DECLARE_EISTRING (linkname);
|
|
|
915 Ichar lastch;
|
|
|
916 Ibyte *resolved;
|
|
|
917
|
|
|
918 /* First check if link is valid */
|
|
|
919 PATHNAME_RESOLVE_LINKS (dir_pathname, resolved);
|
|
|
920 eicpy_rawz (linkname, resolved);
|
|
|
921 lastch = eigetch_char (linkname, eicharlen (linkname) - 1);
|
|
|
922 if (!IS_DIRECTORY_SEP (lastch))
|
|
|
923 eicat_ch (linkname, '\\');
|
|
|
924 eicat_rawz (linkname, val);
|
|
|
925 resolved = mswindows_read_link (eidata (linkname));
|
|
|
926 if (resolved)
|
|
|
927 {
|
|
|
928 xfree (resolved, Ibyte *);
|
|
|
929 len -= 4;
|
|
|
930 val[len] = '\0';
|
|
|
931 }
|
|
|
932 }
|
|
|
933 }
|
|
|
934
|
|
771
|
935 eicpy_rawz (found, val);
|
|
|
936 if (need_to_free)
|
|
1726
|
937 xfree (val, Ibyte *);
|
|
771
|
938
|
|
|
939 if (!NILP (Vmswindows_downcase_file_names))
|
|
|
940 eilwr (found);
|
|
|
941
|
|
|
942 namlen = min (eilen (found), sizeof (dir_static.d_name) - 1);
|
|
|
943 strncpy (dir_static.d_name, (char *) eidata (found), namlen);
|
|
|
944 dir_static.d_name[namlen] = '\0';
|
|
|
945 dir_static.d_namlen = (unsigned short) namlen;
|
|
|
946 }
|
|
|
947
|
|
|
948 return &dir_static;
|
|
|
949 }
|
|
|
950
|
|
|
951 static HANDLE
|
|
867
|
952 open_unc_volume (const Ibyte *path)
|
|
771
|
953 {
|
|
|
954 NETRESOURCEW nr;
|
|
|
955 HANDLE henum;
|
|
|
956 int result;
|
|
|
957
|
|
|
958 nr.dwScope = RESOURCE_GLOBALNET;
|
|
|
959 nr.dwType = RESOURCETYPE_DISK;
|
|
|
960 nr.dwDisplayType = RESOURCEDISPLAYTYPE_SERVER;
|
|
|
961 nr.dwUsage = RESOURCEUSAGE_CONTAINER;
|
|
|
962 nr.lpLocalName = NULL;
|
|
2526
|
963 PATHNAME_CONVERT_OUT (path, nr.lpRemoteName);
|
|
771
|
964 nr.lpComment = NULL;
|
|
|
965 nr.lpProvider = NULL;
|
|
|
966
|
|
|
967 result = qxeWNetOpenEnum (RESOURCE_GLOBALNET, RESOURCETYPE_DISK,
|
|
|
968 RESOURCEUSAGE_CONNECTABLE, &nr, &henum);
|
|
|
969
|
|
|
970 if (result == NO_ERROR)
|
|
|
971 return henum;
|
|
|
972 else
|
|
|
973 return INVALID_HANDLE_VALUE;
|
|
|
974 }
|
|
|
975
|
|
867
|
976 static Ibyte *
|
|
2286
|
977 read_unc_volume (HANDLE UNUSED (henum))
|
|
771
|
978 {
|
|
1204
|
979 DWORD count;
|
|
771
|
980 int result;
|
|
|
981 Extbyte buf[16384];
|
|
867
|
982 Ibyte *ptr;
|
|
1204
|
983 DWORD bufsize = sizeof (buf);
|
|
771
|
984
|
|
|
985 count = 1;
|
|
|
986 /* #### we should just be querying the size and then allocating the
|
|
|
987 right amount, like for all similar API's. but the docs say this ?!
|
|
|
988
|
|
|
989 An application cannot set the lpBuffer parameter to NULL and
|
|
|
990 retrieve the required buffer size from the lpBufferSize
|
|
|
991 parameter. Instead, the application should allocate a buffer of a
|
|
|
992 reasonable size -- 16 kilobytes (K) is typical -- and use the value
|
|
|
993 of lpBufferSize for error detection.
|
|
|
994 */
|
|
|
995
|
|
|
996 result = qxeWNetEnumResource (wnet_enum_handle, &count, buf, &bufsize);
|
|
|
997 if (result != NO_ERROR)
|
|
|
998 return NULL;
|
|
|
999
|
|
|
1000 /* WNetEnumResource returns \\resource\share...skip forward to "share". */
|
|
|
1001 TSTR_TO_C_STRING (((LPNETRESOURCEW) buf)->lpRemoteName, ptr);
|
|
867
|
1002 INC_IBYTEPTR (ptr);
|
|
|
1003 INC_IBYTEPTR (ptr);
|
|
|
1004 while (*ptr && !IS_DIRECTORY_SEP (itext_ichar (ptr)))
|
|
|
1005 INC_IBYTEPTR (ptr);
|
|
|
1006 INC_IBYTEPTR (ptr);
|
|
771
|
1007
|
|
|
1008 return qxestrdup (ptr);
|
|
|
1009 }
|
|
|
1010
|
|
|
1011 static int
|
|
|
1012 close_unc_volume (HANDLE henum)
|
|
|
1013 {
|
|
|
1014 if (henum != INVALID_HANDLE_VALUE)
|
|
|
1015 return WNetCloseEnum (henum) == NO_ERROR ? 0 : -1;
|
|
442
|
1016 else
|
|
|
1017 return -1;
|
|
428
|
1018 }
|
|
|
1019
|
|
771
|
1020 static DWORD
|
|
867
|
1021 unc_volume_file_attributes (const Ibyte *path)
|
|
428
|
1022 {
|
|
771
|
1023 HANDLE henum;
|
|
|
1024 DWORD attrs;
|
|
|
1025
|
|
|
1026 henum = open_unc_volume (path);
|
|
|
1027 if (henum == INVALID_HANDLE_VALUE)
|
|
|
1028 return -1;
|
|
|
1029
|
|
|
1030 attrs = FILE_ATTRIBUTE_READONLY | FILE_ATTRIBUTE_DIRECTORY;
|
|
|
1031
|
|
|
1032 close_unc_volume (henum);
|
|
428
|
1033
|
|
771
|
1034 return attrs;
|
|
|
1035 }
|
|
|
1036
|
|
|
1037 int
|
|
867
|
1038 mswindows_access (const Ibyte *path, int mode)
|
|
771
|
1039 {
|
|
|
1040 DWORD attributes;
|
|
428
|
1041
|
|
771
|
1042 /* MSVC implementation doesn't recognize D_OK. */
|
|
|
1043 if (is_unc_volume (path))
|
|
|
1044 {
|
|
|
1045 attributes = unc_volume_file_attributes (path);
|
|
|
1046 if (attributes == -1)
|
|
|
1047 {
|
|
|
1048 errno = EACCES;
|
|
|
1049 return -1;
|
|
|
1050 }
|
|
428
|
1051 }
|
|
|
1052 else
|
|
|
1053 {
|
|
771
|
1054 Extbyte *pathext;
|
|
|
1055
|
|
2526
|
1056 PATHNAME_CONVERT_OUT (path, pathext);
|
|
771
|
1057 if ((attributes = qxeGetFileAttributes (pathext)) == -1)
|
|
|
1058 {
|
|
|
1059 /* Should try mapping GetLastError to errno; for now just indicate
|
|
|
1060 that path doesn't exist. */
|
|
|
1061 errno = EACCES;
|
|
|
1062 return -1;
|
|
|
1063 }
|
|
428
|
1064 }
|
|
1204
|
1065 if ((mode & X_OK) != 0 && !mswindows_is_executable (path))
|
|
771
|
1066 {
|
|
|
1067 errno = EACCES;
|
|
|
1068 return -1;
|
|
|
1069 }
|
|
|
1070 if ((mode & W_OK) != 0 && (attributes & FILE_ATTRIBUTE_READONLY) != 0)
|
|
428
|
1071 {
|
|
771
|
1072 errno = EACCES;
|
|
|
1073 return -1;
|
|
428
|
1074 }
|
|
771
|
1075 if ((mode & D_OK) != 0 && (attributes & FILE_ATTRIBUTE_DIRECTORY) == 0)
|
|
|
1076 {
|
|
|
1077 errno = EACCES;
|
|
|
1078 return -1;
|
|
|
1079 }
|
|
|
1080 return 0;
|
|
428
|
1081 }
|
|
|
1082
|
|
771
|
1083 /* This only works on NTFS volumes, but is useful to have. */
|
|
|
1084 /* #### NT 5.0 has a function CreateHardLink to do this directly,
|
|
|
1085 and it may do more things. */
|
|
428
|
1086 int
|
|
2957
|
1087 mswindows_link (const Ibyte *old, const Ibyte *new_)
|
|
428
|
1088 {
|
|
771
|
1089 HANDLE fileh;
|
|
|
1090 int result = -1;
|
|
1204
|
1091 Extbyte *oldext;
|
|
771
|
1092
|
|
2957
|
1093 if (old == NULL || new_ == NULL)
|
|
771
|
1094 {
|
|
|
1095 errno = ENOENT;
|
|
|
1096 return -1;
|
|
|
1097 }
|
|
|
1098
|
|
2526
|
1099 PATHNAME_CONVERT_OUT (old, oldext);
|
|
1204
|
1100 fileh = qxeCreateFile (oldext, 0, 0, NULL, OPEN_EXISTING,
|
|
771
|
1101 FILE_FLAG_BACKUP_SEMANTICS, NULL);
|
|
|
1102 if (fileh != INVALID_HANDLE_VALUE)
|
|
|
1103 {
|
|
|
1104 int wlen;
|
|
|
1105 WCHAR *newuni;
|
|
|
1106
|
|
|
1107 /* Confusingly, the "alternate" stream name field does not apply
|
|
|
1108 when restoring a hard link, and instead contains the actual
|
|
|
1109 stream data for the link (ie. the name of the link to create).
|
|
|
1110 The WIN32_STREAM_ID structure before the cStreamName field is
|
|
|
1111 the stream header, which is then immediately followed by the
|
|
|
1112 stream data. */
|
|
|
1113
|
|
|
1114 struct
|
|
|
1115 {
|
|
|
1116 WIN32_STREAM_ID wid;
|
|
2421
|
1117 WCHAR wbuffer[_MAX_PATH]; /* extra space for link name */
|
|
771
|
1118 } data;
|
|
|
1119
|
|
2957
|
1120 TO_EXTERNAL_FORMAT (C_STRING, new_,
|
|
771
|
1121 ALLOCA, (newuni, wlen), Qmswindows_unicode);
|
|
2421
|
1122 if (wlen / sizeof (WCHAR) < _MAX_PATH)
|
|
771
|
1123 {
|
|
|
1124 LPVOID context = NULL;
|
|
|
1125 DWORD wbytes = 0;
|
|
428
|
1126
|
|
771
|
1127 wcscpy (data.wid.cStreamName, newuni);
|
|
|
1128 data.wid.dwStreamId = BACKUP_LINK;
|
|
|
1129 data.wid.dwStreamAttributes = 0;
|
|
|
1130 data.wid.Size.LowPart = wlen; /* in bytes, not chars! */
|
|
|
1131 data.wid.Size.HighPart = 0;
|
|
|
1132 data.wid.dwStreamNameSize = 0;
|
|
|
1133
|
|
|
1134 if (BackupWrite (fileh, (LPBYTE)&data,
|
|
|
1135 offsetof (WIN32_STREAM_ID, cStreamName)
|
|
|
1136 + data.wid.Size.LowPart,
|
|
|
1137 &wbytes, FALSE, FALSE, &context)
|
|
|
1138 && BackupWrite (fileh, NULL, 0, &wbytes, TRUE, FALSE, &context))
|
|
|
1139 {
|
|
|
1140 /* succeeded */
|
|
|
1141 result = 0;
|
|
|
1142 }
|
|
|
1143 else
|
|
|
1144 {
|
|
|
1145 /* Should try mapping GetLastError to errno; for now just
|
|
|
1146 indicate a general error (eg. links not supported). */
|
|
1242
|
1147 errno = EINVAL; /* perhaps EMLINK? */
|
|
771
|
1148 }
|
|
|
1149 }
|
|
|
1150
|
|
|
1151 CloseHandle (fileh);
|
|
|
1152 }
|
|
|
1153 else
|
|
|
1154 errno = ENOENT;
|
|
|
1155
|
|
|
1156 return result;
|
|
|
1157 }
|
|
|
1158
|
|
|
1159 /* sys_open() merged into sysdep.c sys_open() */
|
|
|
1160
|
|
|
1161 int
|
|
867
|
1162 mswindows_rename (const Ibyte *oldname, const Ibyte *newname)
|
|
771
|
1163 {
|
|
|
1164 int result;
|
|
867
|
1165 Ibyte *temp;
|
|
771
|
1166
|
|
|
1167 /* MoveFile on Windows 95 doesn't correctly change the short file name
|
|
428
|
1168 alias in a number of circumstances (it is not easy to predict when
|
|
|
1169 just by looking at oldname and newname, unfortunately). In these
|
|
|
1170 cases, renaming through a temporary name avoids the problem.
|
|
|
1171
|
|
771
|
1172 A second problem on Windows 95 is that renaming through a temp name when
|
|
428
|
1173 newname is uppercase fails (the final long name ends up in
|
|
|
1174 lowercase, although the short alias might be uppercase) UNLESS the
|
|
|
1175 long temp name is not 8.3.
|
|
|
1176
|
|
771
|
1177 So, on Windows 95 we always rename through a temp name, and we make sure
|
|
428
|
1178 the temp name has a long extension to ensure correct renaming. */
|
|
|
1179
|
|
771
|
1180 /* XEmacs: We sprintf() part of OLDNAME into part of OLDNAME + a number,
|
|
|
1181 so the following calculation should certainly be enough. */
|
|
428
|
1182
|
|
867
|
1183 temp = qxestrcpy (alloca_ibytes (2 * qxestrlen (oldname) + 100), oldname);
|
|
771
|
1184
|
|
|
1185 if (mswindows_windows9x_p)
|
|
428
|
1186 {
|
|
867
|
1187 Ibyte *o;
|
|
|
1188 Ibyte *p;
|
|
771
|
1189 int i = 0;
|
|
428
|
1190
|
|
771
|
1191 if (o = qxestrrchr (oldname, '\\'))
|
|
|
1192 o++;
|
|
|
1193 else
|
|
867
|
1194 o = (Ibyte *) oldname;
|
|
771
|
1195
|
|
|
1196 if (p = qxestrrchr (temp, '\\'))
|
|
428
|
1197 p++;
|
|
|
1198 else
|
|
|
1199 p = temp;
|
|
771
|
1200
|
|
|
1201 do
|
|
|
1202 {
|
|
|
1203 Extbyte *oldext, *tempext;
|
|
|
1204 /* Force temp name to require a manufactured 8.3 alias - this
|
|
|
1205 seems to make the second rename work properly. */
|
|
|
1206 qxesprintf (p, "_.%s.%u", o, i);
|
|
|
1207 i++;
|
|
2526
|
1208 PATHNAME_CONVERT_OUT (oldname, oldext);
|
|
|
1209 PATHNAME_CONVERT_OUT (temp, tempext);
|
|
771
|
1210 result = rename (oldext, tempext);
|
|
|
1211 }
|
|
|
1212 /* This loop must surely terminate! */
|
|
|
1213 while (result < 0 && errno == EEXIST);
|
|
|
1214 if (result < 0)
|
|
428
|
1215 return -1;
|
|
|
1216 }
|
|
|
1217
|
|
771
|
1218 /* Emulate Unix behaviour - newname is deleted if it already exists
|
|
428
|
1219 (at least if it is a file; don't do this for directories).
|
|
771
|
1220
|
|
|
1221 Since we mustn't do this if we are just changing the case of the
|
|
|
1222 file name (we would end up deleting the file we are trying to
|
|
|
1223 rename!), we let rename detect if the destination file already
|
|
|
1224 exists - that way we avoid the possible pitfalls of trying to
|
|
|
1225 determine ourselves whether two names really refer to the same
|
|
|
1226 file, which is not always possible in the general case. (Consider
|
|
|
1227 all the permutations of shared or subst'd drives, etc.) */
|
|
|
1228 {
|
|
|
1229 Extbyte *newext, *tempext;
|
|
|
1230
|
|
2526
|
1231 PATHNAME_CONVERT_OUT (newname, newext);
|
|
|
1232 PATHNAME_CONVERT_OUT (temp, tempext);
|
|
|
1233 if (XEUNICODE_P)
|
|
|
1234 {
|
|
|
1235 result = _wrename ((const wchar_t *) tempext,
|
|
|
1236 (const wchar_t *) newext);
|
|
|
1237 if (result < 0
|
|
|
1238 && (errno == EEXIST || errno == EACCES)
|
|
|
1239 && _wchmod ((const wchar_t *) newext, 0666) == 0
|
|
|
1240 && _wunlink ((const wchar_t *) newext) == 0)
|
|
|
1241 result = _wrename ((const wchar_t *) tempext,
|
|
|
1242 (const wchar_t *) newext);
|
|
|
1243 }
|
|
|
1244 else
|
|
|
1245 {
|
|
|
1246 result = rename (tempext, newext);
|
|
|
1247 if (result < 0
|
|
|
1248 && (errno == EEXIST || errno == EACCES)
|
|
|
1249 && _chmod (newext, 0666) == 0
|
|
|
1250 && _unlink (newext) == 0)
|
|
|
1251 result = rename (tempext, newext);
|
|
|
1252 }
|
|
771
|
1253 }
|
|
|
1254
|
|
|
1255 return result;
|
|
|
1256 }
|
|
428
|
1257
|
|
771
|
1258 int
|
|
867
|
1259 mswindows_unlink (const Ibyte *path)
|
|
771
|
1260 {
|
|
|
1261 Extbyte *pathout;
|
|
|
1262
|
|
2526
|
1263 PATHNAME_CONVERT_OUT (path, pathout);
|
|
771
|
1264 /* On Unix, unlink works without write permission. */
|
|
2526
|
1265 if (XEUNICODE_P)
|
|
|
1266 {
|
|
|
1267 _wchmod ((const wchar_t *) pathout, 0666);
|
|
|
1268 return _wunlink ((const wchar_t *) pathout);
|
|
|
1269 }
|
|
|
1270 else
|
|
|
1271 {
|
|
|
1272 _chmod (pathout, 0666);
|
|
|
1273 return _unlink (pathout);
|
|
|
1274 }
|
|
428
|
1275 }
|
|
|
1276
|
|
|
1277 static FILETIME utc_base_ft;
|
|
592
|
1278 static long double utc_base;
|
|
440
|
1279 static int init = 0;
|
|
771
|
1280 static LARGE_INTEGER utc_base_li;
|
|
440
|
1281
|
|
771
|
1282 /* XEmacs: We seem to have a new definition of
|
|
|
1283 mswindows_convert_time(), although I'm not sure why. --ben */
|
|
428
|
1284
|
|
|
1285 time_t
|
|
771
|
1286 mswindows_convert_time (FILETIME uft)
|
|
440
|
1287 {
|
|
|
1288 time_t ret;
|
|
|
1289 #ifndef MAXLONGLONG
|
|
|
1290 SYSTEMTIME st;
|
|
|
1291 struct tm t;
|
|
|
1292 FILETIME ft;
|
|
|
1293 TIME_ZONE_INFORMATION tzi;
|
|
|
1294 DWORD tzid;
|
|
|
1295 #else
|
|
|
1296 LARGE_INTEGER lft;
|
|
|
1297 #endif
|
|
|
1298
|
|
|
1299 if (!init)
|
|
|
1300 {
|
|
|
1301 /* Determine the delta between 1-Jan-1601 and 1-Jan-1970. */
|
|
|
1302 SYSTEMTIME st;
|
|
|
1303
|
|
|
1304 st.wYear = 1970;
|
|
|
1305 st.wMonth = 1;
|
|
|
1306 st.wDay = 1;
|
|
|
1307 st.wHour = 0;
|
|
|
1308 st.wMinute = 0;
|
|
|
1309 st.wSecond = 0;
|
|
|
1310 st.wMilliseconds = 0;
|
|
|
1311
|
|
|
1312 SystemTimeToFileTime (&st, &utc_base_ft);
|
|
|
1313
|
|
|
1314 utc_base_li.LowPart = utc_base_ft.dwLowDateTime;
|
|
|
1315 utc_base_li.HighPart = utc_base_ft.dwHighDateTime;
|
|
|
1316
|
|
|
1317 init = 1;
|
|
|
1318 }
|
|
|
1319
|
|
|
1320 #ifdef MAXLONGLONG
|
|
|
1321
|
|
|
1322 /* On a compiler that supports long integers, do it the easy way */
|
|
|
1323 lft.LowPart = uft.dwLowDateTime;
|
|
|
1324 lft.HighPart = uft.dwHighDateTime;
|
|
|
1325 ret = (time_t) ((lft.QuadPart - utc_base_li.QuadPart) / 10000000);
|
|
|
1326
|
|
|
1327 #else
|
|
|
1328
|
|
|
1329 /* Do it the hard way using mktime. */
|
|
|
1330 FileTimeToLocalFileTime(&uft, &ft);
|
|
|
1331 FileTimeToSystemTime (&ft, &st);
|
|
|
1332 tzid = GetTimeZoneInformation (&tzi);
|
|
|
1333 t.tm_year = st.wYear - 1900;
|
|
|
1334 t.tm_mon = st.wMonth - 1;
|
|
|
1335 t.tm_mday = st.wDay;
|
|
|
1336 t.tm_hour = st.wHour;
|
|
|
1337 t.tm_min = st.wMinute;
|
|
|
1338 t.tm_sec = st.wSecond;
|
|
|
1339 t.tm_isdst = (tzid == TIME_ZONE_ID_DAYLIGHT);
|
|
|
1340 /* st.wMilliseconds not applicable */
|
|
|
1341 ret = mktime(&t);
|
|
|
1342 if (ret == -1)
|
|
|
1343 {
|
|
|
1344 ret = 0;
|
|
|
1345 }
|
|
|
1346
|
|
|
1347 #endif
|
|
|
1348
|
|
|
1349 return ret;
|
|
|
1350 }
|
|
428
|
1351
|
|
771
|
1352 static void
|
|
428
|
1353 convert_from_time_t (time_t time, FILETIME * pft)
|
|
|
1354 {
|
|
|
1355 long double tmp;
|
|
|
1356
|
|
|
1357 if (!init)
|
|
|
1358 {
|
|
|
1359 /* Determine the delta between 1-Jan-1601 and 1-Jan-1970. */
|
|
|
1360 SYSTEMTIME st;
|
|
|
1361
|
|
|
1362 st.wYear = 1970;
|
|
|
1363 st.wMonth = 1;
|
|
|
1364 st.wDay = 1;
|
|
|
1365 st.wHour = 0;
|
|
|
1366 st.wMinute = 0;
|
|
|
1367 st.wSecond = 0;
|
|
|
1368 st.wMilliseconds = 0;
|
|
|
1369
|
|
|
1370 SystemTimeToFileTime (&st, &utc_base_ft);
|
|
|
1371 utc_base = (long double) utc_base_ft.dwHighDateTime
|
|
|
1372 * 4096 * 1024 * 1024 + utc_base_ft.dwLowDateTime;
|
|
|
1373 init = 1;
|
|
|
1374 }
|
|
|
1375
|
|
|
1376 /* time in 100ns units since 1-Jan-1601 */
|
|
|
1377 tmp = (long double) time * 1e7 + utc_base;
|
|
|
1378 pft->dwHighDateTime = (DWORD) (tmp / (4096.0 * 1024 * 1024));
|
|
771
|
1379 pft->dwLowDateTime = (DWORD) (tmp - (4096.0 * 1024 * 1024) *
|
|
|
1380 pft->dwHighDateTime);
|
|
428
|
1381 }
|
|
|
1382
|
|
|
1383 #if 0
|
|
771
|
1384 /* A comment from Emacs 20.6:
|
|
|
1385
|
|
|
1386 No reason to keep this; faking inode values either by hashing or even
|
|
428
|
1387 using the file index from GetInformationByHandle, is not perfect and
|
|
|
1388 so by default Emacs doesn't use the inode values on Windows.
|
|
|
1389 Instead, we now determine file-truename correctly (except for
|
|
|
1390 possible drive aliasing etc). */
|
|
|
1391
|
|
771
|
1392 /* XEmacs: Removed the fake-inodes code here, which was if 0'd out.
|
|
|
1393 If you want it, look in w32.c in Emacs 20.6. */
|
|
428
|
1394 #endif
|
|
|
1395
|
|
442
|
1396 /* #### aichner@ecf.teradyne.com reported that with the library
|
|
|
1397 provided stat/fstat, (file-exist "d:\\tmp\\") =>> nil,
|
|
|
1398 (file-exist "d:\\tmp") =>> t, when d:\tmp exists. Whenever
|
|
|
1399 we opt to use non-encapsulated stat(), this should serve as
|
|
|
1400 a compatibility test. --kkm */
|
|
440
|
1401
|
|
771
|
1402 /* Provide fstat and utime as well as stat for consistent handling of
|
|
|
1403 file timestamps. */
|
|
442
|
1404 int
|
|
771
|
1405 mswindows_fstat (int desc, struct stat *buf)
|
|
432
|
1406 {
|
|
448
|
1407 HANDLE fh = (HANDLE) _get_osfhandle (desc);
|
|
|
1408 BY_HANDLE_FILE_INFORMATION info;
|
|
|
1409 DWORD fake_inode;
|
|
|
1410 int permission;
|
|
|
1411
|
|
|
1412 switch (GetFileType (fh) & ~FILE_TYPE_REMOTE)
|
|
432
|
1413 {
|
|
448
|
1414 case FILE_TYPE_DISK:
|
|
|
1415 buf->st_mode = _S_IFREG;
|
|
|
1416 if (!GetFileInformationByHandle (fh, &info))
|
|
|
1417 {
|
|
|
1418 errno = EACCES;
|
|
|
1419 return -1;
|
|
|
1420 }
|
|
|
1421 break;
|
|
|
1422 case FILE_TYPE_PIPE:
|
|
|
1423 buf->st_mode = _S_IFIFO;
|
|
|
1424 goto non_disk;
|
|
|
1425 case FILE_TYPE_CHAR:
|
|
|
1426 case FILE_TYPE_UNKNOWN:
|
|
|
1427 default:
|
|
|
1428 buf->st_mode = _S_IFCHR;
|
|
|
1429 non_disk:
|
|
|
1430 memset (&info, 0, sizeof (info));
|
|
|
1431 info.dwFileAttributes = 0;
|
|
|
1432 info.ftCreationTime = utc_base_ft;
|
|
|
1433 info.ftLastAccessTime = utc_base_ft;
|
|
|
1434 info.ftLastWriteTime = utc_base_ft;
|
|
|
1435 }
|
|
|
1436
|
|
|
1437 if (info.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
|
|
|
1438 {
|
|
|
1439 buf->st_mode = _S_IFDIR;
|
|
|
1440 buf->st_nlink = 2; /* doesn't really matter */
|
|
|
1441 fake_inode = 0; /* this doesn't either I think */
|
|
432
|
1442 }
|
|
|
1443 else
|
|
|
1444 {
|
|
462
|
1445 buf->st_nlink = (short) info.nNumberOfLinks;
|
|
448
|
1446 /* Might as well use file index to fake inode values, but this
|
|
|
1447 is not guaranteed to be unique unless we keep a handle open
|
|
|
1448 all the time (even then there are situations where it is
|
|
|
1449 not unique). Reputedly, there are at most 48 bits of info
|
|
|
1450 (on NTFS, presumably less on FAT). */
|
|
|
1451 fake_inode = info.nFileIndexLow ^ info.nFileIndexHigh;
|
|
432
|
1452 }
|
|
448
|
1453
|
|
|
1454 /* MSVC defines _ino_t to be short; other libc's might not. */
|
|
|
1455 if (sizeof (buf->st_ino) == 2)
|
|
462
|
1456 buf->st_ino = (unsigned short) (fake_inode ^ (fake_inode >> 16));
|
|
448
|
1457 else
|
|
462
|
1458 buf->st_ino = (unsigned short) fake_inode;
|
|
448
|
1459
|
|
|
1460 /* consider files to belong to current user */
|
|
|
1461 buf->st_uid = 0;
|
|
|
1462 buf->st_gid = 0;
|
|
|
1463
|
|
|
1464 buf->st_dev = info.dwVolumeSerialNumber;
|
|
|
1465 buf->st_rdev = info.dwVolumeSerialNumber;
|
|
|
1466
|
|
|
1467 buf->st_size = info.nFileSizeLow;
|
|
|
1468
|
|
|
1469 /* Convert timestamps to Unix format. */
|
|
771
|
1470 buf->st_mtime = mswindows_convert_time (info.ftLastWriteTime);
|
|
|
1471 buf->st_atime = mswindows_convert_time (info.ftLastAccessTime);
|
|
448
|
1472 if (buf->st_atime == 0) buf->st_atime = buf->st_mtime;
|
|
771
|
1473 buf->st_ctime = mswindows_convert_time (info.ftCreationTime);
|
|
448
|
1474 if (buf->st_ctime == 0) buf->st_ctime = buf->st_mtime;
|
|
|
1475
|
|
|
1476 /* determine rwx permissions */
|
|
|
1477 if (info.dwFileAttributes & FILE_ATTRIBUTE_READONLY)
|
|
|
1478 permission = _S_IREAD;
|
|
|
1479 else
|
|
|
1480 permission = _S_IREAD | _S_IWRITE;
|
|
|
1481
|
|
|
1482 if (info.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
|
|
|
1483 permission |= _S_IEXEC;
|
|
771
|
1484 else
|
|
|
1485 {
|
|
|
1486 #if 0 /* no way of knowing the filename */
|
|
1204
|
1487 if (mswindows_is_executable (name))
|
|
771
|
1488 permission |= _S_IEXEC;
|
|
|
1489 #endif
|
|
|
1490 }
|
|
448
|
1491
|
|
|
1492 buf->st_mode |= permission | (permission >> 3) | (permission >> 6);
|
|
|
1493
|
|
|
1494 return 0;
|
|
432
|
1495 }
|
|
|
1496
|
|
428
|
1497 /* MSVC stat function can't cope with UNC names and has other bugs, so
|
|
|
1498 replace it with our own. This also allows us to calculate consistent
|
|
|
1499 inode values without hacks in the main Emacs code. */
|
|
|
1500 int
|
|
867
|
1501 mswindows_stat (const Ibyte *path, struct stat *buf)
|
|
428
|
1502 {
|
|
867
|
1503 Ibyte *name, *r;
|
|
771
|
1504 WIN32_FIND_DATAW wfd;
|
|
428
|
1505 HANDLE fh;
|
|
|
1506 DWORD fake_inode;
|
|
|
1507 int permission;
|
|
771
|
1508 Bytecount len;
|
|
428
|
1509 int rootdir = FALSE;
|
|
771
|
1510 Extbyte *nameext;
|
|
819
|
1511 int errm;
|
|
428
|
1512
|
|
|
1513 if (path == NULL || buf == NULL)
|
|
|
1514 {
|
|
|
1515 errno = EFAULT;
|
|
|
1516 return -1;
|
|
|
1517 }
|
|
|
1518
|
|
867
|
1519 name = qxestrcpy (alloca_ibytes (qxestrlen (path) + 10), path);
|
|
819
|
1520 errm = SetErrorMode (SEM_FAILCRITICALERRORS
|
|
|
1521 | SEM_NOOPENFILEERRORBOX);
|
|
771
|
1522
|
|
|
1523 get_volume_info (name, &path);
|
|
|
1524 /* must be valid filename, no wild cards or other invalid characters */
|
|
|
1525 if (qxestrpbrk (name, "*?|<>\""))
|
|
428
|
1526 {
|
|
|
1527 errno = ENOENT;
|
|
|
1528 return -1;
|
|
|
1529 }
|
|
|
1530
|
|
771
|
1531 /* If name is "c:/.." or "/.." then stat "c:/" or "/". */
|
|
|
1532 r = IS_DEVICE_SEP (name[1]) ? &name[2] : name;
|
|
|
1533 if (IS_DIRECTORY_SEP (r[0]) && r[1] == '.' && r[2] == '.' && r[3] == '\0')
|
|
|
1534 {
|
|
|
1535 r[1] = r[2] = '\0';
|
|
|
1536 }
|
|
|
1537
|
|
428
|
1538 /* Remove trailing directory separator, unless name is the root
|
|
|
1539 directory of a drive or UNC volume in which case ensure there
|
|
|
1540 is a trailing separator. */
|
|
771
|
1541 len = qxestrlen (name);
|
|
428
|
1542 rootdir = (path >= name + len - 1
|
|
|
1543 && (IS_DIRECTORY_SEP (*path) || *path == 0));
|
|
771
|
1544
|
|
|
1545 if (is_unc_volume (name))
|
|
|
1546 {
|
|
|
1547 DWORD attrs = unc_volume_file_attributes (name);
|
|
|
1548
|
|
|
1549 if (attrs == -1)
|
|
|
1550 return -1;
|
|
428
|
1551
|
|
771
|
1552 memset (&wfd, 0, sizeof (wfd));
|
|
|
1553 wfd.dwFileAttributes = attrs;
|
|
|
1554 wfd.ftCreationTime = utc_base_ft;
|
|
|
1555 wfd.ftLastAccessTime = utc_base_ft;
|
|
|
1556 wfd.ftLastWriteTime = utc_base_ft;
|
|
|
1557 /* XEmacs deleted: strcpy (wfd.cFileName, name);
|
|
|
1558 Not used later on. */
|
|
|
1559 }
|
|
|
1560 else if (rootdir)
|
|
428
|
1561 {
|
|
|
1562 if (!IS_DIRECTORY_SEP (name[len-1]))
|
|
867
|
1563 qxestrcat (name, (Ibyte *) "\\");
|
|
2526
|
1564 /* File has already been resolved and we don't want to do it again
|
|
|
1565 in case of lstat() */
|
|
771
|
1566 C_STRING_TO_TSTR (name, nameext);
|
|
|
1567 if (qxeGetDriveType (nameext) < 2)
|
|
428
|
1568 {
|
|
819
|
1569 SetErrorMode (errm);
|
|
428
|
1570 errno = ENOENT;
|
|
|
1571 return -1;
|
|
|
1572 }
|
|
|
1573 memset (&wfd, 0, sizeof (wfd));
|
|
|
1574 wfd.dwFileAttributes = FILE_ATTRIBUTE_DIRECTORY;
|
|
|
1575 wfd.ftCreationTime = utc_base_ft;
|
|
|
1576 wfd.ftLastAccessTime = utc_base_ft;
|
|
|
1577 wfd.ftLastWriteTime = utc_base_ft;
|
|
771
|
1578 /* XEmacs deleted: strcpy (wfd.cFileName, name);
|
|
|
1579 Not used later on. */
|
|
428
|
1580 }
|
|
|
1581 else
|
|
|
1582 {
|
|
|
1583 if (IS_DIRECTORY_SEP (name[len-1]))
|
|
|
1584 name[len - 1] = 0;
|
|
|
1585
|
|
|
1586 /* (This is hacky, but helps when doing file completions on
|
|
|
1587 network drives.) Optimize by using information available from
|
|
|
1588 active readdir if possible. */
|
|
771
|
1589 if (dir_pathname)
|
|
|
1590 {
|
|
|
1591 len = qxestrlen (dir_pathname);
|
|
|
1592 if (len && IS_DIRECTORY_SEP (dir_pathname[len-1]))
|
|
|
1593 len--;
|
|
|
1594 }
|
|
|
1595 if (dir_find_handle != INVALID_HANDLE_VALUE
|
|
|
1596 && dir_pathname
|
|
801
|
1597 && qxestrncasecmp_i18n (dir_pathname, name, len) == 0
|
|
771
|
1598 && IS_DIRECTORY_SEP (name[len])
|
|
|
1599 && qxestrcasecmp_i18n (name + len + 1,
|
|
867
|
1600 (Ibyte *) dir_static.d_name) == 0)
|
|
428
|
1601 {
|
|
|
1602 /* This was the last entry returned by readdir. */
|
|
|
1603 wfd = dir_find_data;
|
|
|
1604 }
|
|
|
1605 else
|
|
|
1606 {
|
|
771
|
1607 C_STRING_TO_TSTR (name, nameext);
|
|
|
1608 fh = qxeFindFirstFile (nameext, &wfd);
|
|
|
1609 if (fh == INVALID_HANDLE_VALUE)
|
|
|
1610 {
|
|
819
|
1611 SetErrorMode (errm);
|
|
771
|
1612 errno = ENOENT;
|
|
|
1613 return -1;
|
|
|
1614 }
|
|
|
1615 FindClose (fh);
|
|
|
1616 /* XEmacs: Don't need to convert wfd.cFileName because
|
|
|
1617 not used later on. */
|
|
428
|
1618 }
|
|
|
1619 }
|
|
|
1620
|
|
|
1621 if (wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
|
|
|
1622 {
|
|
|
1623 buf->st_mode = _S_IFDIR;
|
|
|
1624 buf->st_nlink = 2; /* doesn't really matter */
|
|
|
1625 fake_inode = 0; /* this doesn't either I think */
|
|
|
1626 }
|
|
771
|
1627 else
|
|
428
|
1628 {
|
|
771
|
1629 if (!NILP (Vmswindows_get_true_file_attributes))
|
|
2526
|
1630 /* File has already been resolved and we don't want to do it again
|
|
|
1631 in case of lstat() */
|
|
771
|
1632 C_STRING_TO_TSTR (name, nameext);
|
|
|
1633 if (!NILP (Vmswindows_get_true_file_attributes)
|
|
|
1634 /* No access rights required to get info. */
|
|
|
1635 && (fh = qxeCreateFile (nameext, 0, 0, NULL, OPEN_EXISTING, 0, NULL))
|
|
|
1636 != INVALID_HANDLE_VALUE)
|
|
|
1637 {
|
|
2526
|
1638 /* This is more accurate in terms of getting the correct number
|
|
771
|
1639 of links, but is quite slow (it is noticable when Emacs is
|
|
|
1640 making a list of file name completions). */
|
|
|
1641 BY_HANDLE_FILE_INFORMATION info;
|
|
428
|
1642
|
|
771
|
1643 if (GetFileInformationByHandle (fh, &info))
|
|
|
1644 {
|
|
|
1645 buf->st_nlink = (short) info.nNumberOfLinks;
|
|
|
1646 /* Might as well use file index to fake inode values, but this
|
|
|
1647 is not guaranteed to be unique unless we keep a handle open
|
|
|
1648 all the time (even then there are situations where it is
|
|
|
1649 not unique). Reputedly, there are at most 48 bits of info
|
|
|
1650 (on NTFS, presumably less on FAT). */
|
|
|
1651 fake_inode = info.nFileIndexLow ^ info.nFileIndexHigh;
|
|
|
1652 }
|
|
|
1653 else
|
|
|
1654 {
|
|
|
1655 buf->st_nlink = 1;
|
|
|
1656 fake_inode = 0;
|
|
|
1657 }
|
|
428
|
1658
|
|
|
1659 switch (GetFileType (fh))
|
|
|
1660 {
|
|
|
1661 case FILE_TYPE_DISK:
|
|
|
1662 buf->st_mode = _S_IFREG;
|
|
|
1663 break;
|
|
|
1664 case FILE_TYPE_PIPE:
|
|
|
1665 buf->st_mode = _S_IFIFO;
|
|
|
1666 break;
|
|
|
1667 case FILE_TYPE_CHAR:
|
|
|
1668 case FILE_TYPE_UNKNOWN:
|
|
|
1669 default:
|
|
|
1670 buf->st_mode = _S_IFCHR;
|
|
|
1671 }
|
|
|
1672 CloseHandle (fh);
|
|
|
1673 }
|
|
|
1674 else
|
|
|
1675 {
|
|
771
|
1676 /* Don't bother to make this information more accurate. */
|
|
|
1677 buf->st_mode = _S_IFREG;
|
|
|
1678 buf->st_nlink = 1;
|
|
|
1679 fake_inode = 0;
|
|
428
|
1680 }
|
|
2526
|
1681
|
|
|
1682 if (mswindows_shortcuts_are_symlinks &&
|
|
|
1683 buf->st_mode == _S_IFREG)
|
|
|
1684 {
|
|
|
1685 len = qxestrlen (name);
|
|
|
1686 if (len > 4 && !qxestrcasecmp_ascii (name + len - 4, ".LNK"))
|
|
|
1687 {
|
|
|
1688 /* check if link is valid */
|
|
|
1689 Ibyte *resolved = mswindows_read_link (name);
|
|
|
1690 if (resolved)
|
|
|
1691 {
|
|
|
1692 xfree (resolved, Ibyte *);
|
|
|
1693 buf->st_mode = S_IFLNK;
|
|
|
1694 }
|
|
|
1695 }
|
|
|
1696 }
|
|
428
|
1697 }
|
|
|
1698
|
|
819
|
1699 SetErrorMode (errm);
|
|
|
1700
|
|
428
|
1701 #if 0
|
|
771
|
1702 /* XEmacs: Removed the fake-inodes code here, which was if 0'd out.
|
|
|
1703 If you want it, look in w32.c in Emacs 20.6. */
|
|
428
|
1704 #endif
|
|
|
1705
|
|
771
|
1706 /* MSVC defines _ino_t to be short; other libc's might not. */
|
|
|
1707 if (sizeof (buf->st_ino) == 2)
|
|
|
1708 buf->st_ino = (unsigned short) (fake_inode ^ (fake_inode >> 16));
|
|
|
1709 else
|
|
|
1710 buf->st_ino = (unsigned short) fake_inode;
|
|
428
|
1711
|
|
|
1712 /* consider files to belong to current user */
|
|
771
|
1713 buf->st_uid = the_passwd.pw_uid;
|
|
|
1714 buf->st_gid = the_passwd.pw_gid;
|
|
428
|
1715
|
|
771
|
1716 /* volume_info is set by get_volume_info */
|
|
428
|
1717 buf->st_dev = volume_info.serialnum;
|
|
|
1718 buf->st_rdev = volume_info.serialnum;
|
|
|
1719
|
|
771
|
1720
|
|
428
|
1721 buf->st_size = wfd.nFileSizeLow;
|
|
|
1722
|
|
|
1723 /* Convert timestamps to Unix format. */
|
|
771
|
1724 buf->st_mtime = mswindows_convert_time (wfd.ftLastWriteTime);
|
|
|
1725 buf->st_atime = mswindows_convert_time (wfd.ftLastAccessTime);
|
|
428
|
1726 if (buf->st_atime == 0) buf->st_atime = buf->st_mtime;
|
|
771
|
1727 buf->st_ctime = mswindows_convert_time (wfd.ftCreationTime);
|
|
428
|
1728 if (buf->st_ctime == 0) buf->st_ctime = buf->st_mtime;
|
|
|
1729
|
|
|
1730 /* determine rwx permissions */
|
|
|
1731 if (wfd.dwFileAttributes & FILE_ATTRIBUTE_READONLY)
|
|
|
1732 permission = _S_IREAD;
|
|
|
1733 else
|
|
|
1734 permission = _S_IREAD | _S_IWRITE;
|
|
|
1735
|
|
|
1736 if (wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
|
|
|
1737 permission |= _S_IEXEC;
|
|
1204
|
1738 else if (mswindows_is_executable (name))
|
|
771
|
1739 permission |= _S_IEXEC;
|
|
428
|
1740
|
|
|
1741 buf->st_mode |= permission | (permission >> 3) | (permission >> 6);
|
|
|
1742
|
|
|
1743 return 0;
|
|
|
1744 }
|
|
|
1745
|
|
|
1746 int
|
|
771
|
1747 mswindows_utime (Lisp_Object path, struct utimbuf *times)
|
|
428
|
1748 {
|
|
771
|
1749 /* #### Supposedly we're providing this because standard utime()
|
|
|
1750 might not work; or at the very least to get consistent results
|
|
|
1751 since we replace other time-handling routines in stat. But out
|
|
|
1752 replacement doesn't seem to work, probably due to some subtle bug
|
|
|
1753 in this routine, which should be investigated eventually. So for
|
|
|
1754 the moment, we just use utime(), which conceivably might be
|
|
|
1755 slightly off in comparison with our own routines? Seems strange,
|
|
|
1756 and so far no problems seen. --ben */
|
|
428
|
1757
|
|
771
|
1758 struct utimbuf deftime;
|
|
|
1759 #if 0
|
|
|
1760 HANDLE fh;
|
|
|
1761 #endif
|
|
|
1762 static FILETIME mtime;
|
|
|
1763 static FILETIME atime;
|
|
|
1764 Extbyte *filename;
|
|
428
|
1765
|
|
771
|
1766 if (times == NULL)
|
|
428
|
1767 {
|
|
771
|
1768 deftime.modtime = deftime.actime = time (NULL);
|
|
|
1769 times = &deftime;
|
|
428
|
1770 }
|
|
|
1771
|
|
2526
|
1772 LISP_PATHNAME_CONVERT_OUT (path, filename);
|
|
771
|
1773 /* APA: SetFileTime fails to set mtime correctly (always 1-Jan-1970) */
|
|
|
1774 #if 0
|
|
|
1775 /* Need write access to set times. */
|
|
|
1776 fh = qxeCreateFile (filename, GENERIC_WRITE,
|
|
|
1777 FILE_SHARE_READ | FILE_SHARE_WRITE,
|
|
|
1778 0, OPEN_EXISTING, 0, NULL);
|
|
|
1779 if (fh)
|
|
|
1780 {
|
|
|
1781 convert_from_time_t (times->actime, &atime);
|
|
|
1782 convert_from_time_t (times->modtime, &mtime);
|
|
|
1783 if (!SetFileTime (fh, NULL, &atime, &mtime))
|
|
|
1784 {
|
|
|
1785 CloseHandle (fh);
|
|
|
1786 errno = EACCES;
|
|
|
1787 return -1;
|
|
|
1788 }
|
|
|
1789 CloseHandle (fh);
|
|
|
1790 }
|
|
|
1791 else
|
|
|
1792 {
|
|
|
1793 errno = EINVAL;
|
|
|
1794 return -1;
|
|
|
1795 }
|
|
|
1796 return 0;
|
|
|
1797 #else
|
|
|
1798 {
|
|
|
1799 struct _utimbuf newtimes;
|
|
|
1800
|
|
|
1801 newtimes.actime = times->actime;
|
|
|
1802 newtimes.modtime = times->modtime;
|
|
|
1803
|
|
|
1804 if (XEUNICODE_P)
|
|
|
1805 return _wutime ((const wchar_t *) filename, &newtimes);
|
|
|
1806 else
|
|
|
1807 return _utime (filename, &newtimes);
|
|
|
1808 }
|
|
|
1809 #endif
|
|
|
1810 }
|
|
|
1811
|
|
867
|
1812 Ibyte *
|
|
771
|
1813 mswindows_getdcwd (int drivelet)
|
|
|
1814 {
|
|
|
1815 Extbyte *cwdext;
|
|
867
|
1816 Ibyte *cwd;
|
|
771
|
1817
|
|
|
1818 if (XEUNICODE_P)
|
|
|
1819 cwdext = (Extbyte *) _wgetdcwd (drivelet, NULL, 0);
|
|
|
1820 else
|
|
|
1821 cwdext = _getdcwd (drivelet, NULL, 0);
|
|
|
1822 TSTR_TO_C_STRING_MALLOC (cwdext, cwd);
|
|
1726
|
1823 xfree (cwdext, Extbyte *);
|
|
771
|
1824 return cwd;
|
|
428
|
1825 }
|
|
|
1826
|
|
442
|
1827
|
|
|
1828 /*--------------------------------------------------------------------*/
|
|
|
1829 /* Memory-mapped files */
|
|
|
1830 /*--------------------------------------------------------------------*/
|
|
|
1831
|
|
428
|
1832 int
|
|
867
|
1833 open_input_file (file_data *p_file, const Ibyte *filename)
|
|
428
|
1834 {
|
|
442
|
1835 /* Synched with FSF 20.6. We fixed some warnings. */
|
|
428
|
1836 HANDLE file;
|
|
|
1837 HANDLE file_mapping;
|
|
771
|
1838 void *file_base;
|
|
428
|
1839 DWORD size, upper_size;
|
|
771
|
1840 Extbyte *fileext;
|
|
428
|
1841
|
|
2526
|
1842 PATHNAME_CONVERT_OUT (filename, fileext);
|
|
771
|
1843
|
|
|
1844 file = qxeCreateFile (fileext, GENERIC_READ, FILE_SHARE_READ, NULL,
|
|
|
1845 OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
|
|
428
|
1846 if (file == INVALID_HANDLE_VALUE)
|
|
|
1847 return FALSE;
|
|
|
1848
|
|
|
1849 size = GetFileSize (file, &upper_size);
|
|
771
|
1850 file_mapping = qxeCreateFileMapping (file, NULL, PAGE_READONLY,
|
|
|
1851 0, size, NULL);
|
|
428
|
1852 if (!file_mapping)
|
|
|
1853 return FALSE;
|
|
|
1854
|
|
|
1855 file_base = MapViewOfFile (file_mapping, FILE_MAP_READ, 0, 0, size);
|
|
|
1856 if (file_base == 0)
|
|
|
1857 return FALSE;
|
|
|
1858
|
|
771
|
1859 p_file->name = filename;
|
|
442
|
1860 p_file->size = size;
|
|
|
1861 p_file->file = file;
|
|
|
1862 p_file->file_mapping = file_mapping;
|
|
771
|
1863 p_file->file_base = file_base;
|
|
442
|
1864
|
|
|
1865 return TRUE;
|
|
|
1866 }
|
|
|
1867
|
|
|
1868 int
|
|
867
|
1869 open_output_file (file_data *p_file, const Ibyte *filename,
|
|
771
|
1870 unsigned long size)
|
|
442
|
1871 {
|
|
|
1872 /* Synched with FSF 20.6. We fixed some warnings. */
|
|
|
1873 HANDLE file;
|
|
|
1874 HANDLE file_mapping;
|
|
771
|
1875 void *file_base;
|
|
|
1876 Extbyte *fileext;
|
|
442
|
1877
|
|
2526
|
1878 PATHNAME_CONVERT_OUT (filename, fileext);
|
|
771
|
1879
|
|
|
1880 file = qxeCreateFile (fileext, GENERIC_READ | GENERIC_WRITE, 0, NULL,
|
|
|
1881 CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0);
|
|
442
|
1882 if (file == INVALID_HANDLE_VALUE)
|
|
|
1883 return FALSE;
|
|
|
1884
|
|
771
|
1885 file_mapping = qxeCreateFileMapping (file, NULL, PAGE_READWRITE,
|
|
|
1886 0, size, NULL);
|
|
442
|
1887 if (!file_mapping)
|
|
|
1888 return FALSE;
|
|
|
1889
|
|
|
1890 file_base = MapViewOfFile (file_mapping, FILE_MAP_WRITE, 0, 0, size);
|
|
|
1891 if (file_base == NULL)
|
|
|
1892 return FALSE;
|
|
|
1893
|
|
|
1894 p_file->name = filename;
|
|
428
|
1895 p_file->size = size;
|
|
|
1896 p_file->file = file;
|
|
|
1897 p_file->file_mapping = file_mapping;
|
|
771
|
1898 p_file->file_base = file_base;
|
|
428
|
1899
|
|
|
1900 return TRUE;
|
|
|
1901 }
|
|
|
1902
|
|
442
|
1903 #if 1 /* !defined(MINGW) */
|
|
|
1904 /* Return pointer to section header for section containing the given
|
|
|
1905 relative virtual address. */
|
|
|
1906 static IMAGE_SECTION_HEADER *
|
|
771
|
1907 rva_to_section (DWORD rva, IMAGE_NT_HEADERS *nt_header)
|
|
442
|
1908 {
|
|
|
1909 /* Synched with FSF 20.6. We added MINGW stuff. */
|
|
|
1910 PIMAGE_SECTION_HEADER section;
|
|
|
1911 int i;
|
|
|
1912
|
|
|
1913 section = IMAGE_FIRST_SECTION (nt_header);
|
|
|
1914
|
|
|
1915 for (i = 0; i < nt_header->FileHeader.NumberOfSections; i++)
|
|
|
1916 {
|
|
|
1917 /* Some linkers (eg. the NT SDK linker I believe) swapped the
|
|
|
1918 meaning of these two values - or rather, they ignored
|
|
|
1919 VirtualSize entirely and always set it to zero. This affects
|
|
|
1920 some very old exes (eg. gzip dated Dec 1993). Since
|
|
|
1921 mswindows_executable_type relies on this function to work reliably,
|
|
|
1922 we need to cope with this. */
|
|
|
1923 DWORD real_size = max (section->SizeOfRawData,
|
|
|
1924 section->Misc.VirtualSize);
|
|
|
1925 if (rva >= section->VirtualAddress
|
|
|
1926 && rva < section->VirtualAddress + real_size)
|
|
|
1927 return section;
|
|
|
1928 section++;
|
|
|
1929 }
|
|
|
1930 return NULL;
|
|
|
1931 }
|
|
|
1932 #endif
|
|
|
1933
|
|
|
1934 void
|
|
867
|
1935 mswindows_executable_type (const Ibyte *filename, int *is_dos_app,
|
|
771
|
1936 int *is_cygnus_app)
|
|
442
|
1937 {
|
|
|
1938 /* Synched with FSF 20.6. We added MINGW stuff and casts. */
|
|
|
1939 file_data executable;
|
|
867
|
1940 Ibyte *p;
|
|
442
|
1941
|
|
|
1942 /* Default values in case we can't tell for sure. */
|
|
|
1943 *is_dos_app = FALSE;
|
|
|
1944 *is_cygnus_app = FALSE;
|
|
|
1945
|
|
|
1946 if (!open_input_file (&executable, filename))
|
|
|
1947 return;
|
|
|
1948
|
|
771
|
1949 p = qxestrrchr (filename, '.');
|
|
442
|
1950
|
|
|
1951 /* We can only identify DOS .com programs from the extension. */
|
|
2367
|
1952 if (p && qxestrcasecmp_ascii (p, ".com") == 0)
|
|
442
|
1953 *is_dos_app = TRUE;
|
|
2367
|
1954 else if (p && (qxestrcasecmp_ascii (p, ".bat") == 0 ||
|
|
|
1955 qxestrcasecmp_ascii (p, ".cmd") == 0))
|
|
442
|
1956 {
|
|
|
1957 /* A DOS shell script - it appears that CreateProcess is happy to
|
|
|
1958 accept this (somewhat surprisingly); presumably it looks at
|
|
|
1959 COMSPEC to determine what executable to actually invoke.
|
|
|
1960 Therefore, we have to do the same here as well. */
|
|
|
1961 /* Actually, I think it uses the program association for that
|
|
|
1962 extension, which is defined in the registry. */
|
|
|
1963 p = egetenv ("COMSPEC");
|
|
|
1964 if (p)
|
|
|
1965 mswindows_executable_type (p, is_dos_app, is_cygnus_app);
|
|
|
1966 }
|
|
|
1967 else
|
|
|
1968 {
|
|
|
1969 /* Look for DOS .exe signature - if found, we must also check that
|
|
|
1970 it isn't really a 16- or 32-bit Windows exe, since both formats
|
|
|
1971 start with a DOS program stub. Note that 16-bit Windows
|
|
|
1972 executables use the OS/2 1.x format. */
|
|
|
1973
|
|
|
1974 #if 0 /* defined( MINGW ) */
|
|
771
|
1975 /* mingw doesn't have enough headers to detect cygwin
|
|
442
|
1976 apps, just do what we can. */
|
|
771
|
1977 FILHDR *exe_header;
|
|
442
|
1978
|
|
771
|
1979 exe_header = (FILHDR *) executable.file_base;
|
|
442
|
1980 if (exe_header->e_magic != DOSMAGIC)
|
|
|
1981 goto unwind;
|
|
|
1982
|
|
771
|
1983 if ((char *) exe_header->e_lfanew > (char *) executable.size)
|
|
442
|
1984 {
|
|
|
1985 /* Some dos headers (pkunzip) have bogus e_lfanew fields. */
|
|
|
1986 *is_dos_app = TRUE;
|
|
|
1987 }
|
|
|
1988 else if (exe_header->nt_signature != NT_SIGNATURE)
|
|
|
1989 {
|
|
|
1990 *is_dos_app = TRUE;
|
|
|
1991 }
|
|
|
1992 #else
|
|
771
|
1993 IMAGE_DOS_HEADER *dos_header;
|
|
|
1994 IMAGE_NT_HEADERS *nt_header;
|
|
442
|
1995
|
|
|
1996 dos_header = (PIMAGE_DOS_HEADER) executable.file_base;
|
|
|
1997 if (dos_header->e_magic != IMAGE_DOS_SIGNATURE)
|
|
|
1998 goto unwind;
|
|
|
1999
|
|
771
|
2000 nt_header = (PIMAGE_NT_HEADERS) ((char *) dos_header +
|
|
|
2001 dos_header->e_lfanew);
|
|
442
|
2002
|
|
771
|
2003 if ((char *) nt_header > (char *) dos_header + executable.size)
|
|
442
|
2004 {
|
|
|
2005 /* Some dos headers (pkunzip) have bogus e_lfanew fields. */
|
|
|
2006 *is_dos_app = TRUE;
|
|
|
2007 }
|
|
|
2008 else if (nt_header->Signature != IMAGE_NT_SIGNATURE &&
|
|
|
2009 LOWORD (nt_header->Signature) != IMAGE_OS2_SIGNATURE)
|
|
|
2010 {
|
|
|
2011 *is_dos_app = TRUE;
|
|
|
2012 }
|
|
|
2013 else if (nt_header->Signature == IMAGE_NT_SIGNATURE)
|
|
|
2014 {
|
|
|
2015 /* Look for cygwin.dll in DLL import list. */
|
|
|
2016 IMAGE_DATA_DIRECTORY import_dir =
|
|
771
|
2017 nt_header->OptionalHeader.
|
|
|
2018 DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT];
|
|
|
2019 IMAGE_IMPORT_DESCRIPTOR *imports;
|
|
|
2020 IMAGE_SECTION_HEADER *section;
|
|
442
|
2021
|
|
|
2022 section = rva_to_section (import_dir.VirtualAddress, nt_header);
|
|
771
|
2023 imports =
|
|
|
2024 (IMAGE_IMPORT_DESCRIPTOR *) RVA_TO_PTR (import_dir.VirtualAddress,
|
|
|
2025 section, executable);
|
|
|
2026
|
|
442
|
2027 for ( ; imports->Name; imports++)
|
|
|
2028 {
|
|
771
|
2029 Extbyte *dllname_ext =
|
|
|
2030 (Extbyte *) RVA_TO_PTR (imports->Name, section, executable);
|
|
867
|
2031 Ibyte *dllname;
|
|
771
|
2032
|
|
|
2033 EXTERNAL_TO_C_STRING (dllname_ext, dllname, Qbinary);
|
|
442
|
2034
|
|
|
2035 /* The exact name of the cygwin dll has changed with
|
|
|
2036 various releases, but hopefully this will be reasonably
|
|
|
2037 future proof. */
|
|
867
|
2038 if (qxestrncasecmp (dllname, (Ibyte *) "cygwin", 6) == 0)
|
|
442
|
2039 {
|
|
|
2040 *is_cygnus_app = TRUE;
|
|
|
2041 break;
|
|
|
2042 }
|
|
|
2043 }
|
|
|
2044 }
|
|
|
2045 #endif
|
|
|
2046 }
|
|
|
2047
|
|
|
2048 unwind:
|
|
|
2049 close_file_data (&executable);
|
|
|
2050 }
|
|
|
2051
|
|
428
|
2052 /* Close the system structures associated with the given file. */
|
|
|
2053 void
|
|
|
2054 close_file_data (file_data *p_file)
|
|
|
2055 {
|
|
611
|
2056 UnmapViewOfFile (p_file->file_base);
|
|
|
2057 CloseHandle (p_file->file_mapping);
|
|
|
2058 CloseHandle (p_file->file);
|
|
428
|
2059 }
|
|
|
2060
|
|
771
|
2061
|
|
|
2062 /* Some miscellaneous functions that are Windows specific, but not GUI
|
|
|
2063 specific (ie. are applicable in terminal or batch mode as well). */
|
|
|
2064
|
|
|
2065 DEFUN ("mswindows-short-file-name", Fmswindows_short_file_name, 1, 1, "", /*
|
|
|
2066 Return the short file name version (8.3) of the full path of FILENAME.
|
|
|
2067 If FILENAME does not exist, return nil.
|
|
|
2068 All path elements in FILENAME are converted to their short names.
|
|
|
2069 */
|
|
|
2070 (filename))
|
|
|
2071 {
|
|
2421
|
2072 Extbyte shortname[PATH_MAX_EXTERNAL];
|
|
771
|
2073 Extbyte *fileext;
|
|
867
|
2074 Ibyte *shortint;
|
|
771
|
2075
|
|
|
2076 CHECK_STRING (filename);
|
|
|
2077
|
|
|
2078 /* first expand it. */
|
|
|
2079 filename = Fexpand_file_name (filename, Qnil);
|
|
|
2080
|
|
2526
|
2081 LISP_PATHNAME_CONVERT_OUT (filename, fileext);
|
|
771
|
2082 /* luckily, this returns the short version of each element in the path. */
|
|
|
2083 if (qxeGetShortPathName (fileext, shortname,
|
|
|
2084 sizeof (shortname) / XETCHAR_SIZE) == 0)
|
|
|
2085 return Qnil;
|
|
|
2086
|
|
|
2087 TSTR_TO_C_STRING (shortname, shortint);
|
|
|
2088 MSWINDOWS_NORMALIZE_FILENAME (shortint);
|
|
|
2089
|
|
1204
|
2090 return build_intstring (shortint);
|
|
771
|
2091 }
|
|
|
2092
|
|
|
2093
|
|
|
2094 DEFUN ("mswindows-long-file-name", Fmswindows_long_file_name, 1, 1, "", /*
|
|
|
2095 Return the long file name version of the full path of FILENAME.
|
|
|
2096 If FILENAME does not exist, return nil.
|
|
|
2097 All path elements in FILENAME are converted to their long names.
|
|
|
2098 */
|
|
|
2099 (filename))
|
|
|
2100 {
|
|
867
|
2101 Ibyte *longname, *canon;
|
|
771
|
2102 Lisp_Object ret;
|
|
|
2103
|
|
|
2104 CHECK_STRING (filename);
|
|
|
2105
|
|
|
2106 /* first expand it. */
|
|
|
2107 filename = Fexpand_file_name (filename, Qnil);
|
|
|
2108
|
|
|
2109 if (!(longname = mswindows_get_long_filename (XSTRING_DATA (filename))))
|
|
|
2110 return Qnil;
|
|
|
2111
|
|
|
2112 canon = mswindows_canonicalize_filename (longname);
|
|
1204
|
2113 ret = build_intstring (canon);
|
|
1726
|
2114 xfree (canon, Ibyte *);
|
|
|
2115 xfree (longname, Ibyte *);
|
|
771
|
2116 return ret;
|
|
|
2117 }
|
|
|
2118
|
|
814
|
2119
|
|
|
2120 void
|
|
|
2121 init_nt (void)
|
|
|
2122 {
|
|
|
2123 /* Initial preparation for subprocess support: replace our standard
|
|
|
2124 handles with non-inheritable versions.
|
|
|
2125
|
|
|
2126 #### Do we still need this? This is left over from the old process
|
|
|
2127 support. */
|
|
|
2128 {
|
|
|
2129 HANDLE parent;
|
|
|
2130 HANDLE stdin_save = INVALID_HANDLE_VALUE;
|
|
|
2131 HANDLE stdout_save = INVALID_HANDLE_VALUE;
|
|
|
2132 HANDLE stderr_save = INVALID_HANDLE_VALUE;
|
|
|
2133
|
|
|
2134 parent = GetCurrentProcess ();
|
|
|
2135
|
|
|
2136 /* ignore errors when duplicating and closing; typically the
|
|
|
2137 handles will be invalid when running as a gui program. */
|
|
|
2138 DuplicateHandle (parent,
|
|
|
2139 GetStdHandle (STD_INPUT_HANDLE),
|
|
|
2140 parent,
|
|
|
2141 &stdin_save,
|
|
|
2142 0,
|
|
|
2143 FALSE,
|
|
|
2144 DUPLICATE_SAME_ACCESS);
|
|
|
2145
|
|
|
2146 DuplicateHandle (parent,
|
|
|
2147 GetStdHandle (STD_OUTPUT_HANDLE),
|
|
|
2148 parent,
|
|
|
2149 &stdout_save,
|
|
|
2150 0,
|
|
|
2151 FALSE,
|
|
|
2152 DUPLICATE_SAME_ACCESS);
|
|
|
2153
|
|
|
2154 DuplicateHandle (parent,
|
|
|
2155 GetStdHandle (STD_ERROR_HANDLE),
|
|
|
2156 parent,
|
|
|
2157 &stderr_save,
|
|
|
2158 0,
|
|
|
2159 FALSE,
|
|
|
2160 DUPLICATE_SAME_ACCESS);
|
|
|
2161
|
|
|
2162 retry_fclose (stdin);
|
|
|
2163 retry_fclose (stdout);
|
|
|
2164 retry_fclose (stderr);
|
|
|
2165
|
|
|
2166 if (stdin_save != INVALID_HANDLE_VALUE)
|
|
|
2167 _open_osfhandle ((long) stdin_save, O_TEXT);
|
|
|
2168 else
|
|
|
2169 _open ("nul", O_TEXT | O_NOINHERIT | O_RDONLY);
|
|
|
2170 _fdopen (0, "r");
|
|
|
2171
|
|
|
2172 if (stdout_save != INVALID_HANDLE_VALUE)
|
|
|
2173 _open_osfhandle ((long) stdout_save, O_TEXT);
|
|
|
2174 else
|
|
|
2175 _open ("nul", O_TEXT | O_NOINHERIT | O_WRONLY);
|
|
|
2176 _fdopen (1, "w");
|
|
|
2177
|
|
|
2178 if (stderr_save != INVALID_HANDLE_VALUE)
|
|
|
2179 _open_osfhandle ((long) stderr_save, O_TEXT);
|
|
|
2180 else
|
|
|
2181 _open ("nul", O_TEXT | O_NOINHERIT | O_WRONLY);
|
|
|
2182 _fdopen (2, "w");
|
|
|
2183 }
|
|
|
2184
|
|
|
2185 /* determine which drives are fixed, for get_cached_volume_information */
|
|
|
2186 {
|
|
|
2187 /* GetDriveType must have trailing backslash. */
|
|
867
|
2188 Ibyte drive[] = "A:\\";
|
|
814
|
2189
|
|
|
2190 /* Loop over all possible drive letters */
|
|
|
2191 while (*drive <= 'Z')
|
|
|
2192 {
|
|
|
2193 Extbyte *driveext;
|
|
|
2194
|
|
2526
|
2195 PATHNAME_CONVERT_OUT (drive, driveext);
|
|
814
|
2196
|
|
|
2197 /* Record if this drive letter refers to a fixed drive. */
|
|
|
2198 fixed_drives[DRIVE_INDEX (*drive)] =
|
|
|
2199 (qxeGetDriveType (driveext) == DRIVE_FIXED);
|
|
|
2200
|
|
|
2201 (*drive)++;
|
|
|
2202 }
|
|
|
2203
|
|
|
2204 /* Reset the volume info cache. */
|
|
|
2205 volume_cache = NULL;
|
|
|
2206 }
|
|
|
2207 }
|
|
|
2208
|
|
771
|
2209 void
|
|
|
2210 syms_of_nt (void)
|
|
|
2211 {
|
|
|
2212 DEFSUBR (Fmswindows_short_file_name);
|
|
|
2213 DEFSUBR (Fmswindows_long_file_name);
|
|
|
2214 }
|
|
|
2215
|
|
440
|
2216 void
|
|
|
2217 vars_of_nt (void)
|
|
|
2218 {
|
|
771
|
2219 DEFVAR_INT ("mswindows-fake-unix-uid", &mswindows_fake_unix_uid /*
|
|
440
|
2220 *Set uid returned by `user-uid' and `user-real-uid'.
|
|
771
|
2221 Under NT and 9x, there are no uids, and even no almighty user called root.
|
|
|
2222 By setting this variable, you can have any uid of choice. Default is 0.
|
|
440
|
2223 Changes to this variable take effect immediately.
|
|
|
2224 */ );
|
|
771
|
2225 mswindows_fake_unix_uid = 0;
|
|
|
2226
|
|
|
2227 DEFVAR_LISP ("mswindows-get-true-file-attributes", &Vmswindows_get_true_file_attributes /*
|
|
|
2228 Non-nil means determine accurate link count in file-attributes.
|
|
|
2229 This option slows down file-attributes noticeably, so is disabled by
|
|
|
2230 default. Note that it is only useful for files on NTFS volumes,
|
|
|
2231 where hard links are supported.
|
|
|
2232 */ );
|
|
|
2233 Vmswindows_get_true_file_attributes = Qnil;
|
|
440
|
2234 }
|
|
|
2235
|
|
428
|
2236 /* end of nt.c */
|
