usr.bin/truss/syscalls.c

   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  * $FreeBSD: src/usr.bin/truss/syscalls.c,v 1.10.2.6 2003/04/14 18:24:38 mdodd Exp $
  32  * $DragonFly: src/usr.bin/truss/syscalls.c,v 1.2 2003/06/17 04:29:33 dillon Exp $
  33  */
  34
  35 /*
  36  * This file has routines used to print out system calls and their
  37  * arguments.
  38  */
  39
  40 #include <sys/types.h>
  41 #include <sys/socket.h>
  42 #include <sys/un.h>
  43 #include <netinet/in.h>
  44 #include <arpa/inet.h>
  45
  46 #include <ctype.h>
  47 #include <err.h>
  48 #include <signal.h>
  49 #include <stdio.h>
  50 #include <stdlib.h>
  51 #include <string.h>
  52 #include <unistd.h>
  53
  54 #include "truss.h"
  55 #include "extern.h"
  56 #include "syscall.h"
  57
  58 /*
  59  * This should probably be in its own file.
  60  */
  61
  62 struct syscall syscalls[] = {
  63         { "readlink", 1, 3,
  64           { { String, 0 } , { String | OUT, 1 }, { Int, 2 }}},
  65         { "lseek", 2, 3,
  66           { { Int, 0 }, {Quad, 2 }, { Int, 4 }}},
  67         { "mmap", 2, 6,
  68           { { Hex, 0 }, {Int, 1}, {Hex, 2}, {Hex, 3}, {Int, 4}, {Quad, 6}}},
  69         { "open", 1, 3,
  70           { { String | IN, 0} , { Hex, 1}, {Octal, 2}}},
  71         { "linux_open", 1, 3,
  72           { { String, 0 }, { Hex, 1}, { Octal, 2 }}},
  73         { "close", 1, 1, { { Int, 0 } } },
  74         { "fstat", 1, 2,
  75           { { Int, 0},  {Ptr | OUT , 1 }}},
  76         { "stat", 1, 2,
  77           { { String | IN, 0 }, { Ptr | OUT, 1 }}},
  78         { "lstat", 1, 2,
  79           { { String | IN, 0 }, { Ptr | OUT, 1 }}},
  80         { "linux_newstat", 1, 2,
  81           { { String | IN, 0 }, { Ptr | OUT, 1 }}},
  82         { "linux_newfstat", 1, 2,
  83           { { Int, 0 }, { Ptr | OUT, 1 }}},
  84         { "write", 1, 3,
  85           { { Int, 0}, { Ptr | IN, 1 }, { Int, 2 }}},
  86         { "ioctl", 1, 3,
  87           { { Int, 0}, { Ioctl, 1 }, { Hex, 2 }}},
  88         { "break", 1, 1, { { Hex, 0 }}},
  89         { "exit", 0, 1, { { Hex, 0 }}},
  90         { "access", 1, 2, { { String | IN, 0 }, { Int, 1 }}},
  91         { "sigaction", 1, 3,
  92           { { Signal, 0 }, { Ptr | IN, 1 }, { Ptr | OUT, 2 }}},
  93         { "accept", 1, 3,
  94           { { Hex, 0 }, { Sockaddr | OUT, 1 }, { Ptr | OUT, 2 } } },
  95         { "bind", 1, 3,
  96           { { Hex, 0 }, { Sockaddr | IN, 1 }, { Int, 2 } } },
  97         { "connect", 1, 3,
  98           { { Hex, 0 }, { Sockaddr | IN, 1 }, { Int, 2 } } },
  99         { "getpeername", 1, 3,
 100           { { Hex, 0 }, { Sockaddr | OUT, 1 }, { Ptr | OUT, 2 } } },
 101         { "getsockname", 1, 3,
 102           { { Hex, 0 }, { Sockaddr | OUT, 1 }, { Ptr | OUT, 2 } } },
 103         { 0, 0, 0, { { 0, 0 }}},
 104 };
 105
 106 /*
 107  * If/when the list gets big, it might be desirable to do it
 108  * as a hash table or binary search.
 109  */
 110
 111 struct syscall *
 112 get_syscall(const char *name) {
 113         struct syscall *sc = syscalls;
 114
 115         while (sc->name) {
 116                 if (!strcmp(name, sc->name))
 117                         return sc;
 118                 sc++;
 119         }
 120         return NULL;
 121 }
 122
 123 /*
 124  * get_struct
 125  *
 126  * Copy a fixed amount of bytes from the process.
 127  */
 128
 129 static int
 130 get_struct(int procfd, void *offset, void *buf, int len) {
 131         char *pos;
 132         FILE *p;
 133         int c, fd;
 134
 135         if ((fd = dup(procfd)) == -1)
 136                 err(1, "dup");
 137         if ((p = fdopen(fd, "r")) == NULL)
 138                 err(1, "fdopen");
 139         fseeko(p, (uintptr_t)offset, SEEK_SET);
 140         for (pos = (char *)buf; len--; pos++) {
 141                 if ((c = fgetc(p)) == EOF)
 142                         return -1;
 143                 *pos = c;
 144         }
 145         fclose(p);
 146         return 0;
 147 }
 148
 149 /*
 150  * get_string
 151  * Copy a string from the process.  Note that it is
 152  * expected to be a C string, but if max is set, it will
 153  * only get that much.
 154  */
 155
 156 char *
 157 get_string(int procfd, void *offset, int max) {
 158         char *buf;
 159         int size, len, c, fd;
 160         FILE *p;
 161
 162         if ((fd = dup(procfd)) == -1)
 163                 err(1, "dup");
 164         if ((p = fdopen(fd, "r")) == NULL)
 165                 err(1, "fdopen");
 166         buf = malloc( size = (max ? max : 64 ) );
 167         len = 0;
 168         buf[0] = 0;
 169         fseeko(p, (uintptr_t)offset, SEEK_SET);
 170         while ((c = fgetc(p)) != EOF) {
 171                 buf[len++] = c;
 172                 if (c == 0 || len == max) {
 173                         buf[len] = 0;
 174                         break;
 175                 }
 176                 if (len == size) {
 177                         char *tmp;
 178                         tmp = realloc(buf, size+64);
 179                         if (tmp == NULL) {
 180                                 buf[len] = 0;
 181                                 fclose(p);
 182                                 return buf;
 183                         }
 184                         size += 64;
 185                         buf = tmp;
 186                 }
 187         }
 188         fclose(p);
 189         return buf;
 190 }
 191
 192
 193 /*
 194  * Gag.  This is really unportable.  Multiplication is more portable.
 195  * But slower, from the code I saw.
 196  */
 197
 198 static long long
 199 make_quad(unsigned long p1, unsigned long p2) {
 200   union {
 201     long long ll;
 202     unsigned long l[2];
 203   } t;
 204   t.l[0] = p1;
 205   t.l[1] = p2;
 206   return t.ll;
 207 }
 208
 209
 210 /*
 211  * print_arg
 212  * Converts a syscall argument into a string.  Said string is
 213  * allocated via malloc(), so needs to be free()'d.  The file
 214  * descriptor is for the process' memory (via /proc), and is used
 215  * to get any data (where the argument is a pointer).  sc is
 216  * a pointer to the syscall description (see above); args is
 217  * an array of all of the system call arguments.
 218  */
 219
 220 char *
 221 print_arg(int fd, struct syscall_args *sc, unsigned long *args) {
 222   char *tmp = NULL;
 223   switch (sc->type & ARG_MASK) {
 224   case Hex:
 225     tmp = malloc(12);
 226     sprintf(tmp, "0x%lx", args[sc->offset]);
 227     break;
 228   case Octal:
 229     tmp = malloc(13);
 230     sprintf(tmp, "0%lo", args[sc->offset]);
 231     break;
 232   case Int:
 233     tmp = malloc(12);
 234     sprintf(tmp, "%ld", args[sc->offset]);
 235     break;
 236   case String:
 237     {
 238       char *tmp2;
 239       tmp2 = get_string(fd, (void*)args[sc->offset], 0);
 240       tmp = malloc(strlen(tmp2) + 3);
 241       sprintf(tmp, "\"%s\"", tmp2);
 242       free(tmp2);
 243     }
 244   break;
 245   case Quad:
 246     {
 247       unsigned long long t;
 248       unsigned long l1, l2;
 249       l1 = args[sc->offset];
 250       l2 = args[sc->offset+1];
 251       t = make_quad(l1, l2);
 252       tmp = malloc(24);
 253       sprintf(tmp, "0x%qx", t);
 254       break;
 255     }
 256   case Ptr:
 257     tmp = malloc(12);
 258     sprintf(tmp, "0x%lx", args[sc->offset]);
 259     break;
 260   case Ioctl:
 261     {
 262       const char *temp = ioctlname(args[sc->offset]);
 263       if (temp)
 264         tmp = strdup(temp);
 265       else {
 266         tmp = malloc(12);
 267         sprintf(tmp, "0x%lx", args[sc->offset]);
 268       }
 269     }
 270     break;
 271   case Signal:
 272     {
 273       long sig;
 274
 275       sig = args[sc->offset];
 276       tmp = malloc(12);
 277       if (sig > 0 && sig < NSIG) {
 278         int i;
 279         sprintf(tmp, "sig%s", sys_signame[sig]);
 280         for (i = 0; tmp[i] != '\0'; ++i)
 281           tmp[i] = toupper(tmp[i]);
 282       } else {
 283         sprintf(tmp, "%ld", sig);
 284       }
 285     }
 286     break;
 287   case Sockaddr:
 288     {
 289       struct sockaddr_storage ss;
 290       char addr[64];
 291       struct sockaddr_in *lsin;
 292       struct sockaddr_in6 *lsin6;
 293       struct sockaddr_un *sun;
 294       struct sockaddr *sa;
 295       char *p;
 296       u_char *q;
 297       int i;
 298
 299       /* yuck: get ss_len */
 300       if (get_struct(fd, (void *)args[sc->offset], (void *)&ss,
 301         sizeof(ss.ss_len) + sizeof(ss.ss_family)) == -1)
 302         err(1, "get_struct %p", (void *)args[sc->offset]);
 303       /* sockaddr_un never have the length filled in! */
 304       if (ss.ss_family == AF_UNIX) {
 305         if (get_struct(fd, (void *)args[sc->offset], (void *)&ss,
 306           sizeof(*sun))
 307           == -1)
 308           err(2, "get_struct %p", (void *)args[sc->offset]);
 309       } else {
 310         if (get_struct(fd, (void *)args[sc->offset], (void *)&ss,
 311             ss.ss_len < sizeof(ss) ? ss.ss_len : sizeof(ss))
 312           == -1)
 313           err(2, "get_struct %p", (void *)args[sc->offset]);
 314       }
 315
 316       switch (ss.ss_family) {
 317       case AF_INET:
 318         lsin = (struct sockaddr_in *)&ss;
 319         inet_ntop(AF_INET, &lsin->sin_addr, addr, sizeof addr);
 320         asprintf(&tmp, "{ AF_INET %s:%d }", addr, htons(lsin->sin_port));
 321         break;
 322       case AF_INET6:
 323         lsin6 = (struct sockaddr_in6 *)&ss;
 324         inet_ntop(AF_INET6, &lsin6->sin6_addr, addr, sizeof addr);
 325         asprintf(&tmp, "{ AF_INET6 [%s]:%d }", addr, htons(lsin6->sin6_port));
 326         break;
 327       case AF_UNIX:
 328         sun = (struct sockaddr_un *)&ss;
 329         asprintf(&tmp, "{ AF_UNIX \"%s\" }", sun->sun_path);
 330         break;
 331       default:
 332         sa = (struct sockaddr *)&ss;
 333         asprintf(&tmp, "{ sa_len = %d, sa_family = %d, sa_data = {%n%*s } }",
 334           (int)sa->sa_len, (int)sa->sa_family, &i,
 335           6 * (int)(sa->sa_len - ((char *)&sa->sa_data - (char *)sa)), "");
 336         if (tmp != NULL) {
 337           p = tmp + i;
 338           for (q = (u_char *)&sa->sa_data; q < (u_char *)sa + sa->sa_len; q++)
 339             p += sprintf(p, " %#02x,", *q);
 340         }
 341       }
 342     }
 343     break;
 344   }
 345   return tmp;
 346 }
 347
 348 /*
 349  * print_syscall
 350  * Print (to trussinfo->outfile) the system call and its arguments.  Note that
 351  * nargs is the number of arguments (not the number of words; this is
 352  * potentially confusing, I know).
 353  */
 354
 355 void
 356 print_syscall(struct trussinfo *trussinfo, const char *name, int nargs, char **s_args) {
 357   int i;
 358   int len = 0;
 359   len += fprintf(trussinfo->outfile, "%s(", name);
 360   for (i = 0; i < nargs; i++) {
 361     if (s_args[i])
 362       len += fprintf(trussinfo->outfile, "%s", s_args[i]);
 363     else
 364       len += fprintf(trussinfo->outfile, "<missing argument>");
 365     len += fprintf(trussinfo->outfile, "%s", i < (nargs - 1) ? "," : "");
 366   }
 367   len += fprintf(trussinfo->outfile, ")");
 368   for (i = 0; i < 6 - (len / 8); i++)
 369         fprintf(trussinfo->outfile, "\t");
 370 }
 371
 372 void
 373 print_syscall_ret(struct trussinfo *trussinfo, const char *name, int nargs, char **s_args, int errorp, int retval) {
 374   print_syscall(trussinfo, name, nargs, s_args);
 375   if (errorp) {
 376     fprintf(trussinfo->outfile, " ERR#%d '%s'\n", retval, strerror(retval));
 377   } else {
 378     fprintf(trussinfo->outfile, " = %d (0x%x)\n", retval, retval);
 379   }
 380 }