Immer die PID von popen

Ich habe ein Programm, das mit popen() um Sie zu öffnen und Lesen Sie die Ausgabe aus einer shell-Befehl. Das problem ist, soweit ich das beurteilen kann, gibt es keinen einfachen Weg, um die PID des Laufenden Prozesses, und daher können Sie nicht töten, wenn es klemmt. Die Frage ist also, wie können Sie abrufen, die PID von einem Prozess geöffnet mit popen?

Sind Sie wollen die PID des /bin/sh Prozess, wird hervorgebracht, oder einer der eventuell mehreren anderen Prozessen, die erzeugt werden als Ergebnis von was auch immer Befehlszeile übergeben wird, um /bin/sh? Im Allgemeinen Fall, es ist nicht unbedingt nur ein PID hier, das ist wahrscheinlich zumindest ein Teil der Grund ist es nicht ohne weiteres verfügbar...
Ja, /bin/sh sollte ausreichen - ich wollte nur etwas-nichts -, die mir erlauben würde, zu töten Prozesse wie iperf-server-Modus.
warum nutzen Sie nicht system("killall -9 iperf")? und was ist der Nachteil bei diesem? Grüße, ugesh
killall -9 iperf würde alle töten iperf-Prozesse system-weit, auch wenn es nichts zu tun hat mit meinem speziellen Anwendung. Plus, es ist nicht nur iperf, die ich brauche, um zu töten, sondern auch Befehle wie ping oder curl.

InformationsquelleAutor Gillespie | 2014-11-10

c c++pid popen

11

Die Lösung kam ich mit (und der Konsens) ist das erstellen eines neuen popen Funktion, die mir erlaubt, abrufen der PID. Da war ich nicht in der Lage zu finden, ein einfaches Beispiel SO, ich wollte nach meiner Umsetzung in der Hoffnung, dass es hilft jemand anderes. Feedback und Alternative Lösungen sind willkommen.
```
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <signal.h>
#include <string.h>
#include <sys/wait.h>
#include <errno.h>
#include <string>
#include <sstream>

using namespace std;

#define READ   0
#define WRITE  1
FILE * popen2(string command, string type, int & pid)
{
    pid_t child_pid;
    int fd[2];
    pipe(fd);

    if((child_pid = fork()) == -1)
    {
        perror("fork");
        exit(1);
    }

    /* child process */
    if (child_pid == 0)
    {
        if (type == "r")
        {
            close(fd[READ]);    //Close the READ end of the pipe since the child's fd is write-only
            dup2(fd[WRITE], 1); //Redirect stdout to pipe
        }
        else
        {
            close(fd[WRITE]);    //Close the WRITE end of the pipe since the child's fd is read-only
            dup2(fd[READ], 0);   //Redirect stdin to pipe
        }

        setpgid(child_pid, child_pid); //Needed so negative PIDs can kill children of /bin/sh
        execl("/bin/sh", "/bin/sh", "-c", command.c_str(), NULL);
        exit(0);
    }
    else
    {
        if (type == "r")
        {
            close(fd[WRITE]); //Close the WRITE end of the pipe since parent's fd is read-only
        }
        else
        {
            close(fd[READ]); //Close the READ end of the pipe since parent's fd is write-only
        }
    }

    pid = child_pid;

    if (type == "r")
    {
        return fdopen(fd[READ], "r");
    }

    return fdopen(fd[WRITE], "w");
}

int pclose2(FILE * fp, pid_t pid)
{
    int stat;

    fclose(fp);
    while (waitpid(pid, &stat, 0) == -1)
    {
        if (errno != EINTR)
        {
            stat = -1;
            break;
        }
    }

    return stat;
}

int main()
{
    int pid;
    string command = "ping 8.8.8.8"; 
    FILE * fp = popen2(command, "r", pid);
    char command_out[100] = {0};
    stringstream output;

    //Using read() so that I have the option of using select() if I want non-blocking flow
    while (read(fileno(fp), command_out, sizeof(command_out)-1) != 0)
    {
        output << string(command_out);
        kill(-pid, 9);
        memset(&command_out, 0, sizeof(command_out));
    }

    string token;
    while (getline(output, token, '\n'))
        printf("OUT: %s\n", token.c_str());

    pclose2(fp, pid);

    return 0;
}
```
- Sie hätten zurückgegeben FILE* mithilfe fdopen
- Toller Vorschlag, da die original - popen zurück FILE * als gut. Ich aktualisierte mein code.
- Sie müssen auch eine pclose2 tun, die waitpid und die fclose
- Stimmt - habe ich aktualisiert. Es macht mich Frage mich, wie das orignal pclose() ist in der Lage, zum abrufen der pid des FILE * zur Verfügung gestellt.
- Sie können die Studie die Umsetzung von popen in einigen freie-software-libc z.B. popen.c von musl-libc
- Da Sie neugierig waren, glibc speichert die pid in die Datei struct 🙂
- Wird diese Arbeit auch richtig mit Multithread-Programm ?
- Ich habe Ihre test main und es hört nie auf, da es tötet die sh aber nicht das ping - 13446 root 928 S /bin/sh -c ping 8.8.8.8 13447 root 924 S ping 8.8.8.8 und wenn töten aufgerufen wird, in der test-code: 13446 root 0 Z [sh] 13447 root 924 S ping 8.8.8.8 - und while-Schleife nie beendet, aber es liest ping-Antwort die ganze Zeit
- Welches OS verwenden Sie? Es funktioniert bei mir auf beiden Ubuntu und Yocto-Projekt Embedded Linux. Möglicherweise müssen Sie ändern popen2 leicht an Ihre Bedürfnisse anpassen.
- busybox, debian Geschmack embedded system... aber paar mal versucht und kein Glück... Kind einer popen2 Schritte-Programm noch weiter zu arbeiten...
- Töten Sie den negativen Wert des PID - verschickt wird das kill-signal an alle Kinder von /bin/sh als gut.
- Basiert eigentlich auf popen.c es sieht aus wie die pids gespeichert werden in einem statischen array, die ist unzugänglich, außerhalb der popen.c
- und Sie werden auch wahrscheinlich benötigen, um hinzuzufügen setpgid(child_pid, child_pid); zu popen2 (siehe oben), so dass der erzeugte Prozess hat seine eigene Gruppen-id.
- Ich habe versucht, die definierten Funktionen, sondern fand auch heraus, dass die pid im C-Programm wurde von der anderen wieder durch den terminal-Befehl pgrep suchen und am Ausgang des ps -aux | grep myNameProc es schien den Prozess der das C-Programm wurde die Gabel einmal mehr seit execl("/bin/sh", "/bin/sh", "-c", command.c_str(), NULL); ist eigentlich die Schaffung eines anderen Prozesses, der nicht /bin/sh cmd string. Ich löste Sie Folgendes tun: execl(command.c_str(), command.c_str(), (char*)NULL);
- Ja, das wird funktionieren, nur im Kopf behalten, werden Sie nicht in der Lage, Argumente zu Ihrem Programm. /bin/sh -c können Sie einen Befehl mit Argumenten.
- Aufruf exit() nach einem gescheiterten exec() rufen Sie in einem Kind-Prozess ist eine schlechte Idee. Das wird bündig alle gepufferten Daten kopiert vom übergeordneten Prozess zum übergeordneten Prozess Bäche und rufen alle exit-Handler, dass der parent-Prozess registriert. In einem C++ Prozess, es wird auch dazu führen, statische Destruktoren ausgeführt. Der Aufruf exit() sollte ersetzt werden, mit _exit().
- Würde die exit() wegen der Gabel scheitern müssen ersetzt werden als gut, oder bedeutet die Tatsache, dass die Gabel versagt, bedeutet, dass die Eltern war Speicher nicht kopiert werden, das Kind (einschließlich atexit-Handler)?
InformationsquelleAutor Gillespie

