Determine programmatically if a program is running

You can walk the pid entries in /proc and check for your process in either the cmdline file or perform a readlink on the exe link (The following uses the first method).

#include <stdlib.h>#include <stdio.h>#include <string.h>#include <unistd.h>#include <dirent.h>#include <sys/types.h>pid_t proc_find(const char* name) {    DIR* dir;    struct dirent* ent;    char* endptr;    char buf[512];    if (!(dir = opendir("/proc"))) {        perror("can't open /proc");        return -1;    }    while((ent = readdir(dir)) != NULL) {        /* if endptr is not a null character, the directory is not         * entirely numeric, so ignore it */        long lpid = strtol(ent->d_name, &endptr, 10);        if (*endptr != '\0') {            continue;        }        /* try to open the cmdline file */        snprintf(buf, sizeof(buf), "/proc/%ld/cmdline", lpid);        FILE* fp = fopen(buf, "r");        if (fp) {            if (fgets(buf, sizeof(buf), fp) != NULL) {                /* check the first token in the file, the program name */                char* first = strtok(buf, " ");                if (!strcmp(first, name)) {                    fclose(fp);                    closedir(dir);                    return (pid_t)lpid;                }            }            fclose(fp);        }    }    closedir(dir);    return -1;}int main(int argc, char* argv[]) {    if (argc == 1) {        fprintf("usage: %s name1 name2 ...\n", argv[0]);        return 1;    }    int i;    for(int i = 1; i < argc; ++i) {        pid_t pid = proc_find(argv[i]);        if (pid == -1) {            printf("%s: not found\n", argv[i]);        } else {            printf("%s: %d\n", argv[i], pid);        }    }    return 0;}

This is the same as the code posted by John Ledbetter . It is good to refer to the file named stat in /proc/pid/ directory than cmdline since the former gives process states and process name. The cmdline file gives complete arguments with which the process is started. So that fails in some cases. Any way the idea given by John is good. Here I posted the modified code of John. I was looking for the code in c in Linux to check dhcp is running or not . With this code, I am able to do that. I hope it may be useful for someone like me.

#include <sys/types.h>#include <dirent.h>#include<unistd.h>#include <stdio.h>#include <string.h>#include <stdlib.h>pid_t proc_find(const char* name) {    DIR* dir;    struct dirent* ent;    char buf[512];    long  pid;    char pname[100] = {0,};    char state;    FILE *fp=NULL;     if (!(dir = opendir("/proc"))) {        perror("can't open /proc");        return -1;    }    while((ent = readdir(dir)) != NULL) {        long lpid = atol(ent->d_name);        if(lpid < 0)            continue;        snprintf(buf, sizeof(buf), "/proc/%ld/stat", lpid);        fp = fopen(buf, "r");        if (fp) {            if ( (fscanf(fp, "%ld (%[^)]) %c", &pid, pname, &state)) != 3 ){                printf("fscanf failed \n");                fclose(fp);                closedir(dir);                return -1;             }            if (!strcmp(pname, name)) {                fclose(fp);                closedir(dir);                return (pid_t)lpid;            }            fclose(fp);        }    }closedir(dir);return -1;}int main(int argc, char* argv[]) {    int i;    if (argc == 1) {        printf("usage: %s name1 name2 ...\n", argv[0]);        return 1;    }    for( i = 1; i < argc; ++i) {        pid_t pid = proc_find(argv[i]);        if (pid == -1) {            printf("%s: not found\n", argv[i]);        } else {            printf("%s: %d\n", argv[i], pid);        }    }    return 0;}

There are ways to avoid /proc usage (and there might be good reasons to do so, e.g. /proc might not be installed at all, and/or it might have been symlinked to something deceptive, or that pid has been hidden in /proc). Granted, the below method doesn't look that good, I wish there were a proper API for that!

Anyway, section 1.9 of a 1997 Unix programming FAQ says:

Use kill() with 0 for the signal number. There are four possible results from this call:

• kill() returns 0

  This implies that a process exists with the given PID, and the system would allow you to send signals to it. It is system-dependent whether the process could be a zombie.

• kill() returns -1, errno == ESRCH

  Either no process exists with the given PID, or security enhancements are causing the system to deny its existence. (On some systems, the process could be a zombie.)

• kill() returns -1, errno == EPERM

  The system would not allow you to kill the specified process. This means that either the process exists (again, it could be a zombie) or draconian security enhancements are present (e.g. your process is not allowed to send signals to anybody).

• kill() returns -1, with some other value of errno

  You are in trouble!

The most-used technique is to assume that success or failure with EPERMimplies that the process exists, and any other error implies that itdoesn't.