Subversion Repositories DevTools

/*

 * MS-DOS SHELL - Unix File I/O Emulation

 *

 * MS-DOS SHELL - Copyright (c) 1990,4 Data Logic Limited

 *

 * This code is subject to the following copyright restrictions:

 *

 * 1.  Redistribution and use in source and binary forms are permitted

 *     provided that the above copyright notice is duplicated in the

 *     source form and the copyright notice in file sh6.c is displayed

 *     on entry to the program.

 *

 * 2.  The sources (or parts thereof) or objects generated from the sources

 *     (or parts of sources) cannot be sold under any circumstances.

 *

 * The directory functions opendir, readdir, closedir are based on the public

 * domain implementation for MS-DOS written by Michael Rendell

 * ({uunet,utai}michael@garfield), August 1897

 *

 * startup () is based on EMX/GCC startup.c in emx/lib/src/startup.  Copyright

 * (c) 1990-1993 by Eberhard Mattes.

 *

 *    $Header: /cvsroot/device/DEVL/UTILS/SH/Sh8.c,v 1.2 2004/05/10 09:30:07 ayoung Exp $

 *

 *    $Log: Sh8.c,v $

 *    Revision 1.2  2004/05/10 09:30:07  ayoung

 *    improved Path/PATH handling

 *    Quote CreateProcess arg0 if embedded spaces are  encountered

 *    Native NT exec dont need to check command line length

 *    Warning when '@' within redirect list

 *    DEBUG_EXEC option, split from PRINT_EXEC option and improved

 *

 *    Revision 1.1  2002/08/02 06:49:35  adamy

 *    imported (reference only)

 *

 *    Revision 1.2  2001/08/03 08:30:55  ayoung

 *    removed mutliple dot conversion under WIN32

 *

 *    Revision 1.1  2001/07/20 05:55:45  ayoung

 *    WIN32 support

 *

 *    Revision 1.2  2000/09/27 08:33:36  adamy

 *    Added EXTENDED_LINE cache and use __systeml_mode during DOS builds.

 *

 *    Revision 1.1.1.1  1999/12/02 01:11:12  gordonh

 *    UTIL

 *

 *      Revision 2.16  1994/08/25  20:49:11  istewart

 *      MS Shell 2.3 Release

 *

 *      Revision 2.15  1994/02/23  09:23:38  istewart

 *      Beta 233 updates

 *

 *      Revision 2.14  1994/02/01  10:25:20  istewart

 *      Release 2.3 Beta 2, including first NT port

 *

 *      Revision 2.13  1994/01/20  14:51:43  istewart

 *      Release 2.3 Beta 1

 *

 *      Revision 2.12  1994/01/11  17:55:25  istewart

 *      Release 2.3 Beta 0 patches

 *

 *      Revision 2.11  1993/11/09  10:39:49  istewart

 *      Beta 226 checking

 *

 *      Revision 2.10  1993/08/25  16:03:57  istewart

 *      Beta 225 - see Notes file

 *

 *      Revision 2.9  1993/07/02  10:21:35  istewart

 *      224 Beta fixes

 *

 *      Revision 2.8  1993/06/14  11:00:12  istewart

 *      More changes for 223 beta

 *

 *      Revision 2.7  1993/06/02  09:52:35  istewart

 *      Beta 223 Updates - see Notes file

 *

 *      Revision 2.6  1993/02/16  16:03:15  istewart

 *      Beta 2.22 Release

 *

 *      Revision 2.5  1993/01/26  18:35:09  istewart

 *      Release 2.2 beta 0

 *

 *      Revision 2.4  1992/12/14  10:54:56  istewart

 *      BETA 215 Fixes and 2.1 Release

 *

 *      Revision 2.3  1992/11/06  10:03:44  istewart

 *      214 Beta test updates

 *

 *      Revision 2.2  1992/07/16  14:33:34  istewart

 *      Beta 212 Baseline

 *

 *      Revision 2.1  1992/07/10  10:52:48  istewart

 *      211 Beta updates

 *

 *      Revision 2.0  1992/04/13  17:39:09  Ian_Stewartson

 *      MS-Shell 2.0 Baseline release

 *

 */

