release/src/router/busybox/procps/fuser.c

   1 /* vi: set sw=4 ts=4: */
   2 /*
   3  * tiny fuser implementation
   4  *
   5  * Copyright 2004 Tony J. White
   6  *
   7  * Licensed under GPLv2, see file LICENSE in this source tree.
   8  */
   9
  10 //usage:#define fuser_trivial_usage
  11 //usage:       "[OPTIONS] FILE or PORT/PROTO"
  12 //usage:#define fuser_full_usage "\n\n"
  13 //usage:       "Find processes which use FILEs or PORTs\n"
  14 //usage:     "\n        -m      Find processes which use same fs as FILEs"
  15 //usage:     "\n        -4,-6   Search only IPv4/IPv6 space"
  16 //usage:     "\n        -s      Don't display PIDs"
  17 //usage:     "\n        -k      Kill found processes"
  18 //usage:     "\n        -SIGNAL Signal to send (default: KILL)"
  19
  20 #include "libbb.h"
  21 #include "common_bufsiz.h"
  22
  23 #define MAX_LINE 255
  24
  25 #define OPTION_STRING "mks64"
  26 enum {
  27         OPT_MOUNT  = (1 << 0),
  28         OPT_KILL   = (1 << 1),
  29         OPT_SILENT = (1 << 2),
  30         OPT_IP6    = (1 << 3),
  31         OPT_IP4    = (1 << 4),
  32 };
  33
  34 typedef struct inode_list {
  35         struct inode_list *next;
  36         ino_t inode;
  37         dev_t dev;
  38 } inode_list;
  39
  40 struct globals {
  41         int recursion_depth;
  42         pid_t mypid;
  43         inode_list *inode_list_head;
  44         smallint kill_failed;
  45         int killsig;
  46 } FIX_ALIASING;
  47 #define G (*(struct globals*)bb_common_bufsiz1)
  48 #define INIT_G() do { \
  49         setup_common_bufsiz(); \
  50         G.mypid = getpid(); \
  51         G.killsig = SIGKILL; \
  52 } while (0)
  53
  54 static void add_inode(const struct stat *st)
  55 {
  56         inode_list **curr = &G.inode_list_head;
  57
  58         while (*curr) {
  59                 if ((*curr)->dev == st->st_dev
  60                  && (*curr)->inode == st->st_ino
  61                 ) {
  62                         return;
  63                 }
  64                 curr = &(*curr)->next;
  65         }
  66
  67         *curr = xzalloc(sizeof(inode_list));
  68         (*curr)->dev = st->st_dev;
  69         (*curr)->inode = st->st_ino;
  70 }
  71
  72 static smallint search_dev_inode(const struct stat *st)
  73 {
  74         inode_list *ilist = G.inode_list_head;
  75
  76         while (ilist) {
  77                 if (ilist->dev == st->st_dev) {
  78                         if (option_mask32 & OPT_MOUNT)
  79                                 return 1;
  80                         if (ilist->inode == st->st_ino)
  81                                 return 1;
  82                 }
  83                 ilist = ilist->next;
  84         }
  85         return 0;
  86 }
  87
  88 enum {
  89         PROC_NET = 0,
  90         PROC_DIR,
  91         PROC_DIR_LINKS,
  92         PROC_SUBDIR_LINKS,
  93 };
  94
  95 static smallint scan_proc_net_or_maps(const char *path, unsigned port)
  96 {
  97         FILE *f;
  98         char line[MAX_LINE + 1], addr[68];
  99         int major, minor, r;
 100         long long uint64_inode;
 101         unsigned tmp_port;
 102         smallint retval;
 103         struct stat statbuf;
 104         const char *fmt;
 105         void *fag, *sag;
 106
 107         f = fopen_for_read(path);
 108         if (!f)
 109                 return 0;
 110
 111         if (G.recursion_depth == PROC_NET) {
 112                 int fd;
 113
 114                 /* find socket dev */
 115                 statbuf.st_dev = 0;
 116                 fd = socket(AF_INET, SOCK_DGRAM, 0);
 117                 if (fd >= 0) {
 118                         fstat(fd, &statbuf);
 119                         close(fd);
 120                 }
 121
 122                 fmt = "%*d: %64[0-9A-Fa-f]:%x %*x:%*x %*x "
 123                         "%*x:%*x %*x:%*x %*x %*d %*d %llu";
 124                 fag = addr;
 125                 sag = &tmp_port;
 126         } else {
 127                 fmt = "%*s %*s %*s %x:%x %llu";
 128                 fag = &major;
 129                 sag = &minor;
 130         }
 131
 132         retval = 0;
 133         while (fgets(line, MAX_LINE, f)) {
 134                 r = sscanf(line, fmt, fag, sag, &uint64_inode);
 135                 if (r != 3)
 136                         continue;
 137
 138                 statbuf.st_ino = uint64_inode;
 139                 if (G.recursion_depth == PROC_NET) {
 140                         r = strlen(addr);
 141                         if (r == 8 && (option_mask32 & OPT_IP6))
 142                                 continue;
 143                         if (r > 8 && (option_mask32 & OPT_IP4))
 144                                 continue;
 145                         if (tmp_port == port)
 146                                 add_inode(&statbuf);
 147                 } else {
 148                         if (major != 0 && minor != 0 && statbuf.st_ino != 0) {
 149                                 statbuf.st_dev = makedev(major, minor);
 150                                 retval = search_dev_inode(&statbuf);
 151                                 if (retval)
 152                                         break;
 153                         }
 154                 }
 155         }
 156         fclose(f);
 157
 158         return retval;
 159 }
 160
 161 static smallint scan_recursive(const char *path)
 162 {
 163         DIR *d;
 164         struct dirent *d_ent;
 165         smallint stop_scan;
 166         smallint retval;
 167
 168         d = opendir(path);
 169         if (d == NULL)
 170                 return 0;
 171
 172         G.recursion_depth++;
 173         retval = 0;
 174         stop_scan = 0;
 175         while (!stop_scan && (d_ent = readdir(d)) != NULL) {
 176                 struct stat statbuf;
 177                 pid_t pid;
 178                 char *subpath;
 179
 180                 subpath = concat_subpath_file(path, d_ent->d_name);
 181                 if (subpath == NULL)
 182                         continue; /* . or .. */
 183
 184                 switch (G.recursion_depth) {
 185                 case PROC_DIR:
 186                         pid = (pid_t)bb_strtou(d_ent->d_name, NULL, 10);
 187                         if (errno != 0
 188                          || pid == G.mypid
 189                         /* "this PID doesn't use specified FILEs or PORT/PROTO": */
 190                          || scan_recursive(subpath) == 0
 191                         ) {
 192                                 break;
 193                         }
 194                         if (option_mask32 & OPT_KILL) {
 195                                 if (kill(pid, G.killsig) != 0) {
 196                                         bb_perror_msg("kill pid %s", d_ent->d_name);
 197                                         G.kill_failed = 1;
 198                                 }
 199                         }
 200                         if (!(option_mask32 & OPT_SILENT))
 201                                 printf("%s ", d_ent->d_name);
 202                         retval = 1;
 203                         break;
 204
 205                 case PROC_DIR_LINKS:
 206                         switch (
 207                                 index_in_substrings(
 208                                         "cwd"  "\0" "exe"  "\0"
 209                                         "root" "\0" "fd"   "\0"
 210                                         "lib"  "\0" "mmap" "\0"
 211                                         "maps" "\0",
 212                                         d_ent->d_name
 213                                 )
 214                         ) {
 215                         enum {
 216                                 CWD_LINK,
 217                                 EXE_LINK,
 218                                 ROOT_LINK,
 219                                 FD_DIR_LINKS,
 220                                 LIB_DIR_LINKS,
 221                                 MMAP_DIR_LINKS,
 222                                 MAPS,
 223                         };
 224                         case CWD_LINK:
 225                         case EXE_LINK:
 226                         case ROOT_LINK:
 227                                 goto scan_link;
 228                         case FD_DIR_LINKS:
 229                         case LIB_DIR_LINKS:
 230                         case MMAP_DIR_LINKS:
 231                                 stop_scan = scan_recursive(subpath);
 232                                 if (stop_scan)
 233                                         retval = stop_scan;
 234                                 break;
 235                         case MAPS:
 236                                 stop_scan = scan_proc_net_or_maps(subpath, 0);
 237                                 if (stop_scan)
 238                                         retval = stop_scan;
 239                         default:
 240                                 break;
 241                         }
 242                         break;
 243                 case PROC_SUBDIR_LINKS:
 244   scan_link:
 245                         if (stat(subpath, &statbuf) < 0)
 246                                 break;
 247                         stop_scan = search_dev_inode(&statbuf);
 248                         if (stop_scan)
 249                                 retval = stop_scan;
 250                 default:
 251                         break;
 252                 }
 253                 free(subpath);
 254         }
 255         closedir(d);
 256         G.recursion_depth--;
 257         return retval;
 258 }
 259
 260 int fuser_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
 261 int fuser_main(int argc UNUSED_PARAM, char **argv)
 262 {
 263         char **pp;
 264
 265         INIT_G();
 266
 267         /* Handle -SIGNAL. Oh my... */
 268         pp = argv;
 269         while (*++pp) {
 270                 int sig;
 271                 char *arg = *pp;
 272
 273                 if (arg[0] != '-')
 274                         continue;
 275                 if (arg[1] == '-' && arg[2] == '\0') /* "--" */
 276                         break;
 277                 if ((arg[1] == '4' || arg[1] == '6') && arg[2] == '\0')
 278                         continue; /* it's "-4" or "-6" */
 279                 sig = get_signum(&arg[1]);
 280                 if (sig < 0)
 281                         continue;
 282                 /* "-SIGNAL" option found. Remove it and bail out */
 283                 G.killsig = sig;
 284                 do {
 285                         pp[0] = arg = pp[1];
 286                         pp++;
 287                 } while (arg);
 288                 break;
 289         }
 290
 291         opt_complementary = "-1"; /* at least one param */
 292         getopt32(argv, OPTION_STRING);
 293         argv += optind;
 294
 295         pp = argv;
 296         while (*pp) {
 297                 /* parse net arg */
 298                 unsigned port;
 299                 char path[sizeof("/proc/net/TCP6")];
 300
 301                 strcpy(path, "/proc/net/");
 302                 if (sscanf(*pp, "%u/%4s", &port, path + sizeof("/proc/net/")-1) == 2
 303                  && access(path, R_OK) == 0
 304                 ) {
 305                         /* PORT/PROTO */
 306                         scan_proc_net_or_maps(path, port);
 307                 } else {
 308                         /* FILE */
 309                         struct stat statbuf;
 310                         xstat(*pp, &statbuf);
 311                         add_inode(&statbuf);
 312                 }
 313                 pp++;
 314         }
 315
 316         if (scan_recursive("/proc")) {
 317                 if (!(option_mask32 & OPT_SILENT))
 318                         bb_putchar('\n');
 319                 return G.kill_failed;
 320         }
 321
 322         return EXIT_FAILURE;
 323 }