"

 COPYRIGHT (c) 1988 by Claus Gittinger

	      All Rights Reserved

 This software is furnished under a license and may be used

 only in accordance with the terms of that license and with the

 inclusion of the above copyright notice.   This software may not

 be provided or otherwise made available to, or used by, any

 other person.  No title to or ownership of the software is

 hereby transferred.

"

Object subclass:#OperatingSystem

	 instanceVariableNames:''

	 classVariableNames:'HostName DomainName LastErrorNumber LastExecStatus OSSignals

	 poolDictionaries:''

	 category:'System-Support'

!

!OperatingSystem primitiveDefinitions!

%{

#if defined(_AIX)

# ifndef WANT_REALPATH

#  define WANT_REALPATH

# endif

# ifndef WANT_SYSTEM

#  define WANT_SYSTEM

# endif

#endif

#ifdef LINUX

# ifndef WANT_SYSTEM

#  define WANT_SYSTEM

# endif

# define WANT_SHM

#endif

#ifdef IRIX5

# define WANT_SYSTEM

#endif

#ifdef ultrix

# define WANT_SYSTEM

#endif

#ifdef hpux

# define WANT_SYSTEM

#endif

#ifdef unixware

# define WANT_SYSTEM

#endif

#ifdef WANT_REALPATH

# include <sys/param.h>

# define _SYS_PARAM_H_INCLUDED_

# include <errno.h>

# define _ERRNO_H_INCLUDED_

# include <sys/stat.h>

# define _SYS_STAT_H_INCLUDED_

#endif /* WANT_REALPATH */

#ifdef WANT_SHM

extern int shmctl(), shmget(), shmdt();

extern char * shmat();

# include <sys/types.h>

# define _SYS_TYPES_H_INCLUDED_

# include <sys/ipc.h>

# define _SYS_IPC_H_INCLUDED_

# include <sys/shm.h>

# define _SYS_SHM_H_INCLUDED_

#endif /* WANT_SHM */

#ifdef IRIX5

# include <sys/syssgi.h>

#endif

#ifdef transputer

# define unlink(f)      ((remove(f) == 0) ? 0 : -1)

#else

# include <signal.h>

# ifdef SYSV

#  include <sys/types.h>

#  include <sys/param.h>

#  include <sys/times.h>

#  include <sys/file.h>

#  if ! defined(sco3_2)

#   include <unistd.h>

#  endif

#  if defined(isc3_2) || defined(sco3_2)

#   include <sys/time.h>

#  endif

#  if !defined(isc3_2)

#   if defined(PCS) && defined(mips)

#    include "/usr/include/bsd/sys/time.h"

#    include "/usr/include/sys/time.h"

#   else

#    include <time.h>

#   endif

#  endif

#  if defined(isc3_2)

#   include <sys/bsdtypes.h>

#  endif

# else /* not SYSV */

#  include <sys/time.h>

#  include <sys/types.h>

# endif

# ifdef aix

#  include <time.h>

#  include <sys/select.h>

# endif

# include <pwd.h>

# include <grp.h>

# include <sys/stat.h>

# include <errno.h>

# define _ERRNO_H_INCLUDED_

# include <stdio.h>

# define _STDIO_H_INCLUDED_

# include <fcntl.h>

/* 

 * posix systems should define these ... 

 * but on some (older) systems, they are not.

 */

# ifndef S_IXUSR

#  ifdef S_IEXEC

#   define S_IXUSR S_IEXEC

#   define S_IXGRP (S_IEXEC>>3)

#   define S_IXOTH (S_IEXEC>>6)

#  endif

# endif

# ifndef S_IXUSR

#  define S_IXUSR 0100

#  define S_IXGRP 0010

#  define S_IXOTH 0001

# endif

# ifndef S_IRUSR

#  define S_IRUSR 0400

#  define S_IRGRP 0040

#  define S_IROTH 0004

# endif

# ifndef S_IWUSR

#  define S_IWUSR 0200

#  define S_IWGRP 0020

#  define S_IWOTH 0002

# endif

# ifndef MAXPATHLEN

#  include <sys/param.h>

#  ifndef MAXPATHLEN

#   define MAXPATHLEN 1024

#  endif

# endif

# if defined(HAS_UNAME)

#  include <sys/utsname.h>

# endif

#endif /* ! transputer */

/*

 * on some systems errno is a macro ... check for it here

 */

#ifndef errno

 extern errno;

#endif

/*

 * some (old ?) systems do not define this ...

 */

#ifndef R_OK

# define R_OK    4       /* Test for Read permission */ 

# define W_OK    2       /* Test for Write permission */

# define X_OK    1       /* Test for eXecute permission */

# define F_OK    0       /* Test for existence of File */

#endif

#define UNIX_LIKE

#if defined(NT)  || defined(MSWINDOWS) || defined(OS2) || defined(MSDOS)

# define MSDOS_LIKE

# undef UNIX_LIKE

#endif

#if defined(transputer)

# undef UNIX_LIKE

#endif

%}

! !

!OperatingSystem primitiveFunctions!

