lukasz.proszek.info

Powrót do listy plików

---

cw3.c

/*
Program do własnej obsługi sygnałów.
*/

#include "cw3.h"

int
main (int argc, char *argv[])
{
// deklaracja zmiennych
  int i;
  int sig_ile;    //ilość sygnałów
  int *sig_id;    // identyfikator sygnału
  int *reakcja;   // reakcja na sygnał

//sprawdzenie ilości argumentów.
  if (argc == 1)
  {
    printf ("nie podano żadnych parametrów");
    printf ("\n wywoływanie: \n $ cw3.run <sig_id> <def|ign|obs>\n");
    printf ("aby usyskać instrukcję używania wywołaj program z parametrem --help\n");
    exit (0);
  }

/* strcmp zwraca 0 jeżeli stringi są równe więc aby uzyskać porządany efekt 
należy zrobić warunek na zaprzeczenie :) */

  if (!strcmp (argv[1], "--help"))
  {
    printf ("\n Program do własnej obsługi sygnałów.");
    printf ("\n wywoływanie: \n $ cw3.run <sig_id> <def|ign|obs>");
    printf ("\n \t sig_id \t identyfikator procesu (patrz lista)");
    printf ("\n \t def \t\t powoduje domyślną obsługę sygnału");
    printf ("\n \t ign \t\t powoduje ignorowanie sygnału (istnieją wyjątki - patrz lista)");
    printf ("\n \t obs \t\t powoduje własną obsługę sygnału (istnieją wyjątki - patrz lista)");
    printf ("\n \n argumenty podajemy parami (wyjątek --help), ilość dowolna");
    printf ("\n");
    printf ("\n lista sygnałów");
    printf ("\n wpisy w kolumnie \"akcja\" oznaczają obsługę sygnału");
    printf ("\n \t Term \t ubicie procesu");
    printf ("\n \t Ign  \t ignorowanie sygnału");
    printf ("\n \t Core \t ubicie procesu ze zrzutem pamięci (core)");
    printf ("\n \t Stop \t zatrzymanie procesu");
    printf ("\n\n Sygnały w standardzie POSIX.1");
    printf ("\n");

/* z lenistwa reszta jest w pliku tekstowym :) */

    switch (fork ())
    {
    case -1:
      perror ("fork error");
      exit (1);
    case 0:
      printf ("aaa");
      execl ("/bin/cat", "cat", "./sygnaly.txt", NULL);
      perror ("execl error");
      exit (2);
    default:
      //wait();
      ;
    }

    exit (0);
  }

// sprawdzenie czy mamy dobrą ilość argumentów. KONIECZNIE po --help :)
  if ((argc - 1) % 2 == 1)
  {
    printf ("zła liczba argumentów. \nWyowałaj program z parametrem --help aby uzyskać pomoc\n");
    exit (0);
  }

// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
// FIXME sprawdzić czy argumenty są w prawidłowej formie
// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

// początek programu. po długiej przeprawie z --help :(

  printf ("Proces %d (czyli ja) czeka na sygnały\n", getpid ());

// ile mamy sygnałów. zagwarantowane mamy już że jest odpowiednia ilość argumentów
  sig_ile = (argc - 1) / 2;

// dynamiczna rezerwacja pamieci na argumenty 

  sig_id = (int *) malloc (sig_ile * sizeof (int));
  reakcja = (int *) malloc (sig_ile * sizeof (int));

  for (i = 0; i < sig_ile * 2; i += 2)
  {     /* przypisanie argumentow do odpowiednich zmiennych */

    sig_id[i / 2] = zamien_id (argv[i + 1]);
    reakcja[i / 2] = zamien_reakcje (argv[i + 2]);
    printf ("Dla sygnalu %s=%i mam wykonac operację %s=%i\n",
      argv[i + 1], sig_id[i / 2], argv[i + 2],
      reakcja[i / 2]);
  }

  for (i = 0; i < sig_ile; i++)
  {     /* a teraz bedziemy juz ustawiac reakcje na dane sygnaly */
    if ((sig_id[i] == 9) || (sig_id[i] == 19))
    {
      printf ("zmiana obsługi sygnału nr %i jest niedozwolona\n Opuszczenie programu\n\n", sig_id[i]);
      exit (0);
    }

    switch (reakcja[i])
    {
    case 0: //defaultowa akcja
      if (signal (sig_id[i], SIG_DFL) == SIG_ERR)
      {
        perror ("Problem z operacja domyslna dla sygnalu...");
        exit (1);
      }
      break;

    case 1: //ignorowanie
      if (signal (sig_id[i], SIG_IGN) == SIG_ERR)
      {
        perror ("Problem ze zignorowaniem sygnalu...");
        exit (2);
      }
      break;
    case 2: //przechwyt
      if (signal (sig_id[i], przechwyt) == SIG_ERR)
      {
        perror ("Problem z przechwyceniem sygnalu");
        exit (3);
      }
      break;
    }
  }

  while (101 % 2 != 0)  //poczekamy sobie do sygnału zakończenia
    pause ();

  return 0;
}

void 
przechwyt (int a)
{
  printf ("nastapiło przechwycenie sygnału\n");
}

int
zamien_reakcje (char *re)
{
  if (!strcmp (re, "def"))
    return 0;
  else if (!strcmp (re, "ign"))
    return 1;
  else if (!strcmp (re, "obs"))
    return 2;
  else
  {
    printf ("zły typ obsługi. \nwywołaj program z opcją --help aby otrzymac więcej informacji\n");
    exit (0);
  }
}


int
zamien_id (char *id)
{
  if ((atoi (id) == 1) || (!strcmp (id, "HUP")))
    return 1;
  else if ((atoi (id) == 2) || (!strcmp (id, "INT")))
    return 2;
  else if ((atoi (id) == 3) || (!strcmp (id, "QUIT")))
    return 3;
  else if ((atoi (id) == 4) || (!strcmp (id, "ILL")))
    return 4;
  else if ((atoi (id) == 6) || (!strcmp (id, "ABRT")))
    return 6;
  else if ((atoi (id) == 8) || (!strcmp (id, "FPE")))
    return 8;
  else if ((atoi (id) == 9) || (!strcmp (id, "KILL")))
    return 9;
  else if ((atoi (id) == 11) || (!strcmp (id, "SEGV")))
    return 11;
  else if ((atoi (id) == 13) || (!strcmp (id, "PIPE")))
    return 13;
  else if ((atoi (id) == 14) || (!strcmp (id, "ALRM")))
    return 14;
  else if ((atoi (id) == 15) || (!strcmp (id, "TERM")))
    return 15;
  else if ((atoi (id) == 10) || (!strcmp (id, "USR1")))
    return 10;
  else if ((atoi (id) == 12) || (!strcmp (id, "USR2")))
    return 12;
  else if ((atoi (id) == 17) || (!strcmp (id, "CHLD")))
    return 17;
  else if ((atoi (id) == 18) || (!strcmp (id, "CONT")))
    return 18;
  else if ((atoi (id) == 19) || (!strcmp (id, "STOP")))
    return 19;
  else if ((atoi (id) == 20) || (!strcmp (id, "TSTP")))
    return 20;
  else if ((atoi (id) == 21) || (!strcmp (id, "TTIN")))
    return 21;
  else if ((atoi (id) == 22) || (!strcmp (id, "TTOU")))
    return 22;
  else
  {
    printf ("zły identyfikator procesu. \nwywołaj program z opcją --help aby otrzymac więcej informacji\n");
    exit (0);
  }
}

---

składania pokolorowana przez Code2HTML, v. 0.9.1