compiler/posixc/__posixc_nixmain.c

   1 /*
   2     Copyright © 1995-2014, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: special main function for code which has to use special *nix features.
   6           This function gets called from a function with a similar name statically
   7           linked with the program. This is so to make the program not depend on a
   8           particular libc version.
   9
  10     Lang: english
  11 */
  12
  13 #include LC_LIBDEFS_FILE
  14
  15 #include <proto/exec.h>
  16 #include <proto/dos.h>
  17 #include <exec/lists.h>
  18 #include <dos/dos.h>
  19 #include <aros/startup.h>
  20
  21 #define DEBUG 0
  22 #include <aros/debug.h>
  23
  24 #include <setjmp.h>
  25 #include <string.h>
  26 #include <stdlib.h>
  27 #include <sys/param.h>
  28
  29 #include "__upath.h"
  30
  31 static BOOL clone_vars(struct MinList *old_vars);
  32 static void restore_vars(struct MinList *old_vars);
  33 static void free_vars(struct MinList *vars);
  34 static void update_PATH(void);
  35
  36 int __posixc_nixmain(int (*main)(int argc, char *argv[]), int argc, char *argv[])
  37 {
  38     struct PosixCIntBase *PosixCBase, *pPosixCBase;
  39     int *errorptr = __stdc_get_errorptr();
  40     char *old_argv0 = NULL;
  41     char *new_argv0 = NULL;
  42     struct MinList old_vars;
  43
  44     D(bug("__posixc_nixmain: @begin, Task=%x\n", FindTask(NULL)));
  45     PosixCBase = (struct PosixCIntBase *)__aros_getbase_PosixCBase();
  46
  47     /* Trigger *nix path handling on.  */
  48     PosixCBase->doupath = 1;
  49
  50     /* argv[0] usually contains the name of the program, possibly with the full
  51        path to it. Here we translate that path, which is an AmigaDOS-style path,
  52        into a unix-style one.  */
  53     if (argv && argv[0])
  54     {
  55         new_argv0 = strdup(__path_a2u(argv[0]));
  56         if (new_argv0 == NULL)
  57             return RETURN_FAIL;
  58
  59         old_argv0 = argv[0];
  60         argv[0] = new_argv0;
  61     }
  62
  63     /* Here we clone environment variables. We do this because
  64        if we've been invoked as a coroutine via dos.library/RunCommand()
  65        rather than as a newly created process, then we share our env variables
  66        with the caller, but we do not want that. It's kind of wasteful to do
  67        it even if we've been started as a fresh process, though, so if we can
  68        we avoid it.
  69        The cloning does not need to be performed if flags of parent have VFORK_PARENT
  70        or EXEC_PARENT flags */
  71     pPosixCBase = __GM_GetBaseParent(PosixCBase);
  72     D(bug("__posixc_nixmain: pPosixCBase = %x, Task=%x\n", pPosixCBase, FindTask(NULL)));
  73     if (!pPosixCBase || !(pPosixCBase->flags & (VFORK_PARENT | EXEC_PARENT)))
  74     {
  75         D(bug("__posixc_nixmain: Cloning LocalVars"));
  76         if (!clone_vars(&old_vars))
  77         {
  78             if (errorptr)
  79                 *errorptr = RETURN_FAIL;
  80             goto err_vars;
  81         }
  82     }
  83
  84     /* If the PATH variable is not defined, then define it to be what CLI's path list
  85        points to.  */
  86     if (!getenv("PATH"))
  87         update_PATH();
  88
  89     /* Call the real main.  */
  90     jmp_buf exitjmp, dummyjmp;
  91     if (setjmp(exitjmp) == 0)
  92     {
  93         int ret;
  94
  95         __stdc_set_exitjmp(exitjmp, dummyjmp);
  96
  97         ret = (*main)(argc, argv);
  98         if (errorptr)
  99             *errorptr = ret;
 100     }
 101     else
 102         D(bug("__posixc_nixmain: setjmp() != 0\n"));
 103
 104     D(bug("__posixc_nixmain: pPosixCBase = %x, Task=%x\n", pPosixCBase, FindTask(NULL)));
 105     if (!pPosixCBase || !(pPosixCBase->flags & (VFORK_PARENT | EXEC_PARENT)))
 106         restore_vars(&old_vars);
 107
 108 err_vars:
 109
 110     /* Restore the old argv[0].  */
 111     if (old_argv0 != NULL)
 112     {
 113         free(new_argv0);
 114         argv[0] = (char *)old_argv0;
 115     }
 116
 117     D(bug("__posixc_nixmain: @end, Task=%x\n", FindTask(NULL)));
 118
 119     return (errorptr != NULL) ? *errorptr : 0;
 120 }
 121
 122 /* Clone the process' environment variables list. Once this function returns,
 123    the _cloned_ vars are used in place of the old ones.
 124
 125    Returns the old list's content in the old_vars argument. Use this list only as
 126    argument to restore_vars() and for _nothing_ else.
 127
 128    If this function fails, then FALSE is returned, otherwise TRUE is returned.
 129
 130    One might argue that the whole affair is solved the wrong way around, that is
 131    clone_vars() should return the _cloned_ list and restore_vars() should be really
 132    named replace_vars() and take the cloned list as argument and replace the current
 133    one with that one, but doing it this way means breaking any programs which saved
 134    vars list's internals before invoking this program, although that is not even guaranteed
 135    to work normally, as the called program could change the env list anytime...  Well,
 136    in either case it doesn't do much of a difference, since the same amount of operations
 137    would be performed, only the order would change. */
 138
 139 BOOL clone_vars(struct MinList *old_vars)
 140 {
 141     struct MinList l;
 142     struct LocalVar *lv, *newVar;
 143     struct Process *me;
 144
 145     NEWLIST(&l);
 146
 147     me = (struct Process *)FindTask(NULL);
 148     /* Copied and adapted from rom/dos/createnewproc.c. Perhaps there should
 149        be a public function for this?  */
 150     ForeachNode(&me->pr_LocalVars, lv)
 151     {
 152         size_t copyLength = strlen(lv->lv_Node.ln_Name) + 1 + sizeof(struct LocalVar);
 153
 154         newVar = (struct LocalVar *)AllocVec(copyLength, MEMF_PUBLIC);
 155         if (newVar == NULL)
 156         {
 157             free_vars(&l);
 158             return FALSE;
 159         }
 160
 161         memcpy(newVar, lv, copyLength);
 162         newVar->lv_Node.ln_Name = (char *)newVar + sizeof(struct LocalVar);
 163         if (lv->lv_Len)
 164         {
 165             newVar->lv_Value = AllocMem(lv->lv_Len, MEMF_PUBLIC);
 166
 167             if (newVar->lv_Value == NULL)
 168             {
 169                 FreeVec(newVar);
 170                 free_vars(&l);
 171                 return FALSE;
 172             }
 173
 174             memcpy(newVar->lv_Value, lv->lv_Value, lv->lv_Len);
 175         }
 176         else
 177         {
 178             /* lv_Len of 0 is a valid case for empty string, lv_Value is NULL */
 179             newVar->lv_Value = NULL;
 180         }
 181
 182         ADDTAIL(&l, newVar);
 183     }
 184
 185     *old_vars = me->pr_LocalVars;
 186     me->pr_LocalVars = l;
 187
 188     l.mlh_Head->mln_Pred     = (struct MinNode *)&me->pr_LocalVars.mlh_Head;
 189     l.mlh_TailPred->mln_Succ = (struct MinNode *)&me->pr_LocalVars.mlh_Tail;
 190
 191     return TRUE;
 192 }
 193
 194 /* Restores the old env var's list content */
 195 static void restore_vars(struct MinList *old_vars)
 196 {
 197     struct Process *me = (struct Process *)FindTask(NULL);
 198
 199     free_vars(&me->pr_LocalVars);
 200     me->pr_LocalVars = *old_vars;
 201 }
 202
 203 /* taken from rom/dos/createnewproc.c.  */
 204 static void free_vars(struct MinList *vars)
 205 {
 206     struct LocalVar *varNode;
 207     struct Node     *tempNode;
 208
 209     ForeachNodeSafe(vars, varNode, tempNode)
 210     {
 211         FreeMem(varNode->lv_Value, varNode->lv_Len);
 212         Remove((struct Node *)varNode);
 213         FreeVec(varNode);
 214     }
 215 }
 216
 217 /* setenv("PATH", current_cli_path, 1) */
 218 static void update_PATH(void)
 219 {
 220     typedef struct
 221     {
 222         BPTR next;
 223         BPTR lock;
 224     } PathEntry;
 225
 226     #define PE(x) ((PathEntry *)(BADDR(x)))
 227
 228     UBYTE aname[PATH_MAX]; /* PATH_MAX ought to be enough; it would be too complicated
 229                               handling aname dynamically (thanks to our sucky dos.library).  */
 230     char *PATH = NULL;
 231     size_t PATH_len = 0;
 232     PathEntry *cur;
 233     struct CommandLineInterface *cli = Cli();
 234
 235     /* No cli, no luck.  */
 236     if (cli == NULL)
 237         return;
 238
 239     for
 240     (
 241         cur = PE(cli->cli_CommandDir);
 242         cur != NULL;
 243         cur = PE(cur->next)
 244     )
 245     {
 246         char *new_PATH;
 247         const char *uname;
 248         size_t uname_len;
 249
 250         if (NameFromLock(cur->lock, aname, sizeof(aname)) == DOSFALSE)
 251             continue;
 252
 253         D(bug("aname = %s\n", aname));
 254
 255         uname = __path_a2u((const char *)aname);
 256         if (!uname)
 257             continue;
 258         uname_len = strlen(uname);
 259
 260         D(bug("uname = %s\n", uname));
 261
 262         new_PATH = realloc(PATH, PATH_len + uname_len + 1);
 263         if (!new_PATH)
 264             continue;
 265         PATH = new_PATH;
 266
 267         memcpy(PATH + PATH_len, uname, uname_len);
 268         PATH_len += uname_len;
 269         PATH[PATH_len++] = ':';
 270
 271         D(bug("PATH_len = %d, PATH = %.*s\n", PATH_len, PATH_len, PATH));
 272     }
 273
 274     if (PATH)
 275     {
 276         PATH[PATH_len ? (PATH_len - 1) : 0] = '\0';
 277
 278         setenv("PATH", PATH, 1);
 279     }
 280 }