%{

/*

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

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

 * (LINUX is one of them)

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

 * OperatingSystem>>executeCommand, you ought to define WANT_SYSTEM

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

 *

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

 * for the child which enables other threads to continue.

 * (i.e. it is RT safe)

 */

#if defined(WANT_SYSTEM)

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

# define DPRINTF(x)     /* nothing */

# ifndef _STDDEF_H_INCLUDED_

#  include <stddef.h>

#  define _STDDEF_H_INCLUDED_

# endif

# ifndef _STDLIB_H_INCLUDED_

#  include <stdlib.h>

#  define _STDLIB_H_INCLUDED_

# endif

# ifndef _UNISTD_H_INCLUDED_

#  include <unistd.h>

#  define _UNISTD_H_INCLUDED_

# endif

# ifndef _SYS_WAIT_H_INCLUDED

#  include <sys/wait.h>

#  define _SYS_WAIT_H_INCLUDED

# endif

# ifndef _SIGNAL_H_INCLUDED_

#  include <signal.h>

#  define _SIGNAL_H_INCLUDED_

# endif

# ifndef _SYS_TYPES_H_INCLUDED_

#  include <sys/types.h>

#  define _SYS_TYPES_H_INCLUDED_

# endif

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

#  define       __environ       environ

#  if !defined(LINUX)

#   define      __sigemptyset   sigemptyset

#   define      __sigaction     sigaction

#   define      __sigaddset     sigaddset

#   define      __sigprocmask   sigprocmask

#   define      __execve        execve

#   define      __wait          wait

#   define      __waitpid       waitpid

#   if defined(ultrix) || defined(hpux) || defined(HAS_VFORK)

#    define     FORK            vfork

#   else

#    define     FORK            fork

#   endif

#  endif /* ! LINUX */

   extern char **environ;

# endif

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

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

# ifndef        FORK

#  define       FORK    __fork

# endif

# ifndef CONST

#  ifdef __GNUC__

#   define CONST const

#  else

#   define CONST /* nothing */

#  endif

# endif

int

mySystem(line)

    register CONST char *line;

{

    int status, save;

    pid_t pid;

    struct sigaction sa, intr, quit;

    sigset_t block, omask;

    if (line == NULL)

	return 1;

    sa.sa_handler = SIG_IGN;

    sa.sa_flags = 0;

    __sigemptyset (&sa.sa_mask);

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

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

	return -1;

    }

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

	save = errno;

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

	errno = save;

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

	return -1;

    }

    __sigemptyset (&block);

    __sigaddset (&block, SIGCHLD);

    save = errno;

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

	if (errno == ENOSYS)

	    errno = save;

	else {

	    save = errno;

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

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

	    errno = save;

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

	    return -1;

	}

    }

    pid = FORK ();

    if (pid == (pid_t) 0) {

	/* Child side.  */

	CONST char *new_argv[4];

	new_argv[0] = SHELL_NAME;

	new_argv[1] = "-c";

	new_argv[2] = line;

	new_argv[3] = NULL;

	/* Restore the signals.  */

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

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

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

	/* Exec the shell.  */

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

	_exit (127);

    } else {

	if (pid < (pid_t) 0) {

	    /* The fork failed.  */

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

	    status = -1;

	} else {

	    /* Parent side.  */

#ifdef  NO_WAITPID

	    pid_t child;

	    do {

		child = __wait (&status);

		if (child <= -1) {

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

		    status = -1;

		    break;

		}

	    } while (child != pid);

#else

	    pid_t child;

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

	    do {

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

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

	    if (child != pid) {

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

		status = -1;

	    }

#endif /* NO_WAITPID */

	}

    }

    save = errno;

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

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

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

	if (errno == ENOSYS) {

	    errno = save;

	} else {

	    status = -1;

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

	}

    }

    return status;

}

#endif /* WANT_SYSTEM */

/*

 * some systems do not have realpath();

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

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

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

 */

#if defined(HAS_REALPATH)

# undef WANT_REALPATH

#endif

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

# undef WANT_REALPATH

#endif

#if defined(WANT_REALPATH)

# ifndef NULL

#  define NULL (char *)0

# endif

# define MAX_READLINKS 32

# ifndef MAXPATHLEN

#  define MAXPATHLEN     1024

# endif

static

char *realpath(path, resolved_path)

char *path;

char resolved_path [];

{

	char copy_path[MAXPATHLEN];

	char link_path[MAXPATHLEN];

	char *new_path = resolved_path;

	char *max_path;

	int readlinks = 0;

	int n;

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

	strcpy(copy_path, path);

	path = copy_path;

	max_path = copy_path + MAXPATHLEN - 2;

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

	if (*path != '/') {

#ifdef HAS_GETCWD

		getcwd(new_path, MAXPATHLEN - 1);

#else

		getwd(new_path);

#endif

		new_path += strlen(new_path);

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

			*new_path++ = '/';

	}

	else {

		*new_path++ = '/';

		path++;

	}

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

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

		/* Ignore stray "/". */

		if (*path == '/') {

			path++;

			continue;

		}

		if (*path == '.') {

			/* Ignore ".". */

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

				path++;

				continue;

			}

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

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

					path += 2;

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

					if (new_path == resolved_path + 1)

						continue;

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

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

						;

					continue;

				}

			}

		}

		/* Safely copy the next pathname component. */