home *** CD-ROM | disk | FTP | other *** search
/ Geek Gadgets 1 / ADE-1.bin / ade-dist / ixemul-45.0-src.tgz / tar.out / contrib / ixemul / library / __load_seg.c < prev    next >
C/C++ Source or Header  |  1996-09-28  |  11KB  |  435 lines
  1. /*
  2.  *  This file is part of ixemul.library for the Amiga.
  3.  *  Copyright (C) 1991, 1992  Markus M. Wild
  4.  *
  5.  *  This library is free software; you can redistribute it and/or
  6.  *  modify it under the terms of the GNU Library General Public
  7.  *  License as published by the Free Software Foundation; either
  8.  *  version 2 of the License, or (at your option) any later version.
  9.  *
  10.  *  This library is distributed in the hope that it will be useful,
  11.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13.  *  Library General Public License for more details.
  14.  *
  15.  *  You should have received a copy of the GNU Library General Public
  16.  *  License along with this library; if not, write to the Free
  17.  *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18.  *
  19.  *  __load_seg.c,v 1.1.1.1 1994/04/04 04:30:54 amiga Exp
  20.  *
  21.  *  __load_seg.c,v
  22.  * Revision 1.1.1.1  1994/04/04  04:30:54  amiga
  23.  * Initial CVS check in.
  24.  *
  25.  *  Revision 1.5  1992/09/14  01:38:35  mwild
  26.  *  fix a bug with #! expansion (forgot separating /)
  27.  *
  28.  *  Revision 1.4  1992/08/09  20:37:07  amiga
  29.  *  change to use 2.x header files by default
  30.  *
  31.  *  Revision 1.3  1992/07/04  19:02:39  mwild
  32.  *  fix typo, the buffer for interpreter-expansion was ways too small...
  33.  *
  34.  * Revision 1.2  1992/05/22  01:45:00  mwild
  35.  * rewrote interpreter expansion, `should' now work as expected
  36.  *
  37.  * Revision 1.1  1992/05/14  19:55:40  mwild
  38.  * Initial revision
  39.  *
  40.  */
  41.  
  42. #define _KERNEL
  43. #include "ixemul.h"
  44. #include "kprintf.h"
  45.  
  46. #include <ctype.h>
  47. #include <string.h>
  48.  
  49. /* 2.0 support */
  50. #include <utility/tagitem.h>
  51. #include <dos/dostags.h>
  52.  
  53. extern void *kmalloc (size_t size);
  54.  
  55. static struct my_seg *try_load_seg (BPTR lock, char *name, char **args, char *progname);
  56.  
  57. char *basename(char *tmp)
  58. {
  59.   char *cp = rindex (tmp, '/');
  60.  
  61.   if (cp)
  62.     return cp + 1;
  63.   if ((cp = index (tmp, ':')))
  64.     return cp + 1;
  65.   return tmp;
  66. }
  67.  
  68. static struct my_seg *
  69. check_resident (char *tmp)
  70. {
  71.   struct my_seg *res = 0;
  72.   struct Segment *seg;
  73.   char *base;
  74.  
  75.   /* big problem: Commo only stores the bare names in the resident
  76.      list. So we have to truncate to the filename part, and so lose
  77.      the ability to explicitly load the disk version even if a 
  78.      resident version is installed */
  79.  
  80.  
  81.   base = basename(tmp);
  82.   Forbid();
  83.   seg = FindSegment(base, 0, 0);
  84.   if (seg)
  85.     {
  86.       /* strange they didn't provide a function for this... */
  87.       if (seg->seg_UC >= 0) 
  88.         seg->seg_UC++;
  89.     }
  90.   Permit();
  91.  
  92.   if (seg && (res = (struct my_seg *)kmalloc(sizeof(*res) + strlen(tmp) + 1)))
  93.     {
  94.       res->segment = seg->seg_Seg;
  95.       res->type    = RESSEG;
  96.       res->priv    = (u_int)seg;
  97.       res->name    = (char *)&res[1];
  98.       strcpy(res->name, tmp);
  99.     }
  100.   else if (seg)
  101.     {
  102.       Forbid();
  103.       if (seg->seg_UC > 0)
  104.     seg->seg_UC--;
  105.       Permit();
  106.     }
  107.  
  108.   return res;
  109. }
  110.  
  111.  
  112. static struct my_seg *
  113. check_loadseg (char *tmp)
  114. {
  115.   struct my_seg *res = 0;
  116.   BPTR seg;
  117.   int err;
  118.  
  119.   /* Note that LoadSeg returns NULL and sets IoErr() to 0 if the file it
  120.      is trying to load is less than 4 bytes long. */
  121.   seg = LoadSeg (tmp);
  122.   if (seg && (res = kmalloc (sizeof (*res) + strlen(tmp) + 1)))
  123.     {
  124.       res->segment = seg;
  125.       res->type       = LOADSEG;
  126.       res->priv    = seg;
  127.       res->name    = (char *)&res[1];
  128.       strcpy(res->name, tmp);
  129.     }
  130.   else if (seg)
  131.     {
  132.       UnLoadSeg (seg);
  133.       errno = ENOMEM;
  134.       return NULL;
  135.     }
  136.   err = IoErr();
  137.   errno = (err ? __ioerr_to_errno(err) : ENOENT);
  138.  
  139.   if (errno == EINVAL)
  140.     errno = ENOENT;
  141.     
  142.   return res;
  143. }
  144.  
  145.  
  146. void
  147. __free_seg (BPTR *seg)
  148. {
  149.   struct my_seg *ms;
  150.   
  151.   ms = (struct my_seg *) seg;
  152.   
  153.   if (ms->type == RESSEG)
  154.     {
  155.       struct Segment *s = (struct Segment *) ms->priv;
  156.  
  157.       Forbid ();
  158.       if (s->seg_UC > 0)
  159.     s->seg_UC--;
  160.       Permit ();
  161.     }
  162.   else
  163.     UnLoadSeg (ms->priv);
  164.  
  165.   kfree (ms);
  166. }
  167.  
  168.  
  169. /*
  170.  * This function does what LoadSeg() does, and a little bit more ;-)
  171.  * Besides walking the PATH of the user, we try to do interpreter expansion as
  172.  * well. But, well, we do it a little bit different then a usual Amiga-shell.
  173.  * We check the magic cookies `#!' and `;!', and if found, run the interpreter
  174.  * specified on this first line of text. This does *not* depend on any script
  175.  * bit set!
  176.  */
  177.  
  178. /*
  179.  * IMPORTANT: only call this function with all signals masked!!! 
  180.  */
  181.  
  182. /*
  183.  * name:        the name of the command to load. Can be relative to installed PATH
  184.  * args:        if set, a string to the first part of an expanded command is stored
  185.  */
  186.  
  187. BPTR *
  188. __load_seg (char *name, char **args)
  189. {
  190.   BPTR lock;
  191.   struct my_seg *seg;
  192.  
  193.   /* perhaps the name is vanilla enough, so that even LoadSeg() groks it? */
  194.   if (args) *args = 0;
  195.  
  196.   seg = check_resident (name);
  197.  
  198.   if (! seg)
  199.     seg = check_loadseg (name);
  200.  
  201.   if (seg)
  202.     return &seg->segment;
  203.  
  204.   if (errno != ENOENT)
  205.     return 0;
  206.  
  207.   /* try to lock the file (using __lock() provides full path-parsing ;-)) */
  208.   lock = __lock (name, ACCESS_READ);
  209.   if (lock)
  210.     {
  211.       int err;
  212.       BPTR parent = ParentDir(lock);
  213.       struct FileInfoBlock *fib;
  214.  
  215.       fib = alloca (sizeof(*fib) + 2);
  216.       fib = LONG_ALIGN (fib);
  217.       if (Examine (lock, fib))
  218.         seg = try_load_seg (parent, fib->fib_FileName, args, name);
  219.       else
  220.         seg = try_load_seg (parent, basename(name), args, name);
  221.       err = errno;
  222.  
  223.       __unlock (parent);
  224.       __unlock (lock);
  225.  
  226.       errno = err;
  227.       if (!seg && errno != ENOENT)
  228.         return 0;
  229.     }
  230.  
  231.   /* now we may have a valid segment */
  232.   if (seg)
  233.     return &seg->segment;
  234.  
  235.   /* if the command was specified with some kind of path, for example with a
  236.    * device or a directory in it, we don't run it thru the PATH expander
  237.    */
  238.   if (strpbrk (name, ":/"))
  239.     {
  240.       errno = ENOENT;
  241.       return 0;
  242.     }
  243.  
  244.   /* so the command is not directly addressable, but perhaps it's in our PATH? */
  245.   {
  246.     struct Process *me = (struct Process *)(SysBase->ThisTask);
  247.     struct CommandLineInterface *cli;
  248.  
  249.     /* but we need a valid CLI then */
  250.     if ((cli = BTOCPTR (me->pr_CLI)))
  251.       {
  252.     struct path_element {
  253.       BPTR    next;
  254.       BPTR     lock;
  255.     } *lock_list;
  256.     BPTR ocd;
  257.  
  258.     for (lock_list = BTOCPTR (cli->cli_CommandDir);
  259.          lock_list;
  260.          lock_list = BTOCPTR (lock_list->next))
  261.       {
  262.             ocd = CurrentDir (lock_list->lock);
  263.         seg = try_load_seg (lock_list->lock, name, args, name);
  264.         CurrentDir(ocd);
  265.         if (seg)
  266.           break;
  267.         if (errno != ENOENT)
  268.               return 0;
  269.       }
  270.       }
  271.   }
  272.   
  273.   if (seg)
  274.     return &seg->segment;
  275.  
  276.   errno = ENOENT;
  277.   KPRINTF (("&errno = %lx, errno = %ld\n", &errno, errno));
  278.   return 0;
  279. }
  280.  
  281. static struct my_seg *
  282. try_load_seg (BPTR parent, char *name, char **args, char *progname)
  283. {
  284.   BPTR ocd, tmpcd;
  285.   short oroot;
  286.   struct my_seg *seg;
  287.  
  288.   if (args) *args = 0;
  289.   ocd = CurrentDir (parent);
  290.   oroot = u.u_is_root;
  291.   u.u_is_root = 0;
  292.   
  293.   seg = check_loadseg (name);
  294.  
  295.   if (!seg && errno != ENOENT)
  296.     {
  297.       CurrentDir(ocd);
  298.       u.u_is_root = oroot;
  299.       return 0;
  300.     }
  301.  
  302.   /* try to do interpreter - expansion, but only if args is non-zero */
  303.   if (!seg && args)
  304.     {
  305.       int fd, n;
  306.       char magic[5];
  307.       struct stat stb;
  308.  
  309.       if (syscall (SYS_stat, name, &stb) == 0 && S_ISREG (stb.st_mode))
  310.     {
  311.       if ((fd = syscall (SYS_open, name, 0)) >= 0)
  312.             {
  313.               /*
  314.                *  If the .key line of an AmigaOS script isn't the first
  315.                *  line of the script, the AmigaOS shell gets very confused.
  316.                *  Therefore, we skip the first line if it begins with .key,
  317.                *  and we test the second line for #! or ;!.
  318.                */
  319.           if ((n = syscall (SYS_read, fd, magic, 4)) == 4)
  320.             {
  321.               magic[4] = 0;
  322.               if (!strcasecmp(magic, ".key"))
  323.                 {
  324.                   n = 0;
  325.                   /* skip this line */
  326.                   while (syscall (SYS_read, fd, magic, 1) == 1)
  327.                     if (magic[0] == '\n')
  328.                       {
  329.                         n = syscall (SYS_read, fd, magic, 4);
  330.                         break;
  331.                       }
  332.                 }
  333.             }
  334.           if (n >= 2 && (magic[0] == '#' || magic[0] == ';') && magic[1] == '!')
  335.             {
  336.               char interp[MAXPATHLEN + 1], *interp_start;
  337.           
  338.               interp[0] = magic[2];
  339.               interp[1] = magic[3];
  340.               n -= 2;
  341.               n = n + syscall (SYS_read, fd, interp + n, MAXINTERP - n);
  342.               if (n > 0)
  343.             {
  344.               char *cp, ch;
  345.               char *interp_path;
  346.  
  347.               /* okay.. got one.. terminate with 0 and try to find end of it */
  348.               interp[n] = 0;
  349.               for (interp_start = interp; isspace(*interp_start) && interp_start < interp + n; interp_start++);
  350.               for (cp = interp_start; cp < interp + n; cp++)
  351.                 if (*cp == 0 || isspace (*cp)) break;
  352.               ch = *cp;
  353.               *cp = 0;
  354.  
  355.               /* okay, lets try to load this instead. Call us recursively,
  356.                * but leave out the argument-argument, so we can't get
  357.                * into infinite recursion. Interpreter-Expansion is only
  358.                * done the first time __load_seg() is called from
  359.                * execve()
  360.                */
  361.                       tmpcd = CurrentDir(ocd);
  362.               u.u_is_root = oroot;
  363.               seg = (struct my_seg *) __load_seg (interp_start, 0);
  364.                       CurrentDir(tmpcd);
  365.               u.u_is_root = 0;
  366.               *cp = ch;
  367.               if (!seg)
  368.                 goto fd_close;
  369.           
  370.               /* in this case, set the argument as well. 
  371.                */
  372.  
  373.               /* first skip intergap whitespace */
  374.               for (; cp < interp + n; cp++)
  375.             if (!*cp || !isspace(*cp) || *cp == '\n')
  376.               break;
  377.  
  378.               if (*cp && *cp != '\n')
  379.                 {
  380.               /* we read a certain amount of bytes, but we 
  381.                * unconditionally stop when we hit newline
  382.                */
  383.               interp_path = cp;
  384.  
  385.                   /* crop any further arguments, only ONE argument
  386.                    * is supported
  387.                */
  388.                   for (; cp < interp + n; cp++) 
  389.                 if (isspace (*cp)) 
  390.                   break;
  391.                   if (cp < interp + n)
  392.                 *cp = 0;
  393.  
  394.               *cp++ = ' ';
  395.             }
  396.               else
  397.             cp = interp_path = interp_start;
  398.  
  399.               if (progname[0] != '/' && !index(progname, ':'))
  400.             {
  401.                           BPTR lock;
  402.  
  403.                           CurrentDir (ocd);
  404.                           lock = __llock (progname, ACCESS_READ);
  405.               *cp++ = '/';
  406.               if (lock && NameFromLock (lock, cp, 
  407.                         MAXPATHLEN-(cp-interp)) == -1)
  408.                 {
  409.                   if ((cp = index(cp, ':')))
  410.                     *cp = '/';
  411.                 }
  412.               else
  413.                 strcpy (cp - 1, progname);
  414.                           if (lock)
  415.                             __unlock (lock);
  416.             }
  417.               else
  418.             strcpy (cp, progname);
  419.  
  420.               *args = (char *) syscall (SYS_strdup, interp_path);
  421.             }
  422.             }
  423. fd_close:
  424.           syscall (SYS_close, fd);
  425.         }
  426.         }
  427.     }
  428.   CurrentDir (ocd);
  429.   u.u_is_root = oroot;
  430.  
  431.   if (!seg)  
  432.     errno = ENOENT;
  433.   return seg;
  434. }
  435.