[bpt/emacs.git] / lib-src / ntlib.c

/* Utility and Unix shadow routines for GNU Emacs support programs on NT.

Copyright (C) 1994, 2001-2012 Free Software Foundation, Inc.

Author: Geoff Voelker (voelker@cs.washington.edu)
Created: 10-8-94

This file is part of GNU Emacs.

GNU Emacs is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

GNU Emacs is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */

#include <windows.h>
#include <stdlib.h>
#include <stdio.h>
#include <time.h>
#include <direct.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <errno.h>
#include <ctype.h>

#include "ntlib.h"

#define MAXPATHLEN _MAX_PATH

/* Emulate sleep...we could have done this with a define, but that
   would necessitate including windows.h in the files that used it.
   This is much easier.  */
void
sleep (unsigned long seconds)
{
  Sleep (seconds * 1000);
}

/* Get the current working directory.  */
char *
getwd (char *dir)
{
  if (GetCurrentDirectory (MAXPATHLEN, dir) > 0)
    return dir;
  return NULL;
}

static HANDLE getppid_parent;
static int    getppid_ppid;

int
getppid (void)
{
  char *ppid;
  DWORD result;

  ppid = getenv ("EM_PARENT_PROCESS_ID");
  if (!ppid)
    {
      printf ("no pid.\n");
      return 0;
    }
  else
    {
      getppid_ppid = atoi (ppid);
    }

  if (!getppid_parent)
    {
      getppid_parent = OpenProcess (SYNCHRONIZE, FALSE, atoi (ppid));
      if (!getppid_parent)
	{
	  printf ("Failed to open handle to parent process: %d\n",
		 GetLastError ());
	  exit (1);
	}
    }

  result = WaitForSingleObject (getppid_parent, 0);
  switch (result)
    {
    case WAIT_TIMEOUT:
      /* The parent is still alive.  */
      return getppid_ppid;
    case WAIT_OBJECT_0:
      /* The parent is gone.  Return the pid of Unix init (1).  */
      return 1;
    case WAIT_FAILED:
    default:
      printf ("Checking parent status failed: %d\n", GetLastError ());
      exit (1);
    }
}

char *
getlogin (void)
{
  static char user_name[256];
  DWORD  length = sizeof (user_name);

  if (GetUserName (user_name, &length))
    return user_name;
  return NULL;
}

char *
cuserid (char * s)
{
  char * name = getlogin ();
  if (s)
    return strcpy (s, name ? name : "");
  return name;
}

unsigned
getuid (void)
{
  return 0;
}

unsigned
getgid (void)
{
  return 0;
}

unsigned
getegid (void)
{
  return 0;
}

int
setuid (unsigned uid)
{
  return 0;
}

int
setregid (unsigned rgid, unsigned gid)
{
  return 0;
}

struct passwd *
getpwuid (unsigned uid)
{
  return NULL;
}

char *
getpass (const char * prompt)
{
  static char input[256];
  HANDLE in;
  HANDLE err;
  DWORD  count;

  in = GetStdHandle (STD_INPUT_HANDLE);
  err = GetStdHandle (STD_ERROR_HANDLE);

  if (in == INVALID_HANDLE_VALUE || err == INVALID_HANDLE_VALUE)
    return NULL;

  if (WriteFile (err, prompt, strlen (prompt), &count, NULL))
    {
      int istty = (GetFileType (in) == FILE_TYPE_CHAR);
      DWORD old_flags;
      int rc;

      if (istty)
	{
	  if (GetConsoleMode (in, &old_flags))
	    SetConsoleMode (in, ENABLE_LINE_INPUT | ENABLE_PROCESSED_INPUT);
	  else
	    istty = 0;
	}
      rc = ReadFile (in, input, sizeof (input), &count, NULL);
      if (count >= 2 && input[count - 2] == '\r')
	input[count - 2] = '\0';
      else
	{
	  char buf[256];
	  while (ReadFile (in, buf, sizeof (buf), &count, NULL) > 0)
	    if (count >= 2 && buf[count - 2] == '\r')
	      break;
	}
      WriteFile (err, "\r\n", 2, &count, NULL);
      if (istty)
	SetConsoleMode (in, old_flags);
      if (rc)
	return input;
    }

  return NULL;
}

int
fchown (int fd, unsigned uid, unsigned gid)
{
  return 0;
}

/* Place a wrapper around the MSVC version of ctime.  It returns NULL
   on network directories, so we handle that case here.
   (Ulrich Leodolter, 1/11/95).  */
char *
sys_ctime (const time_t *t)
{
  char *str = (char *) ctime (t);
  return (str ? str : "Sun Jan 01 00:00:00 1970");
}

