Commit | Line | Data |
---|---|---|
a4a9692d DL |
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, ®s); | |
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, ®s); | |
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, ®s); | |
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, ®s); | |
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, ®s); | |
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 | } |