ipc_pipe.c

schedule, threads & multi Matrix

/* 
 *  Operating System Practice
 *  Lab3
 *  Filename	: ipc_pipe.c
 *  Compile	: 
 *  Execute	: 
 */


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

#define TRANS_BUF 5
#define BUF_SIZE (TRANS_BUF + sizeof(int))


char ceasarEncrypt(char y);
void parseArgument(int argc, char ** argv);
void child();
void parent();

char buffer[BUF_SIZE];
int fd[2];


char inputFile[256];
char outputFile[256];

int main(int argc, char **argv)
{
    pid_t pid; /* variable to record process id of child */ 

    parseArgument(argc, argv);

	pipe(fd);

	
    if( (pid = fork()) == -1) /* check for error in spawning child process */
    {
        perror("error in fork");
        exit (1);
    }

    if (pid == 0)
    {
		/* Child process  */	
		child();	
	}
	else
	{
		/* Parent process */
		parent();
		
	}		
	return 0;
}

void parent()
{
    int read;
    int * transfer;
    FILE* input;
    FILE* wstream;

	

    close(fd[0]);

	wstream = fdopen(fd[1], "w");
	

    input = fopen(inputFile, "r");
    if(input == NULL)
    {
        printf("Error Input. Exit!\n");
        exit(1);
    }
    while(!feof(input))
    {
        read = fread(buffer + sizeof(int), sizeof(char), TRANS_BUF, input);
        transfer = (int *) buffer;
        // set the number of bytes going to transfer.
        *transfer = read;

        fwrite(buffer, sizeof(char), read + sizeof(int), wstream);
        fflush(wstream);
    }
    fclose(input);
    fclose(wstream);
}

void child()
{
    FILE* rstream;	
    FILE* output;
    
    int read;
    int i;
    int endOfStream = 0;
    int * transfer;

    char * beginData;
    close(fd[1]);
	rstream = fdopen(fd[0], "r");

    output = fopen(outputFile, "w");
    
    beginData = buffer + sizeof(int);

    while(!endOfStream)
    {
        read = fread(buffer, sizeof(char), BUF_SIZE, rstream);
        read -= sizeof(int);
        transfer = (int *) buffer;
        if(transfer == 0)
            break;

        if(*transfer < TRANS_BUF)
        {
            endOfStream = 1;
        }
        
        //encrypt string received
        for(i = 0; i < read; i++)
            beginData[i] = ceasarEncrypt(beginData[i]);
        
        fwrite(buffer + sizeof(int), sizeof(char), read, output);
    }

    fclose(rstream);
    fclose(output);
}

char ceasarEncrypt(char y)
{
	if(y == ' ')	
		return '\\';	
	else if ( ('A' <= y && y <= 'W') || ('a' <= y && y <= 'w') || ('0' <= y && y <= '6'))
		return y+3;	
	else if ( 'X' <= y && y <= 'Z' )	
		return y+9;
	else if ( 'x' <= y && y <= 'z' )
		return y-72;
	else if ( '7' <= y && y <= '9')
		return y+10;
	else
		return '*';
}

void parseArgument(int argc, char ** argv)
{
    int opt;
    int errFlag = 0;
    extern char * optarg;
    // parse command line 
    while((opt = getopt(argc, argv, "i:o:")) != EOF)
    {
        switch(opt){
            case 'i':
                strcpy(inputFile, optarg);
                errFlag++; 
                break;
            case 'o':
                strcpy(outputFile, optarg);
                errFlag++; 
                break;
            default:                
                break;
        }
    }
     
    if(errFlag != 2){
        printf("Usage: program -i <input file> -o <output file>\n");
        exit(1);
    }
}