Zadanka od Podróżnika

FORK
-------------------------------------------------
#include <sys/types.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>

int main(int argc, char** argv)
{
    pid_t pid_potomka;
    char *komunikat;
    int powtorzen;
    printf("Na razie działa jeden proces\n");
    pid_potomka = fork();
    switch (pid_potomka)
    {
        case -1:
            printf("rozwidlenie procesu nie powiodlo sie\n");
            exit(1);
        case 0:
            komunikat = "Jestem potomkiem";
            powtorzen = 5;
            break;
        default:
            komunikat = "Jestem rodzicem";
            powtorzen = 5;
            break;
    }
    for (; powtorzen > 0; powtorzen--)
    {
        puts(komunikat);
        sleep(10);
    }
}

----------------------------------------------

#include <sys/types.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>

//odczytywanie PIDa potomka, obecnego procesu i rodzica

const int DL_NAPISU=80;

int main(int argc, char** argv)
{
    pid_t pid_potomka,pid_moj,pid_rodzica;
    char komunikat[DL_NAPISU];
    int powtorzen;
    printf("Na razie działa jeden proces\n");
    pid_potomka = fork();
    pid_rodzica=getppid();
    pid_moj=getpid();
    switch (pid_potomka)
    {
        case -1:
            perror("rozwidlenie procesu nie powiodło się");
            exit(1);
        case 0:
            snprintf(komunikat,DL_NAPISU,"Jestem potomkiem, PID potomka = %d, moj PID=%d a PID rodzica =%d",
                    pid_potomka,pid_moj,pid_rodzica);
            powtorzen = 5;
            break;
        default:
            snprintf(komunikat,DL_NAPISU,"Jestem rodzicem, PID potomka = %d, moj PID=%d a PID rodzica =%d",
                    pid_potomka,pid_moj,pid_rodzica);
            powtorzen = 5;
            break;
    }
    for (; powtorzen > 0; powtorzen--)
    {
        puts(komunikat);
        sleep(1);
    }
}

--------------------------------------------------------

#include <sys/types.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>

//zombie - potomek konczy wykonywanie wczesniej
//sierota - rodzic konczy wykonywanie wczesniej

const int DL_NAPISU=80;