#if defined (__EMX__)

#  include <sys/emx.h>

#endif

#include <sys/types.h>

#include <sys/stat.h>

#include <stdio.h>

#include <signal.h>

#include <errno.h>

#include <setjmp.h>

#include <stdlib.h>

#include <fcntl.h>

#include <string.h>

#include <unistd.h>

#include <limits.h>

#include <dirent.h>

#include <ctype.h>

#include <stdarg.h>

#if defined (__EMX__)

#  include <sys/ioctl.h>

#endif

/*

 * There appears to be no alloca in TurboC

 */

#if defined (__TURBOC__)

#  include <alloc.h>

#  include <dir.h>

#  define alloca(x)             malloc (x)

#  define alloca_free(x)        free (x)

#elif defined(_MSC_VER)

#  include <malloc.h>

#  define alloca(x)             calloc (x,1)

#  define alloca_free(x)        free (x)

#else

#  include <malloc.h>

#  define alloca_free(x)

#endif

#include "sh.h"

#define MAX_LINE        160             /* Max line length              */

#define F_START         4

#define NSTART          16              /* default number of words to   */

                                        /* allow for initially          */

#define IS_OCTAL(a)     (((a) >= '0') && ((a) <= '7'))

static char            *nopipe = "can't create pipe";

/* List of open files to allow us to simulate the Unix open and unlink

 * operation for temporary files

 */

typedef struct flist {

    struct flist        *fl_next;       /* Next link                    */

    char                *fl_name;       /* File name                    */

    bool                fl_close;       /* Delete on close flag         */

    int                 fl_size;        /* Size of fl_fd array          */

    int                 fl_count;       /* Number of entries in array   */

    int                 fl_mode;        /* File open mode               */

    int                 *fl_fd;         /* File ID array (for dup)      */

} s_flist;

static s_flist                  *list_start = (s_flist *)NULL;

static s_flist * F_LOCAL        find_entry (int);

static void F_LOCAL             SaveFileDescriptor (FILE *);

static char * F_LOCAL           _Ex_SkipWhiteSpace (char *);

#if (OS_TYPE != OS_UNIX)

static void F_LOCAL             _Ex_ExpandIndirectFile (char *, Word_B **);

static char * F_LOCAL           _Ex_GetSpace (int, char *);

static void F_LOCAL             _Ex_ExpandField (char *, Word_B **);

static char * F_LOCAL           _Ex_ConvertEnvVariables (char *);

static void F_LOCAL             _Ex_SaveArgvValue (char *, bool, Word_B **);

static void F_LOCAL             _Ex_CommandLine (char *, Word_B **);

static unsigned long F_LOCAL    QueryApplicationType1 (int);

#endif

#if (OS_TYPE == OS_OS2)

static void F_LOCAL             _Ex_ProcessEMXArguments (char *, Word_B **);

#endif

#if (OS_TYPE == OS_DOS) && (__WATCOMC__)

extern char                     *_LpCmdLine;

extern char                     *_LpPgmName;

static void F_LOCAL             OutputBIOSString (char *);

#endif

#ifdef __WATCOMC__

char                            *_getdcwd (int, char *, int);

#endif

#ifdef __EMX__

char                            *_getdcwd (int, char *, int);

#endif

/*

 * Command Line pointers

 */

#if defined (__TURBOC__)        /* Borland C                            */

#  define ARG_ARRAY     _argv

#  define ARG_COUNT     _argc

#  define ENTRY_POINT   _setargv

#elif defined (__WATCOMC__)     /* WatCom C                             */

#  define ARG_ARRAY     ___Argv

#  define ARG_COUNT     ___Argc

#  define ENTRY_POINT   __Init_Argv

#elif defined (__IBMC__)        /* IBM C Set/2                          */

#  define ARG_ARRAY     _argv

#  define ARG_COUNT     _argc

#  define ENTRY_POINT   _setuparg

#elif defined (__EMX__)         /* Gcc/EMX                              */

#  define ARG_ARRAY     _argv

#  define ARG_COUNT     _argc

