msdos/is_exec.c

   1 /* IS_EXEC.C
   2  *
   3  * Copyright (C) 1995 DJ Delorie
   4  * Copyright (C) 1994 Eli Zaretskii <eliz@is.elta.co.il>
   5  *
   6  * (See the README file in this directory for the copyright and license
   7  * history of this file.)
   8  *
   9  * This file is free software: you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation, either version 3 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * This file is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this file.  If not, see <http://www.gnu.org/licenses/>.
  21  *
  22  * Commentary:
  23  *
  24  * Given a filename or a file handle, and the extension of the file,
  25  * determine if the file is executable.
  26  * First, the file extension is checked in case it uniquely identifies
  27  * the file as either an executable or not.  Failing this, the first
  28  * two bytes of the file are tested for known signatures of executable
  29  * files.
  30  *
  31  */
  32
  33 #include <libc/stubs.h>
  34 #include <stdio.h>
  35 #include <string.h>
  36 #include <ctype.h>
  37 #include <errno.h>
  38 #include <dpmi.h>
  39 #include <go32.h>
  40 #include <io.h>
  41 #include <libc/farptrgs.h>
  42 #include <libc/dosio.h>
  43
  44 extern unsigned short _djstat_flags;
  45 unsigned short        _get_magic(const char *, int);
  46 int                   _is_executable(const char *, int, const char *);
  47
  48 /*
  49  * Read a MAGIC NUMBER from a given file.  These are the first
  50  * two bytes of the file, if we look at them as an unsigned short. */
  51
  52 #define _STAT_EXEC_EXT      2   /* get execute bits from file extension? */
  53 #define _STAT_EXEC_MAGIC    4   /* get execute bits from magic signature? */
  54
  55 unsigned short
  56 _get_magic(const char *s, int fh)
  57 {
  58   __dpmi_regs          regs;
  59   unsigned short       retval;
  60   unsigned short       fpos_high = 0, fpos_low = 0;
  61   int                  read_fail = 0;
  62
  63   /* If given a pathname, open the file. */
  64   if (s)
  65   {
  66     int handle;
  67     if((handle = _open(s,0)) == -1)
  68       return 0;
  69     regs.x.bx = handle;
  70   }
  71   /* Else file already open.  Remember its current file position
  72      and move to beginning of file. */
  73   else
  74   {
  75     regs.x.ax = 0x4201;         /* set pointer from current position */
  76     regs.x.bx = fh;
  77     regs.x.cx = regs.x.dx = 0;  /* move 0 bytes (i.e., stay put) */
  78     __dpmi_int(0x21, &regs);
  79     if (regs.x.flags & 1)
  80     {
  81       errno = __doserr_to_errno(regs.x.ax);
  82       return 0;
  83     }
  84     fpos_high = regs.x.dx;      /* got current position */
  85     fpos_low  = regs.x.ax;
  86
  87     regs.x.ax = 0x4200;         /* set pointer from the beginning of file */
  88     regs.x.cx = regs.x.dx = 0;  /* move to beginning of file */
  89     __dpmi_int(0x21, &regs);
  90     if (regs.x.flags & 1)
  91     {
  92       errno = __doserr_to_errno(regs.x.ax);
  93       return 0;
  94     }
  95   }
  96   regs.x.ds = __tb_segment;
  97   regs.x.dx = __tb_offset;
  98
  99   /* Read 2 bytes from the file. */
 100   regs.x.ax = 0x3f00;
 101   regs.x.cx = 2;
 102   __dpmi_int(0x21, &regs);
 103
 104   /* We can either (1) succeed, (2) read less than 2 bytes,
 105      or (3) fail to read at all.  */
 106   if (regs.x.ax != 2)
 107     read_fail = (regs.x.flags & 1) ? regs.x.ax : -1;
 108
 109   /* If called with filename, close the file. */
 110   if (s)
 111   {
 112     regs.x.ax = 0x3e00;
 113     __dpmi_int(0x21, &regs);
 114     if (regs.x.flags & 1)
 115       errno = __doserr_to_errno(regs.x.ax);
 116   }
 117   /* Else leave file pointer where we found it. */
 118   else
 119   {
 120     regs.x.ax = 0x4200;         /* set pointer from the beginning of file */
 121     regs.x.bx = fh;
 122     regs.x.cx = fpos_high;
 123     regs.x.dx = fpos_low;
 124     __dpmi_int(0x21, &regs);
 125     if (regs.x.flags & 1)
 126     {
 127       errno = __doserr_to_errno(regs.x.ax);
 128       return 0;
 129     }
 130   }
 131
 132   if (read_fail == 0)
 133     retval = _farpeekw(_dos_ds, __tb);
 134   else
 135   {
 136     /* The file couldn't be read: assume non-executable.  If the file
 137        *is* executable, but was passed as a file-handle, and the user
 138        opened it in write-only mode, they lose...  */
 139     retval = 0;
 140     if (read_fail != -1)
 141       errno = __doserr_to_errno(read_fail);
 142   }
 143
 144   return retval;
 145 }
 146
 147 /* A list of extensions which designate executable files.  These
 148    are NOT tested for the magic number.  */
 149 static char executables[] = "|EXE|COM|BAT|BTM|DLL|VXD|";
 150
 151 /* A list of extensions which belong to files known to NEVER be
 152    executables.  These exist to minimize read()'ing files while
 153    detecting executables by magic number.  You are welcome to
 154    add to this list, but remember: only extensions which could
 155    NEVER be present in executables should go here.  */
 156 static char non_executables[] = "\
 157 |A|A01|A02|A03|A04|A05|ADL|ARC|ARJ|ASC|ASM|AUX|AWK\
 158 |BAS|BIB|BGI|BMP\
 159 |C|CC|CFG|CGZ|CH3|CHR|CI|CLP|CMF|CPI|CPP|CXX\
 160 |DAT|DBF|DIZ|DOC|DVI\
 161 |E|EL|ELC\
 162 |F77|FN3\
 163 |GIF|GZ\
 164 |H|HLP|HPP|HXX\
 165 |ICO|IN|INC|INF|INI\
 166 |JPG\
 167 |L|LEX|LF|LIB|LOG|LST|LZH\
 168 |M|MAK|MAP|MF|MID|MPG\
 169 |O|OBJ\
 170 |PAK|PAS|PBM|PCD|PCX|PDS|PIC|PIF|PN3|PRJ|PS\
 171 |RAS|RGB|RLE\
 172 |S|SND|SY3\
 173 |TAR|TAZ|TEX|TGA|TGZ|TIF|TXH|TXI|TXT\
 174 |VOC\
 175 |WAV|WK1|WK3|WKB|WQ1|WQ3|WQ4|WQ5|WQ6|WQ!\
 176 |XBM\
 177 |Y\
 178 |ZIP|ZOO|";
 179
 180 int
 181 _is_executable(const char *filename, int fhandle, const char *extension)
 182 {
 183   if (!extension && filename)
 184   {
 185     const char *cp, *ep=0;
 186     for (cp=filename; *cp; cp++)
 187     {
 188       if (*cp == '.')
 189         ep = cp;
 190       if (*cp == '/' || *cp == '\\' || *cp == ':')
 191         ep = 0;
 192     }
 193     extension = ep;
 194   }
 195   if ((_djstat_flags & _STAT_EXEC_EXT) == 0
 196       && extension
 197       && *extension
 198       && strlen(extension) <= ((extension[0]=='.') ? 4 : 3))
 199     {
 200       /* Search the list of extensions in executables[]. */
 201       char tmp_buf[6], *tp = tmp_buf;
 202
 203       *tp++ = '|';
 204       if (*extension == '.')
 205         extension++;
 206       while (*extension)
 207         *tp++ = toupper (*extension++);
 208       *tp++ = '|';
 209       *tp = '\0';
 210       if (strstr(non_executables, tmp_buf))
 211         return 0;
 212       else if (strstr(executables, tmp_buf))
 213         return 1;
 214     }
 215
 216   /* No extension, or extension doesn't define execute
 217      bits unambiguously.  We are in for some dirty work.
 218      Read the first two bytes of the file and see if they
 219      are any of the known magic numbers which designate
 220      executable files.
 221      Unix-like shells, which have executable shell scripts
 222      without extensions and DON'T have "#!" as their FIRST
 223      TWO CHARACTERS, lose here.  Sorry, folks.  */
 224   if ( (_djstat_flags & _STAT_EXEC_MAGIC) == 0 )
 225     {
 226       switch (_get_magic(filename, fhandle))
 227         {
 228           case 0x5a4d:      /* "MZ" */
 229           case 0x010b:
 230           case 0x014c:
 231           case 0x2123:      /* "#!" */
 232               return 1;
 233         }
 234     }
 235
 236   return 0;
 237 }
 238