msdos/is_exec.c

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