#  define ENTRY_POINT   GetArgcV

#elif defined (_MSC_VER)

                                /* Microsoft C                          */

#  define ARG_ARRAY     __argv

#  define ARG_COUNT     __argc

#  define ENTRY_POINT   __cdecl _setargv

#endif

#if (OS_TYPE != OS_UNIX)

#  if defined (__EMX__)                 /* Gcc/EMX                      */

extern void     __startup (int argc, char **argv);

extern void     ENTRY_POINT (void);

static char     **ARG_ARRAY;            /* Current argument address     */

static int      ARG_COUNT;              /* Current argument count       */

#  else

extern void     ENTRY_POINT (void);

extern char     **ARG_ARRAY;            /* Current argument address     */

extern int      ARG_COUNT;              /* Current argument count       */

#  endif

/*

 * Some EMX startup statics

 */

#  if defined (__EMX__)

                                        /* The version of this libc.*/

static const char       _libc_version[] = " libc for emx 0.8h";

/* Display this warning if emx.dll or emx.exe is out of date. */

static const char       _version_warning[] = 

                                "WARNING: emx 0.8h or later required\r\n";

                                        /* The buffer for stdin. */

static char             ibuf[BUFSIZ];

#  endif

/*

 * General OS independent start of the command line and program name.

 */

char            *_ACmdLine;

char            *_APgmName;             /* Program name                 */

#  if defined (OS2)

extern ushort far _aenvseg;

extern ushort far _acmdln;

#  endif

/*

 * Directory functions internals structure.

 */

typedef struct _dircontents     DIRCONT;

static void                     FreeDirectoryListing (DIRCONT *);

#endif

/*

 * Open a file and add it to the Open file list.  Errors are the same as

 * for a normal open.

 */

int S_open (bool d_flag, const char *pName, int mode)

