granicus.if.org Git - strace/blob - uid.c

   1 #ifdef STRACE_UID_SIZE
   2 # if STRACE_UID_SIZE != 16
   3 #  error invalid STRACE_UID_SIZE
   4 # endif
   5
   6 # define SIZEIFY(x)             SIZEIFY_(x,STRACE_UID_SIZE)
   7 # define SIZEIFY_(x,size)       SIZEIFY__(x,size)
   8 # define SIZEIFY__(x,size)      x ## size
   9
  10 # define printuid       SIZEIFY(printuid)
  11 # define sys_chown      SIZEIFY(sys_chown)
  12 # define sys_fchown     SIZEIFY(sys_fchown)
  13 # define sys_getgroups  SIZEIFY(sys_getgroups)
  14 # define sys_getresuid  SIZEIFY(sys_getresuid)
  15 # define sys_getuid     SIZEIFY(sys_getuid)
  16 # define sys_setfsuid   SIZEIFY(sys_setfsuid)
  17 # define sys_setgroups  SIZEIFY(sys_setgroups)
  18 # define sys_setresuid  SIZEIFY(sys_setresuid)
  19 # define sys_setreuid   SIZEIFY(sys_setreuid)
  20 # define sys_setuid     SIZEIFY(sys_setuid)
  21 #endif /* STRACE_UID_SIZE */
  22
  23 #include "defs.h"
  24
  25 #ifdef STRACE_UID_SIZE
  26 # if !NEED_UID16_PARSERS
  27 #  undef STRACE_UID_SIZE
  28 # endif
  29 #else
  30 # define STRACE_UID_SIZE 32
  31 #endif
  32
  33 #ifdef STRACE_UID_SIZE
  34
  35 # undef uid_t
  36 # define uid_t          uid_t_(STRACE_UID_SIZE)
  37 # define uid_t_(size)   uid_t__(size)
  38 # define uid_t__(size)  uint ## size ## _t
  39
  40 SYS_FUNC(getuid)
  41 {
  42         if (exiting(tcp))
  43                 tcp->u_rval = (uid_t) tcp->u_rval;
  44         return RVAL_UDECIMAL;
  45 }
  46
  47 SYS_FUNC(setfsuid)
  48 {
  49         if (entering(tcp))
  50                 tprintf("%u", (uid_t) tcp->u_arg[0]);
  51         else
  52                 tcp->u_rval = (uid_t) tcp->u_rval;
  53         return RVAL_UDECIMAL;
  54 }
  55
  56 SYS_FUNC(setuid)
  57 {
  58         printuid("", tcp->u_arg[0]);
  59
  60         return RVAL_DECODED;
  61 }
  62
  63 static void
  64 get_print_uid(struct tcb *tcp, const char *prefix, const long addr)
  65 {
  66         uid_t uid;
  67
  68         tprints(prefix);
  69         if (!umove_or_printaddr(tcp, addr, &uid))
  70                 tprintf("[%u]", uid);
  71 }
  72
  73 SYS_FUNC(getresuid)
  74 {
  75         if (entering(tcp))
  76                 return 0;
  77
  78         get_print_uid(tcp, "", tcp->u_arg[0]);
  79         get_print_uid(tcp, ", ", tcp->u_arg[1]);
  80         get_print_uid(tcp, ", ", tcp->u_arg[2]);
  81
  82         return 0;
  83 }
  84
  85 SYS_FUNC(setreuid)
  86 {
  87         printuid("", tcp->u_arg[0]);
  88         printuid(", ", tcp->u_arg[1]);
  89
  90         return RVAL_DECODED;
  91 }
  92
  93 SYS_FUNC(setresuid)
  94 {
  95         printuid("", tcp->u_arg[0]);
  96         printuid(", ", tcp->u_arg[1]);
  97         printuid(", ", tcp->u_arg[2]);
  98
  99         return RVAL_DECODED;
 100 }
 101
 102 SYS_FUNC(chown)
 103 {
 104         printpath(tcp, tcp->u_arg[0]);
 105         printuid(", ", tcp->u_arg[1]);
 106         printuid(", ", tcp->u_arg[2]);
 107
 108         return RVAL_DECODED;
 109 }
 110
 111 SYS_FUNC(fchown)
 112 {
 113         printfd(tcp, tcp->u_arg[0]);
 114         printuid(", ", tcp->u_arg[1]);
 115         printuid(", ", tcp->u_arg[2]);
 116
 117         return RVAL_DECODED;
 118 }
 119
 120 void
 121 printuid(const char *text, const unsigned int uid)
 122 {
 123         if ((unsigned int) -1 == uid || (uid_t) -1 == uid)
 124                 tprintf("%s-1", text);
 125         else
 126                 tprintf("%s%u", text, uid);
 127 }
 128
 129 SYS_FUNC(setgroups)
 130 {
 131         unsigned long cur, abbrev_end;
 132         uid_t gid;
 133         int failed = 0;
 134         const unsigned long len = tcp->u_arg[0];
 135         const unsigned long start = tcp->u_arg[1];
 136         const unsigned long size = len * sizeof(gid);
 137         const unsigned long end = start + size;
 138
 139         tprintf("%lu, ", len);
 140         if (len == 0) {
 141                 tprints("[]");
 142                 return RVAL_DECODED;
 143         }
 144         if (!start || !verbose(tcp) ||
 145             size / sizeof(gid) != len || end < start) {
 146                 printaddr(start);
 147                 return RVAL_DECODED;
 148         }
 149         if (abbrev(tcp)) {
 150                 abbrev_end = start + max_strlen * sizeof(gid);
 151                 if (abbrev_end < start)
 152                         abbrev_end = end;
 153         } else {
 154                 abbrev_end = end;
 155         }
 156         tprints("[");
 157         for (cur = start; cur < end; cur += sizeof(gid)) {
 158                 if (cur > start)
 159                         tprints(", ");
 160                 if (cur >= abbrev_end) {
 161                         tprints("...");
 162                         break;
 163                 }
 164                 if (umoven(tcp, cur, sizeof(gid), &gid) < 0) {
 165                         tprints("?");
 166                         failed = 1;
 167                         break;
 168                 }
 169                 tprintf("%u", (unsigned int) gid);
 170         }
 171         tprints("]");
 172         if (failed) {
 173                 tprints(" ");
 174                 printaddr(start);
 175         }
 176
 177         return RVAL_DECODED;
 178 }
 179
 180 SYS_FUNC(getgroups)
 181 {
 182         if (entering(tcp)) {
 183                 tprintf("%lu, ", tcp->u_arg[0]);
 184         } else {
 185                 unsigned long cur, abbrev_end;
 186                 uid_t gid;
 187                 int failed = 0;
 188                 const unsigned long len = tcp->u_rval;
 189                 const unsigned long size = len * sizeof(gid);
 190                 const unsigned long start = tcp->u_arg[1];
 191                 const unsigned long end = start + size;
 192
 193                 if (!start) {
 194                         printaddr(start);
 195                         return 0;
 196                 }
 197                 if (len == 0) {
 198                         tprints("[]");
 199                         return 0;
 200                 }
 201                 if (!verbose(tcp) || syserror(tcp) ||
 202                     size / sizeof(gid) != len || end < start) {
 203                         printaddr(start);
 204                         return 0;
 205                 }
 206                 if (abbrev(tcp)) {
 207                         abbrev_end = start + max_strlen * sizeof(gid);
 208                         if (abbrev_end < start)
 209                                 abbrev_end = end;
 210                 } else {
 211                         abbrev_end = end;
 212                 }
 213                 tprints("[");
 214                 for (cur = start; cur < end; cur += sizeof(gid)) {
 215                         if (cur > start)
 216                                 tprints(", ");
 217                         if (cur >= abbrev_end) {
 218                                 tprints("...");
 219                                 break;
 220                         }
 221                         if (umoven(tcp, cur, sizeof(gid), &gid) < 0) {
 222                                 tprints("?");
 223                                 failed = 1;
 224                                 break;
 225                         }
 226                         tprintf("%u", (unsigned int) gid);
 227                 }
 228                 tprints("]");
 229                 if (failed) {
 230                         tprints(" ");
 231                         printaddr(start);
 232                 }
 233         }
 234         return 0;
 235 }
 236
 237 #endif /* STRACE_UID_SIZE */