Lab10

#include <stdio.h>
#include <math.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <stdlib.h>
#include <err.h>
#include <sys/sem.h>
#include <err.h>
#include <string.h>


#define SHM_SIZE sizeof(char)


union semun
{
    int val;
    struct semid_ds *buf;
    unsigned short int *array;
    struct seminfo *__buf;
};

int semlock(int semid)
{

	struct sembuf opr;
    opr.sem_num =  0;
    opr.sem_op  = -1;
    opr.sem_flg =  0;

	if (semop(semid, &opr, 1) == -1){
    	warn("Blad blokowania semafora!");
    	return 0;
    }else{
    	return 1;
    }
}

int semunlock(int semid)
{
	struct sembuf opr;

    opr.sem_num = 0;
    opr.sem_op  = 1;
    opr.sem_flg = 0;

	if (semop(semid, &opr, 1) == -1)
    {
    	warn("Blad odblokowania semafora!");
    	return 0;
    }
    else
    {
    	return 1;
    }
}

int main(int argc, char *argv[])
{

    printf("Podaj nazwe pliku do otwarcia: ");
    char filename[20];
    char text[256];
    char ch;
    int caesarkey;
    scanf("%s", filename);
    FILE* file = fopen(filename, "r+");
    if(file == NULL) {
        printf("Blad przy odczytywaniu pliku!");
        return -1;
    }
    printf("Otworzono plik. Podaj klucz do szyfru Cezara: ");

    scanf("%d", &caesarkey);
    caesarkey%=256;
    int i = 0; // wczytywanie
    while((ch = fgetc(file)) != EOF) {
        text[i]= ch;
        i++;
    }
    text[i] = '\0';
    printf("Wczytano:\n%s\n", text);
    printf("Podaj nazwe pliku do zapisu: ");
    char filename2[20];
    scanf("%s", filename2);
    FILE* file2 = fopen(filename2, "w+");
    if(file2 == NULL) {
        printf("Blad przy otwieraniu pliku do zapisu!");
        return -2;
    }


	key_t key1, key2;			// klucz dla semaforow
	int   semid1, semid2;	// ID semaforow
	union semun ctl;			// unia do kontroli semafora


	if ((key1 = ftok(".", 'A')) == -1)
        errx(1, "Blad tworzenia klucza!");

    if ((semid1 = semget(key1, 1, IPC_CREAT | 0600)) == -1)
    	errx(2, "Blad tworzenia semafora!");

    ctl.val = 1;
    if (semctl(semid1, 0, SETVAL, ctl) == -1)
    	errx(3, "Blad ustawiania semafora!");

	if ((key2 = ftok(".", 'B')) == -1)
        errx(1, "Blad tworzenia klucza!");

    if ((semid2 = semget(key2, 1, IPC_CREAT | 0600)) == -1)
    	errx(2, "Blad tworzenia semafora!");

    ctl.val = 1;
    if (semctl(semid2, 0, SETVAL, ctl) == -1)
    	errx(3, "Blad ustawiania semafora!");

	semlock(semid2);


    int datakey;
    if ((datakey = ftok(".", 'A')) == -1)
    errx(1, "Blad tworzenia klucza!");
    int shmid;
    char *shm;
    if ((shmid = shmget(datakey, SHM_SIZE, IPC_CREAT | 0666)) < 0)
    	errx(2, "Blad tworzenia segmentu pamieci dzielonej!");
    if ((shm = shmat(shmid, NULL, 0)) == (char *) -1)
    	errx(3, "Blad przylaczania pamieci dzielonej!");

    int ilosc_znakow = strlen(text);
    int j = 0;

    if(fork())
    {
        for(i = 0; i < ilosc_znakow; i++)
        {
            semlock(semid1);
            char*floatmem = (char*)shm;
            *floatmem = text[j++];
            printf("Znak w PP1: %c\n", *floatmem);
            fflush(stdout);
            semunlock(semid2);
        }
    }
    else
    {
        for(i = 0; i < ilosc_znakow; i++)
        {
            semlock(semid2);
            char*floatmem = (char*)shm;
            char znak= *floatmem;
            printf("Znak w PP2: %c\n", znak);

            if(znak>='a' && znak<='z') { // szyfrowanie
                znak+=caesarkey;
                if(znak > 'z' )
                    znak-=26;
            }
            if(znak>='A' && znak<='Z') {
                znak+=caesarkey;
                if(znak > 'Z' )
                    znak-=26;
            }
            printf("Zaszyfrowany znak w PP2: %c\n", znak);
            fprintf(file2,"%c",znak);

            semunlock(semid1);
        }
    }
    shmdt(shm);
	shmctl(shmid, IPC_RMID, NULL);

    return 0;
}