{

    int                 pmask;

    s_flist             *fp = (s_flist *)NULL;

    int                 *f_list = (int *)NULL;

    char                *f_name = (char *)NULL;

    void                (_SIGDECL *save_signal)(int);

#ifdef __IBMC__

    HFILE               shfFileHandle;

    ULONG               ActionTaken;

    ULONG               ulFileAttribute;

    ULONG               ulOpenFlag;

    ULONG               ulOpenMode;

    APIRET              rc;            /* Return code */

#endif

    char                name[ MAX_PATH ];

/* Check this is a valid file name */

    CheckDOSFileName (pName, name);

/* Grap some space.  If it fails, free space and return an error */

    if (((fp = (s_flist *) GetAllocatedSpace (sizeof (s_flist)))

                == (s_flist *)NULL) ||

        ((f_list = (int *) GetAllocatedSpace (sizeof (int) * F_START))

                == (int *)NULL) ||

        ((f_name = StringSave (name)) == null))

    {

        if (f_list == (int *)NULL)

            ReleaseMemoryCell ((void *)f_list);

        if (fp == (s_flist *)NULL)

            ReleaseMemoryCell ((void *)fp);

        return -1;

    }

/* Disable signals */

    save_signal = signal (SIGINT, SIG_IGN);

/* Set up the structure.  Change two Unix device names to the DOS

 * equivalents and disable create

 */

#if (OS_TYPE != OS_UNIX)

    if (strnicmp (name, DeviceNameHeader, LEN_DEVICE_NAME_HEADER) == 0)

    {

        if (stricmp (&name[5], "tty") == 0)

            strcpy (&name[5], "con");

        else if (stricmp (&name[5], "null") == 0)

            strcpy (&name[5], "nul");

        mode &= ~(O_CREAT | O_TRUNC);

    }

#endif

    fp->fl_name  = strcpy (f_name, name);

    fp->fl_close = d_flag;

    fp->fl_size  = F_START;

    fp->fl_count = 1;

    fp->fl_fd    = f_list;

    fp->fl_mode  = mode;

/*

 * The IBM C Set/2 OS/2 2.x library function, open, does not appear work

 * correctly.  So I've replaced it with a emulator here

 */

#ifdef __IBMC__

/* Set up open actions */

    if (mode & O_CREAT)

         ulOpenFlag = OPEN_ACTION_CREATE_IF_NEW |

                        ((mode & O_EXCL)

                            ? OPEN_ACTION_FAIL_IF_EXISTS

                                : ((mode & O_TRUNC)

                                    ? OPEN_ACTION_REPLACE_IF_EXISTS

                                    : OPEN_ACTION_OPEN_IF_EXISTS));

    else

         ulOpenFlag = OPEN_ACTION_FAIL_IF_NEW |

                        ((mode & O_TRUNC)

                            ? OPEN_ACTION_REPLACE_IF_EXISTS

                            : OPEN_ACTION_OPEN_IF_EXISTS);

/* Set up open mode */

    ulOpenMode = OPEN_FLAGS_SEQUENTIAL | OPEN_SHARE_DENYNONE;

    if (mode & O_NOINHERIT)

        ulOpenMode |= OPEN_FLAGS_NOINHERIT;

    if (mode & O_WRONLY)

        ulOpenMode |= OPEN_ACCESS_WRITEONLY;

    else if (mode & O_RDONLY)

        ulOpenMode |= OPEN_ACCESS_READONLY;

    else

        ulOpenMode |= OPEN_ACCESS_READWRITE;

    DISABLE_HARD_ERRORS;

    rc = DosOpen (name, &shfFileHandle, &ActionTaken, (ULONG)0, FILE_NORMAL,

                  ulOpenFlag, ulOpenMode, (PEAOP2)NULL);

    ENABLE_HARD_ERRORS;

    if (!rc)

    {

        if (mode & O_TEXT)

            setmode (shfFileHandle, O_TEXT);

        else if (mode & O_BINARY)

            setmode (shfFileHandle, O_BINARY);

        fp->fl_fd[0] = shfFileHandle;

    }

    else

        fp->fl_fd[0] = -1;

#else

    DISABLE_HARD_ERRORS;

    fp->fl_fd[0] = open (name, mode, S_IREAD | S_IWRITE);

    ENABLE_HARD_ERRORS;

#endif

/* Open the file */

    if (fp->fl_fd[0] < 0)

    {

        ReleaseMemoryCell ((void *)f_name);

        ReleaseMemoryCell ((void *)f_list);

        ReleaseMemoryCell ((void *)fp);

        pmask = -1;

    }

/* Make sure everything is in area 0 */

    else

    {

        SetMemoryAreaNumber ((void *)fp, 0);

        SetMemoryAreaNumber ((void *)f_list, 0);

/* List into the list */

        fp->fl_next   = list_start;

        list_start = fp;

/* Return the file descriptor */

        pmask = fp->fl_fd[0];

/* Mark in use */

        ChangeFileDescriptorStatus (pmask, TRUE);

    }

/* Restore signals */

    signal (SIGINT, save_signal);

    return pmask;

}

/*

 * Scan the File list for the appropriate entry for the specified ID

 */

static s_flist * F_LOCAL find_entry (int fid)

{

    s_flist     *fp = list_start;

    int         i;

    while (fp != (s_flist *)NULL)

    {

        for (i = 0; i < fp->fl_count; i++)

        {

            if (fp->fl_fd[i] == fid)

                return fp;

        }

        fp = fp->fl_next;

    }

    return (s_flist *)NULL;

}

/* Close the file

 *

 * We need a version of close that does everything but close for dup2 as

 * new file id is closed.  If c_flag is TRUE, close the file as well.

 */

int     S_close (int fid, bool c_flag)

