Magellan Linux

  • Back to homepage
    • /[magellan-source]/trunk/mkinitrd-magellan/busybox/procps/fuser.c

    Contents of /trunk/mkinitrd-magellan/busybox/procps/fuser.c

    Parent Directory Parent Directory | Revision Log Revision Log

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