40 

    41 #if defined(MSWINDOWS) || defined(OS2) || defined(MSDOS) || defined(WIN32)

    42 # ifndef MSDOS_LIKE

    43 #  define MSDOS_LIKE

    44 # endif

    45 # undef UNIX_LIKE       /* oops - we were too optimistic - no OS */

    46 # ifdef i386

    47 #  ifndef _X86_

    48 #   define _X86_

    49 #  endif

    50 # endif

    51 #endif /* any MS-non-OS */

    52 

    53 #if defined(transputer)

    54 # undef MSDOS_LIKE

    55 # undef UNIX_LIKE       /* oops - we were too optimistic - no OS */

    56 #endif

    57 

    58 #if defined(_AIX)

    59 # ifndef WANT_REALPATH

    60 #  define WANT_REALPATH

    61 # endif

    62 # ifndef WANT_SYSTEM

    63 #  define WANT_SYSTEM

    64 # endif

    65 #endif

    66 

    67 #ifdef LINUX

    68   /* use inline string macros */

    69 # define __STRINGDEFS__

    70 # include <linuxIntern.h>

    71 

    72 # ifndef WANT_SYSTEM

    73 #  define WANT_SYSTEM

    74 # endif

    75 # define WANT_SHM

    76 #endif

    77 

    78 #ifdef IRIX5

    79 # define WANT_SYSTEM

    80 #endif

    81 

    82 #ifdef ultrix

    83 # define WANT_SYSTEM

    84 #endif

    85 

    86 #ifdef hpux

    87 # define WANT_SYSTEM

    88 #endif

    89 

    90 #ifdef solaris

    91 # define WANT_SYSTEM

    92 #endif

    93 

    94 #if defined(SYSV4) && defined(i386) /* e.g. unixware */

    95 # define WANT_SYSTEM

    96 #endif

   196 #ifdef WANT_REALPATH

   197 

   198 # ifndef NO_SYS_PARAM_H

   199 #  include <sys/param.h>

   200 #  define _SYS_PARAM_H_INCLUDED_

   201 # endif

   202 

   203 # include <errno.h>

   204 # define _ERRNO_H_INCLUDED_

   205 

   206 # include <sys/stat.h>

   207 # define _SYS_STAT_H_INCLUDED_

   208 

   209 #endif /* WANT_REALPATH */

   210 

   211 

   480 

   481 # ifndef S_IXUSR

   482 #  define S_IXUSR 0100

   483 #  define S_IXGRP 0010

   484 #  define S_IXOTH 0001

   485 # endif

   486 

   487 # ifndef S_IRUSR

   488 #  define S_IRUSR 0400

   489 #  define S_IRGRP 0040

   490 #  define S_IROTH 0004

   491 # endif

   492 

   493 # ifndef S_IWUSR

   494 #  define S_IWUSR 0200

   495 #  define S_IWGRP 0020

   496 #  define S_IWOTH 0002

   497 # endif

   498 

   614 #ifdef __osf__

   615 # define TIME_T time_t

   616 # define OFF_T  off_t

   617 #endif

   660 

   661 /*

   662  * some systems' system() is broken in that it does not correctly 

   663  * handle EINTR and returns failure even though it actually succeeded. 

   664  * (LINUX is one of them)

   665  * Here is a fixed version. If you encounter EINTR returns from

   666  * OpenVMSOperatingSystem>>executeCommand, you ought to define WANT_SYSTEM

   667  * in the xxxIntern.h file to get this fixed version.

   668  *

   669  * As an added BONUS, this system() enables interrupts while waiting

   670  * for the child which enables other threads to continue.

   671  * (i.e. it is RT safe)

   672  */

   673 

   674 #if defined(WANT_SYSTEM)

   675 

   676 /* # define DPRINTF(x)     printf x */

   677 # define DPRINTF(x)     /* nothing */

   678 

   679 # ifndef _STDDEF_H_INCLUDED_

   680 #  include <stddef.h>

   681 #  define _STDDEF_H_INCLUDED_

   682 # endif

   683 

   684 # ifndef _STDLIB_H_INCLUDED_

   685 #  include <stdlib.h>

   686 #  define _STDLIB_H_INCLUDED_

   687 # endif

   688 

   689 # ifndef _UNISTD_H_INCLUDED_

   690 #  include <unistd.h>

   691 #  define _UNISTD_H_INCLUDED_

   692 # endif

   693 

   694 # ifndef _SYS_WAIT_H_INCLUDED

   695 #  include <sys/wait.h>

   696 #  define _SYS_WAIT_H_INCLUDED

   697 # endif

   698 

   699 # ifndef _SIGNAL_H_INCLUDED_

   700 #  include <signal.h>

   701 #  define _SIGNAL_H_INCLUDED_

   702 # endif

   703 

   704 # ifndef _SYS_TYPES_H_INCLUDED_

   705 #  include <sys/types.h>

   706 #  define _SYS_TYPES_H_INCLUDED_

   707 # endif

   708 

   709 # if (!defined(HAVE_GNU_LD) && !defined (__ELF__)) || !defined(LINUX)

   710 #  define       __environ       environ

   711 #  if !defined(LINUX)

   712 #   define      __sigemptyset   sigemptyset

   713 #   define      __sigaction     sigaction

   714 #   define      __sigaddset     sigaddset

   715 #   define      __sigprocmask   sigprocmask

   716 #   define      __execve        execve

   717 #   define      __wait          wait

   718 #   define      __waitpid       waitpid

   719 #   if defined(HAS_VFORK)

   720 #    define     FORK            vfork

   721 #   else

   722 #    define     FORK            fork

   723 #   endif

   724 #  endif /* ! LINUX */

   725    extern char **environ;

   726 # endif

   727 

   728 # define        SHELL_PATH      "/bin/sh"       /* Path of the shell.  */

   729 # define        SHELL_NAME      "sh"            /* Name to give it.  */

   730 

   731 # ifndef        FORK

   732 #  define       FORK    __fork

   733 # endif

   734 

   735 # ifndef CONST

   736 #  ifdef __GNUC__

   737 #   define CONST const

   738 #  else

   739 #   define CONST /* nothing */

   740 #  endif

   741 # endif

   742 

   743 static int

   744 mySystem(line)

   745     register CONST char *line;

   746 {

   747     int status, save;

   748     pid_t pid;

   749     struct sigaction sa, intr, quit;

   750     sigset_t block, omask;

   751 

   752     if (line == NULL)

   753 	return -1;

   754 

   755     sa.sa_handler = SIG_IGN;

   756     sa.sa_flags = 0;

   757     __sigemptyset (&sa.sa_mask);

   758 

   759     if (__sigaction (SIGINT, &sa, &intr) < 0) {

   760 	DPRINTF(("1: errno=%d\n", errno));

   761 	return -1;

   762     }

   763     if (__sigaction (SIGQUIT, &sa, &quit) < 0) {

   764 	save = errno;

   765 	(void) __sigaction (SIGINT, &intr, (struct sigaction *) NULL);

   766 	errno = save;

   767 	DPRINTF(("2: errno=%d\n", errno));

   768 	return -1;

   769     }

   770 

   771     __sigemptyset (&block);

   772     __sigaddset (&block, SIGCHLD);

   773     save = errno;

   774     if (__sigprocmask(SIG_BLOCK, &block, &omask) < 0) {

   775 	if (errno == ENOSYS)

   776 	    errno = save;

   777 	else {

   778 	    save = errno;

   779 	    (void) __sigaction(SIGINT, &intr, (struct sigaction *) NULL);

   780 	    (void) __sigaction (SIGQUIT, &quit, (struct sigaction *) NULL);

   781 	    errno = save;

   782 	    DPRINTF(("3: errno=%d\n", errno));

   783 	    return -1;

   784 	}

   785     }

   786 

   787     pid = FORK ();

   788     if (pid == (pid_t) 0) {

   789 	/* Child side.  */

   790 	CONST char *new_argv[4];

   791 	new_argv[0] = SHELL_NAME;

   792 	new_argv[1] = "-c";

   793 	new_argv[2] = line;

   794 	new_argv[3] = NULL;

   795 

   796 	/* Restore the signals.  */

   797 	(void) __sigaction (SIGINT, &intr, (struct sigaction *) NULL);

   798 	(void) __sigaction (SIGQUIT, &quit, (struct sigaction *) NULL);

   799 	(void) __sigprocmask (SIG_SETMASK, &omask, (sigset_t *) NULL);

   800 

   801 	/* Exec the shell.  */

   802 	(void) __execve (SHELL_PATH, (char *CONST *) new_argv, __environ);

   803 	_exit (127);

   804     } else {

   805 	if (pid < (pid_t) 0) {

   806 	    /* The fork failed.  */

   807 	    DPRINTF(("4: errno=%d\n", errno));

   808 	    status = -1;

   809 	} else {

   810 	    /* Parent side.  */

   811 #ifdef  NO_WAITPID

   812 	    pid_t child;

   813 

   814 	    do {

   815 		__BEGIN_INTERRUPTABLE__

   816 		child = __wait (&status);

   817 		__END_INTERRUPTABLE__

   818 		if (child < 0 && errno != EINTR) {

   819 		    DPRINTF(("5: errno=%d\n", errno));

   820 		    status = -1;

   821 		    break;

   822 		}

   823 	    } while (child != pid);

   824 #else

   825 	    pid_t child;

   826 

   827 	    /* claus: the original did not care for EINTR here ... */

   828 	    do {

   829 		__BEGIN_INTERRUPTABLE__

   830 		child = __waitpid (pid, &status, 0);

   831 		__END_INTERRUPTABLE__

   832 	    } while ((child != pid) && (errno == EINTR));

   833 	    if (child != pid) {

   834 		DPRINTF(("6: errno=%d\n", errno));

   835 		status = -1;

   836 	    }

   837 #endif /* NO_WAITPID */

   838 	}

   839     }

   840     save = errno;

   841     if ((__sigaction (SIGINT, &intr, (struct sigaction *) NULL)

   842      | __sigaction (SIGQUIT, &quit, (struct sigaction *) NULL)

   843      | __sigprocmask (SIG_SETMASK, &omask, (sigset_t *) NULL)) != 0) {

   844 	if (errno == ENOSYS) {

   845 	    errno = save;

   846 	} else {

   847 	    status = -1;

   848 	    DPRINTF(("7: errno=%d\n", errno));

   849 	}

   850     }

   851 

   852     return status;

   853 }

   854 #else

   855 # define __wait wait

   856 #endif /* WANT_SYSTEM */

   857 

   858 

   859 /*

   860  * some systems do not have realpath();

   861  * the alternative of reading from a 'pwp'-pipe

   862  * is way too slow. Here is a realpath for the rest of us.

   863  * define WANT_REALPATH in the xxxIntern-file to get it.

   864  */

   865 

   866 #if defined(HAS_REALPATH)

   867 # undef WANT_REALPATH

   868 #endif

   869 #if !defined(HAS_GETWD) && !defined(HAS_GETCWD)

   870 # undef WANT_REALPATH

   871 #endif

   872 

   873 #if defined(WANT_REALPATH)

   874 

   875 # ifndef NULL

   876 #  define NULL (char *)0

   877 # endif

   878 

   879 # define MAX_READLINKS 32

   880 

   881 # ifndef MAXPATHLEN

   882 #  define MAXPATHLEN     1024

   883 # endif

   884 

   885 static

   886 char *realpath(path, resolved_path)

   887 char *path;

   888 char resolved_path [];

   889 {

   890 	char copy_path[MAXPATHLEN];

   891 	char link_path[MAXPATHLEN];

   892 	char *new_path = resolved_path;

   893 	char *max_path;

   894 	int readlinks = 0;

   895 	int n;

   896 

   897 	/* Make a copy of the source path since we may need to modify it. */

   898 	strcpy(copy_path, path);

   899 	path = copy_path;

   900 	max_path = copy_path + MAXPATHLEN - 2;

   901 	/* If it's a relative pathname use getwd for starters. */

   902 	if (*path != '/') {

   903 #ifdef HAS_GETCWD

   904 		new_path = getcwd(new_path, MAXPATHLEN - 1);

   905 #else

   906 		new_path = getwd(new_path);

   907 #endif

   908 		if (new_path == NULL) 

   909 		    return(NULL);

   910 

   911 		new_path += strlen(new_path);

   912 		if (new_path[-1] != '/')

   913 			*new_path++ = '/';

   914 	}

   915 	else {

   916 		*new_path++ = '/';

   917 		path++;

   918 	}

   919 	/* Expand each slash-separated pathname component. */

   920 	while (*path != '\0') {

   921 		/* Ignore stray "/". */

   922 		if (*path == '/') {

   923 			path++;

   924 			continue;

   925 		}

   926 		if (*path == '.') {

   927 			/* Ignore ".". */

   928 			if (path[1] == '\0' || path[1] == '/') {

   929 				path++;

   930 				continue;

   931 			}

   932 			if (path[1] == '.') {

   933 				if (path[2] == '\0' || path[2] == '/') {

   934 					path += 2;

   935 					/* Ignore ".." at root. */

   936 					if (new_path == resolved_path + 1)

   937 						continue;

   938 					/* Handle ".." by backing up. */

   939 					while ((--new_path)[-1] != '/')

   940 						;

   941 					continue;

   942 				}

   943 			}

   944 		}

   945 		/* Safely copy the next pathname component. */

   946 		while (*path != '\0' && *path != '/') {

   947 			if (path > max_path) {

   948 				errno = ENAMETOOLONG;

   949 				return NULL;

   950 			}

   951 			*new_path++ = *path++;

   952 		}

   953 #ifdef S_IFLNK

   954 		/* Protect against infinite loops. */

   955 		if (readlinks++ > MAX_READLINKS) {

   956 			errno = ELOOP;

   957 			return NULL;

   958 		}

   959 		/* See if latest pathname component is a symlink. */

   960 		*new_path = '\0';

   961 		n = readlink(resolved_path, link_path, MAXPATHLEN - 1);

   962 		if (n < 0) {

   963 			/* EINVAL means the file exists but isn't a symlink. */

   964 			if (errno != EINVAL)

   965 				return NULL;

   966 		}

   967 		else {

   968 			/* Note: readlink doesn't add the null byte. */

   969 			link_path[n] = '\0';

   970 			if (*link_path == '/')

   971 				/* Start over for an absolute symlink. */

   972 				new_path = resolved_path;

   973 			else

   974 				/* Otherwise back up over this component. */

   975 				while (*(--new_path) != '/')

   976 					;

   977 			/* Safe sex check. */

   978 			if (strlen(path) + n >= MAXPATHLEN) {

   979 				errno = ENAMETOOLONG;

   980 				return NULL;

   981 			}

   982 			/* Insert symlink contents into path. */

   983 			strcat(link_path, path);

   984 			strcpy(copy_path, link_path);

   985 			path = copy_path;

   986 		}

   987 #endif /* S_IFLNK */

   988 		*new_path++ = '/';

   989 	}

   990 	/* Delete trailing slash but don't whomp a lone slash. */

   991 	if (new_path != resolved_path + 1 && new_path[-1] == '/')

   992 		new_path--;

   993 	/* Make sure it's null terminated. */

   994 	*new_path = '\0';

   995 	return resolved_path;

   996 }

   997 # define HAS_REALPATH

   998 #endif /* WANT_REALPATH && not HAS_REALPATH */

  2926 #ifdef WIN32

  2927 	    /*

  2928 	     * WIN32 GetLastError returns

  2929 	     */

  2930 # ifdef ERROR_FILE_NOT_FOUND

  2931 	    case WIN32_ERR(ERROR_FILE_NOT_FOUND):

  2932 		msg = "File not found";

  2933 		sym = @symbol(ERROR_FILE_NOT_FOUND);

  2934 		break;

  2935 # endif

  2936 # ifdef ERROR_BROKEN_PIPE

  2937 	    case WIN32_ERR(ERROR_BROKEN_PIPE):

  2938 		msg = "Broken pipe";

  2939 		sym = @symbol(ERROR_BROKEN_PIPE);

  2940 		break;

  2941 # endif

  2942 

  2943 #endif /* WINM32 */

  2944 

  3219 

  5441 # ifndef WIN32

  5445 # endif

  5597 !

  5598 

  5599 primTerminateProcess:pid

  5600     "terminate a WIN32 process.

  5601     The TerminateProcess function is used to unconditionally cause

  5602     a process to exit. Use it only in extreme circumstances. The state of

  5603     global data maintained by dynamic-link libraries (DLLs)

  5604     may be compromised if TerminateProcess is used."

  5605 

  6336 #else

  6337 # ifdef WIN32

  6338     pid = GetCurrentProcessId() & 0x3FFFFFFF;

  6339 # endif

  7052 # ifndef HAVE_TIME

  7053 #  ifdef WIN32

  7054     t = GetTickCount();

  7055 #   define HAVE_TIME

  7056 #  endif

  7057 # endif

  7058 

  7059 # ifndef HAVE_TIME

  7060 #  ifdef MSDOS_LIKE

  7061     struct _timeb timebuffer;

  7062 

  7063     _ftime(&timebuffer);

  7064     t = (timebuffer.time * 1000) + timebuffer.millitm;

  7065 #   define HAVE_TIME

  7066 #  endif

  7067 # endif

  7229 #ifdef xxWIN32

  7230     /*

  7231      * does not work under WIN95 - sigh

  7232      */

  7233     int t = __intVal(millis);

  7234 

  7235     if (t) {

  7236 	Sleep(t);

  7237     }

  7238     RETURN (self);

  7239 #endif

  7478 # endif

  7479 #else

  7480 # ifdef WIN32

  7481     if (firstCall) {

  7482 	int nameSize = sizeof(cachedName);

  7483 

  7484 	if (GetUserName(cachedName, &nameSize) == TRUE) {

  7485 	    name = cachedName;

  7486 	    firstCall = 0;

  7487 	}

  7488     } else {