{

    s_flist     *fp = find_entry (fid);

    s_flist     *last = (s_flist *)NULL;

    s_flist     *fp1 = list_start;

    int         i = 0;

    bool        release = TRUE;

    bool        delete = FALSE;

    char        *fname = 0;

    void        (_SIGDECL *save_signal)(int);

/* Disable signals */

    save_signal = signal (SIGINT, SIG_IGN);

/* Find the entry for this ID */

    if (fp != (s_flist *)NULL)

    {

        for (i = 0; i < fp->fl_count; i++)

        {

            if (fp->fl_fd[i] == fid)

                fp->fl_fd[i] = -1;

            if (fp->fl_fd[i] != -1)

                release = FALSE;

        }

/* Are all the Fids closed ? */

        if (release)

        {

            fname = fp->fl_name;

            delete = fp->fl_close;

            ReleaseMemoryCell ((void *)fp->fl_fd);

/* Scan the list and remove the entry */

            while (fp1 != (s_flist *)NULL)

            {

                if (fp1 != fp)

                {

                    last = fp1;

                    fp1 = fp1->fl_next;

                    continue;

                }

                if (last == (s_flist *)NULL)

                    list_start = fp->fl_next;

                else

                    last->fl_next = fp->fl_next;

                break;

            }

/* OK - delete the area */

            ReleaseMemoryCell ((void *)fp);

        }

    }

/* Flush these two in case they were re-directed */

    FlushStreams ();

/* Close the file anyway */

    if (c_flag)

    {

        i = close (fid);

        ChangeFileDescriptorStatus (fid, FALSE);

    }

/* Delete the file ? */

    if (delete)

    {

        unlink (fname);

        ReleaseMemoryCell ((void *)fname);

    }

/* Restore signals */

    signal (SIGINT, save_signal);

    return i;

}

/*

 * Version of fclose

 */

void    S_fclose (FILE *FP, bool d_flag)

{

    CloseFile (FP);

    S_close (fileno (FP), d_flag);

}

/*

 * Duplicate file handler.  Add the new handler to the ID array for this

 * file.

 */

int S_dup (int old_fid)

{

    int         new_fid;

    if ((new_fid = dup (old_fid)) >= 0)

        S_Remap (old_fid, new_fid);

    return new_fid;

}

/*

 * Add the ID to the ID array for this file

 */

int S_Remap (int old_fid, int new_fid)

{

    s_flist     *fp = find_entry (old_fid);

    int         *flist;

    int         i;

    ChangeFileDescriptorStatus (new_fid, TRUE);

    if (fp == (s_flist *)NULL)

        return new_fid;

/* Is there an empty slot ? */

    for (i = 0; i < fp->fl_count; i++)

    {

        if (fp->fl_fd[i] == -1)

            return (fp->fl_fd[i] = new_fid);

    }

/* Is there any room at the end ? No - grap somemore space and effect a

 * re-alloc.  What to do if the re-alloc fails - should really get here.

 * Safty check only??

 */

    if (fp->fl_count == fp->fl_size)

    {

        flist = (int *)ReAllocateSpace ((void *)fp->fl_fd,

                                        (fp->fl_size + F_START) * sizeof (int));

        if (flist == (int *)NULL)

            return new_fid;

        SetMemoryAreaNumber ((void *)flist, 0);

        fp->fl_fd   = flist;

        fp->fl_size += F_START;

    }

    return (fp->fl_fd[fp->fl_count++] = new_fid);

}

/*

 * Duplicate file handler onto specific handler

 */

int S_dup2 (int old_fid, int new_fid)

{

    int         res = -1;

    int         i;

    Save_IO     *sp;

/* If duping onto stdin, stdout or stderr, Search the Save IO stack for an

 * entry matching us

 */

    if ((new_fid >= STDIN_FILENO) && (new_fid <= STDERR_FILENO))

    {

        for (sp = SSave_IO, i = 0;

             (i < NSave_IO_E) && (SSave_IO[i].depth < Execute_stack_depth);

             i++, ++sp)

            continue;

/* If depth is greater the Execute_stack_depth - we should panic as this

 * should not happen.  However, for the moment, I'll ignore it

 */

/* If there an entry for this depth ? */

        if (i == NSave_IO_E)

        {

/* Do we need more space? */

            if (NSave_IO_E == MSave_IO_E)

            {

                sp = (Save_IO *)ReAllocateSpace ((MSave_IO_E != 0)

                                                    ? SSave_IO : (void *)NULL,

                                                 (MSave_IO_E + SSAVE_IO_SIZE) *

                                                    sizeof (Save_IO));

/* Check for error */

                if (sp == (Save_IO *)NULL)

                    return -1;

/* Save original data */

                SetMemoryAreaNumber ((void *)sp, 1);

                SSave_IO = sp;

                MSave_IO_E += SSAVE_IO_SIZE;

            }

/* Initialise the new entry */

            sp = &SSave_IO[NSave_IO_E++];

            sp->depth             = Execute_stack_depth;

            sp->fp[STDIN_FILENO]  = -1;

            sp->fp[STDOUT_FILENO] = -1;

            sp->fp[STDERR_FILENO] = -1;

        }

        if (sp->fp[new_fid] == -1)

            sp->fp[new_fid] = ReMapIOHandler (new_fid);

        FlushStreams ();

    }

/* OK - Dup the descriptor */

    if ((old_fid != -1) && ((res = dup2 (old_fid, new_fid)) >= 0))

    {

        S_close (new_fid, FALSE);

        res = S_Remap (old_fid, new_fid);

    }

    return res;

}

