compiler/clib/__arosc_nixmain.c

   1 /*
   2     Copyright © 1995-2012, 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 "__arosc_privdata.h"
  30 #include "__upath.h"
  31
  32 static BOOL clone_vars(struct MinList *old_vars);
  33 static void restore_vars(struct MinList *old_vars);
  34 static void free_vars(struct MinList *vars);
  35 static void update_PATH(void);
  36
  37 int __arosc_nixmain(int (*main)(int argc, char *argv[]), int argc, char *argv[])
  38 {
  39     struct aroscbase *aroscbase = __aros_getbase_aroscbase(), *paroscbase;
  40     int *errorptr = __arosc_get_errorptr();
  41     char *old_argv0 = NULL;
  42     char *new_argv0 = NULL;
  43     struct MinList old_vars;
  44
  45     D(bug("__arosc_nixmain: @begin, Task=%x\n", FindTask(NULL)));
  46
  47     /* Trigger *nix path handling on.  */
  48     aroscbase->acb_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 an unix-style one.  */
  53     if (argv && argv[0] && !aroscbase->acb_parent_does_upath)
  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     paroscbase = __GM_GetBaseParent(aroscbase);
  72     D(bug("__arosc_nixmain: paroscbase = %x, Task=%x\n", paroscbase, FindTask(NULL)));
  73     if (!paroscbase || !(paroscbase->acb_flags & (VFORK_PARENT | EXEC_PARENT)))
  74     {
  75         D(bug("__arosc_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         __arosc_set_exitjmp(exitjmp, dummyjmp);
  96
  97         ret = (*main)(argc, argv);
  98         if (errorptr)
  99             *errorptr = ret;
 100     }
 101     else
 102         D(bug("__arosc_nixmain: setjmp() != 0\n"));
 103
 104     D(bug("__arosc_nixmain: paroscbase = %x, Task=%x\n", paroscbase, FindTask(NULL)));
 105     if (!paroscbase || !(paroscbase->acb_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("__arosc_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;
 153
 154         if (lv->lv_Len == 0)
 155             continue;
 156
 157         copyLength = strlen(lv->lv_Node.ln_Name) + 1 + sizeof(struct LocalVar);
 158
 159         newVar = (struct LocalVar *)AllocVec(copyLength, MEMF_PUBLIC);
 160         if (newVar == NULL)
 161         {
 162             free_vars(&l);
 163             return FALSE;
 164         }
 165
 166         memcpy(newVar, lv, copyLength);
 167         newVar->lv_Node.ln_Name = (char *)newVar + sizeof(struct LocalVar);
 168         newVar->lv_Value        = AllocMem(lv->lv_Len, MEMF_PUBLIC);
 169
 170         if (newVar->lv_Value == NULL)
 171         {
 172             FreeVec(newVar);
 173             free_vars(&l);
 174             return FALSE;
 175         }
 176
 177         memcpy(newVar->lv_Value, lv->lv_Value, lv->lv_Len);
 178
 179         ADDTAIL(&l, newVar);
 180     }
 181
 182     *old_vars = me->pr_LocalVars;
 183     me->pr_LocalVars = l;
 184
 185     l.mlh_Head->mln_Pred     = (struct MinNode *)&me->pr_LocalVars.mlh_Head;
 186     l.mlh_TailPred->mln_Succ = (struct MinNode *)&me->pr_LocalVars.mlh_Tail;
 187
 188     return TRUE;
 189 }
 190
 191 /* Restores the old env var's list content */
 192 static void restore_vars(struct MinList *old_vars)
 193 {
 194     struct Process *me = (struct Process *)FindTask(NULL);
 195
 196     free_vars(&me->pr_LocalVars);
 197     me->pr_LocalVars = *old_vars;
 198 }
 199
 200 /* taken from rom/dos/createnewproc.c.  */
 201 static void free_vars(struct MinList *vars)
 202 {
 203     struct LocalVar *varNode;
 204     struct Node     *tempNode;
 205
 206     ForeachNodeSafe(vars, varNode, tempNode)
 207     {
 208         FreeMem(varNode->lv_Value, varNode->lv_Len);
 209         Remove((struct Node *)varNode);
 210         FreeVec(varNode);
 211     }
 212 }
 213
 214 /* setenv("PATH", current_cli_path, 1) */
 215 static void update_PATH(void)
 216 {
 217     typedef struct
 218     {
 219         BPTR next;
 220         BPTR lock;
 221     } PathEntry;
 222
 223     #define PE(x) ((PathEntry *)(BADDR(x)))
 224
 225     UBYTE aname[PATH_MAX]; /* PATH_MAX ought to be enough; it would be too complicated
 226                               handling aname dynamically (thanks to our sucky dos.library).  */
 227     char *PATH = NULL;
 228     size_t PATH_len = 0;
 229     PathEntry *cur;
 230     struct CommandLineInterface *cli = Cli();
 231
 232     /* No cli, no luck.  */
 233     if (cli == NULL)
 234         return;
 235
 236     for
 237     (
 238         cur = PE(cli->cli_CommandDir);
 239         cur != NULL;
 240         cur = PE(cur->next)
 241     )
 242     {
 243         char *new_PATH;
 244         const char *uname;
 245         size_t uname_len;
 246
 247         if (NameFromLock(cur->lock, aname, sizeof(aname)) == DOSFALSE)
 248             continue;
 249
 250         D(bug("aname = %s\n", aname));
 251
 252         uname = __path_a2u((const char *)aname);
 253         if (!uname)
 254             continue;
 255         uname_len = strlen(uname);
 256
 257         D(bug("uname = %s\n", uname));
 258
 259         new_PATH = realloc(PATH, PATH_len + uname_len + 1);
 260         if (!new_PATH)
 261             continue;
 262         PATH = new_PATH;
 263
 264         memcpy(PATH + PATH_len, uname, uname_len);
 265         PATH_len += uname_len;
 266         PATH[PATH_len++] = ':';
 267
 268         D(bug("PATH_len = %d, PATH = %.*s\n", PATH_len, PATH_len, PATH));
 269     }
 270
 271     if (PATH)
 272     {
 273         PATH[PATH_len ? (PATH_len - 1) : 0] = '\0';
 274
 275         setenv("PATH", PATH, 1);
 276     }
 277 }