int main(int argc, char** argv)
{
    pid_t pid_potomka,pid_moj,pid_rodzica;
    char komunikat[DL_NAPISU];
    int powtorzen;
    printf("Na razie dziala jeden proces\n");
    pid_potomka = fork();
    pid_rodzica=getppid();
    pid_moj=getpid();
    switch (pid_potomka)
    {
        case -1:
            perror("rozwidlenie procesu nie powiodlo sie\n);
            exit(1);
        case 0:
            snprintf(komunikat,DL_NAPISU,"Jestem potomkiem, PID potomka = %d, moj PID=%d a PID mojego rodzica =%d",
                    pid_potomka,pid_moj,pid_rodzica);
            powtorzen = 1;
            break;
        default:
            snprintf(komunikat,DL_NAPISU,"Jestem rodzicem, PID potomka = %d, moj PID=%d a PID mojego rodzica =%d",
                    pid_potomka,pid_moj,pid_rodzica);
            powtorzen =3;
            break;
    }
    for (; powtorzen > 0; powtorzen--)
    {
        puts(komunikat);
        sleep(1);
    }
    switch (pid_potomka)
    {   //wyswietlany listy procesow tuz przed zakonczeniem - dzieki temu mozna zaobserwowac status zombie
        case 0: system("ps -ef | grep fork3 | grep -v grep");
                printf("Jestem potomkiem i koncze wykonanie\n");
                break;
        default: system("ps -ef | grep fork3 | grep -v grep");
                 printf("Jetem rodzicem i koncze wykonanie\n");
                 break;
    }
}

---------------------------------------------

#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>

//zombie - potomek konczy wykonywanie wczesniej
//sierota - rodzic konczy wykonywanie wczesniej
//pasywne czekanie na zakonczenie potomka - rodzic jest blokowany

const int DL_NAPISU=80;

int main(int argc, char** argv)
{
    pid_t pid_potomka,pid_moj,pid_rodzica;
    char komunikat[DL_NAPISU];
    int powtorzen;
    int status=0;
    printf("Na razie dziala jeden proces\n");
    pid_potomka = fork();
    pid_rodzica=getppid();
    pid_moj=getpid();
    switch (pid_potomka)
    {
        case -1:
            perror("rozwidlenie procesu nie powiodlo sie\n");
            exit(1);
        case 0:
            snprintf(komunikat,DL_NAPISU,"Jestem potomkiem, PID potomka = %d, moj PID=%d a PID mojego rodzica =%d",
                    pid_potomka,pid_moj,pid_rodzica);
            powtorzen = 15;
            break;
        default:
            snprintf(komunikat,DL_NAPISU,"Jestem rodzicem, PID potomka = %d, moj PID=%d a PID mojego rodzica =%d",
                    pid_potomka,pid_moj,pid_rodzica);
            powtorzen = 5;
            break;
    }
    for (; powtorzen > 0; powtorzen--)
    {
        puts(komunikat);
        sleep(1);
    }
    switch (pid_potomka)
    {   //wyswietlamy listy procesow tuz przed zakonczeniem - obserwujemy status zombie
        case 0: system("ps aux | grep fork");
                printf("Jestem potomkiem i koncze wykonanie\n");
                break;
        default: printf("Jestem rodzicem i czekam na zakonczenie potomka\n");
                 //rodzic jest blokowany
                 pid_potomka=wait(&status);
                 printf("Jestem rodzicem, potomek o PID=%d wlasnie sie zakonczyl\n",pid_potomka);
                 system("ps aux | grep fork");
                 printf("Jetem rodzicem i koncze wykonanie\n");
                 break;
    }
}
.
.
.
.
default: pid_potomka=0;
                 //czekamy w petli na zakonczenie potomka - rodzic tez pracuje
while (pid_potomka==0){
printf("Jestem rodzicem i czekam na zakończenie potomka\n");
                        pid_potomka=waitpid(-1,       //dowolny proces potomny
                             &status,   //status
                           WNOHANG); //nie zatrzymuje procesu wywolujacego
                        sleep(1);}
                 printf("Jestem rodzicem, potomek o PID=%d wlasnie sie zakonczyl\n",pid_potomka);
                 //system("ps aux | grep fork");
                 printf("Jestem rodzicem i koncze wykonanie\n");
                 break;

---------------------------

SYGNAŁY

#include <signal.h>
#include <stdio.h>
#include <unistd.h>

//podstawowa wersja programu wyswietla cykliczne 3 napisy po nacisnieciu CTRL+C
//zakonczenie programu CTRL+\ (SIGQUIT)

char napisy[3][80]={"Ha! Ha! Ha! To tylko sygnal‚ powierzchowny!\n",
                    "Tylko proces %d smieje sie sygnalowi %d prosto w twarz!\n",
                    "Auc - to bolalo!\n"};
int nr_napisu=0;

void obsluga_sig_int(int sig)
{
    printf(napisy[nr_napisu],getpid(),sig);
    nr_napisu=((nr_napisu + 1) % 3);
}

int main(int argc, char** argv)
{
    signal(SIGINT,obsluga_sig_int);

    while (true)
    {
        printf("Czesc tu proces: %d\n",getpid());
        sleep(1);
    }

    return 0;
}


------------------------------
#include <stdlib.h>
#include <signal.h>
#include <stdio.h>
#include <unistd.h>

//podstawowy program zmodyfikowany tak aby konczyc sie po 4-tym nacisnieciu CTRL+C
char napisy[3][80]={"Ha! Ha! Ha! To tylko sygnal‚ powierzchowny!\n",
                    "Tylko proces %d smieje sie sygnalowi %d prosto w twarz!\n",
                    "Auc - to bolalo!\n"};
int nr_napisu=0;

void obsluga_sig_int(int sig)
{
    if (nr_napisu==3)
    {
        printf("Dobrze! Dobrze! Juz koncze!\n");
        exit(1);
    }
    printf(napisy[nr_napisu],getpid(),sig);
    nr_napisu++;
}

int main(int argc, char** argv)
{
    signal(SIGINT,obsluga_sig_int);

    while (true)
    {
        printf("Czesc tu proces: %d\n",getpid());
        sleep(1);
    }

    return 0;
}


--------------------------------

#include <stdlib.h>
#include <signal.h>
#include <stdio.h>
#include <unistd.h>

//przywracenie domyslnej obslugi CTRL+C za pomoca… SIGQUIT (CTRL+\)

char napisy[3][80]={"Ha! Ha! Ha! To tylko sygnal‚ powierzchowny!\n",
                    "Tylko proces %d smieje sie sygnalowi %d prosto w twarz!\n",
                    "Auc - to bolalo!\n"};
int nr_napisu=0;

void obsluga_sig_int(int sig)
{
    printf(napisy[nr_napisu],getpid(),sig);
    nr_napisu=(nr_napisu + 1) % 3;
}

void obsluga_sig_quit(int sig)
{
    printf("Przywracam domyslna obsluge CTRL+C\n");
    //makro SIG_DFL - domyslna obsluga sygnalu
    signal(SIGINT,SIG_DFL);
}

int main(int argc, char** argv)
{
    signal(SIGINT,obsluga_sig_int);
    signal(SIGQUIT,obsluga_sig_quit);

    while (true)
    {
        printf("Czesc tu proces: %d\n",getpid());
        sleep(1);
    }

    return 0;
}

----------------------------------

#include <stdlib.h>
#include <signal.h>
#include <stdio.h>
#include <unistd.h>

//przywracenie domyslnej obslugi CTRL+C za pomoca alarmu

char napisy[3][80]={"Ha! Ha! Ha! To tylko sygnal‚ powierzchowny!\n",
                    "Tylko proces %d smieje sie sygnalowi %d prosto w twarz!\n",
                    "Auc - to bolalo!\n"};
int nr_napisu=0;

void obsluga_sig_int(int sig)
{
    printf(napisy[nr_napisu],getpid(),sig);
    nr_napisu=(nr_napisu + 1) % 3;
}

void obsluga_sig_alrm(int sig)
{
    printf("Ding! Ding! - Przywracam standardowy CTRL+C\n");
    signal(SIGINT,SIG_DFL);
}

int main(int argc, char** argv)
{
    signal(SIGINT,obsluga_sig_int);
    signal(SIGALRM,obsluga_sig_alrm);

    //przywracamy domyslna obsluga po 15 sekundach
    alarm(15);

    while (true)
    {
        printf("Czesc tu proces: %d\n",getpid());
        sleep(1);
    }

    return 0;
}

------------------------------------

SYSTEMY PLIKOW

#include <sys/types.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>

//odczytywanie PID, UID i GID procesu

int main(int argc, char** argv)
{
    pid_t pid;
    uid_t uid;
    gid_t gid;
    uid_t euid;
    gid_t egid;
    pid=getpid();
    uid=getuid();
    gid=getgid();
    euid=geteuid();
    egid=getegid();
    system("id");
    printf("MĂłj numer procesu to PID=%d\n",pid);
    printf("Rzeczywisty identyfikator uzytkownika UID=%d i grupy GID=%d\n",uid,gid);
    printf(" Efektywny identyfikator uzytkownika UID=%d i grupy GID=%d\n",euid,egid);
    system("id");

    setuid(0);
    setgid(0);
    seteuid(0);
    setegid(0);
    uid=getuid();
    gid=getgid();
    euid=geteuid();
    egid=getegid();
    printf("Rzeczywisty identyfikator uzytkownika UID=%d i grupy GID=%d\n",uid,gid);
    printf(" Efektywny identyfikator uzytkownika UID=%d i grupy GID=%d\n",euid,egid);
    system("id");

    setuid(500);
    setgid(500);
    seteuid(500);
    setegid(500);
    uid=getuid();
    gid=getgid();
    euid=geteuid();
    egid=getegid();
    printf("Rzeczywisty identyfikator uzytkownika UID=%d i grupy GID=%d\n",uid,gid);
    printf(" Efektywny identyfikator uzytkownika UID=%d i grupy GID=%d\n",euid,egid);
    system("id");
}

------------------------

#include <sys/types.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <iostream>
#include <string.h>
using namespace std;

//zombie - potomek konczy wykowanie wczesniej
//sierota - rodzic konczy wykonanie wczesniej

int main(int argc, char** argv, char **envp)
{
    pid_t pid_potomka,pid_moj,pid_rodzica;
    printf("Na razie dziala jeden proces\n");

    char something[40];

    char katalog[150];
    getcwd(katalog, 150);
    printf("katalog biezacy to %s\n",katalog);

    pid_potomka = fork();
    pid_rodzica=getppid();
    pid_moj=getpid();
    switch (pid_potomka)
    {
        case -1:
            perror("rozwidlenie procesu nie powiodło się");
            exit(1);
        case 0:
            printf("Jestem potomkiem, PID potomka = %d, moj PID=%d a PID mojego rodzica =%d\n",
                    pid_potomka,pid_moj,pid_rodzica);
            getcwd(katalog, sizeof(katalog));
            printf("katalog biezacy potomka to %s\n",katalog);
            if (argv[1] == NULL)
                {
                    printf("Nie podales nazwy katalogu jako argumentu wywolania programu\n");
                    exit(1);
                }
            else
        {
                    strcpy(katalog,argv[1]);
                cout << "Enter your name: ";
                cin >> something;
                cout<<"Podales: "<<something<<"\n";
                }
            //chdir("/home/maciejp/Pulpit");
            //printf("podaj nazwe katalogu: ");
        //cin>>katalog;

            chdir(katalog);

            getcwd(katalog, sizeof(katalog));
            printf("Nowa wartosc katlogu roboczego odczytanego przez getcwd() to: %s\n",katalog);
            sleep(5);
            break;
        default:
            printf("Jestem rodzicem, PID potomka = %d, moj PID=%d a PID mojego rodzica =%d - koncze dzialanie\n",
                    pid_potomka,pid_moj,pid_rodzica);
            sleep(1);
            break;
    }
}

-------------------------------------

#include <sys/types.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <iostream>
#include <string.h>
#include <sys/stat.h>
using namespace std;

int main(int argc, char** argv, char **envp)
{
    char *ptr;

    if ( (ptr = getenv("HOME")) == (char *) 0)
        printf("HOME nie jest zdefiniowana\n");
    else
        printf("HOME=%s\n",ptr);
    exit(0);
}


------------------------------

#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <stdio.h>

int main(int argc, char *argv[])
{
    struct stat sb;
    int ret;

    if (argc < 2)
    {
        fprintf(stderr, "Uzycie programu:%s <nazwa pliku>\n", argv[0]);
        return 1;
    }
    ret=stat(argv[1], &sb);
    if (ret)
    {
        perror("stat");
        return 1;
    }
    printf("%s ma rozmiar %ld bajtow\n", argv[1], sb.st_size);
    return 0;
}
-----------------------------