/*

 * Restore the Stdin, Stdout and Stderr to original values.  If change is

 * FALSE, just remove entries from stack.  A special case for exec.

 */

int RestoreStandardIO (int rv, bool change)

{

    int         j, i;

    Save_IO     *sp;

/* Start at the top and remove any entries above the current execute stack

 * depth

 */

    for (j = NSave_IO_E; j > 0; j--)

    {

       sp = &SSave_IO[j - 1];

       if (sp->depth < Execute_stack_depth)

           break;

/* Reduce number of entries */

        --NSave_IO_E;

/* If special case (changed at this level) - continue */

        if (!change && (sp->depth == Execute_stack_depth))

            continue;

/* Close and restore any files */

        for (i = STDIN_FILENO; i <= STDERR_FILENO; i++)

        {

            if (sp->fp[i] != -1)

            {

                S_close (i, TRUE);

                dup2 (sp->fp[i], i);

                S_close (sp->fp[i], TRUE);

            }

        }

    }

    return rv;

}

/*

 * Create a Pipe

 */

int OpenAPipe (void)

{

    int         i;

    if ((i = S_open (TRUE, GenerateTemporaryFileName (), O_PMASK)) < 0)

        PrintErrorMessage (nopipe);

    return i;

}

/*

 * Close a pipe

 */

void CloseThePipe (int pv)

{

    if (pv != -1)

        S_close (pv, TRUE);

}

/*

 * Check for restricted shell

 */

bool CheckForRestrictedShell (char *s)

{

    if (RestrictedShellFlag)

    {

        PrintErrorMessage (BasicErrorMessage, s, "restricted");

        return TRUE;

    }

    return FALSE;

}

/*

 * Check to see if a file is a shell script.  If it is, return the file

 * handler for the file

 */

static char *Extensions[] = { null, SHELLExtension, KSHELLExtension};

int OpenForExecution (char *path, char **params, int *nargs)

{

    int         RetVal = -1;

    int         j;

    int         EndP = strlen (path);

    char        *local_path;

/* Work on a copy of the path */

    if ((local_path = AllocateMemoryCell (EndP + 5)) == (char *)NULL)

        return -1;

    strcpy (local_path, path);

/* Try the file name and then with a .sh and then .ksh appended */

    for (j = 0; j < 3; j++)

    {

        strcpy (&local_path[EndP], Extensions[j]);

        if ((RetVal = CheckForScriptFile (local_path, params, nargs)) >= 0)

            break;

    }

    ReleaseMemoryCell ((void *)local_path);

    return RetVal;

}

/*

 * Check for shell script

 */

int CheckForScriptFile (char *path, char **params, int *nargs)

