Determinar programáticamente si un programa se está ejecutando

En C, ¿cómo puedo averiguar mediante programación si un proceso ya se está ejecutando en Linux/Ubuntu para evitar que se inicie dos veces? Estoy buscando algo similar a pidof.

Puedes caminar por pid entradas en /proc y verifique su proceso en cualquiera de los cmdline presentar o realizar una readlink sobre el exe link (Lo siguiente usa el primer método).

#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;
}

Este es el mismo código publicado por John Ledbetter. Es bueno consultar el archivo llamado stat en el directorio /proc/pid/ que cmdline ya que el primero proporciona los estados del proceso y el nombre del proceso. El archivo cmdline proporciona argumentos completos con los que se inicia el proceso. Entonces eso falla en algunos casos. De todos modos, la idea dada por John es buena. Aquí publiqué el código modificado de John. Estaba buscando el código en c en Linux para verificar si dhcp se está ejecutando o no. Con este código, soy capaz de hacer eso. Espero que pueda ser útil para alguien como yo.

#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;
}

Hay formas de evitar /proc uso (y puede haber buenas razones para hacerlo, por ejemplo, /proc podría no estar instalado en absoluto, y/o podría haber sido vinculado a algo engañoso, o ese pid se ha ocultado en /proc). De acuerdo, el siguiente método no se ve tan bien, ¡ojalá hubiera una API adecuada para eso!

De todos modos, la sección 1.9 de un 1997 Preguntas frecuentes sobre la programación de Unix dice:

Utilizar kill() con 0 para el número de señal. Hay cuatro posibles resultados de esta llamada:

• kill() devuelve 0

  Esto implica que existe un proceso con el PID dado, y el sistema le permitiría enviarle señales. Depende del sistema si el proceso podría ser un zombi.

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

  O no existe ningún proceso con el PID dado o las mejoras de seguridad están causando que el sistema niegue su existencia. (En algunos sistemas, el proceso podría ser un zombi).

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

  El sistema no le permitiría eliminar el proceso especificado. Esto significa que el proceso existe (nuevamente, podría ser un zombi) o hay mejoras de seguridad draconianas (por ejemplo, su proceso no puede enviar señales a cualquiera).

• kill() devuelve -1, con algún otro valor de errno

  ¡Estás en problemas!

La técnica más utilizada es asumir que el éxito o el fracaso con EPERM
implica que el proceso existe, y cualquier otro error implica que no existe.

pidof funciona caminando sobre el /proc sistema de archivos. En C, podrías hacer algo similar enumerando /proc; apertura /proc/X/cmdline para cada X donde X es una lista de uno o más números decimales. No sé si tienes algún requisito de portabilidad, pero tenlo en cuenta si vas a confiar en la disponibilidad de /proc.

Este problema se resuelve más comúnmente en sistemas similares a UNIX ajustando el inicio del programa y manteniendo un archivo PID. Ver /etc/init.d/* para ejemplos clásicos de este enfoque. Deberá tener cuidado para asegurarse de que el código que lee o escribe el archivo PID lo hace de manera segura (atómicamente). Si su sistema operativo de destino tiene un init más capaz (como sistemad), es posible que pueda externalizar este trabajo a eso.