Changeset 2020

Timestamp:

Jun 12, 2005, 1:52:12 PM (20 years ago)

Author:

bird

Message:

o Handle .cmd, .bat, .btm and hash-bang script files if DosExecPgm()

fails. (I'm a little bit uncertain about argv[0], but it appears to work.)

Location:

trunk/src/emx

Files:

• ChangeLog.LIBC (modified) (2 diffs, 1 prop)
• src/lib/sys/__spawnve.c (modified) (11 diffs, 1 prop)

trunk/src/emx/ChangeLog.LIBC

@@ -3 +3 @@
 2005-06-11: knut st. osmundsen <bird-gccos2-spam@anduin.net>
     - libc:
-        o The smallcnv stuff is gone, waste of space since we're not really into 
+        o The smallcnv stuff is gone, waste of space since we're not really into
           static linking. Should've done this when switching to gdtoa.
         o Ported the msun and some other math bits from current FreeBSD libc.
@@ -10 +10 @@
           if we're gonna catch up on the C99 bits and make libstdc++ happy.
           There are some new headers, complex.h and fenv.h being the importan ones.
-          float.h have gotten some updates while math.h is totally replaced. 
+          float.h have gotten some updates while math.h is totally replaced.
           More than 100 standard functions were added!
-          NOTE: msun is using MATH_ERREXCEPT (math_errhandling) and not 
+          NOTE: msun is using MATH_ERREXCEPT (math_errhandling) and not
                 MATH_ERRNO for error reporting.
           I really hope this is not gonna uncover more OS/2 387 mess.
+        o Handle .cmd, .bat, .btm and hash-bang script files if DosExecPgm()
+          fails. (I'm a little bit uncertain about argv[0], but it appears to work.)
 
 2005-06-05: knut st. osmundsen <bird-gccos2-spam@anduin.net>

trunk/src/emx/src/lib/sys/__spawnve.c

@@ -11 +11 @@
 #define INCL_DOSPROCESS
 #define INCL_FSMACROS
+#define INCL_DOSERRORS
 #include <os2emx.h>
 #include "b_fs.h"
@@ -114 +115 @@
 
 #define ADD(n) do { \
-  while (arg_size + n > arg_alloc) \
+  while (cbArgs + n > cbArgsBuf) \
     { \
-      arg_alloc += 512; \
-      arg_buf = _trealloc (arg_buf, arg_alloc); \
-      if (arg_buf == NULL) \
+      cbArgsBuf += 512; \
+      pszArgsBuf = _trealloc (pszArgsBuf, cbArgsBuf); \
+      if (pszArgsBuf == NULL) \
         { \
           errno = ENOMEM; \
           LIBCLOG_RETURN_INT(-1); \
         } \
-      arg_ptr = arg_buf + arg_size; \
+      pszArg = pszArgsBuf + cbArgs; \
     } \
-  arg_size += n; } while (0)
-
-
-int __spawnve (struct _new_proc *np)
+  cbArgs += n; } while (0)
+
+
+int __spawnve(struct _new_proc *np)
 {
     LIBCLOG_ENTER("np=%p:{mode=%#x}\n", (void *)np, np->mode);
-    __LIBC_PSPMPROCESS    pEmbryo;
-    ULONG                 mode;
-    char *arg_ptr, *arg_buf;
-    char *pgm_name, *base;
-    const char *src, *s;
-    size_t arg_size, arg_alloc, len;
-    int i, quote, bs, method;
     FS_VAR();
-
-    arg_buf = NULL; arg_alloc = 0; arg_size = 0; arg_ptr = NULL;
 
     /*
      * Validate mode.
      */
-    mode = np->mode;
-    switch (mode & 0xff)
+    ULONG ulMode = np->mode;
+    switch (ulMode & 0xff)
     {
         case P_WAIT:
@@ -154 +146 @@
         default:
             errno = EINVAL;
-            LIBC_ASSERTM_FAILED("invalid mode 0x%08lx\n", mode);
+            LIBC_ASSERTM_FAILED("invalid mode 0x%08lx\n", ulMode);
             LIBCLOG_RETURN_INT(-1);
     }
 
     /*
-     * Allocate space for the program name and check if it's an OS/2 shell.
+     * Allocate space for the program name and resolve the filename.
      */
-    pgm_name = alloca (strlen ((const char *)np->fname_off) + 5);
-    strcpy (pgm_name, (const char *)np->fname_off);
-    _defext (pgm_name, "exe");
-    base = _getname (pgm_name);
-    method = 0;
-    if (stricmp (base, "cmd.exe") == 0 || stricmp (base, "4os2.exe") == 0)
-        method = 1;
+    size_t cch = strlen((const char *)np->fname_off);
+    char *pszPgmName = alloca(cch + 5);
+    memcpy(pszPgmName, (const char *)np->fname_off, cch + 1);
+    _defext(pszPgmName, "exe");
     char szNativePath[PATH_MAX];
-    int rc = __libc_back_fsResolve(pgm_name, BACKFS_FLAGS_RESOLVE_FULL, &szNativePath[0], NULL);
+    int rc = __libc_back_fsResolve(pszPgmName, BACKFS_FLAGS_RESOLVE_FULL, &szNativePath[0], NULL);
     if (rc)
     {
-        LIBC_ASSERTM_FAILED("Failed to resolve program name: '%s' rc=%d.\n", pgm_name, rc);
-        errno = -rc;
-        LIBCLOG_RETURN_INT(-1);
+        if (pszPgmName[cch])
+        {
+            pszPgmName[cch] = '\0';
+            rc = __libc_back_fsResolve(pszPgmName, BACKFS_FLAGS_RESOLVE_FULL, &szNativePath[0], NULL);
+        }
+        if (rc)
+        {
+            LIBC_ASSERTM_FAILED("Failed to resolve program name: '%s' rc=%d.\n", pszPgmName, rc);
+            errno = -rc;
+            LIBCLOG_RETURN_INT(-1);
+        }
     }
-    pgm_name = &szNativePath[0];
+    pszPgmName = &szNativePath[0];
 
     /*
-     * Process arguments.
+     * cmd.exe and 4os2.exe needs different argument handling.
+     * (1 == cmd or 4os2 shell, 0 == anything else)
      */
-    src = (const char *)np->arg_off;
+    char *psz = _getname(pszPgmName);
+    int method = stricmp(psz, "cmd.exe") == 0
+              || stricmp(psz, "4os2.exe") == 0;
+
+    /*
+     * Construct the commandline.
+     */
+    const char *pszSrc = (const char *)np->arg_off;
+    char       *pszArgsBuf = NULL;
+    size_t      cbArgsBuf = 0;
+    char       *pszArg = NULL;
+    size_t      cbArgs = 0;
     if (np->arg_count > 0)
     {
-        ++src;                    /* skip flags byte */
-        len = strlen (src) + 1;
-        ADD (len);
-        memcpy (arg_ptr, src, len);
-        arg_ptr += len; src += len;
+        ++pszSrc;                    /* skip flags byte */
+        cch = strlen(pszSrc) + 1;
+        ADD(cch);
+        memcpy(pszArg, pszSrc, cch);
+        pszArg += cch; pszSrc += cch;
     }
+    int i;
     for (i = 1; i < np->arg_count; ++i)
     {
         if (i > 1)
         {
-            ADD (1);
-            *arg_ptr++ = ' ';
-        }
-        ++src;                    /* skip flags byte */
-        quote = FALSE;
-        if (*src == 0)
-            quote = TRUE;
-        else if (mode & P_QUOTE)
-        {
-            if (src[0] == '@' && src[1] != 0)
-                quote = TRUE;
+            ADD(1);
+            *pszArg++ = ' ';
+        }
+        ++pszSrc;                    /* skip flags byte */
+        BOOL fQuote = FALSE;
+        if (*pszSrc == 0)
+            fQuote = TRUE;
+        else if (ulMode & P_QUOTE)
+        {
+            if (pszSrc[0] == '@' && pszSrc[1] != 0)
+                fQuote = TRUE;
             else
-                for (s = src; *s != 0; ++s)
-                    if (*s == '?' || *s == '*')
-                    {
-                        quote = TRUE;
+                for (psz = (char *)pszSrc; *psz != 0; ++psz)
+                    if (*psz == '?' || *psz == '*')
+                    {
+                        fQuote = TRUE;
                         break;
                     }
         }
-        if (!quote)
-            for (s = src; *s != 0; ++s)
-                if (*s == ' ' || *s == '\t' || (*s == '"' && method == 1))
-                {
-                    quote = TRUE;
+        if (!fQuote)
+        {
+            for (psz = (char *)pszSrc; *psz != 0; ++psz)
+                if (*psz == ' ' || *psz == '\t' || (*psz == '"' && method == 1))
+                {
+                    fQuote = TRUE;
                     break;
                 }
-        if (quote)
-        {
-            ADD (1);
-            *arg_ptr++ = '"';
-        }
-        bs = 0;
-        while (*src != 0)
-        {
-            if (*src == '"' && method == 0)
+        }
+        if (fQuote)
+        {
+            ADD(1);
+            *pszArg++ = '"';
+        }
+        size_t bs = 0;
+        while (*pszSrc != 0)
+        {
+            if (*pszSrc == '"' && method == 0)
             {
                 ++bs;
-                ADD (bs);
-                memset (arg_ptr, '\\', bs); arg_ptr += bs;
+                ADD(bs);
+                memset(pszArg, '\\', bs); pszArg += bs;
                 bs = 0;
             }
-            else if (*src == '\\' && method == 0)
+            else if (*pszSrc == '\\' && method == 0)
                 ++bs;
             else
                 bs = 0;
-            ADD (1);
-            *arg_ptr++ = *src;
-            ++src;
-        }
-        if (quote)
-        {
-            ADD (1+bs);
-            memset (arg_ptr, '\\', bs); arg_ptr += bs;
-            *arg_ptr++ = '"';
-        }
-        ++src;
+            ADD(1);
+            *pszArg++ = *pszSrc;
+            ++pszSrc;
+        }
+        if (fQuote)
+        {
+            ADD(1+bs);
+            memset(pszArg, '\\', bs); pszArg += bs;
+            *pszArg++ = '"';
+        }
+        ++pszSrc;
     }
     /* The arguments are an array of zero terminated strings, ending with an empty string. */
-    ADD (2);
-    *arg_ptr++ = '\0';
-    *arg_ptr++ = '\0';
+    ADD(2);
+    *pszArg++ = '\0';
+    *pszArg++ = '\0';
 
 
@@ -261 +273 @@
      */
     _fmutex_request(&__libc_gmtxExec, 0);
-    pEmbryo = __libc_spmCreateEmbryo(getpid());
+    __LIBC_PSPMPROCESS pEmbryo = __libc_spmCreateEmbryo(getpid());
     if (pEmbryo)
     {
@@ -272 +284 @@
             RESULTCODES resc;
             char        szObj[40];
-            int         rc;
 
             /*
@@ -278 +289 @@
              */
             FS_SAVE_LOAD();
-            LIBCLOG_MSG("Calling DosExecPgm pgm: %s args: %s\\0%s\\0\\0\n", pgm_name, arg_buf, arg_buf + strlen(arg_buf) + 1);
-            rc = DosExecPgm(szObj, sizeof(szObj), EXEC_ASYNCRESULT, (PCSZ)arg_buf, (PCSZ)np->env_off, &resc, (PCSZ)pgm_name);
+            LIBCLOG_MSG("Calling DosExecPgm pgm: %s args: %s\\0%s\\0\\0\n", pszPgmName, pszArgsBuf, pszArgsBuf + strlen(pszArgsBuf) + 1);
+            rc = DosExecPgm(szObj, sizeof(szObj), EXEC_ASYNCRESULT, (PCSZ)pszArgsBuf, (PCSZ)np->env_off, &resc, (PCSZ)pszPgmName);
+            int cTries = 3;
+            while (     (   rc == ERROR_INVALID_EXE_SIGNATURE
+                         || rc == ERROR_BAD_EXE_FORMAT)
+                   &&   --cTries > 0)
+            {
+                /*
+                 * This could be a batch, rexx or hash bang script.
+                 * The first two is recognized by the filename extension, the latter
+                 * requires inspection of the first line of the file.
+                 */
+                char szLineBuf[256];
+                const char *pszInterpreter = NULL;
+                const char *pszInterpreterArgs = NULL;
+                psz = _getext(pszPgmName);
+                if (psz && (!stricmp(psz, ".cmd") || !stricmp(psz, ".bat") || !stricmp(psz, ".btm")))
+                {
+                    pszInterpreterArgs = "/C";
+                    pszInterpreter = getenv("COMSPEC");
+                    if (!pszInterpreter)
+                    {
+                        pszInterpreter = getenv("OS2_SHELL");
+                        if (!pszInterpreter)
+                            pszInterpreter = stricmp(psz, ".btm") ? "cmd.exe" : "4os2.exe";
+                    }
+
+                    /* make sure the slashes in the script name goes the DOS way. */
+                    psz = szNativePath;
+                    while ((psz = strchr(szNativePath, '/')) != NULL)
+                        *psz++ = '\\';
+                }
+                else
+                {
+                    /*
+                     * Read the first line of the file into szLineBuf and terminate
+                     * it stripping trailing blanks.
+                     */
+                    HFILE hFile = NULLHANDLE;
+                    ULONG ulAction = 0;
+                    int rc2 = DosOpen((PCSZ)pszPgmName, &hFile, &ulAction, 0, FILE_NORMAL,
+                                      OPEN_ACTION_FAIL_IF_NEW | OPEN_ACTION_OPEN_IF_EXISTS,
+                                      OPEN_FLAGS_SEQUENTIAL | OPEN_FLAGS_NOINHERIT | OPEN_SHARE_DENYNONE | OPEN_ACCESS_READONLY,
+                                      NULL);
+                    if (!rc2)
+                    {
+                        ULONG cbRead = 0;
+                        rc2 = DosRead(hFile, szLineBuf, sizeof(szLineBuf) - 1, &cbRead);
+                        DosClose(hFile);
+                        if (!rc2)
+                        {
+                            szLineBuf[cbRead < sizeof(szLineBuf) ? cbRead : sizeof(szLineBuf) - 1] = '\0';
+                            psz = strpbrk(szLineBuf, "\r\n");
+                            if (psz)
+                            {
+                                register char ch;
+                                while ((ch = *--psz) == ' ' || ch == '\t')
+                                    /* nothing */;
+                                psz[1] = '\0';
+
+                                /*
+                                 * Check for '#[ \t]*!'
+                                 */
+                                psz = &szLineBuf[0];
+                                if (*psz++ == '#')
+                                {
+                                    while ((ch = *psz) == ' ' && ch == '\t')
+                                        psz++;
+                                    if (*psz++ == '!')
+                                    {
+                                        while ((ch = *psz) == ' ' && ch == '\t')
+                                            psz++;
+                                        pszInterpreter = psz;
+
+                                        /*
+                                         * Find end of interpreter and start of potential arguments.
+                                         * I've never seen quoted interpreter names, so we won't bother with that yet.
+                                         */
+                                        while ((ch = *psz) != ' ' && ch != '\t' && ch != '\0')
+                                            psz++;
+                                        if (ch)
+                                        {
+                                            *psz++ = '\0';
+                                            while ((ch = *psz) == ' ' && ch == '\t')
+                                                psz++;
+                                            if (ch)
+                                                pszInterpreterArgs = psz;
+                                        }
+                                    } /* if bang */
+                                } /* if hash */
+                            } /* if full line */
+                        } /* if read */
+                    } /* if open */
+                }
+                if (!pszInterpreter)
+                    break;
+
+                /*
+                 * Squeeze the interpreter arguments + the program name into
+                 * the argument buffer after argv[0].
+                 * ASSUME that the arguments and program name require no escaping.
+                 */
+                size_t cchPgmName = strlen(pszPgmName);
+                int cchInterpreterArgs = pszInterpreterArgs ? strlen(pszInterpreterArgs) : -1;
+                BOOL fQuote = strpbrk(pszPgmName, " \t") != NULL;
+                cch = cchPgmName + cchInterpreterArgs + 2 + 2 * fQuote;
+
+                /* grow and shift the argument buffer. */
+                ADD(cch);
+                psz = pszArgsBuf + strlen(pszArgsBuf) + 1;
+                memmove(psz + cch, psz, cbArgs);
+
+                /* add arguments */
+                if (pszInterpreterArgs)
+                {
+                    memcpy(psz, pszInterpreterArgs, cchInterpreterArgs);
+                    psz += cchInterpreterArgs;
+                    *psz++ = ' ';
+                }
+
+                /* script name */
+                if (fQuote)
+                    *psz++ = '"';
+                memcpy(psz, pszPgmName, cchPgmName);
+                psz += cchPgmName;
+                if (fQuote)
+                    *psz++ = '"';
+                *psz++ = ' ';
+
+                /*
+                 * Resolve the interpreter name.
+                 * If the specified name fails, we'll try search the path for it and
+                 * also adding an .exe extension before we give up.
+                 */
+                rc = __libc_back_fsResolve(pszInterpreter, BACKFS_FLAGS_RESOLVE_FULL, &szNativePath[0], NULL);
+                if (rc)
+                {
+                    char szPath[512];
+                    _searchenv(pszInterpreter, "PATH", szPath); /** @todo _searchenv is not safe, it can easily overflow szPath! */
+                    if (!szPath[0])
+                    {
+                        cch = strlen(pszInterpreter);
+                        memcpy(szNativePath, pszInterpreter, cch + 1);
+                        _defext(szNativePath, "exe");
+                        if (szNativePath[cch])
+                            _searchenv(szNativePath, "PATH", szPath);
+                    }
+                    if (szPath[0])
+                        rc = __libc_back_fsResolve(szPath, BACKFS_FLAGS_RESOLVE_FULL, &szNativePath[0], NULL);
+                    if (rc)
+                        break;
+                }
+
+                /*
+                 * Try execute it.
+                 */
+                LIBCLOG_MSG("Calling DosExecPgm pgm: %s args: %s\\0%s\\0\\0\n", pszPgmName, pszArgsBuf, pszArgsBuf + strlen(pszArgsBuf) + 1);
+                rc = DosExecPgm(szObj, sizeof(szObj), EXEC_ASYNCRESULT, (PCSZ)pszArgsBuf, (PCSZ)np->env_off, &resc, (PCSZ)pszPgmName);
+            } /* while */
             FS_RESTORE();
             if (!rc)
@@ -290 +458 @@
                 __libc_spmRelease(pEmbryo);
                 doInheritDone();
-                if (arg_buf != NULL)
-                    _tfree (arg_buf);
+                if (pszArgsBuf != NULL)
+                    _tfree(pszArgsBuf);
                 _fmutex_release(&__libc_gmtxExec);
 
@@ -297 +465 @@
                  * Exit depends on the mode.
                  */
-                switch (mode & 0xff)
+                switch (ulMode & 0xff)
                 {
                     /*
@@ -332 +500 @@
                             LIBC_ASSERTM(pidEnded == pid, "Expected pid 0x%04lx and got 0x%04lx!\n", pid, pidEnded);
 
-                            if (mode == P_OVERLAY)
+                            if (ulMode == P_OVERLAY)
                             {
                                 LIBCLOG_MSG("Calling DosExit(,0)\n");
@@ -354 +522 @@
                 /* won't ever get here! */
             }
+            else if (rc > 0)
+                _sys_set_errno(rc);
             else
-                _sys_set_errno (rc);
+                errno = -rc;
             doInheritDone();
         }
@@ -362 +532 @@
     }
 
-    if (arg_buf != NULL)
-        _tfree (arg_buf);
+    if (pszArgsBuf != NULL)
+        _tfree(pszArgsBuf);
     _fmutex_release(&__libc_gmtxExec);
     LIBCLOG_RETURN_INT(-1);