{

    char        buf[512];               /* Input buffer                 */

    int         fp;                     /* File handler                 */

    int         nbytes;                 /* Number of bytes read         */

    char        *bp;                    /* Pointers into buffers        */

    char        *ep;

    if ((fp = S_open (FALSE, path, O_RMASK)) < 0)

        return -1;

/* zero or less bytes - not a script */

    memset (buf, 0, 512);

    nbytes = read (fp, buf, 512);

    lseek (fp, 0L, SEEK_SET);

    for (ep = &buf[nbytes], bp = buf;

         (bp < ep) && ((unsigned char)*bp >= 0x08); ++bp)

        continue;

/* If non-ascii file or length is less than 1 - not a script */

    if ((bp != ep) || (nbytes < 1))

    {

        S_close (fp, TRUE);

        return -1;

    }

/* Ensure end of buffer detected */

    buf[511] = 0;

/* Initialise the return parameters, if specified */

    if (params != (char **)NULL)

        *params = null;

    if (nargs != (int *)NULL)

        *nargs = 0;

/* We don't care how many bytes were read now, so use it to count the

 * additional arguments

 */

    nbytes = 0;

/* Find the end of the first line */

    if ((bp = strchr (buf, CHAR_NEW_LINE)) != (char *)NULL)

        *bp = 0;

    bp = buf;

    ep = (char *)NULL;

/* Check for script */

    if ((*(bp++) != CHAR_COMMENT) || (*(bp++) != '!'))

        return fp;

    while (*bp)

    {

/* Save the start of the arguments */

        if (*(bp = _Ex_SkipWhiteSpace (bp)))

        {

            if (ep == (char *)NULL)

                ep = bp;

/* Count the arguments */

            ++nbytes;

        }

        bp = SkipToWhiteSpace (bp);

    }

/* Set up the return parameters, if appropriate */

    if ((params != (char **)NULL) && (strlen (ep) != 0))

    {

        if ((*params = AllocateMemoryCell (strlen (ep) + 1)) == (char *)NULL)

        {

            *params = null;

            S_close (fp, TRUE);

            return -1;

        }

        strcpy (*params, ep);

    }

    if (nargs != (int *)NULL)

        *nargs = nbytes;

    return fp;

}

/*

 * Get the file descriptor type.

 */

#if (OS_TYPE == OS_OS2)

int      GetDescriptorType (int fp)

{

    OSCALL_PARAM        fsType = HANDTYPE_FILE;

    OSCALL_PARAM        usDeviceAttr;

    if (DosQHandType (fp, &fsType, &usDeviceAttr))

        return DESCRIPTOR_UNKNOWN;

    if (LOBYTE (fsType) == HANDTYPE_PIPE)

        return DESCRIPTOR_PIPE;

    else if (LOBYTE (fsType) != HANDTYPE_DEVICE)

        return DESCRIPTOR_FILE;

/* The value 0x8083 seems to be the value returned by the console */

    else if (usDeviceAttr == 0x8083)

        return DESCRIPTOR_CONSOLE;

    else

        return DESCRIPTOR_DEVICE;

}

#endif

/* NT version */

#if (OS_TYPE == OS_NT)

int      GetDescriptorType (int fp)

{

    DWORD               fdwMode;

    HANDLE              osfp = (HANDLE)_get_osfhandle (fp);

    switch (GetFileType (osfp))

    {

        default:

            return DESCRIPTOR_UNKNOWN;

        case FILE_TYPE_DISK:

            return DESCRIPTOR_FILE;

        case FILE_TYPE_PIPE:

            return DESCRIPTOR_PIPE;

        case FILE_TYPE_CHAR:

        {

            if (!GetConsoleMode (osfp, &fdwMode))

                return DESCRIPTOR_DEVICE;

            else

                return DESCRIPTOR_CONSOLE;

        }

    }

}

#endif

/* DOS Version */

#if (OS_TYPE == OS_DOS)

int      GetDescriptorType (int fp)

{

    union REGS  r;

    r.x.REG_AX = 0x4400;

    r.x.REG_BX = fp;

    DosInterrupt (&r, &r);

    if (r.x.REG_CFLAGS)

        return DESCRIPTOR_UNKNOWN;

    if ((r.x.REG_DX & 0x0080) == 0)

        return DESCRIPTOR_FILE;

    if ((r.x.REG_DX & 0x0081) != 0x0081)

        return DESCRIPTOR_DEVICE;

/*

 * Check to see if the console is really the console or something else.

 * Look at /dev/con and see if the console i/o bits are set

 */

    r.x.REG_AX = 0x4400;

    r.x.REG_BX = open ("con", 0);

    DosInterrupt (&r, &r);