src/killall5.c

   1 /*
   2  * kilall5.c    Kill all processes except processes that have the
   3  *              same session id, so that the shell that called us
   4  *              won't be killed. Typically used in shutdown scripts.
   5  *
   6  * pidof.c      Tries to get the pid of the process[es] named.
   7  *
   8  * Version:     2.86 30-Jul-2004 MvS
   9  *
  10  * Usage:       killall5 [-][signal]
  11  *              pidof [-s] [-o omitpid [-o omitpid]] program [program..]
  12  *
  13  * Authors:     Miquel van Smoorenburg, miquels@cistron.nl
  14  *
  15  *              Riku Meskanen, <mesrik@jyu.fi>
  16  *              - return all running pids of given program name
  17  *              - single shot '-s' option for backwards combatibility
  18  *              - omit pid '-o' option and %PPID (parent pid metavariable)
  19  *              - syslog() only if not a connected to controlling terminal
  20  *              - swapped out programs pids are caught now
  21  *
  22  *              Werner Fink
  23  *              - make omit dynamic
  24  *              - provide '-n' to skip stat(2) syscall on network based FS
  25  *
  26  *              This file is part of the sysvinit suite,
  27  *              Copyright (C) 1991-2004 Miquel van Smoorenburg.
  28  *
  29  *              This program is free software; you can redistribute it and/or modify
  30  *              it under the terms of the GNU General Public License as published by
  31  *              the Free Software Foundation; either version 2 of the License, or
  32  *              (at your option) any later version.
  33  *
  34  *              This program is distributed in the hope that it will be useful,
  35  *              but WITHOUT ANY WARRANTY; without even the implied warranty of
  36  *              MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  37  *              GNU General Public License for more details.
  38  *
  39  *              You should have received a copy of the GNU General Public License
  40  *              along with this program; if not, write to the Free Software
  41  *              Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  42  */
  43 #include <dirent.h>
  44 #include <errno.h>
  45 #include <getopt.h>
  46 #include <limits.h>
  47 #include <mntent.h>
  48 #include <stdarg.h>
  49 #include <stdio.h>
  50 #include <stdlib.h>
  51 #include <signal.h>
  52 #include <string.h>
  53 #include <syslog.h>
  54 #include <sys/mman.h>
  55 #include <sys/param.h>
  56 #include <sys/stat.h>
  57 #include <sys/types.h>
  58 #include <sys/wait.h>
  59 #include <unistd.h>
  60
  61 char *Version = "@(#)killall5 2.86 31-Jul-2004 miquels@cistron.nl";
  62
  63 #ifndef PATH_MAX
  64 #  ifdef MAXPATHLEN
  65 #    define PATH_MAX MAXPATHLEN
  66 #  else
  67 #    define PATH_MAX 2048
  68 #  endif
  69 #endif
  70
  71 #define STATNAMELEN     15
  72 #define DO_NETFS 2
  73 #define DO_STAT 1
  74 #define NO_STAT 0
  75
  76 /* Info about a process. */
  77 typedef struct proc {
  78         char *pathname;         /* full path to executable        */
  79         char *argv0;            /* Name as found out from argv[0] */
  80         char *argv0base;        /* `basename argv[1]`             */
  81         char *argv1;            /* Name as found out from argv[1] */
  82         char *argv1base;        /* `basename argv[1]`             */
  83         char *statname;         /* the statname without braces    */
  84         ino_t ino;              /* Inode number                   */
  85         dev_t dev;              /* Device it is on                */
  86         pid_t pid;              /* Process ID.                    */
  87         pid_t sid;              /* Session ID.                    */
  88         char kernel;            /* Kernel thread or zombie.       */
  89         char nfs;               /* Name found on network FS.      */
  90         struct proc *next;      /* Pointer to next struct.        */
  91 } PROC;
  92
  93 /* pid queue */
  94
  95 typedef struct pidq {
  96         PROC            *proc;
  97         struct pidq     *next;
  98 } PIDQ;
  99
 100 typedef struct {
 101         PIDQ            *head;
 102         PIDQ            *tail;
 103         PIDQ            *next;
 104 } PIDQ_HEAD;
 105
 106 typedef struct _s_omit {
 107         struct _s_omit *next;
 108         struct _s_omit *prev;
 109         pid_t pid;
 110 } OMIT;
 111
 112 typedef struct _s_shadow
 113 {
 114         struct _s_shadow *next;
 115         struct _s_shadow *prev;
 116         size_t nlen;
 117         char * name;
 118 } SHADOW;
 119
 120 typedef struct _s_nfs
 121 {
 122         struct _s_nfs *next;    /* Pointer to next struct. */
 123         struct _s_nfs *prev;    /* Pointer to previous st. */
 124         SHADOW *shadow;         /* Pointer to shadows      */
 125         size_t nlen;
 126         char * name;
 127 } NFS;
 128
 129 /* List of processes. */
 130 PROC *plist;
 131
 132 /* List of processes to omit. */
 133 OMIT *omit;
 134
 135 /* List of NFS mountes partitions. */
 136 NFS *nlist;
 137
 138 /* Did we stop all processes ? */
 139 int sent_sigstop;
 140
 141 int scripts_too = 0;
 142
 143 char *progname; /* the name of the running program */
 144 #ifdef __GNUC__
 145 __attribute__ ((format (printf, 2, 3)))
 146 #endif
 147 void nsyslog(int pri, char *fmt, ...);
 148
 149 #if !defined(__STDC_VERSION__) || (__STDC_VERSION__ < 199901L)
 150 # ifndef  inline
 151 #  define inline        __inline__
 152 # endif
 153 # ifndef  restrict
 154 #  define restrict      __restrict__
 155 # endif
 156 #endif
 157 #define alignof(type)   ((sizeof(type)+(sizeof(void*)-1)) & ~(sizeof(void*)-1))
 158
 159 /*
 160  *      Malloc space, barf if out of memory.
 161  */
 162 #ifdef __GNUC__
 163 static void *xmalloc(size_t) __attribute__ ((__malloc__));
 164 #endif
 165 static void *xmalloc(size_t bytes)
 166 {
 167         void *p;
 168
 169         if ((p = malloc(bytes)) == NULL) {
 170                 if (sent_sigstop) kill(-1, SIGCONT);
 171                 nsyslog(LOG_ERR, "out of memory");
 172                 exit(1);
 173         }
 174         return p;
 175 }
 176
 177 #ifdef __GNUC__
 178 static inline void xmemalign(void **, size_t, size_t) __attribute__ ((__nonnull__ (1)));
 179 #endif
 180 static inline void xmemalign(void **memptr, size_t alignment, size_t size)
 181 {
 182         if ((posix_memalign(memptr, alignment, size)) < 0) {
 183                 if (sent_sigstop) kill(-1, SIGCONT);
 184                 nsyslog(LOG_ERR, "out of memory");
 185                 exit(1);
 186         }
 187 }
 188
 189 /*
 190  *      See if the proc filesystem is there. Mount if needed.
 191  */
 192 int mount_proc(void)
 193 {
 194         struct stat     st;
 195         char            *args[] = { "mount", "-t", "proc", "proc", "/proc", 0 };
 196         pid_t           pid, rc;
 197         int             wst;
 198         int             did_mount = 0;
 199
 200         /* Stat /proc/version to see if /proc is mounted. */
 201         if (stat("/proc/version", &st) < 0 && errno == ENOENT) {
 202
 203                 /* It's not there, so mount it. */
 204                 if ((pid = fork()) < 0) {
 205                         nsyslog(LOG_ERR, "cannot fork");
 206                         exit(1);
 207                 }
 208                 if (pid == 0) {
 209                         /* Try a few mount binaries. */
 210                         execv("/bin/mount", args);
 211                         execv("/sbin/mount", args);
 212
 213                         /* Okay, I give up. */
 214                         nsyslog(LOG_ERR, "cannot execute mount");
 215                         exit(1);
 216                 }
 217                 /* Wait for child. */
 218                 while ((rc = wait(&wst)) != pid)
 219                         if (rc < 0 && errno == ECHILD)
 220                                 break;
 221                 if (rc != pid || WEXITSTATUS(wst) != 0)
 222                         nsyslog(LOG_ERR, "mount returned non-zero exit status");
 223
 224                 did_mount = 1;
 225         }
 226
 227         /* See if mount succeeded. */
 228         if (stat("/proc/version", &st) < 0) {
 229                 if (errno == ENOENT)
 230                         nsyslog(LOG_ERR, "/proc not mounted, failed to mount.");
 231                 else
 232                         nsyslog(LOG_ERR, "/proc unavailable.");
 233                 exit(1);
 234         }
 235
 236         return did_mount;
 237 }
 238
 239 static inline int isnetfs(const char * type)
 240 {
 241         static const char* netfs[] = {"nfs", "nfs4", "smbfs", "cifs", "afs", "ncpfs", (char*)0};
 242         int n;
 243         for (n = 0; netfs[n]; n++) {
 244                 if (!strcasecmp(netfs[n], type))
 245                         return 1;
 246         }
 247         return 0;
 248 }
 249
 250 /*
 251  *     Remember all NFS typed partitions.
 252  */
 253 void init_nfs(void)
 254 {
 255         struct stat st;
 256         struct mntent * ent;
 257         FILE * mnt;
 258
 259         nlist = (NFS*)0;
 260
 261         if (stat("/proc/version", &st) < 0)
 262                 return;
 263         if ((mnt = setmntent("/proc/mounts", "r")) == (FILE*)0)
 264                 return;
 265
 266         while ((ent = getmntent(mnt))) {
 267                 if (isnetfs(ent->mnt_type)) {
 268                         size_t nlen = strlen(ent->mnt_dir);
 269                         NFS *restrict p;
 270                         xmemalign((void*)&p, sizeof(void*), alignof(NFS)+(nlen+1));
 271                         p->name = ((char*)p)+alignof(NFS);
 272                         p->nlen = nlen;
 273                         p->shadow = (SHADOW*)0;
 274
 275                         strcpy(p->name, ent->mnt_dir);
 276                         if (nlist)
 277                                 nlist->prev = p;
 278                         p->next = nlist;
 279                         p->prev = (NFS*)0;
 280                         nlist = p;
 281                 }
 282         }
 283         endmntent(mnt);
 284
 285         if ((mnt = setmntent("/proc/mounts", "r")) == (FILE*)0)
 286                 return;
 287
 288         while ((ent = getmntent(mnt))) {
 289                 NFS *p;
 290
 291                 for (p = nlist; p; p = p->next) {
 292                         SHADOW * restrict s;
 293                         size_t nlen;
 294
 295                         if (strcmp(ent->mnt_dir, p->name) == 0)
 296                                 continue;
 297                         if (strncmp(ent->mnt_dir, p->name, p->nlen) != 0)
 298                                 continue;
 299
 300                         nlen = strlen(ent->mnt_dir);
 301                         xmemalign((void*)&s, sizeof(void*), alignof(SHADOW)+(nlen+1));
 302                         s->name = ((char*)s)+alignof(SHADOW);
 303                         s->nlen = nlen;
 304
 305                         strcpy(s->name, ent->mnt_dir);
 306                         if (p->shadow)
 307                             p->shadow->prev = s;
 308                         s->next = p->shadow;
 309                         s->prev = (SHADOW*)0;
 310                         p->shadow = s;
 311                 }
 312         }
 313         endmntent(mnt);
 314 }
 315
 316 static void clear_shadow(SHADOW *restrict shadow)
 317 {
 318         SHADOW *s, *n, *l;
 319
 320         n = shadow;
 321         l = (SHADOW*)0;
 322         for (s = shadow; n; s = n) {
 323                 l = s->prev;
 324                 n = s->next;
 325                 if (s == shadow) {
 326                         if (n) n->prev = (SHADOW*)0;
 327                         shadow = n;
 328                 } else if (l) {
 329                         if (n) n->prev = l;
 330                         l->next = n;
 331                 }
 332                 free(s);
 333         }
 334 }
 335
 336 static void clear_mnt(void)
 337 {
 338         NFS *p, *n, *l;
 339
 340         n = nlist;
 341         l = (NFS*)0;
 342         for (p = nlist; n; p = n) {
 343                 l = p->prev;
 344                 n = p->next;
 345                 if (p == nlist) {
 346                         if (n) n->prev = (NFS*)0;
 347                         nlist = n;
 348                 } else if (l) {
 349                         if (n) n->prev = l;
 350                         l->next = n;
 351                 }
 352                 if (p->shadow)
 353                         clear_shadow(p->shadow);
 354                 free(p);
 355         }
 356 }
 357
 358 /*
 359  *     Check if path is a shadow off a NFS partition.
 360  */
 361 static int shadow(SHADOW *restrict this, const char *restrict name, const size_t nlen)
 362 {
 363         SHADOW *s;
 364
 365         if (!this)
 366                 goto out;
 367         for (s = this; s; s = s->next) {
 368                 if (nlen < s->nlen)
 369                         continue;
 370                 if (name[s->nlen] != '\0' && name[s->nlen] != '/')
 371                         continue;
 372                 if (strncmp(name, s->name, s->nlen) == 0)
 373                         return 1;
 374         }
 375 out:
 376         return 0;
 377 }
 378
 379 /*
 380  *     Check path is located on a network based partition.
 381  */
 382 int check4nfs(const char * path, char * real)
 383 {
 384         char buf[PATH_MAX+1];
 385         const char *curr;
 386         int deep = MAXSYMLINKS;
 387
 388         if (!nlist) return 0;
 389
 390         curr = path;
 391         do {
 392                 const char *prev;
 393                 int len;
 394
 395                 if ((prev = strdupa(curr)) == NULL) {
 396                         nsyslog(LOG_ERR, "strdupa(): %s\n", strerror(errno));
 397                         return 0;
 398                 }
 399
 400                 errno = 0;
 401                 if ((len = readlink(curr, buf, PATH_MAX)) < 0)
 402                         break;
 403                 buf[len] = '\0';
 404
 405                 if (buf[0] != '/') {
 406                         const char *slash;
 407
 408                         if ((slash = strrchr(prev, '/'))) {
 409                                 size_t off = slash - prev + 1;
 410
 411                                 if (off + len > PATH_MAX)
 412                                         len = PATH_MAX - off;
 413
 414                                 memmove(&buf[off], &buf[0], len + 1);
 415                                 memcpy(&buf[0], prev, off);
 416                         }
 417                 }
 418                 curr = &buf[0];
 419
 420                 if (deep-- <= 0) return 0;
 421
 422         } while (1);
 423
 424         if (real) strcpy(real, curr);
 425
 426         if (errno == EINVAL) {
 427                 const size_t nlen = strlen(curr);
 428                 NFS *p;
 429                 for (p = nlist; p; p = p->next) {
 430                         if (nlen < p->nlen)
 431                                 continue;
 432                         if (curr[p->nlen] != '\0' && curr[p->nlen] != '/')
 433                                 continue;
 434                         if (!strncmp(curr, p->name, p->nlen)) {
 435                                 if (shadow(p->shadow, curr, nlen))
 436                                         continue;
 437                                 return 1;
 438                         }
 439                 }
 440         }
 441
 442         return 0;
 443 }
 444
 445 int readarg(FILE *fp, char *buf, int sz)
 446 {
 447         int             c = 0, f = 0;
 448
 449         while (f < (sz-1) && (c = fgetc(fp)) != EOF && c)
 450                 buf[f++] = c;
 451         buf[f] = 0;
 452
 453         return (c == EOF && f == 0) ? c : f;
 454 }
 455
 456 /*
 457  *      Read the proc filesystem.
 458  *      CWD must be /proc to avoid problems if / is affected by the killing (ie depend on fuse).
 459  */
 460 int readproc(int do_stat)
 461 {
 462         DIR             *dir;
 463         FILE            *fp;
 464         PROC            *p, *n;
 465         struct dirent   *d;
 466         struct stat     st;
 467         char            path[PATH_MAX+1];
 468         char            buf[PATH_MAX+1];
 469         char            *s, *q;
 470         unsigned long   startcode, endcode;
 471         int             pid, f;
 472         ssize_t         len;
 473
 474         /* Open the /proc directory. */
 475         if (chdir("/proc") == -1) {
 476                 nsyslog(LOG_ERR, "chdir /proc failed");
 477                 return -1;
 478         }
 479         if ((dir = opendir(".")) == NULL) {
 480                 nsyslog(LOG_ERR, "cannot opendir(/proc)");
 481                 return -1;
 482         }
 483
 484         /* Free the already existing process list. */
 485         n = plist;
 486         for (p = plist; n; p = n) {
 487                 n = p->next;
 488                 if (p->argv0) free(p->argv0);
 489                 if (p->argv1) free(p->argv1);
 490                 if (p->statname) free(p->statname);
 491                 free(p->pathname);
 492                 free(p);
 493         }
 494         plist = NULL;
 495
 496         /* Walk through the directory. */
 497         while ((d = readdir(dir)) != NULL) {
 498
 499                 /* See if this is a process */
 500                 if ((pid = atoi(d->d_name)) == 0) continue;
 501
 502                 /* Get a PROC struct . */
 503                 p = (PROC *)xmalloc(sizeof(PROC));
 504                 memset(p, 0, sizeof(PROC));
 505
 506                 /* Open the status file. */
 507                 snprintf(path, sizeof(path), "%s/stat", d->d_name);
 508
 509                 /* Read SID & statname from it. */
 510                 if ((fp = fopen(path, "r")) != NULL) {
 511                         if (!fgets(buf, sizeof(buf), fp))
 512                                 buf[0] = '\0';
 513
 514                         if (buf[0] == '\0') {
 515                                 nsyslog(LOG_ERR,
 516                                         "can't read from %s\n", path);
 517                                 fclose(fp);
 518                                 free(p);
 519                                 continue;
 520                         }
 521
 522                         /* See if name starts with '(' */
 523                         s = buf;
 524                         while (*s && *s != ' ') s++;
 525                         if (*s) s++;
 526                         if (*s == '(') {
 527                                 /* Read program name. */
 528                                 q = strrchr(buf, ')');
 529                                 if (q == NULL) {
 530                                         p->sid = 0;
 531                                         nsyslog(LOG_ERR,
 532                                         "can't get program name from /proc/%s\n",
 533                                                 path);
 534                                         fclose(fp);
 535                                         if (p->argv0) free(p->argv0);
 536                                         if (p->argv1) free(p->argv1);
 537                                         if (p->statname) free(p->statname);
 538                                         free(p->pathname);
 539                                         free(p);
 540                                         continue;
 541                                 }
 542                                 s++;
 543                         } else {
 544                                 q = s;
 545                                 while (*q && *q != ' ') q++;
 546                         }
 547                         if (*q) *q++ = 0;
 548                         while (*q == ' ') q++;
 549                         p->statname = (char *)xmalloc(strlen(s)+1);
 550                         strcpy(p->statname, s);
 551
 552                         /* Get session, startcode, endcode. */
 553                         startcode = endcode = 0;
 554                         if (sscanf(q,   "%*c %*d %*d %d %*d %*d %*u %*u "
 555                                         "%*u %*u %*u %*u %*u %*d %*d "
 556                                         "%*d %*d %*d %*d %*u %*u %*d "
 557                                         "%*u %lu %lu",
 558                                         &p->sid, &startcode, &endcode) != 3) {
 559                                 p->sid = 0;
 560                                 nsyslog(LOG_ERR, "can't read sid from %s\n",
 561                                         path);
 562                                 fclose(fp);
 563                                 if (p->argv0) free(p->argv0);
 564                                 if (p->argv1) free(p->argv1);
 565                                 if (p->statname) free(p->statname);
 566                                 free(p->pathname);
 567                                 free(p);
 568                                 continue;
 569                         }
 570                         if (startcode == 0 && endcode == 0)
 571                                 p->kernel = 1;
 572                         fclose(fp);
 573                 } else {
 574                         /* Process disappeared.. */
 575                         if (p->argv0) free(p->argv0);
 576                         if (p->argv1) free(p->argv1);
 577                         if (p->statname) free(p->statname);
 578                         free(p->pathname);
 579                         free(p);
 580                         continue;
 581                 }
 582
 583                 snprintf(path, sizeof(path), "%s/cmdline", d->d_name);
 584                 if ((fp = fopen(path, "r")) != NULL) {
 585
 586                         /* Now read argv[0] */
 587                         f = readarg(fp, buf, sizeof(buf));
 588
 589                         if (buf[0]) {
 590                                 /* Store the name into malloced memory. */
 591                                 p->argv0 = (char *)xmalloc(f + 1);
 592                                 strcpy(p->argv0, buf);
 593
 594                                 /* Get a pointer to the basename. */
 595                                 p->argv0base = strrchr(p->argv0, '/');
 596                                 if (p->argv0base != NULL)
 597                                         p->argv0base++;
 598                                 else
 599                                         p->argv0base = p->argv0;
 600                         }
 601
 602                         /* And read argv[1] */
 603                         while ((f = readarg(fp, buf, sizeof(buf))) != EOF)
 604                                 if (buf[0] != '-') break;
 605
 606                         if (buf[0]) {
 607                                 /* Store the name into malloced memory. */
 608                                 p->argv1 = (char *)xmalloc(f + 1);
 609                                 strcpy(p->argv1, buf);
 610
 611                                 /* Get a pointer to the basename. */
 612                                 p->argv1base = strrchr(p->argv1, '/');
 613                                 if (p->argv1base != NULL)
 614                                         p->argv1base++;
 615                                 else
 616                                         p->argv1base = p->argv1;
 617                         }
 618
 619                         fclose(fp);
 620
 621                 } else {
 622                         /* Process disappeared.. */
 623                         if (p->argv0) free(p->argv0);
 624                         if (p->argv1) free(p->argv1);
 625                         if (p->statname) free(p->statname);
 626                         free(p->pathname);
 627                         free(p);
 628                         continue;
 629                 }
 630
 631                 /* Try to stat the executable. */
 632                 snprintf(path, sizeof(path), "/proc/%s/exe", d->d_name);
 633
 634                 p->nfs = 0;
 635
 636                 switch (do_stat) {
 637                 case DO_NETFS:
 638                         if ((p->nfs = check4nfs(path, buf)))
 639                                 goto link;
 640                 case DO_STAT:
 641                         if (stat(path, &st) != 0)
 642                                 break;
 643                         p->dev = st.st_dev;
 644                         p->ino = st.st_ino;
 645
 646                         /* Fall through */
 647                 default:
 648                 link:
 649                         len = readlink(path, buf, PATH_MAX);
 650                         if (len > 0) {
 651                                 p->pathname = (char *)xmalloc(len + 1);
 652                                 memcpy(p->pathname, buf, len);
 653                                 p->pathname[len] = '\0';
 654                         }
 655                         break;
 656                 }
 657
 658                 /* Link it into the list. */
 659                 p->next = plist;
 660                 plist = p;
 661                 p->pid = pid;
 662         }
 663         closedir(dir);
 664
 665         /* Done. */
 666         return 0;
 667 }
 668
 669 PIDQ_HEAD *init_pid_q(PIDQ_HEAD *q)
 670 {
 671         q->head =  q->next = q->tail = NULL;
 672         return q;
 673 }
 674
 675 int empty_q(PIDQ_HEAD *q)
 676 {
 677         return (q->head == NULL);
 678 }
 679
 680 int add_pid_to_q(PIDQ_HEAD *q, PROC *p)
 681 {
 682         PIDQ *tmp;
 683
 684         tmp = (PIDQ *)xmalloc(sizeof(PIDQ));
 685
 686         tmp->proc = p;
 687         tmp->next = NULL;
 688
 689         if (empty_q(q)) {
 690                 q->head = tmp;
 691                 q->tail  = tmp;
 692         } else {
 693                 q->tail->next = tmp;
 694                 q->tail = tmp;
 695         }
 696         return 0;
 697 }
 698
 699 PROC *get_next_from_pid_q(PIDQ_HEAD *q)
 700 {
 701         PROC            *p;
 702         PIDQ            *tmp = q->head;
 703
 704         if (!empty_q(q)) {
 705                 p = q->head->proc;
 706                 q->head = tmp->next;
 707                 free(tmp);
 708                 return p;
 709         }
 710
 711         return NULL;
 712 }
 713
 714 /* Try to get the process ID of a given process. */
 715 PIDQ_HEAD *pidof(char *prog)
 716 {
 717         PROC            *p;
 718         PIDQ_HEAD       *q;
 719         struct stat     st;
 720         char            *s;
 721         int             nfs = 0;
 722         int             dostat = 0;
 723         int             foundone = 0;
 724         int             ok = 0;
 725         const int       root = (getuid() == 0);
 726         char            real[PATH_MAX+1];
 727
 728         if (! prog)
 729                 return NULL;
 730
 731         /* Try to stat the executable. */
 732         if (prog[0] == '/') {
 733                 memset(&real[0], 0, sizeof(real));
 734
 735                 if (check4nfs(prog, real))
 736                         nfs++;
 737
 738                 if (real[0] != '\0')
 739                         prog = &real[0];        /* Binary located on network FS. */
 740
 741                 if ((nfs == 0) && (stat(prog, &st) == 0))
 742                         dostat++;               /* Binary located on a local FS. */
 743         }
 744
 745         /* Get basename of program. */
 746         if ((s = strrchr(prog, '/')) == NULL)
 747                 s = prog;
 748         else
 749                 s++;
 750
 751         if (! *s)
 752                 return NULL;
 753
 754         q = (PIDQ_HEAD *)xmalloc(sizeof(PIDQ_HEAD));
 755         q = init_pid_q(q);
 756
 757         /* First try to find a match based on dev/ino pair. */
 758         if (dostat && !nfs) {
 759                 for (p = plist; p; p = p->next) {
 760                         if (p->nfs)
 761                                 continue;
 762                         if (p->dev == st.st_dev && p->ino == st.st_ino) {
 763                                 add_pid_to_q(q, p);
 764                                 foundone++;
 765                         }
 766                 }
 767         }
 768
 769         /* Second try to find a match based on full path name on
 770          * network FS located binaries */
 771         if (!foundone && nfs) {
 772                 for (p = plist; p; p = p->next) {
 773                         if (!p->pathname)
 774                                 continue;
 775                         if (!p->nfs)
 776                                 continue;
 777                         if (strcmp(prog, p->pathname) != 0)
 778                                 continue;
 779                         add_pid_to_q(q, p);
 780                         foundone++;
 781                 }
 782         }
 783
 784         /* If we didn't find a match based on dev/ino, try the name. */
 785         if (!foundone) for (p = plist; p; p = p->next) {
 786                 if (prog[0] == '/') {
 787                         if (!p->pathname) {
 788                                 if (root)
 789                                         continue;
 790                                 goto fallback;
 791                         }
 792                         if (strcmp(prog, p->pathname)) {
 793                                 int len = strlen(prog);
 794                                 if (strncmp(prog, p->pathname, len))
 795                                 {
 796                                         if (scripts_too)
 797                                                 goto fallback;
 798                                         continue;
 799                                 }
 800                                 if (strcmp(" (deleted)", p->pathname + len))
 801                                 {
 802                                         if (scripts_too)
 803                                                 goto fallback;
 804                                         continue;
 805                                 }
 806                         }
 807                         add_pid_to_q(q, p);
 808                         continue;
 809                 }
 810
 811         fallback:
 812                 ok = 0;
 813
 814                 /*             matching        nonmatching
 815                  * proc name   prog name       prog name
 816                  * ---         -----------     ------------
 817                  *   b         b, p/b, q/b
 818                  * p/b         b, p/b          q/b
 819                  *
 820                  * Algorithm: Match if:
 821                  *    cmd = arg
 822                  * or cmd = base(arg)
 823                  * or base(cmd) = arg
 824                  *
 825                  * Specifically, do not match just because base(cmd) = base(arg)
 826                  * as was done in earlier versions of this program, since this
 827                  * allows /aaa/foo to match /bbb/foo .
 828                  */
 829                 ok |=
 830                         (p->argv0 && strcmp(p->argv0, prog) == 0)
 831                         || (p->argv0 && s != prog && strcmp(p->argv0, s) == 0)
 832                         || (p->argv0base && strcmp(p->argv0base, prog) == 0);
 833
 834                 /* For scripts, compare argv[1] as well. */
 835                 if (
 836                         scripts_too && p->statname && p->argv1base
 837                         && !strncmp(p->statname, p->argv1base, STATNAMELEN)
 838                 ) {
 839                         ok |=
 840                                 (p->argv1 && strcmp(p->argv1, prog) == 0)
 841                                 || (p->argv1 && s != prog && strcmp(p->argv1, s) == 0)
 842                                 || (p->argv1base && strcmp(p->argv1base, prog) == 0);
 843                 }
 844
 845                 /*
 846                  *      if we have a space in argv0, process probably
 847                  *      used setproctitle so try statname.
 848                  */
 849                 if (strlen(s) <= STATNAMELEN &&
 850                     (p->argv0 == NULL ||
 851                      p->argv0[0] == 0 ||
 852                      strchr(p->argv0, ' '))) {
 853                         ok |= (strcmp(p->statname, s) == 0);
 854                 }
 855
 856                 /*
 857                  *      if we have a `-' as the first character, process
 858                  *      probably used as a login shell
 859                  */
 860                 if (strlen(s) <= STATNAMELEN &&
 861                     p->argv1 == NULL &&
 862                     (p->argv0 != NULL &&
 863                      p->argv0[0] == '-')) {
 864                         ok |= (strcmp(p->statname, s) == 0);
 865                 }
 866
 867                 if (ok) add_pid_to_q(q, p);
 868         }
 869
 870         return q;
 871 }
 872
 873 /* Give usage message and exit. */
 874 void usage(void)
 875 {
 876         nsyslog(LOG_ERR, "only one argument, a signal number, allowed");
 877         closelog();
 878         exit(1);
 879 }
 880
 881 /* write to syslog file if not open terminal */
 882 #ifdef __GNUC__
 883 __attribute__ ((format (printf, 2, 3)))
 884 #endif
 885 void nsyslog(int pri, char *fmt, ...)
 886 {
 887         va_list  args;
 888
 889         va_start(args, fmt);
 890
 891         if (ttyname(0) == NULL) {
 892                 vsyslog(pri, fmt, args);
 893         } else {
 894                 fprintf(stderr, "%s: ",progname);
 895                 vfprintf(stderr, fmt, args);
 896                 fprintf(stderr, "\n");
 897         }
 898
 899         va_end(args);
 900 }
 901
 902 #define PIDOF_SINGLE    0x01
 903 #define PIDOF_OMIT      0x02
 904 #define PIDOF_NETFS     0x04
 905
 906 /*
 907  *      Pidof functionality.
 908  */
 909 int main_pidof(int argc, char **argv)
 910 {
 911         PIDQ_HEAD       *q;
 912         PROC            *p;
 913         char            *token, *here;
 914         int             f;
 915         int             first = 1;
 916         int             opt, flags = 0;
 917         int             chroot_check = 0;
 918         struct stat     st;
 919         char            tmp[512];
 920
 921         omit = (OMIT*)0;
 922         nlist = (NFS*)0;
 923         opterr = 0;
 924
 925         if ((token = getenv("PIDOF_NETFS")) && (strcmp(token,"no") != 0))
 926                 flags |= PIDOF_NETFS;
 927
 928         while ((opt = getopt(argc,argv,"hco:sxn")) != EOF) switch (opt) {
 929                 case '?':
 930                         nsyslog(LOG_ERR,"invalid options on command line!\n");
 931                         closelog();
 932                         exit(1);
 933                 case 'c':
 934                         if (geteuid() == 0) chroot_check = 1;
 935                         break;
 936                 case 'o':
 937                         here = optarg;
 938                         while ((token = strsep(&here, ",;:"))) {
 939                                 OMIT *restrict optr;
 940                                 pid_t opid;
 941
 942                                 if (strcmp("%PPID", token) == 0)
 943                                         opid = getppid();
 944                                 else
 945                                         opid = (pid_t)atoi(token);
 946
 947                                 if (opid < 1) {
 948                                         nsyslog(LOG_ERR,
 949                                                 "illegal omit pid value "
 950                                                 "(%s)!\n", token);
 951                                         continue;
 952                                 }
 953                                 xmemalign((void*)&optr, sizeof(void*), alignof(OMIT));
 954                                 optr->next = omit;
 955                                 optr->prev = (OMIT*)0;
 956                                 optr->pid  = opid;
 957                                 omit = optr;
 958                         }
 959                         flags |= PIDOF_OMIT;
 960                         break;
 961                 case 's':
 962                         flags |= PIDOF_SINGLE;
 963                         break;
 964                 case 'x':
 965                         scripts_too++;
 966                         break;
 967                 case 'n':
 968                         flags |= PIDOF_NETFS;
 969                         break;
 970                 default:
 971                         /* Nothing */
 972                         break;
 973         }
 974         argc -= optind;
 975         argv += optind;
 976
 977         /* Check if we are in a chroot */
 978         if (chroot_check) {
 979                 snprintf(tmp, 512, "/proc/%d/root", getpid());
 980                 if (stat(tmp, &st) < 0) {
 981                         nsyslog(LOG_ERR, "stat failed for %s!\n", tmp);
 982                         closelog();
 983                         exit(1);
 984                 }
 985         }
 986
 987         if (flags & PIDOF_NETFS)
 988                 init_nfs();             /* Which network based FS are online? */
 989
 990         /* Print out process-ID's one by one. */
 991         readproc((flags & PIDOF_NETFS) ? DO_NETFS : DO_STAT);
 992
 993         for(f = 0; f < argc; f++) {
 994                 if ((q = pidof(argv[f])) != NULL) {
 995                         pid_t spid = 0;
 996                         while ((p = get_next_from_pid_q(q))) {
 997                                 if ((flags & PIDOF_OMIT) && omit) {
 998                                         OMIT * optr;
 999                                         for (optr = omit; optr; optr = optr->next) {
1000                                                 if (optr->pid == p->pid)
1001                                                         break;
1002                                         }
1003
1004                                         /*
1005                                          *      On a match, continue with
1006                                          *      the for loop above.
1007                                          */
1008                                         if (optr)
1009                                                 continue;
1010                                 }
1011                                 if (flags & PIDOF_SINGLE) {
1012                                         if (spid)
1013                                                 continue;
1014                                         else
1015                                                 spid = 1;
1016                                 }
1017                                 if (chroot_check) {
1018                                         struct stat st2;
1019                                         snprintf(tmp, 512, "/proc/%d/root",
1020                                                  p->pid);
1021                                         if (stat(tmp, &st2) < 0 ||
1022                                             st.st_dev != st2.st_dev ||
1023                                             st.st_ino != st2.st_ino) {
1024                                                 continue;
1025                                         }
1026                                 }
1027                                 if (!first)
1028                                         printf(" ");
1029                                 printf("%d", p->pid);
1030                                 first = 0;
1031                         }
1032                 }
1033         }
1034         if (!first)
1035                 printf("\n");
1036
1037         clear_mnt();
1038
1039         closelog();
1040         return(first ? 1 : 0);
1041 }
1042
1043 /* Main for either killall or pidof. */
1044 int main(int argc, char **argv)
1045 {
1046         PROC            *p;
1047         int             pid, sid = -1;
1048         int             sig = SIGKILL;
1049         int             c;
1050
1051         /* return non-zero if no process was killed */
1052         int             retval = 2;
1053
1054         /* Get program name. */
1055         if ((progname = strrchr(argv[0], '/')) == NULL)
1056                 progname = argv[0];
1057         else
1058                 progname++;
1059
1060         /* Now connect to syslog. */
1061         openlog(progname, LOG_CONS|LOG_PID, LOG_DAEMON);
1062
1063         /* Were we called as 'pidof' ? */
1064         if (strcmp(progname, "pidof") == 0)
1065                 return main_pidof(argc, argv);
1066
1067         /* Right, so we are "killall". */
1068         omit = (OMIT*)0;
1069
1070         if (argc > 1) {
1071                 for (c = 1; c < argc; c++) {
1072                         if (argv[c][0] == '-') (argv[c])++;
1073                         if (argv[c][0] == 'o') {
1074                                 char * token, * here;
1075
1076                                 if (++c >= argc)
1077                                         usage();
1078
1079                                 here = argv[c];
1080                                 while ((token = strsep(&here, ",;:"))) {
1081                                         OMIT *restrict optr;
1082                                         pid_t opid = (pid_t)atoi(token);
1083
1084                                         if (opid < 1) {
1085                                                 nsyslog(LOG_ERR,
1086                                                         "illegal omit pid value "
1087                                                         "(%s)!\n", token);
1088                                                 continue;
1089                                         }
1090                                         xmemalign((void*)&optr, sizeof(void*), alignof(OMIT));
1091                                         optr->next = omit;
1092                                         optr->prev = (OMIT*)0;
1093                                         optr->pid  = opid;
1094                                         omit = optr;
1095                                 }
1096                         }
1097                         else if ((sig = atoi(argv[1])) <= 0 || sig > 31)
1098                                 usage();
1099                 }
1100         }
1101
1102         /* First get the /proc filesystem online. */
1103         mount_proc();
1104
1105         /*
1106          *      Ignoring SIGKILL and SIGSTOP do not make sense, but
1107          *      someday kill(-1, sig) might kill ourself if we don't
1108          *      do this. This certainly is a valid concern for SIGTERM-
1109          *      Linux 2.1 might send the calling process the signal too.
1110          */
1111         signal(SIGTERM, SIG_IGN);
1112         signal(SIGSTOP, SIG_IGN);
1113         signal(SIGKILL, SIG_IGN);
1114
1115         /* lock us into memory */
1116         mlockall(MCL_CURRENT | MCL_FUTURE);
1117
1118         /* Now stop all processes. */
1119         kill(-1, SIGSTOP);
1120         sent_sigstop = 1;
1121
1122         /* Read /proc filesystem */
1123         if (readproc(NO_STAT) < 0) {
1124                 kill(-1, SIGCONT);
1125                 return(1);
1126         }
1127
1128         /* Now kill all processes except init (pid 1) and our session. */
1129         sid = (int)getsid(0);
1130         pid = (int)getpid();
1131         for (p = plist; p; p = p->next) {
1132                 if (p->pid == 1 || p->pid == pid || p->sid == sid || p->kernel)
1133                         continue;
1134
1135                 if (omit) {
1136                         OMIT * optr;
1137                         for (optr = omit; optr; optr = optr->next) {
1138                                 if (optr->pid == p->pid)
1139                                         break;
1140                         }
1141
1142                         /* On a match, continue with the for loop above. */
1143                         if (optr)
1144                                 continue;
1145                 }
1146
1147                 kill(p->pid, sig);
1148                 retval = 0;
1149         }
1150
1151         /* And let them continue. */
1152         kill(-1, SIGCONT);
1153
1154         /* Done. */
1155         closelog();
1156
1157         /* Force the kernel to run the scheduler */
1158         usleep(1);
1159
1160         return retval;
1161 }