compiler/clib/__exec.c

   1 /*
   2     Copyright © 2008-2011, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Support functions for POSIX exec*() functions.
   6 */
   7 #include <exec/types.h>
   8 #include <dos/dos.h>
   9 #include <proto/dos.h>
  10
  11 #include <aros/libcall.h>
  12
  13 #include <errno.h>
  14 #include <ctype.h>
  15 #include <assert.h>
  16 #include <strings.h>
  17 #include <stdlib.h>
  18 #include <stdarg.h>
  19 #include <unistd.h>
  20 #include <sys/stat.h>
  21 #include <fcntl.h>
  22
  23 #include "__arosc_privdata.h"
  24 #include "__exec.h"
  25 #include "__upath.h"
  26 #include "__errno.h"
  27 #include "__fdesc.h"
  28
  29 #define DEBUG 0
  30 #include <aros/debug.h>
  31
  32 static BOOL containswhite(const char *str);
  33 static char *escape(const char *str);
  34 static char *appendarg(char *argptr, int *argptrsize, const char *arg, APTR pool);
  35 static char *appendargs(char *argptr, int *argptrsize, char *const args[], APTR pool);
  36 static void __exec_cleanup(struct arosc_privdata *privdata);
  37 static void close_on_exec();
  38
  39 /* Public functions */
  40 /********************/
  41
  42 APTR __exec_prepare(const char *filename, int searchpath, char *const argv[], char *const envp[])
  43 {
  44     struct arosc_privdata *privdata = __get_arosc_privdata();
  45     char *filename2 = NULL;
  46     int argssize = 512;
  47     struct Process *me;
  48
  49     D(bug("Entering __exec_prepare(\"%s\", %d, %x, %x)\n",
  50           filename, searchpath, argv, envp
  51     ));
  52     /* Sanity check */
  53     if (filename == NULL || filename[0] == '\0' || argv == NULL)
  54     {
  55         errno = EINVAL;
  56         goto error;
  57     }
  58
  59     /* Use own memory to allocate so that no arosstdc.library functions need to be called
  60        exec_pool can also be allocated in __exec_valist2array
  61     */
  62     if (!privdata->acpd_exec_pool)
  63         privdata->acpd_exec_pool = CreatePool(MEMF_PUBLIC, 1024, 512);
  64     if (!privdata->acpd_exec_pool)
  65     {
  66         errno = ENOMEM;
  67         goto error;
  68     }
  69
  70     /* Search path if asked and no directory separator is present in the file */
  71     if (searchpath && index(filename, '/') == NULL && index(filename, ':') == NULL)
  72     {
  73         int i, len, size;
  74         char *path = NULL, *path_ptr, *path_item;
  75         BPTR lock;
  76
  77         if (environ)
  78         {
  79             for (i=0; environ[i]; i++)
  80             {
  81                 if (strncmp(environ[i], "PATH=", 5) == 0)
  82                 {
  83                     path = &environ[i][5];
  84                     break;
  85                 }
  86             }
  87         }
  88
  89         if (!path)
  90             path = getenv("PATH");
  91
  92         if (!path)
  93             path = ":/bin:/usr/bin";
  94
  95         D(bug("__exec_prepare: PATH('%s')\n", path));
  96
  97         path_ptr = AllocPooled(privdata->acpd_exec_pool, strlen(path) + 1);
  98         strcpy(path_ptr, path);
  99         path = path_ptr;
 100
 101         D(bug("__exec_prepare: PATH('%s')\n", path));
 102
 103         size = 128;
 104         filename2 = AllocPooled(privdata->acpd_exec_pool, size);
 105         if (!filename2)
 106         {
 107             errno = ENOMEM;
 108             goto error;
 109         }
 110
 111         for(path_ptr = path, lock = (BPTR)NULL, path_item = strsep(&path_ptr, ",:");
 112             lock == (BPTR)NULL && path_item != NULL;
 113             path_item = strsep(&path_ptr, ",:")
 114         )
 115         {
 116             if(path_item[0] == '\0')
 117                 path_item = ".";
 118
 119             len = strlen(path_item) + strlen(filename) + 2;
 120
 121             if (len > size)
 122             {
 123                 FreePooled(privdata->acpd_exec_pool, filename2, size);
 124                 size = len;
 125                 filename2 = AllocPooled(privdata->acpd_exec_pool, size);
 126                 if (!filename2)
 127                 {
 128                     errno = ENOMEM;
 129                     goto error;
 130                 }
 131             }
 132
 133             strcpy(filename2, path_item);
 134             strcat(filename2, "/");
 135             strcat(filename2, filename);
 136             lock = Lock(__path_u2a(filename2), SHARED_LOCK);
 137             D(bug("__exec_prepare: Lock(\"%s\") == %x\n", filename2, (APTR)lock));
 138         }
 139
 140         if(lock != (BPTR)NULL)
 141             UnLock(lock);
 142         else
 143         {
 144             errno = ENOENT;
 145             goto error;
 146         }
 147     }
 148     else
 149         filename2 = (char *)filename;
 150
 151
 152     if (privdata->acpd_flags & PRETEND_CHILD)
 153     {
 154         struct vfork_data *udata = privdata->acpd_vfork_data;
 155
 156         udata->exec_filename = filename2;
 157         udata->exec_argv = argv;
 158         udata->exec_envp = envp;
 159
 160         /* Set this so the child knows that __exec_prepare was called */
 161         udata->child_executed = 1;
 162
 163         D(bug("__exec_prepare: Calling child\n"));
 164         /* Now call child process, so it will call __exec_prepare */
 165         Signal(udata->child, 1 << udata->child_signal);
 166
 167         D(bug("__exec_prepare: Waiting for child to finish __exec_prepare\n"));
 168         /* __exec_prepare should be finished now on child */
 169         Wait(1 << udata->parent_signal);
 170
 171         if (!udata->exec_id)
 172         {
 173             D(bug("__exec_prepare: Continue child immediately on error\n"));
 174             Signal(udata->child, 1 << udata->child_signal);
 175
 176             return NULL;
 177         }
 178
 179         D(bug("__exec_prepare: Exiting from forked __exec_prepare id=%x, errno=%d\n",
 180               udata->exec_id, udata->child_errno
 181         ));
 182
 183         return privdata;
 184     }
 185
 186     D(bug("__exec_prepare: Not running as PRETEND_CHILD\n"));
 187     privdata->acpd_exec_args = AllocPooled(privdata->acpd_exec_pool, argssize);
 188     privdata->acpd_exec_args[0] = '\0';
 189
 190     /* Let's check if it's a script */
 191     BPTR fh = Open((CONST_STRPTR)__path_u2a(filename2), MODE_OLDFILE);
 192     if(fh)
 193     {
 194         if(FGetC(fh) == '#' && FGetC(fh) == '!')
 195         {
 196            char firstline[128], *linebuf, *inter, *interargs = NULL;
 197
 198             /* It is a script, let's read the first line */
 199             if(FGets(fh, (STRPTR)firstline, sizeof(firstline) - 1))
 200             {
 201                 /* delete end of line if present */
 202                 if(firstline[0] && firstline[strlen(firstline)-1] == '\n')
 203                     firstline[strlen(firstline)-1] = '\0';
 204                 linebuf = firstline;
 205                 while(isblank(*linebuf)) linebuf++;
 206                 if(*linebuf != '\0')
 207                 {
 208                     /* Interpreter name is here */
 209                     inter = linebuf;
 210                     while(*linebuf != '\0' && !isblank(*linebuf)) linebuf++;
 211                     if(*linebuf != '\0')
 212                     {
 213                         *linebuf++ = '\0';
 214                         while(isblank(*linebuf)) linebuf++;
 215                         if(*linebuf != '\0')
 216                             /* Interpreter arguments are here */
 217                             interargs = linebuf;
 218                     }
 219
 220                     /* Add interpeter args and the script name to command line args */
 221                     char *args[] = {NULL, NULL, NULL};
 222                     if (interargs)
 223                     {
 224                         args[0] = interargs;
 225                         args[1] = filename2;
 226                     }
 227                     else
 228                     {
 229                         args[0] = filename2;
 230                     }
 231                     privdata->acpd_exec_args = appendargs(
 232                         privdata->acpd_exec_args, &argssize, args, privdata->acpd_exec_pool
 233                     );
 234                     if (!privdata->acpd_exec_args)
 235                     {
 236                         errno = ENOMEM;
 237                         goto error;
 238                     }
 239
 240                     /* Set file to execute as the script interpreter */
 241                     filename2 = AllocPooled(privdata->acpd_exec_pool, strlen(inter) + 1);
 242                     strcpy(filename2, inter);
 243                 }
 244             }
 245         }
 246         Close(fh);
 247     }
 248     else
 249     {
 250         /* Simply assume it doesn't exist */
 251         errno = IoErr2errno(IoErr());
 252         goto error;
 253     }
 254
 255     /* Add arguments to command line args */
 256     privdata->acpd_exec_args = appendargs(privdata->acpd_exec_args, &argssize, argv + 1, privdata->acpd_exec_pool);
 257     if (!privdata->acpd_exec_args)
 258     {
 259         errno = ENOMEM;
 260         goto error;
 261     }
 262
 263     /* End command line args with '\n' */
 264     if(strlen(privdata->acpd_exec_args) > 0)
 265         privdata->acpd_exec_args[strlen(privdata->acpd_exec_args) - 1] = '\n';
 266     else
 267         strcat(privdata->acpd_exec_args, "\n");
 268
 269
 270     /* let's make some sanity tests */
 271     struct stat st;
 272     if(stat(filename2, &st) == 0)
 273     {
 274         if(!(st.st_mode & S_IXUSR) && !(st.st_mode & S_IXGRP) && !(st.st_mode & S_IXOTH))
 275         {
 276             /* file is not executable */
 277             errno = EACCES;
 278             goto error;
 279         }
 280         if(st.st_mode & S_IFDIR)
 281         {
 282             /* it's a directory */
 283             errno = EACCES;
 284             goto error;
 285         }
 286     }
 287     else
 288     {
 289         /* couldn't stat file */
 290         goto error;
 291     }
 292
 293     /* Set taskname */
 294     privdata->acpd_exec_taskname = AllocPooled(privdata->acpd_exec_pool, strlen(filename2) + 1);
 295     if (!privdata->acpd_exec_taskname)
 296     {
 297         errno = ENOMEM;
 298         goto error;
 299     }
 300     strcpy(privdata->acpd_exec_taskname, filename2);
 301
 302     /* Load file to execute */
 303     privdata->acpd_exec_seglist = LoadSeg((CONST_STRPTR)__path_u2a(filename2));
 304     if (!privdata->acpd_exec_seglist)
 305     {
 306         errno = ENOEXEC;
 307         goto error;
 308     }
 309
 310     me = (struct Process *)FindTask(NULL);
 311
 312     if (envp && envp != environ)
 313     {
 314         struct MinList tempenv;
 315         struct LocalVar *lv, *lv2;
 316         char *const *envit;
 317         int env_ok = 1;
 318
 319         /* Remember previous environment variables so they can be put back
 320          * if something goes wrong
 321          */
 322         NEWLIST(&tempenv);
 323         ForeachNodeSafe(&me->pr_LocalVars, lv, lv2)
 324         {
 325             Remove((struct Node *)lv);
 326             AddTail((struct List *)&tempenv, (struct Node *)lv);
 327         }
 328
 329         NEWLIST(&me->pr_LocalVars);
 330         environ = NULL;
 331
 332         for (envit = envp; *envit && env_ok; envit++)
 333             env_ok = putenv(*envit) == 0;
 334
 335         if (env_ok)
 336             /* Old vars may be freed */
 337             ForeachNodeSafe(&tempenv, lv, lv2)
 338             {
 339                 Remove((struct Node *)lv);
 340                 FreeMem(lv->lv_Value, lv->lv_Len);
 341                 FreeVec(lv);
 342             }
 343         else
 344         {
 345             /* Free new nodes */
 346             ForeachNodeSafe(&me->pr_LocalVars, lv, lv2)
 347             {
 348                 Remove((struct Node *)lv);
 349                 FreeMem(lv->lv_Value, lv->lv_Len);
 350                 FreeVec(lv);
 351             }
 352
 353             /* Put old ones back */
 354             ForeachNodeSafe(&tempenv, lv, lv2)
 355             {
 356                 Remove((struct Node *)lv);
 357                 AddTail((struct List *)&me->pr_LocalVars, (struct Node *)lv);
 358             }
 359
 360             errno = ENOMEM;
 361             goto error;
 362         }
 363     }
 364
 365     /* Set standard files to the standard files from arosc */
 366     fdesc *in = __getfdesc(STDIN_FILENO), *out = __getfdesc(STDOUT_FILENO),
 367         *err = __getfdesc(STDERR_FILENO);
 368
 369     if(in)
 370         privdata->acpd_exec_oldin = SelectInput(in->fcb->fh);
 371     if(out)
 372         privdata->acpd_exec_oldout = SelectOutput(out->fcb->fh);
 373     if (err)
 374     {
 375         privdata->acpd_exec_olderr = me->pr_CES;
 376         me->pr_CES = err->fcb->fh;
 377     }
 378
 379     /* Generate new privdata for the exec */
 380     assert(!(privdata->acpd_flags & KEEP_OLD_ACPD));
 381     privdata->acpd_flags |= CREATE_NEW_ACPD;
 382     privdata->acpd_exec_aroscbase = OpenLibrary("arosc.library", 0);
 383     if(!privdata->acpd_exec_aroscbase)
 384     {
 385         errno = ENOMEM;
 386         goto error;
 387     }
 388
 389     /* Initialize some data of the new generated privdata */
 390     struct arosc_privdata *newprivdata = __get_arosc_privdata();
 391     assert(!(newprivdata->acpd_flags & CREATE_NEW_ACPD));
 392     newprivdata->acpd_flags |= KEEP_OLD_ACPD;
 393     newprivdata->acpd_parent_does_upath = privdata->acpd_doupath;
 394
 395     /* Everything OK */
 396     return (APTR)privdata;
 397
 398 error:
 399     __exec_cleanup(privdata);
 400
 401     return (APTR)NULL;
 402 }
 403
 404
 405 void __exec_do(APTR id)
 406 {
 407     struct arosc_privdata *privdata = id;
 408     char *oldtaskname;
 409     struct CommandLineInterface *cli = Cli();
 410     struct Task *self = FindTask(NULL);
 411     LONG returncode;
 412
 413     D(bug("[__exec_do] Entering, id(%x)\n", id));
 414
 415     if (__get_arosc_privdata()->acpd_flags & PRETEND_CHILD)
 416     {
 417         struct vfork_data *udata = __get_arosc_privdata()->acpd_vfork_data;
 418
 419         D(bug("[__exec_do] PRETEND_CHILD\n"));
 420
 421         close_on_exec();
 422
 423         /* Signal child that __exec_do is called */
 424         Signal(udata->child, 1 << udata->child_signal);
 425
 426         /* Clean up in parent */
 427         __exec_cleanup(privdata);
 428
 429         /* Continue as parent process */
 430         _exit(0);
 431
 432         assert(0); /* Should not be reached */
 433         return;
 434     }
 435
 436     D(bug("[__exec_do] !PRETEND_CHILD\n"));
 437
 438     oldtaskname = self->tc_Node.ln_Name;
 439     self->tc_Node.ln_Name = privdata->acpd_exec_taskname;
 440     SetProgramName((STRPTR)privdata->acpd_exec_taskname);
 441
 442     returncode = RunCommand(
 443         privdata->acpd_exec_seglist,
 444         cli->cli_DefaultStack * CLI_DEFAULTSTACK_UNIT,
 445         (STRPTR)privdata->acpd_exec_args,
 446         strlen(privdata->acpd_exec_args)
 447     );
 448
 449     self->tc_Node.ln_Name = oldtaskname;
 450     SetProgramName((STRPTR)oldtaskname);
 451
 452     __exec_cleanup(privdata);
 453
 454     D(bug("[__exec_do] exiting from non-forked\n"));
 455     _exit(returncode);
 456 }
 457
 458
 459 char *const *__exec_valist2array(const char *arg1, va_list list)
 460 {
 461     struct arosc_privdata *privdata = __get_arosc_privdata();
 462     int argc, i;
 463     static char *no_arg[] = {NULL};
 464     va_list list2;
 465     char *argit;
 466
 467     assert(privdata->acpd_exec_tmparray == NULL);
 468
 469     va_copy(list2, list);
 470
 471     if (arg1 == NULL)
 472         return no_arg;
 473
 474     for (argit = va_arg(list, char *), argc = 1;
 475          argit != NULL;
 476          argit = va_arg(list, char *)
 477     )
 478         argc++;
 479
 480     if (!(privdata->acpd_exec_tmparray = malloc((argc+1)*(sizeof(char *)))))
 481     {
 482         D(bug("__exec_valist2array: Memory allocation failed\n"));
 483         va_end(list2);
 484         return NULL;
 485     }
 486
 487     privdata->acpd_exec_tmparray[0] = (char *)arg1;
 488     for (argit = va_arg(list2, char *), i = 1;
 489          i <= argc; /* i == argc will copy the NULL pointer */
 490          argit = va_arg(list2, char *), i++
 491     )
 492     {
 493         D(bug("arg %d: %x\n", i, argit));
 494         privdata->acpd_exec_tmparray[i] = argit;
 495     }
 496
 497     va_end(list2);
 498
 499     return privdata->acpd_exec_tmparray;
 500 }
 501
 502
 503 void __exec_cleanup_array()
 504 {
 505     struct arosc_privdata *privdata = __get_arosc_privdata();
 506     if (privdata->acpd_exec_tmparray)
 507     {
 508         free((void *)privdata->acpd_exec_tmparray);
 509         privdata->acpd_exec_tmparray = NULL;
 510     }
 511 }
 512
 513
 514 /* Support functions */
 515 /*********************/
 516
 517 /* Return TRUE if there are any white spaces in the string */
 518 static BOOL containswhite(const char *str)
 519 {
 520     while(*str != '\0')
 521         if(isspace(*str++)) return TRUE;
 522     return FALSE;
 523 }
 524
 525 /* Escape the string and quote it */
 526 static char *escape(const char *str)
 527 {
 528     const char *strptr = str;
 529     char *escaped, *escptr;
 530     /* Additional two characters for '"', and one for '\0' */
 531     int bufsize = strlen(str) + 3;
 532     /* Take into account characters to ecape */
 533     while(*strptr != '\0')
 534     {
 535         switch(*strptr++)
 536         {
 537         case '\n':
 538         case '"':
 539         case '*':
 540             bufsize++;
 541         }
 542     }
 543     escptr = escaped = (char*) malloc(bufsize);
 544     if(!escaped)
 545         return NULL;
 546     *escptr++ = '"';
 547     for(strptr = str; *strptr != '\0'; strptr++)
 548     {
 549         switch(*strptr)
 550         {
 551         case '\n':
 552         case '"':
 553         case '*':
 554             *escptr++ = '*';
 555             *escptr++ = (*strptr == '\n' ? 'N' : *strptr);
 556             break;
 557         default:
 558             *escptr++ = *strptr;
 559             break;
 560         }
 561     }
 562     *escptr++ = '"';
 563     *escptr = '\0';
 564     return escaped;
 565 }
 566
 567 /* Append arg string to argptr increasing argptr if needed */
 568 static char *appendarg(char *argptr, int *argptrsize, const char *arg, APTR pool)
 569 {
 570     while(strlen(argptr) + strlen(arg) + 2 > *argptrsize)
 571     {
 572         char *argptr2;
 573         int argptrsize2 = 2*(*argptrsize);
 574
 575         argptr2 = AllocPooled(pool, argptrsize2);
 576         if(!argptr2)
 577         {
 578             FreePooled(pool, argptr, *argptrsize);
 579             return NULL;
 580         }
 581         strcpy(argptr2, argptr);
 582         FreePooled(pool, argptr, *argptrsize);
 583         argptr = argptr2;
 584         *argptrsize = argptrsize2;
 585     }
 586     strcat(argptr, arg);
 587     strcat(argptr, " ");
 588
 589     return argptr;
 590 }
 591
 592 static char *appendargs(char *argptr, int *argssizeptr, char *const args[], APTR pool)
 593 {
 594     char *const *argsit;
 595
 596     for (argsit = args; *argsit && argptr; argsit++)
 597     {
 598         if(containswhite(*argsit))
 599         {
 600             char *escaped = escape(*argsit);
 601             if(!escaped) {
 602                 return NULL;
 603             }
 604             argptr = appendarg(argptr, argssizeptr, escaped, pool);
 605             free(escaped);
 606         }
 607         else
 608             argptr = appendarg(argptr, argssizeptr, *argsit, pool);
 609     }
 610
 611     return argptr;
 612 }
 613
 614 static void __exec_cleanup(struct arosc_privdata *privdata)
 615 {
 616     D(bug("__exec_cleanup: me(%x)\n", FindTask(NULL)));
 617
 618     /* Delete old private data */
 619     if (privdata->acpd_exec_aroscbase)
 620     {
 621         CloseLibrary(privdata->acpd_exec_aroscbase);
 622         privdata->acpd_exec_aroscbase = NULL;
 623     }
 624
 625     if(privdata->acpd_exec_oldin)
 626     {
 627         SelectInput(privdata->acpd_exec_oldin);
 628         privdata->acpd_exec_oldin = (BPTR)NULL;
 629     }
 630     if(privdata->acpd_exec_oldout)
 631     {
 632         SelectOutput(privdata->acpd_exec_oldout);
 633         privdata->acpd_exec_oldout = (BPTR)NULL;
 634     }
 635     if(privdata->acpd_exec_olderr)
 636     {
 637         struct Process *me = (struct Process *)FindTask(NULL);
 638
 639         me->pr_CES = privdata->acpd_exec_olderr;
 640         privdata->acpd_exec_olderr = BNULL;
 641     }
 642
 643     if (privdata->acpd_exec_pool)
 644     {
 645         DeletePool(privdata->acpd_exec_pool);
 646         privdata->acpd_exec_pool = NULL;
 647     }
 648     if (privdata->acpd_exec_seglist)
 649     {
 650         UnLoadSeg(privdata->acpd_exec_seglist);
 651         privdata->acpd_exec_seglist = (BPTR)NULL;
 652     }
 653 }
 654
 655 static void close_on_exec(void)
 656 {
 657     int i;
 658     fdesc *fd;
 659
 660     for (i = __getfdslots() - 1; i >= 0; i--)
 661     {
 662         if ((fd = __getfdesc(i)) != NULL)
 663         {
 664             D(bug("close_on_exec: checking fd %d\n", i));
 665             if (fd->fdflags & FD_CLOEXEC)
 666             {
 667                 D(bug("close_on_exec: closing fd %d\n", i));
 668                 assert(close(i) == 0);
 669             }
 670         }
 671     }
 672 }