lib/get_progname_of.c

   1 /* Determine the program name of a given process.
   2    Copyright (C) 2016-2024 Free Software Foundation, Inc.
   3    Written by Bruno Haible <bruno@clisp.org>, 2019.
   4
   5    This file is free software: you can redistribute it and/or modify
   6    it under the terms of the GNU Lesser General Public License as
   7    published by the Free Software Foundation, either version 3 of the
   8    License, or (at your option) any later version.
   9
  10    This file is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13    GNU Lesser General Public License for more details.
  14
  15    You should have received a copy of the GNU Lesser General Public License
  16    along with this program.  If not, see <https://www.gnu.org/licenses/>.  */
  17
  18 #include <config.h>
  19
  20 /* Specification.  */
  21 #include "get_progname_of.h"
  22
  23 #include <stdio.h>
  24 #include <stdlib.h>
  25 #include <string.h>
  26
  27 #if defined __linux__ || defined __ANDROID__ || (defined __FreeBSD_kernel__ && !defined __FreeBSD__) || defined __GNU__ || defined __NetBSD__ || defined __FreeBSD__ /* Linux, GNU/kFreeBSD, GNU/Hurd, NetBSD, FreeBSD */
  28 # include <unistd.h>
  29 # if defined __ANDROID__
  30 #  include <fcntl.h>
  31 # endif
  32 #endif
  33
  34 #if defined __minix || defined __sun                        /* Minix, Solaris */
  35 # include <fcntl.h>
  36 # include <unistd.h>
  37 #endif
  38
  39 #if defined __OpenBSD__                                     /* OpenBSD */
  40 # include <sys/sysctl.h> /* sysctl, struct kinfo_proc */
  41 #endif
  42
  43 #if defined __APPLE__ && defined __MACH__                   /* Mac OS X */
  44 /* Get MAC_OS_X_VERSION_MIN_REQUIRED, MAC_OS_X_VERSION_MAX_ALLOWED.
  45    The version at runtime satisfies
  46    MAC_OS_X_VERSION_MIN_REQUIRED <= version <= MAC_OS_X_VERSION_MAX_ALLOWED.  */
  47 # include <AvailabilityMacros.h>
  48 # if MAC_OS_X_VERSION_MAX_ALLOWED >= 1050
  49 #  include <libproc.h>
  50 #  if MAC_OS_X_VERSION_MIN_REQUIRED < 1050
  51 /* Mac OS X versions < 10.5 don't have this function.  Therefore declare it as
  52    weak, in order to avoid a runtime error when the binaries are run on these
  53    older versions.  */
  54 extern int proc_pidinfo (int, int, uint64_t, void *, int) WEAK_IMPORT_ATTRIBUTE;
  55 #  endif
  56 # endif
  57 #endif
  58
  59 #if defined _AIX                                            /* AIX */
  60 # include <procinfo.h>
  61 #endif
  62
  63 #if defined __hpux                                          /* HP-UX */
  64 # include <unistd.h>
  65 # include <sys/param.h>
  66 # include <sys/pstat.h>
  67 #endif
  68
  69 #if defined __sgi                                           /* IRIX */
  70 # include <unistd.h>
  71 # include <fcntl.h>
  72 # include <sys/procfs.h>
  73 #endif
  74
  75 #if defined __CYGWIN__                                      /* Cygwin */
  76 # define WIN32_LEAN_AND_MEAN
  77 # include <windows.h> /* needed to get 'struct external_pinfo' defined */
  78 # include <sys/cygwin.h>
  79 #endif
  80
  81 #if defined __BEOS__ || defined __HAIKU__                   /* BeOS, Haiku */
  82 # include <OS.h>
  83 #endif
  84
  85 char *
  86 get_progname_of (pid_t pid)
  87 {
  88 #if defined __linux__ || defined __ANDROID__ || (defined __FreeBSD_kernel__ && !defined __FreeBSD__) || defined __GNU__ || defined __NetBSD__ /* Linux, GNU/kFreeBSD, GNU/Hurd, NetBSD */
  89 /* GNU/kFreeBSD mounts /proc as linprocfs, which looks like a Linux /proc
  90    file system.  */
  91
  92   /* Read the symlink /proc/<pid>/exe.  */
  93   {
  94     char filename[6 + 10 + 4 + 1];
  95     char linkbuf[1024 + 1];
  96     ssize_t linklen;
  97
  98     sprintf (filename, "/proc/%u/exe", (unsigned int) pid);
  99     linklen = readlink (filename, linkbuf, sizeof (linkbuf) - 1);
 100     if (linklen > 0)
 101       {
 102         char *slash;
 103
 104         /* NUL-terminate the link.  */
 105         linkbuf[linklen] = '\0';
 106         /* Find the portion after the last slash.  */
 107         slash = strrchr (linkbuf, '/');
 108         return strdup (slash != NULL ? slash + 1 : linkbuf);
 109       }
 110   }
 111
 112 # if defined __ANDROID__
 113   /* But it may fail with "Permission denied".  As a fallback,
 114      read the contents of /proc/<pid>/cmdline into memory.  */
 115   {
 116     char filename[6 + 10 + 8 + 1];
 117     int fd;
 118
 119     sprintf (filename, "/proc/%u/cmdline", (unsigned int) pid);
 120     fd = open (filename, O_RDONLY | O_CLOEXEC);
 121     if (fd >= 0)
 122       {
 123         char buf[4096 + 1];
 124         ssize_t nread = read (fd, buf, sizeof (buf) - 1);
 125         close (fd);
 126         if (nread >= 0)
 127           {
 128             char *slash;
 129
 130             /* NUL-terminate the buffer (just in case it does not have the
 131                expected format).  */
 132             buf[nread] = '\0';
 133             /* The program name and each argument is followed by a NUL byte.  */
 134             /* Find the portion after the last slash.  */
 135             slash = strrchr (buf, '/');
 136             return strdup (slash != NULL ? slash + 1 : buf);
 137           }
 138       }
 139   }
 140 # endif
 141
 142 #endif
 143
 144 #if defined __FreeBSD__                                     /* FreeBSD */
 145
 146   /* Read the symlink /proc/<pid>/file.  */
 147   char filename[6 + 10 + 5 + 1];
 148   char linkbuf[1024 + 1];
 149   ssize_t linklen;
 150
 151   sprintf (filename, "/proc/%u/file", (unsigned int) pid);
 152   linklen = readlink (filename, linkbuf, sizeof (linkbuf) - 1);
 153   if (linklen > 0)
 154     {
 155       char *slash;
 156
 157       /* NUL-terminate the link.  */
 158       linkbuf[linklen] = '\0';
 159       /* Find the portion after the last slash.  */
 160       slash = strrchr (linkbuf, '/');
 161       return strdup (slash != NULL ? slash + 1 : linkbuf);
 162     }
 163
 164 #endif
 165
 166 #if defined __minix                                         /* Minix */
 167
 168   /* Read the contents of /proc/<pid>/psinfo into memory.  */
 169   char filename[6 + 10 + 7 + 1];
 170   int fd;
 171
 172   sprintf (filename, "/proc/%u/psinfo", (unsigned int) pid);
 173   fd = open (filename, O_RDONLY | O_CLOEXEC);
 174   if (fd >= 0)
 175     {
 176       char buf[4096 + 1];
 177       ssize_t nread = read (fd, buf, sizeof (buf) - 1);
 178       close (fd);
 179       if (nread >= 0)
 180         {
 181           char *p;
 182           int count;
 183
 184           /* NUL-terminate the buffer.  */
 185           buf[nread] = '\0';
 186
 187           /* Search for the 4th space-separated field.  */
 188           p = strchr (buf, ' ');
 189           for (count = 1; p != NULL && count < 3; count++)
 190             p = strchr (p + 1, ' ');
 191           if (p != NULL)
 192             {
 193               char *start = p + 1;
 194               char *end = strchr (p + 1, ' ');
 195               if (end != NULL)
 196                 {
 197                   *end = '\0';
 198                   return strdup (start);
 199                 }
 200             }
 201         }
 202     }
 203
 204 #endif
 205
 206 #if defined __sun                                           /* Solaris */
 207
 208   /* Read the symlink /proc/<pid>/path/a.out.
 209      When it succeeds, it doesn't truncate.  */
 210   {
 211     char filename[6 + 10 + 11 + 1];
 212     char linkbuf[1024 + 1];
 213     ssize_t linklen;
 214
 215     sprintf (filename, "/proc/%u/path/a.out", (unsigned int) pid);
 216     linklen = readlink (filename, linkbuf, sizeof (linkbuf) - 1);
 217     if (linklen > 0)
 218       {
 219         char *slash;
 220
 221         /* NUL-terminate the link.  */
 222         linkbuf[linklen] = '\0';
 223         /* Find the portion after the last slash.  */
 224         slash = strrchr (linkbuf, '/');
 225         return strdup (slash != NULL ? slash + 1 : linkbuf);
 226       }
 227   }
 228
 229   /* But it may fail with "Permission denied".  As a fallback,
 230      read the contents of /proc/<pid>/psinfo into memory.
 231      Alternatively, we could read the contents of /proc/<pid>/status into
 232      memory.  But it contains a lot of information that we don't need.  */
 233   {
 234     char filename[6 + 10 + 7 + 1];
 235     int fd;
 236
 237     sprintf (filename, "/proc/%u/psinfo", (unsigned int) pid);
 238     fd = open (filename, O_RDONLY | O_CLOEXEC);
 239     if (fd >= 0)
 240       {
 241         /* The contents is a 'struct psinfo'.  But since 'struct psinfo'
 242            has a different size in a 32-bit and a 64-bit environment, we
 243            avoid it.  Nevertheless, the size of this contents depends on
 244            whether the process that reads it is 32-bit or 64-bit!  */
 245         #if defined __LP64__
 246         # define PSINFO_SIZE 416
 247         # define PSINFO_FNAME_OFFSET 136
 248         #else
 249         # define PSINFO_SIZE 336
 250         # define PSINFO_FNAME_OFFSET 88
 251         #endif
 252         char buf[PSINFO_SIZE];
 253         ssize_t nread = read (fd, buf, sizeof (buf));
 254         close (fd);
 255         if (nread >= PSINFO_FNAME_OFFSET + 16)
 256           {
 257             /* Make sure it's NUL-terminated.  */
 258             buf[PSINFO_FNAME_OFFSET + 16] = '\0';
 259             return strdup (&buf[PSINFO_FNAME_OFFSET]);
 260           }
 261       }
 262   }
 263
 264 #endif
 265
 266 #if defined __OpenBSD__                                     /* OpenBSD */
 267
 268   /* Documentation: https://man.openbsd.org/sysctl.2  */
 269   int info_path[] =
 270     { CTL_KERN, KERN_PROC, KERN_PROC_PID, pid, sizeof (struct kinfo_proc), 1 };
 271   struct kinfo_proc info;
 272   size_t len;
 273
 274   len = sizeof (info);
 275   if (sysctl (info_path, 6, &info, &len, NULL, 0) >= 0 && len == sizeof (info))
 276     return strdup (info.p_comm);
 277
 278 #endif
 279
 280 #if defined __APPLE__ && defined __MACH__                   /* Mac OS X */
 281 # if MAC_OS_X_VERSION_MAX_ALLOWED >= 1050
 282
 283   /* Mac OS X >= 10.7 has PROC_PIDT_SHORTBSDINFO.  */
 284 #  if defined PROC_PIDT_SHORTBSDINFO
 285 #   if MAC_OS_X_VERSION_MIN_REQUIRED < 1050
 286   if (proc_pidinfo != NULL) /* at runtime Mac OS X >= 10.5 ? */
 287 #   endif
 288     {
 289       struct proc_bsdshortinfo info;
 290
 291       if (proc_pidinfo (pid, PROC_PIDT_SHORTBSDINFO, 0, &info, sizeof (info))
 292           == sizeof (info))
 293         return strdup (info.pbsi_comm);
 294     }
 295 #  endif
 296
 297 #  if MAC_OS_X_VERSION_MIN_REQUIRED < 1070
 298   /* For older versions, use PROC_PIDTBSDINFO instead.  */
 299   /* Note: The second part of 'struct proc_bsdinfo' differs in size between
 300      32-bit and 64-bit environments, and the kernel of Mac OS X 10.5 knows
 301      only about the 32-bit 'struct proc_bsdinfo'.  Fortunately all the info
 302      we need is in the first part, which is the same in 32-bit and 64-bit.  */
 303 #   if MAC_OS_X_VERSION_MIN_REQUIRED < 1050
 304   if (proc_pidinfo != NULL) /* at runtime Mac OS X >= 10.5 ? */
 305 #   endif
 306     {
 307       struct proc_bsdinfo info;
 308
 309       if (proc_pidinfo (pid, PROC_PIDTBSDINFO, 0, &info, 128) == 128)
 310         return strdup (info.pbi_comm);
 311     }
 312 #  endif
 313
 314 # endif
 315 #endif
 316
 317 #if defined _AIX                                            /* AIX */
 318
 319   /* Reference: https://www.ibm.com/support/knowledgecenter/en/ssw_aix_61/com.ibm.aix.basetrf1/getprocs.htm
 320   */
 321   struct procentry64 procs;
 322   if (getprocs64 (&procs, sizeof procs, NULL, 0, &pid, 1) > 0)
 323     return strdup (procs.pi_comm);
 324
 325 #endif
 326
 327 #if defined __hpux                                          /* HP-UX */
 328
 329   char *p;
 330   struct pst_status status;
 331   if (pstat_getproc (&status, sizeof status, 0, pid) > 0)
 332     {
 333       char *ucomm = status.pst_ucomm;
 334       char *cmd = status.pst_cmd;
 335       if (strlen (ucomm) < PST_UCOMMLEN - 1)
 336         p = ucomm;
 337       else
 338         {
 339           /* ucomm is truncated to length PST_UCOMMLEN - 1.
 340              Look at cmd instead.  */
 341           char *space = strchr (cmd, ' ');
 342           if (space != NULL)
 343             *space = '\0';
 344           p = strrchr (cmd, '/');
 345           if (p != NULL)
 346             p++;
 347           else
 348             p = cmd;
 349           if (strlen (p) > PST_UCOMMLEN - 1
 350               && memcmp (p, ucomm, PST_UCOMMLEN - 1) == 0)
 351             /* p is less truncated than ucomm.  */
 352             ;
 353           else
 354             p = ucomm;
 355         }
 356       p = strdup (p);
 357     }
 358   else
 359     {
 360 # if !defined __LP64__
 361       /* Support for 32-bit programs running in 64-bit HP-UX.
 362          The documented way to do this is to use the same source code
 363          as above, but in a compilation unit where '#define _PSTAT64 1'
 364          is in effect.  I prefer a single compilation unit; the struct
 365          size and the offsets are not going to change.  */
 366       char status64[1216];
 367       if (__pstat_getproc64 (status64, sizeof status64, 0, pid) > 0)
 368         {
 369           char *ucomm = status64 + 288;
 370           char *cmd = status64 + 168;
 371           if (strlen (ucomm) < PST_UCOMMLEN - 1)
 372             p = ucomm;
 373           else
 374             {
 375               /* ucomm is truncated to length PST_UCOMMLEN - 1.
 376                  Look at cmd instead.  */
 377               char *space = strchr (cmd, ' ');
 378               if (space != NULL)
 379                 *space = '\0';
 380               p = strrchr (cmd, '/');
 381               if (p != NULL)
 382                 p++;
 383               else
 384                 p = cmd;
 385               if (strlen (p) > PST_UCOMMLEN - 1
 386                   && memcmp (p, ucomm, PST_UCOMMLEN - 1) == 0)
 387                 /* p is less truncated than ucomm.  */
 388                 ;
 389               else
 390                 p = ucomm;
 391             }
 392           p = strdup (p);
 393         }
 394       else
 395 # endif
 396         p = NULL;
 397     }
 398   if (p != NULL)
 399     return strdup (p);
 400
 401 #endif
 402
 403 #if defined __sgi                                           /* IRIX */
 404
 405   char filename[12 + 10 + 1];
 406   int fd;
 407
 408   sprintf (filename, "/proc/pinfo/%u", pid);
 409   fd = open (filename, O_RDONLY | O_CLOEXEC);
 410   if (0 <= fd)
 411     {
 412       prpsinfo_t buf;
 413       int ioctl_ok = 0 <= ioctl (fd, PIOCPSINFO, &buf);
 414       close (fd);
 415       if (ioctl_ok)
 416         {
 417           char *name = buf.pr_fname;
 418           size_t namesize = sizeof buf.pr_fname;
 419           /* It may not be NUL-terminated.  */
 420           char *namenul = memchr (name, '\0', namesize);
 421           size_t namelen = namenul ? namenul - name : namesize;
 422           char *namecopy = malloc (namelen + 1);
 423           if (namecopy)
 424             {
 425               namecopy[namelen] = '\0';
 426               return memcpy (namecopy, name, namelen);
 427             }
 428         }
 429     }
 430
 431 #endif
 432
 433 #if defined __CYGWIN__                                      /* Cygwin */
 434
 435   struct external_pinfo *info =
 436     (struct external_pinfo *) cygwin_internal (CW_GETPINFO, pid);
 437   if (info != NULL)
 438     {
 439       const char *name = info->progname;
 440       size_t namesize = sizeof (info->progname);
 441       /* It may not be NUL-terminated.  */
 442       const char *namenul = memchr (name, '\0', namesize);
 443       size_t namelen = namenul ? namenul - name : namesize;
 444
 445       /* Find the portion after the last backslash.
 446          Cygwin does not have memrchr().  */
 447       {
 448         const char *backslash = memchr (name, '\\', namelen);
 449         if (backslash != NULL)
 450           {
 451             const char *name_end = name + namelen;
 452             for (;;)
 453               {
 454                 const char *next_backslash =
 455                   memchr (backslash + 1, '\\', name_end - (backslash + 1));
 456                 if (next_backslash == NULL)
 457                   break;
 458                 backslash = next_backslash;
 459               }
 460             name = backslash + 1;
 461             namelen = name_end - name;
 462           }
 463       }
 464
 465       {
 466         char *namecopy = malloc (namelen + 1);
 467         if (namecopy)
 468           {
 469             namecopy[namelen] = '\0';
 470             return memcpy (namecopy, name, namelen);
 471           }
 472       }
 473     }
 474
 475 #endif
 476
 477 #if defined __BEOS__ || defined __HAIKU__                   /* BeOS, Haiku */
 478
 479   team_info info;
 480   if (_get_team_info (pid, &info, sizeof (info)) == B_OK)
 481     {
 482       const char *name = info.args;
 483       size_t namesize = sizeof (info.args);
 484       /* It may not be NUL-terminated.  */
 485       const char *namenul = memchr (name, '\0', namesize);
 486       size_t namelen = namenul ? namenul - name : namesize;
 487
 488       /* Take the portion up to the first space.  */
 489       {
 490         const char *space = memchr (name, ' ', namelen);
 491         if (space != NULL)
 492           namelen = space - name;
 493       }
 494
 495       /* Find the portion after the last slash.  */
 496       {
 497         const char *slash = memchr (name, '/', namelen);
 498         if (slash != NULL)
 499           {
 500             const char *name_end = name + namelen;
 501             for (;;)
 502               {
 503                 const char *next_slash =
 504                   memchr (slash + 1, '/', name_end - (slash + 1));
 505                 if (next_slash == NULL)
 506                   break;
 507                 slash = next_slash;
 508               }
 509             name = slash + 1;
 510             namelen = name_end - name;
 511           }
 512       }
 513
 514       {
 515         char *namecopy = malloc (namelen + 1);
 516         if (namecopy)
 517           {
 518             namecopy[namelen] = '\0';
 519             return memcpy (namecopy, name, namelen);
 520           }
 521       }
 522     }
 523
 524 #endif
 525
 526   return NULL;
 527 }
 528
 529 #ifdef TEST
 530
 531 #include <stdlib.h>
 532 #include <unistd.h>
 533
 534 /* Usage: ./a.out
 535    or:    ./a.out PID
 536  */
 537 int
 538 main (int argc, char *argv[])
 539 {
 540   char *arg = argv[1];
 541   pid_t pid = (arg != NULL ? atoi (arg) : getpid ());
 542   char *progname = get_progname_of (pid);
 543   printf ("PID=%lu COMMAND=%s\n",
 544           (unsigned long) pid, progname != NULL ? progname : "(null)");
 545   free (progname);
 546   return 0;
 547 }
 548
 549 /*
 550  * Local Variables:
 551  * compile-command: "gcc -ggdb -DTEST -Wall -I.. get_progname_of.c"
 552  * End:
 553  */
 554
 555 #endif