[depream]

Hi @ all,

ich weiß nicht genau ob ich dieses Thema im richtigen Forum erstelle, aber ich habe leider keinen besseren gefunden welches zu meinem Problem passt.

Mein Problem:
Ich habe Übungsaufgaben für meine Prüfungsvorbereitung jedoch komme ich nicht mehr weiter, habe jede Mögliche Art und Weise meinerseits ausprobiert aber ich komme zu keinem Erfolg.

#include <string.h>
#include <cstdlib>
#include <iostream>
#include <unistd.h>  
#include <sys/wait.h>  
#include <sys/types.h>  
#include <signal.h> // für SIGINT

using namespace std;

pid_t childpid = 0;

// SIGINT (Ctrl+C) = Unterbrechung eines Prozesses
// Beispiel: firefox -> Ctrl+C unterbricht den Prozess!

void signalhandler_SIGINT(int signum) {
    cout << endl;
    cout << "Ein SIGINT wurde erkannt!\n";
}


// SIGTSTP (Ctrl+Z) = Anhalten eines Prozesses

void signalhandler_SIGTSTP(int signum) {
    //    if (childpid!=0){
    //        vpid.push_back(childpid);
    //        cout << "Stopped "<< child
    //        pid<<"\n";
    //        kill(childpid,SIGTSTP);
    //        childpid=0;
    //    }
    cout << "\nCaught SIGTSTP\n";
}

// Bringt einen "angehaltenen Prozess" durch 'Ctrl+C' in den Vordergrund!

void fg() {
    ;
}

// Zerlegt die "Getline"

void zerlegen(char *line, char **argv) {
    while (*line != '\0') {
        while (*line == ' ' || *line == '\t' || *line == '\n') {
            *line++ = '\0';
        }
        *argv++ = line;
        while (*line != '\0' && *line != ' ' && *line != '\t' && *line != '\n') {
            line++;
        }
    }
    *argv = '\0';
}

// Prüft ob ein &-Symbol im Char enthalten ist

bool aufUNDpruefen(char *argv) {
    for (int i = 0; i <= sizeof (argv); i++) {
        if (argv[i] == '&') {
            return true;
        }
    }
}

// Falls ein &-Zeichen vorhanden ist wird dieser gelöscht

char* UNDentfernen(char *argv) {
    for (int i = 0; i <= sizeof (argv); i++) {
        if (argv[i] == '&') {
            argv[i] = '\0';
            return argv;
        }
    }
}

void ausfuehren(char **argv) {
    pid_t pid = fork();

    bool containsAnd = false;

    containsAnd = aufUNDpruefen(*argv);

    if (containsAnd == true) {
        *argv = UNDentfernen(*argv);
    }

    int status;
    // Ein Fork darf nicht kleiner 0 sein, sonst schlägt dieser fehl!
    if (pid < 0) {
        cout << "FEHLER: 'forking' eines Kind-Prozesses fehlgeschlagen!\n";
        exit(1);

        // KIND-PROZESS:
        // Erst wenn die PID uns eine 0 zurückgibt kommen wir in das Kindprozess!!
    } else if (pid == 0) {
        if (execvp(*argv, argv) < 0) {
            // Zum Hinweis 5:
            // Falls das COMMAND nicht exisiert kommt es zum ERROR
            cout << "FEHLER: 'exec'!\n";
            exit(1);
        }

        //ELTERN-PROZESS:
        //da der Wert nur noch größer 0 sein kann also, PID > 0!
    } else {
        if (containsAnd == true) {
            ;
        }
        while (waitpid(pid, &status, WNOHANG) != pid) { // Wartet auf Beendigung des aktuellen Prozesses
                ;  
        }
    }
}

int main() {

    signal(SIGINT, signalhandler_SIGINT);
    signal(SIGTSTP, signalhandler_SIGTSTP);
    cout << "Signal Handler Installed\n";

    char line[1024];
    char *argv[64];

    //    if (signal(SIGCHLD, SIG_IGN) == SIG_ERR) {
    //        exit(1);
    //    }

    while (1) {
        cout << "SHELL-COMMAND: ";
        cin.getline(line, 1024);

        cout << "\n";
        zerlegen(line, argv);
        // Vergleiche ob Eingabe ein Logout ist [Aufgabe 1.4]
        if (strcmp(argv[0], "logout") == 0) {
            exit(0);
        } 
        ausfuehren(argv);
    }
    return 0;
}

Das ist mein bisheriger Code, dieser sei richtig, wobei es bestimmt ein Paar Verbesserungsvorschläge gibt



Das ist meine Aufgabenstellung. Da es leider keinen bestimmte Lösung gibt würde ich gerne mal hoffen, dass mir jemand behilflich sein könnte.

Ich erwarte keinen fertigen Code, besser wäre es, denn so verstehe ich einiges um so besser.

Danke im voraus.

[fightclub1]

Hmm, sieht so aus, als ob Du ein paar ganz grundsätzliche Verständnisprobleme hast.

- Signal-Callbacks sind ja zumindest registriert

- der Kommando-Parser ist grottig
-> ein sizeof( char* ) liefert was anderes als ein strlen(), so in aufUNDpruefen, UNDentfernen
-> Grundlagen von Strings in C!

- der Executer ist auch nix besonderes
-> Null-Pointer werden dereferenziert ohne Prüfung auf Gültigkeit (*argv)
-> Grundlagen Pointer in C!

Btw:
char buf[64];
char* buf[64];

sind auch zwei verschieden Paar Schuhe...

Das sind aber Verständnisfragen, die du selber lösen musst. Literatur-Tipp: K&R: "Programmieren in C" oder Eckel: Thinking in C++