KLÄRUNG

Ich habe versucht, die definierten Funktionen von @Gillespie ' s Antwort, fand aber heraus, dass die pid in der C/C++ Programm wurde von der anderen wieder durch den terminal-Befehl pgrep suchen und am Ausgang des ps -aux | grep myNameProc es schien den Prozess der das C-Programm wurde die Gabel einmal mehr.

Denke ich, weil execl("/bin/sh", "/bin/sh", "-c", command.c_str(), NULL); ist eigentlich äquivalent zu /bin/sh cmd string. Also im Grunde wird der Kind-Prozess der C (oder C++) - Programm ist das erstellen eines neuen Prozess, der nicht /bin/sh yourRealProcess wo yourRealProcess ist, das angegeben wird das die command string.

Löste ich wie folgt: execl(command.c_str(), command.c_str(), (char*)NULL);. Jedoch, wie angegeben durch @Gillespie in der vorherigen Kommentare, die in diese Weise werden Sie nicht in der Lage sein, Argumente übergeben an Ihren Prozess.

C-IMPLEMENTIERUNG

Nach meinen Bedürfnissen ich readapted @Gillespie Funktionen umfassen die oben diskutierten änderung und zur Arbeit in die C-Programmierung Sprache:

FILE * custom_popen(char* command, char type, pid_t* pid)
{
    pid_t child_pid;
    int fd[2];
    pipe(fd);

    if((child_pid = fork()) == -1)
    {
        perror("fork");
        exit(1);
    }

    /* child process */
    if (child_pid == 0)
    {
        if (type == 'r')
        {
            close(fd[0]);    //Close the READ end of the pipe since the child's fd is write-only
            dup2(fd[1], 1); //Redirect stdout to pipe
        }
        else
        {
            close(fd[1]);    //Close the WRITE end of the pipe since the child's fd is read-only
            dup2(fd[0], 0);   //Redirect stdin to pipe
        }

        setpgid(child_pid, child_pid); //Needed so negative PIDs can kill children of /bin/sh
        execl(command, command, (char*)NULL);
        exit(0);
    }
    else
    {
        printf("child pid %d\n", child_pid);
        if (type == 'r')
        {
            close(fd[1]); //Close the WRITE end of the pipe since parent's fd is read-only
        }
        else
        {
            close(fd[0]); //Close the READ end of the pipe since parent's fd is write-only
        }
    }

    *pid = child_pid;

    if (type == 'r')
    {
        return fdopen(fd[0], "r");
    }

    return fdopen(fd[1], "w");
}

int custom_pclose(FILE * fp, pid_t pid)
{
    int stat;

    fclose(fp);
    while (waitpid(pid, &stat, 0) == -1)
    {
        if (errno != EINTR)
        {
            stat = -1;
            break;
        }
    }

    return stat;
}

InformationsquelleAutor Francesco Boi

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.