projekt5

// includes.h

#ifndef INCLUDES_H
#define INCLUDES_H

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <sys/wait.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <sys/shm.h>
#include <errno.h>

#endif

// semafory.h

#ifndef SEMAFORY_H
#define SEMAFORY_H

int semafor;

void semafor_create(void);
void semafor_set(void);
void semafor_wait(unsigned short sem_number);
void semafor_signal(unsigned short sem_number);
void semafor_delete(void);
void semafor_access_child(void);

#endif

// semafory.c

#include "semafory.h"
#include "includes.h"

void semafor_create(void)
{
  key_t klucz = ftok(".", 'A');

  if (klucz == -1)
  {
    perror("Błąd ftok\n");
    exit(-1);
  }
  else
    semafor = semget(klucz, 2, 0600 | IPC_CREAT | IPC_EXCL);

  if (semafor == -1)
  {
    printf("Błąd utworzenia semafora\n");
    exit(EXIT_FAILURE);
  }
  else
    printf("Semafor został utworzony: %d\n", semafor);
}

void semafor_access_child(void)
{
  key_t klucz = ftok(".", 'A');

  if (klucz == -1)
  {
    perror("Błąd ftok\n");
    exit(-1);
  }
  else
    semafor = semget(klucz, 1, 0600 | IPC_CREAT);

  if (semafor == -1)
  {
    printf("Błąd dostępu do semafora dziecka\n");
    exit(EXIT_FAILURE);
  }
  else
    printf("Semafor został odnaleziony i uzyskał dostęp: %d\n", semafor);
}

void semafor_set(void)
{
  int ustaw_sem;
  unsigned short arr[2] = {1, 0};

  ustaw_sem = semctl(semafor, 0, SETALL, arr);

  if (ustaw_sem == -1)
  {
    printf("Błąd ustawiania semafora\n");
    exit(EXIT_FAILURE);
  }
  else
    printf("Semafory zostały ustawione.\n");
}

void semafor_wait(unsigned short sem_number)
{
  int zmien_sem;
  struct sembuf bufor_sem;
  bufor_sem.sem_num = sem_number;
  bufor_sem.sem_op = -1;
  bufor_sem.sem_flg = 0;

  for (;;)
  {
    zmien_sem = semop(semafor, &bufor_sem, 1);

    if (zmien_sem == 0 || errno != 4)
      break;
  }

  if (zmien_sem == -1 && errno != 4)
  {
    printf("Błąd zamykania semafora\n");
    semafor_delete();
    exit(EXIT_FAILURE);
  }
  else
  {
    int stan = semctl(semafor, 0, GETVAL);
    if (stan != -1)
    {
      printf("Stan semafora wait() = %d\n", stan);
      printf("\tsemafor_wait() - opuszczanie semafora\n");
    }
  }
}

void semafor_signal(unsigned short sem_number)
{
  int zmien_sem;
  struct sembuf bufor_sem;
  bufor_sem.sem_num = sem_number;
  bufor_sem.sem_op = 1;
  bufor_sem.sem_flg = 0;

  for (;;)
  {
    zmien_sem = semop(semafor, &bufor_sem, 1);

    if (zmien_sem == 0 || errno != 4)
      break;
  }

  if (zmien_sem == -1 && errno != 4)
  {
    printf("Błąd otwierania semafora\n");
    semafor_delete();
    exit(EXIT_FAILURE);
  }
  else
  {
    int stan = semctl(semafor, 0, GETVAL);
    if (stan != 1)
    {
      printf("Stan semafora signal() = %d\n", stan);
      printf("\tsemafor_signal() - podniesienie semafora\n");
    }
  }
}

void semafor_delete(void)
{
  int sem;
  sem = semctl(semafor, 0, IPC_RMID);

  if (sem == -1)
  {
    printf("Błąd usuwania semafora\n");
    exit(EXIT_FAILURE);
  }
  else
    printf("Semafory zostały usunięte. Kod: %d\n", sem);
}

// pamiec_dzielona.h

#ifndef PAMIEC_DZIELONA_H
#define PAMIEC_DZIELONA_H

int id_pamiec;
char *address;

void pd_create(int is_producent);
char *pd_address();
void pd_detach(int only_d2);

#endif

// pamiec_dzielona.c

#include "includes.h"
#include "pamiec_dzielona.h"
#include "semafory.h"

