1 /* 2 * Copryight 1997 Sean Eric Fagan 3 * 4 * Redistribution and use in source and binary forms, with or without 5 * modification, are permitted provided that the following conditions 6 * are met: 7 * 1. Redistributions of source code must retain the above copyright 8 * notice, this list of conditions and the following disclaimer. 9 * 2. Redistributions in binary form must reproduce the above copyright 10 * notice, this list of conditions and the following disclaimer in the 11 * documentation and/or other materials provided with the distribution. 12 * 3. All advertising materials mentioning features or use of this software 13 * must display the following acknowledgement: 14 * This product includes software developed by Sean Eric Fagan 15 * 4. Neither the name of the author may be used to endorse or promote 16 * products derived from this software without specific prior written 17 * permission. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 22 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 29 * SUCH DAMAGE. 30 */ 31 32 #ifndef lint 33 static const char rcsid[] = 34 "$FreeBSD$"; 35 #endif /* not lint */ 36 37 /* 38 * This file has routines used to print out system calls and their 39 * arguments. 40 */ 41 42 #include <err.h> 43 #include <stdio.h> 44 #include <stdlib.h> 45 #include <string.h> 46 #include <unistd.h> 47 #include <sys/types.h> 48 #include <signal.h> 49 #include "syscall.h" 50 51 /* 52 * This should probably be in its own file. 53 */ 54 55 struct syscall syscalls[] = { 56 { "readlink", 1, 3, 57 { { String, 0 } , { String | OUT, 1 }, { Int, 2 }}}, 58 { "lseek", 2, 3, 59 { { Int, 0 }, {Quad, 2 }, { Int, 4 }}}, 60 { "mmap", 2, 6, 61 { { Hex, 0 }, {Int, 1}, {Hex, 2}, {Hex, 3}, {Int, 4}, {Quad, 6}}}, 62 { "open", 1, 3, 63 { { String | IN, 0} , { Int, 1}, {Octal, 2}}}, 64 { "linux_open", 1, 3, 65 { { String, 0 }, { Int, 1}, { Octal, 2 }}}, 66 { "close", 1, 1, { { Int, 0 } } }, 67 { "fstat", 1, 2, 68 { { Int, 0}, {Ptr | OUT , 1 }}}, 69 { "stat", 1, 2, 70 { { String | IN, 0 }, { Ptr | OUT, 1 }}}, 71 { "lstat", 1, 2, 72 { { String | IN, 0 }, { Ptr | OUT, 1 }}}, 73 { "linux_newstat", 1, 2, 74 { { String | IN, 0 }, { Ptr | OUT, 1 }}}, 75 { "linux_newfstat", 1, 2, 76 { { Int, 0 }, { Ptr | OUT, 1 }}}, 77 { "write", 1, 3, 78 { { Int, 0}, { Ptr | IN, 1 }, { Int, 2 }}}, 79 { "ioctl", 1, 3, 80 { { Int, 0}, { Ioctl, 1 }, { Hex, 2 }}}, 81 { "break", 1, 1, { { Hex, 0 }}}, 82 { "exit", 0, 1, { { Hex, 0 }}}, 83 { "access", 1, 2, { { String | IN, 0 }, { Int, 1 }}}, 84 { "sigaction", 1, 3, 85 { { Signal, 0 }, { Ptr | IN, 1 }, { Ptr | OUT, 2 }}}, 86 { 0, 0, 0, { { 0, 0 }}}, 87 }; 88 89 char * ioctlname __P((int)); 90 91 /* 92 * If/when the list gets big, it might be desirable to do it 93 * as a hash table or binary search. 94 */ 95 96 struct syscall * 97 get_syscall(const char *name) { 98 struct syscall *sc = syscalls; 99 100 while (sc->name) { 101 if (!strcmp(name, sc->name)) 102 return sc; 103 sc++; 104 } 105 return NULL; 106 } 107 108 /* 109 * get_string 110 * Copy a string from the process. Note that it is 111 * expected to be a C string, but if max is set, it will 112 * only get that much. 113 */ 114 115 char * 116 get_string(int procfd, void *offset, int max) { 117 char *buf; 118 int size, len, c, fd; 119 FILE *p; 120 121 if ((fd = dup(procfd)) == -1) 122 err(1, "dup"); 123 if ((p = fdopen(fd, "r")) == NULL) 124 err(1, "fdopen"); 125 buf = malloc( size = (max ? max : 64 ) ); 126 len = 0; 127 buf[0] = 0; 128 fseek(p, (long)offset, SEEK_SET); 129 while ((c = fgetc(p)) != EOF) { 130 buf[len++] = c; 131 if (c == 0 || len == max) { 132 buf[len] = 0; 133 break; 134 } 135 if (len == size) { 136 char *tmp; 137 tmp = realloc(buf, size+64); 138 if (tmp == NULL) { 139 buf[len] = 0; 140 fclose(p); 141 return buf; 142 } 143 size += 64; 144 buf = tmp; 145 } 146 } 147 fclose(p); 148 return buf; 149 } 150 151 152 /* 153 * Gag. This is really unportable. Multiplication is more portable. 154 * But slower, from the code I saw. 155 */ 156 157 static long long 158 make_quad(unsigned long p1, unsigned long p2) { 159 union { 160 long long ll; 161 unsigned long l[2]; 162 } t; 163 t.l[0] = p1; 164 t.l[1] = p2; 165 return t.ll; 166 } 167 168 169 /* 170 * print_arg 171 * Converts a syscall argument into a string. Said string is 172 * allocated via malloc(), so needs to be free()'d. The file 173 * descriptor is for the process' memory (via /proc), and is used 174 * to get any data (where the argument is a pointer). sc is 175 * a pointer to the syscall description (see above); args is 176 * an array of all of the system call arguments. 177 */ 178 179 char * 180 print_arg(int fd, struct syscall_args *sc, unsigned long *args) { 181 char *tmp = NULL; 182 switch (sc->type & ARG_MASK) { 183 case Hex: 184 tmp = malloc(12); 185 sprintf(tmp, "0x%lx", args[sc->offset]); 186 break; 187 case Octal: 188 tmp = malloc(13); 189 sprintf(tmp, "0%lo", args[sc->offset]); 190 break; 191 case Int: 192 tmp = malloc(12); 193 sprintf(tmp, "%ld", args[sc->offset]); 194 break; 195 case String: 196 { 197 char *tmp2; 198 tmp2 = get_string(fd, (void*)args[sc->offset], 0); 199 tmp = malloc(strlen(tmp2) + 3); 200 sprintf(tmp, "\"%s\"", tmp2); 201 free(tmp2); 202 } 203 break; 204 case Quad: 205 { 206 unsigned long long t; 207 unsigned long l1, l2; 208 l1 = args[sc->offset]; 209 l2 = args[sc->offset+1]; 210 t = make_quad(l1, l2); 211 tmp = malloc(24); 212 sprintf(tmp, "0x%qx", t); 213 break; 214 } 215 case Ptr: 216 tmp = malloc(12); 217 sprintf(tmp, "0x%lx", args[sc->offset]); 218 break; 219 case Ioctl: 220 { 221 char *temp = ioctlname(args[sc->offset]); 222 if (temp) 223 tmp = strdup(temp); 224 else { 225 tmp = malloc(12); 226 sprintf(tmp, "0x%lx", args[sc->offset]); 227 } 228 } 229 break; 230 case Signal: 231 { 232 long sig; 233 234 sig = args[sc->offset]; 235 tmp = malloc(12); 236 if (sig > 0 && sig < NSIG) { 237 int i; 238 sprintf(tmp, "sig%s", sys_signame[sig]); 239 for (i = 0; tmp[i] != '\0'; ++i) 240 tmp[i] = toupper(tmp[i]); 241 } else { 242 sprintf(tmp, "%ld", sig); 243 } 244 } 245 break; 246 } 247 return tmp; 248 } 249 250 /* 251 * print_syscall 252 * Print (to outfile) the system call and its arguments. Note that 253 * nargs is the number of arguments (not the number of words; this is 254 * potentially confusing, I know). 255 */ 256 257 void 258 print_syscall(FILE *outfile, const char *name, int nargs, char **s_args) { 259 int i; 260 int len = 0; 261 len += fprintf(outfile, "%s(", name); 262 for (i = 0; i < nargs; i++) { 263 if (s_args[i]) 264 len += fprintf(outfile, "%s", s_args[i]); 265 else 266 len += fprintf(outfile, "<missing argument>"); 267 len += fprintf(outfile, "%s", i < (nargs - 1) ? "," : ""); 268 } 269 len += fprintf(outfile, ")"); 270 for (i = 0; i < 6 - (len / 8); i++) 271 fprintf(outfile, "\t"); 272 } 273 274 void 275 print_syscall_ret(FILE *outfile, const char *name, int nargs, char **s_args, int errorp, int retval) { 276 print_syscall(outfile, name, nargs, s_args); 277 if (errorp) { 278 fprintf(outfile, " ERR#%d '%s'\n", retval, strerror(retval)); 279 } else { 280 fprintf(outfile, " = %d (0x%x)\n", retval, retval); 281 } 282 } 283