procps/fuser.c

   1 /*
   2  * tiny fuser implementation
   3  *
   4  * Copyright 2004 Tony J. White
   5  *
   6  * May be distributed under the conditions of the
   7  * GNU Library General Public License
   8  */
   9
  10 #include <stdio.h>
  11 #include <stdlib.h>
  12 #include <unistd.h>
  13 #include <string.h>
  14 #include <limits.h>
  15 #include <dirent.h>
  16 #include <signal.h>
  17 #include <sys/types.h>
  18 #include <sys/ioctl.h>
  19 #include <sys/stat.h>
  20 #include <sys/socket.h>
  21 #include <sys/sysmacros.h>
  22 #include "busybox.h"
  23
  24 #define FUSER_PROC_DIR "/proc"
  25 #define FUSER_MAX_LINE 255
  26
  27 #define FUSER_OPT_MOUNT  1
  28 #define FUSER_OPT_KILL   2
  29 #define FUSER_OPT_SILENT 4
  30 #define FUSER_OPT_IP6    8
  31 #define FUSER_OPT_IP4    16
  32
  33 typedef struct inode_list {
  34         ino_t inode;
  35         dev_t dev;
  36         struct inode_list *next;
  37 } inode_list;
  38
  39 typedef struct pid_list {
  40         pid_t pid;
  41         struct pid_list *next;
  42 } pid_list;
  43
  44 static int fuser_option(char *option)
  45 {
  46         int opt = 0;
  47
  48         if(!(strlen(option))) return 0;
  49         if(option[0] != '-') return 0;
  50         ++option;
  51         while(*option != '\0') {
  52                 if(*option == 'm') opt |= FUSER_OPT_MOUNT;
  53                 else if(*option == 'k') opt |= FUSER_OPT_KILL;
  54                 else if(*option == 's') opt |= FUSER_OPT_SILENT;
  55                 else if(*option == '6') opt |= FUSER_OPT_IP6;
  56                 else if(*option == '4') opt |= FUSER_OPT_IP4;
  57                 else {
  58                         bb_error_msg_and_die(
  59                                 "Unsupported option '%c'", *option);
  60                 }
  61                 ++option;
  62         }
  63         return opt;
  64 }
  65
  66 static int fuser_file_to_dev_inode(const char *filename,
  67          dev_t *dev, ino_t *inode)
  68 {
  69         struct stat f_stat;
  70         if((stat(filename, &f_stat)) < 0) return 0;
  71         *inode = f_stat.st_ino;
  72         *dev = f_stat.st_dev;
  73         return 1;
  74 }
  75
  76 static int fuser_find_socket_dev(dev_t *dev)
  77 {
  78         int fd = socket(PF_INET, SOCK_DGRAM,0);
  79         struct stat buf;
  80
  81         if (fd >= 0 && (fstat(fd, &buf)) == 0) {
  82                 *dev =  buf.st_dev;
  83                 close(fd);
  84                 return 1;
  85         }
  86         return 0;
  87 }
  88
  89 static int fuser_parse_net_arg(const char *filename,
  90         const char **proto, int *port)
  91 {
  92         char path[sizeof(FUSER_PROC_DIR)+12], tproto[5];
  93
  94         if((sscanf(filename, "%d/%4s", port, tproto)) != 2) return 0;
  95         sprintf(path, "%s/net/%s", FUSER_PROC_DIR, tproto);
  96         if((access(path, R_OK)) != 0) return 0;
  97         *proto = bb_xstrdup(tproto);
  98         return 1;
  99 }
 100
 101 static int fuser_add_pid(pid_list *plist, pid_t pid)
 102 {
 103         pid_list *curr = NULL, *last = NULL;
 104
 105         if(plist->pid == 0) plist->pid = pid;
 106         curr = plist;
 107         while(curr != NULL) {
 108                 if(curr->pid == pid) return 1;
 109                 last = curr;
 110                 curr = curr->next;
 111         }
 112         curr = xmalloc(sizeof(pid_list));
 113         last->next = curr;
 114         curr->pid = pid;
 115         curr->next = NULL;
 116         return 1;
 117 }
 118
 119 static int fuser_add_inode(inode_list *ilist, dev_t dev, ino_t inode)
 120 {
 121         inode_list *curr = NULL, *last = NULL;
 122
 123         if(!ilist->inode && !ilist->dev) {
 124                 ilist->dev = dev;
 125                 ilist->inode = inode;
 126         }
 127         curr = ilist;
 128         while(curr != NULL) {
 129                 if(curr->inode == inode && curr->dev == dev) return 1;
 130                 last = curr;
 131                 curr = curr->next;
 132         }
 133         curr = xmalloc(sizeof(inode_list));
 134         last->next = curr;
 135         curr->dev = dev;
 136         curr->inode = inode;
 137         curr->next = NULL;
 138         return 1;
 139 }
 140
 141 static int fuser_scan_proc_net(int opts, const char *proto,
 142         int port, inode_list *ilist)
 143 {
 144         char path[sizeof(FUSER_PROC_DIR)+12], line[FUSER_MAX_LINE+1];
 145         char addr[128];
 146         ino_t tmp_inode;
 147         dev_t tmp_dev;
 148         long long  uint64_inode;
 149         int tmp_port;
 150         FILE *f;
 151
 152         if(!fuser_find_socket_dev(&tmp_dev)) tmp_dev = 0;
 153         sprintf(path, "%s/net/%s", FUSER_PROC_DIR, proto);
 154
 155         if (!(f = fopen(path, "r"))) return 0;
 156         while(fgets(line, FUSER_MAX_LINE, f)) {
 157                 if(sscanf(line,
 158                         "%*d: %64[0-9A-Fa-f]:%x %*x:%*x %*x %*x:%*x "
 159                         "%*x:%*x %*x %*d %*d %llu",
 160                         addr, &tmp_port, &uint64_inode) == 3) {
 161                         if((strlen(addr) == 8) &&
 162                                 (opts & FUSER_OPT_IP6)) continue;
 163                         else if((strlen(addr) > 8) &&
 164                                 (opts & FUSER_OPT_IP4)) continue;
 165                         if(tmp_port == port) {
 166                                 tmp_inode = uint64_inode;
 167                                 fuser_add_inode(ilist, tmp_dev, tmp_inode);
 168                         }
 169                 }
 170
 171         }
 172         fclose(f);
 173         return 1;
 174 }
 175
 176 static int fuser_search_dev_inode(int opts, inode_list *ilist,
 177         dev_t dev, ino_t inode)
 178 {
 179         inode_list *curr;
 180         curr = ilist;
 181
 182         while(curr) {
 183                 if((opts & FUSER_OPT_MOUNT) &&  curr->dev == dev)
 184                         return 1;
 185                 if(curr->inode == inode && curr->dev == dev)
 186                         return 1;
 187                 curr = curr->next;
 188         }
 189         return 0;
 190 }
 191
 192 static int fuser_scan_pid_maps(int opts, const char *fname, pid_t pid,
 193         inode_list *ilist, pid_list *plist)
 194 {
 195         FILE *file;
 196         char line[FUSER_MAX_LINE + 1];
 197         int major, minor;
 198         ino_t inode;
 199         long long uint64_inode;
 200         dev_t dev;
 201
 202         if (!(file = fopen(fname, "r"))) return 0;
 203         while (fgets(line, FUSER_MAX_LINE, file)) {
 204                 if(sscanf(line, "%*s %*s %*s %x:%x %llu",
 205                         &major, &minor, &uint64_inode) != 3) continue;
 206                 inode = uint64_inode;
 207                 if(major == 0 && minor == 0 && inode == 0) continue;
 208                 dev = makedev(major, minor);
 209                 if(fuser_search_dev_inode(opts, ilist, dev, inode)) {
 210                         fuser_add_pid(plist, pid);
 211                 }
 212
 213         }
 214         fclose(file);
 215         return 1;
 216 }
 217
 218 static int fuser_scan_link(int opts, const char *lname, pid_t pid,
 219         inode_list *ilist, pid_list *plist)
 220 {
 221         ino_t inode;
 222         dev_t dev;
 223
 224         if(!fuser_file_to_dev_inode(lname, &dev, &inode)) return 0;
 225         if(fuser_search_dev_inode(opts, ilist, dev, inode))
 226                 fuser_add_pid(plist, pid);
 227         return 1;
 228 }
 229
 230 static int fuser_scan_dir_links(int opts, const char *dname, pid_t pid,
 231         inode_list *ilist, pid_list *plist)
 232 {
 233         DIR *d;
 234         struct dirent *de;
 235         char *lname;
 236
 237         if((d = opendir(dname))) {
 238                 while((de = readdir(d)) != NULL) {
 239                         lname = concat_subpath_file(dname, de->d_name);
 240                         if(lname == NULL)
 241                                 continue;
 242                         fuser_scan_link(opts, lname, pid, ilist, plist);
 243                         free(lname);
 244                 }
 245                 closedir(d);
 246         }
 247         else return 0;
 248         return 1;
 249
 250 }
 251
 252 static int fuser_scan_proc_pids(int opts, inode_list *ilist, pid_list *plist)
 253 {
 254         DIR *d;
 255         struct dirent *de;
 256         pid_t pid;
 257         char *dname;
 258
 259         if(!(d = opendir(FUSER_PROC_DIR))) return 0;
 260         while((de = readdir(d)) != NULL) {
 261                 pid = (pid_t)atoi(de->d_name);
 262                 if(!pid) continue;
 263                 dname = concat_subpath_file(FUSER_PROC_DIR, de->d_name);
 264                 if(chdir(dname) < 0) {
 265                         free(dname);
 266                         continue;
 267                 }
 268                 free(dname);
 269                 fuser_scan_link(opts, "cwd", pid, ilist, plist);
 270                 fuser_scan_link(opts, "exe", pid, ilist, plist);
 271                 fuser_scan_link(opts, "root", pid, ilist, plist);
 272                 fuser_scan_dir_links(opts, "fd", pid, ilist, plist);
 273                 fuser_scan_dir_links(opts, "lib", pid, ilist, plist);
 274                 fuser_scan_dir_links(opts, "mmap", pid, ilist, plist);
 275                 fuser_scan_pid_maps(opts, "maps", pid, ilist, plist);
 276                 chdir("..");
 277         }
 278         closedir(d);
 279         return 1;
 280 }
 281
 282 static int fuser_print_pid_list(pid_list *plist)
 283 {
 284         pid_list *curr = plist;
 285
 286         if(plist == NULL) return 0;
 287         while(curr != NULL) {
 288                 if(curr->pid > 0) printf("%d ", curr->pid);
 289                 curr = curr->next;
 290         }
 291         printf("\n");
 292         return 1;
 293 }
 294
 295 static int fuser_kill_pid_list(pid_list *plist, int sig)
 296 {
 297         pid_list *curr = plist;
 298         pid_t mypid = getpid();
 299         int success = 1;
 300
 301         if(plist == NULL) return 0;
 302         while(curr != NULL) {
 303                 if(curr->pid > 0 && curr->pid != mypid) {
 304                         if (kill(curr->pid, sig) != 0) {
 305                                 bb_perror_msg(
 306                                         "Could not kill pid '%d'", curr->pid);
 307                                 success = 0;
 308                         }
 309                 }
 310                 curr = curr->next;
 311         }
 312         return success;
 313 }
 314
 315 int fuser_main(int argc, char **argv)
 316 {
 317         int port, i, optn;
 318         int* fni; /* file name indexes of argv */
 319         int fnic = 0;  /* file name index count */
 320         const char *proto;
 321         static int opt = 0; /* FUSER_OPT_ */
 322         dev_t dev;
 323         ino_t inode;
 324         pid_list *pids;
 325         inode_list *inodes;
 326         int killsig = SIGTERM;
 327         int success = 1;
 328
 329         if (argc < 2)
 330                 bb_show_usage();
 331
 332         fni = xmalloc(sizeof(int));
 333         for(i=1;i<argc;i++) {
 334                 optn = fuser_option(argv[i]);
 335                 if(optn) opt |= optn;
 336                 else if(argv[i][0] == '-') {
 337                         if(!(u_signal_names(argv[i]+1, &killsig, 0)))
 338                                 killsig = SIGTERM;
 339                 }
 340                 else {
 341                         fni = xrealloc(fni, sizeof(int) * (fnic+2));
 342                         fni[fnic++] = i;
 343                 }
 344         }
 345         if(!fnic) return 1;
 346
 347         pids = xmalloc(sizeof(pid_list));
 348         inodes = xmalloc(sizeof(inode_list));
 349         for(i=0;i<fnic;i++) {
 350                 if(fuser_parse_net_arg(argv[fni[i]], &proto, &port)) {
 351                         fuser_scan_proc_net(opt, proto, port, inodes);
 352                 }
 353                 else {
 354                         if(!fuser_file_to_dev_inode(
 355                                 argv[fni[i]], &dev, &inode)) {
 356                                 free(pids);
 357                                 free(inodes);
 358                                 bb_perror_msg_and_die(
 359                                         "Could not open '%s'", argv[fni[i]]);
 360                         }
 361                         fuser_add_inode(inodes, dev, inode);
 362                 }
 363         }
 364         success = fuser_scan_proc_pids(opt, inodes, pids);
 365         /* if the first pid in the list is 0, none have been found */
 366         if(pids->pid == 0) success = 0;
 367         if(success) {
 368                 if(opt & FUSER_OPT_KILL) {
 369                         success = fuser_kill_pid_list(pids, killsig);
 370                 }
 371                 else if(!(opt & FUSER_OPT_SILENT)) {
 372                         success = fuser_print_pid_list(pids);
 373                 }
 374         }
 375         free(pids);
 376         free(inodes);
 377         /* return 0 on (success == 1) 1 otherwise */
 378         return (success != 1);
 379 }