void pd_create(int is_producent)
{
  key_t klucz = ftok(".", 'B');

  if (klucz == -1)
  {
    perror("Błąd ftok\n");
    exit(-1);
  }
  else
  {
    if (is_producent == 1)
    {
      printf("Producent - shmget: ");
      id_pamiec = shmget(klucz, sizeof(char), 0600 | IPC_CREAT);
    }
    else
    {
      printf("Konsument - shmget: ");
      id_pamiec = shmget(klucz, sizeof(char), 0600 | IPC_CREAT);
    }
  }

  if (id_pamiec == -1)
  {
    printf("Błąd shmget: %d\n", errno);
    exit(-1);
  }
  else
    printf("Utworzono segment pamięci: %d\n", id_pamiec);
}

char *pd_address()
{
  char *address2;

  address2 = (char *)shmat(id_pamiec, 0, 0);

  if (address2 == (char *) -1)
  {
    perror("Błąd shmat\n");
    exit(-1);
  }
  else
    printf("Uzyskano adres %p segmentu pamięci %d\n", &address2, id_pamiec);

  address = address2;
  return address2;
}

void pd_detach(int only_d2)
{
  int d1, d2;

  if (!only_d2)
  {
    d1 = shmctl(id_pamiec, IPC_RMID, 0);
    d2 = shmdt(address);

    if (d1 == -1 || d2 == -1)
    {
      perror("Błąd shmctl lub shmdt\n");
      exit(-1);
    }
    else
      printf("Odłączono pamięć dzieloną: %d\n", id_pamiec);
  }
  else
  {
    d2 = shmdt(address);

    if (d2 == -1)
    {
      perror("Błąd shmdt\n");
      exit(-1);
    }
    else
      printf("Odłączono pamięć dzieloną: %d\n", id_pamiec);
  }
}

// producent.c

#include "includes.h"
#include "pamiec_dzielona.h"
#include "semafory.h"

int main()
{
  printf("Proces producenta: PID = %d\n", getpid());

  semafor_create();
  semafor_set();

  FILE *input_file;
  char ch = '0';

  pd_create(1);
  pd_address();

  input_file = fopen("./input.txt", "r");

  if (!input_file)
  {
    perror("Błąd odczytu pliku wejściowego\n");
    pd_detach(0);
    semafor_delete();
    exit(-1);
  }
  else
  {
    do
    {
      printf("\t\tProducent (%d): ", getpid());

      ch = (char) fgetc(input_file);

      if (ch != EOF)
      {
        semafor_wait(0);

        *address = ch;

        if (ch == 0x0A)
          printf("Producent - zapis (%d) = Enter\n", ch);
        else if (ch == 32)
          printf("Producent - zapis (%d) = Spacja\n", ch);
        else
          printf("Producent - zapis (%d) = (%c)\n", ch, ch);

        semafor_signal(1);
      }
    } while (ch != EOF);

    semafor_wait(0);
    *address = EOF;
    semafor_signal(1);
  }

  semafor_signal(1);

  if (ch == EOF)
  {
    semafor_signal(1);
    semafor_wait(0);
    fclose(input_file);
  }

  printf("Zakończenie pracy producenta.\n");

  return 0;
}

// konsument.c

#include "includes.h"
#include "pamiec_dzielona.h"
#include "semafory.h"

int main()
{
  printf("Proces konsumenta: PID = %d\n", getpid());

  semafor_access_child();

  FILE *output_file;
  char ch = '0';

  pd_create(0);
  pd_address();

  output_file = fopen("./output.txt", "w");

  if (!output_file)
  {
    perror("Błąd odczytu pliku wyjściowego\n");
    pd_detach(0);
    semafor_delete();
    exit(-1);
  }
  else
  {
    do
    {
      printf("\t\tKonsument (%d): ", getpid());

      semafor_wait(1);

      ch = *address;

      if (ch != EOF)
      {
        fputc(ch, output_file);

        if (ch == 0x0A)
          printf("Konsument - odczyt (%d) = Enter\n", ch);
        else if (ch == 32)
          printf("Konsument - odczyt (%d) = Spacja\n", ch);
        else
          printf("Konsument - odczyt (%d) = (%c)\n", ch, ch);

        semafor_signal(0);
      }
    } while (ch != EOF);
  }

  if (ch == EOF)
  {
    semafor_wait(1);
    fclose(output_file);
    semafor_signal(0);
    shmdt(address);
    shmctl(id_pamiec, IPC_RMID, 0);
  }

  semafor_delete();

  printf("Zakończenie pracy konsumenta.\n");

  return 0;
}