FILE *
sys_fopen (const char * path, const char * mode)
{
  return fopen (path, mode);
}

int
sys_chdir (const char * path)
{
  return _chdir (path);
}

static FILETIME utc_base_ft;
static long double utc_base;
static int init = 0;

static time_t
convert_time (FILETIME ft)
{
  long double ret;

  if (CompareFileTime (&ft, &utc_base_ft) < 0)
    return 0;

  ret = (long double) ft.dwHighDateTime
    * 4096.0L * 1024.0L * 1024.0L + ft.dwLowDateTime;
  ret -= utc_base;
  return (time_t) (ret * 1e-7L);
}

static int
is_exec (const char * name)
{
  char * p = strrchr (name, '.');
  return
    (p != NULL
     && (stricmp (p, ".exe") == 0 ||
	 stricmp (p, ".com") == 0 ||
	 stricmp (p, ".bat") == 0 ||
	 stricmp (p, ".cmd") == 0));
}

/* FIXME?  This is in config.nt now - is this still needed?  */
#define IS_DIRECTORY_SEP(x) ((x) == '/' || (x) == '\\')

/* We need this because nt/inc/sys/stat.h defines struct stat that is
   incompatible with the MS run-time libraries.  */
int
stat (const char * path, struct stat * buf)
{
  WIN32_FIND_DATA wfd;
  HANDLE fh;
  int permission;
  int len;
  int rootdir = FALSE;
  char *name = alloca (FILENAME_MAX);

  if (!init)
    {
      /* Determine the delta between 1-Jan-1601 and 1-Jan-1970. */
      SYSTEMTIME st;

      st.wYear = 1970;
      st.wMonth = 1;
      st.wDay = 1;
      st.wHour = 0;
      st.wMinute = 0;
      st.wSecond = 0;
      st.wMilliseconds = 0;

      SystemTimeToFileTime (&st, &utc_base_ft);
      utc_base = (long double) utc_base_ft.dwHighDateTime
	* 4096.0L * 1024.0L * 1024.0L + utc_base_ft.dwLowDateTime;
      init = 1;
    }

  if (path == NULL || buf == NULL || *path == '\0')
    {
      errno = EFAULT;
      return -1;
    }
  if (_mbspbrk (path, "*?|<>\""))
    {
      errno = ENOENT;
      return -1;
    }

  strcpy (name, path);
  /* Remove trailing directory separator, unless name is the root
     directory of a drive in which case ensure there is a trailing
     separator. */
  len = strlen (name);
  rootdir = IS_DIRECTORY_SEP (name[0])
    || (len == 3 && name[1] == ':' && IS_DIRECTORY_SEP (name[2]));
  if (rootdir)
    {
      if (GetDriveType (name) < 2)
	{
	  errno = ENOENT;
	  return -1;
	}
      memset (&wfd, 0, sizeof (wfd));
      wfd.dwFileAttributes = FILE_ATTRIBUTE_DIRECTORY;
      wfd.ftCreationTime = utc_base_ft;
      wfd.ftLastAccessTime = utc_base_ft;
      wfd.ftLastWriteTime = utc_base_ft;
      strcpy (wfd.cFileName, name);
    }
  else
    {
      if (IS_DIRECTORY_SEP (name[len-1]))
	name[len - 1] = 0;

      fh = FindFirstFile (name, &wfd);
      if (fh == INVALID_HANDLE_VALUE)
	{
	  errno = ENOENT;
	  return -1;
	}
      FindClose (fh);
    }
  buf->st_mode = (wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) ?
    S_IFDIR : S_IFREG;
  buf->st_nlink = 1;
  buf->st_ino = 0;

  if (name[0] && name[1] == ':')
    buf->st_dev = tolower (name[0]) - 'a' + 1;
  else
    buf->st_dev = _getdrive ();
  buf->st_rdev = buf->st_dev;

  buf->st_size = wfd.nFileSizeLow;

  /* Convert timestamps to Unix format. */
  buf->st_mtime = convert_time (wfd.ftLastWriteTime);
  buf->st_atime = convert_time (wfd.ftLastAccessTime);
  if (buf->st_atime == 0) buf->st_atime = buf->st_mtime;
  buf->st_ctime = convert_time (wfd.ftCreationTime);
  if (buf->st_ctime == 0) buf->st_ctime = buf->st_mtime;

  /* determine rwx permissions */
  if (wfd.dwFileAttributes & FILE_ATTRIBUTE_READONLY)
    permission = S_IREAD;
  else
    permission = S_IREAD | S_IWRITE;

  if (wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
    permission |= S_IEXEC;
  else if (is_exec (name))
    permission |= S_IEXEC;

  buf->st_mode |= permission | (permission >> 3) | (permission >> 6);

  return 0;
}

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