/* Program:    mygzip
 * Author:    Filip Hianik 0426173
 * Date:    27.05.2007
 * Purpose:    Der Programm liest von stdin Files die mit gzip zu komprimieren sind und komprimiert diese in einem File (falls dessen Name als Argument übergeben wird) oder in stdout.
 * Usage:    mygzip [file]
 * Beispiel:    3b_mygzip
 */


/*
 * ******************************************************************************************* defines ****
 */


#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <limits.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/wait.h>


/*
 * ******************************************************************************************** globals ***
 */


const char *szCommand = "<not yet set>";                        /* command name */
static int pPipe[2];
static int pPipe2[2];
static pid_t pid, pid2;
static FILE *pStream = (FILE *) 0;
static FILE *pStream2 = (FILE *) 0;
FILE *fdopen (int filedes, const char *mode);


/*
 * ***************************************************************************************** prototypes ***
 */


void BailOut (const char *szMessage);                        /* forward declaration */


/*
 * ****************************************************************************************** functions ***
 */


void PrintError (const char *szMessage)
{
   if (errno != 0)
   {
      (void) fprintf (stderr, "%s: %s - %s\n", szCommand, szMessage, strerror (errno));
   }
   else
   {
      (void) fprintf (stderr, "%s: %s\n", szCommand, szMessage);
   }
}


void FreeResources (void)
{
   if (pStream != (FILE *) 0)
   {
      if (fclose ((FILE *) pStream) == EOF)
      {
         pStream = (FILE *) 0;
         BailOut ("Can not close pipe stream!");
      }
      pStream = (FILE *) 0;                                /* pipe no longer open */
   }


   if (pStream2 != (FILE *) 0)
   {
      if (fclose ((FILE *) pStream2) == EOF)
      {
         pStream2 = (FILE *) 0;
         BailOut ("Can not close pipe stream 2");
      }
      pStream2 = (FILE *) 0;
   }
}


void BailOut (const char *szMessage)
{
   if (szMessage != (const char *) 0)                        /* print error message? */
   {
      PrintError (szMessage);
   }
   FreeResources ();
   exit (EXIT_FAILURE);
}


void AllocateResources (void)
{
   if (pipe (pPipe) == -1)
   {
      BailOut ("Can not create pipe!");
   }


   if (pipe (pPipe2) == -1)
   {
      BailOut ("Can not create pipe 2!");
   }
}


void Usage (void)
{
   (void) fprintf (stderr, "USAGE: %s [file]\n", szCommand);
   BailOut ((const char *) 0);
}


void FatherProcess (void)
{
   int c;


   if (close (pPipe[0]) == -1)
   {
      BailOut ("Error closing the read descriptor!");
   }

   if ((pStream = fdopen (pPipe[1], "w")) == (FILE *) NULL)
   {
      BailOut ("Can not open pipe for writing");
   }

   while ((c = fgetc (stdin)) != EOF)
   {
      fputc (c, pStream);
   }


   FreeResources ();
}


void ChildProcess (void)
{
   int c;


   if (close (pPipe[1]) == -1)
   {
      BailOut ("Error closing the write descriptor!");
   }


   if ((pStream = fdopen (pPipe[0], "r")) == (FILE *) NULL)
   {
      BailOut ("Can not open pipe for reading!");
   }


   if (close (pPipe2[0]) == -1)
   {
      BailOut ("Error closing the write descriptor 2!");
   }


   if ((pStream2 = fdopen (pPipe2[1], "w")) == (FILE *) NULL)
   {
      BailOut ("Can not open pipe2 for writing!");
   }


   while ((c = fgetc (pStream)) != EOF)
   {
      fputc (c, pStream2);
   }


   if (ferror (pStream))
   {
      BailOut ("Can not read from pipe!");
   }


   FreeResources ();
}


void ChildProcess2 (void)
{
   int c;
   if (close (pPipe2[1]) == -1)
   {
      BailOut ("Error closing the write descriptor!");
   }


   if ((pStream2 = fdopen (pPipe2[0], "r")) == (FILE *) NULL)
   {
      BailOut ("Can not open pipe2 for reading!");
   }


   while ((c = fgetc (pStream2)) != EOF)
   {
      fputc (c, stdout);
   }


   if (ferror (pStream2))
   {
      BailOut ("Can not read from pipe2!");
   }


   FreeResources ();
}


int main (int argc, char **argv)
{
   pid_t wpid, wpid2;
   int status, status2;


   szCommand = argv[0];


   if (argc > 2)
   {
      Usage();
   }


   AllocateResources ();


   switch (pid = fork ())
   {
      case -1:
         BailOut ("Fork failed!");
      break;


      case 0:
         ChildProcess ();
      break;


      default:


         switch (pid2 = fork ())
         {
            case -1:
               BailOut ("Fork2 failed!");
            break;


            case 0:
               ChildProcess2 ();
            break;


            default:
               FatherProcess ();               
            break;
         }

         while ((wpid = wait (&status)) != pid)
         {
            if (wpid != -1)
            {
               continue;
            }
            if (errno == EINTR)
            {
               continue;
            }
            BailOut ("Error waiting for child process 1!");
         }


         while ((wpid2 = wait (&status2)) != pid2)
         {
            if (wpid2 != -1)
            {
              continue;
            }


            if (errno == EINTR)
            {
              continue;
            }


            BailOut ("Error waiting for child process 2!");
         }




      break;      
   }
   exit (EXIT_SUCCESS);
}

#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>


#define MAX_LENGTH 50






int main (int argc, char **argv)
{
   char line[MAX_LENGTH+1];
   char invertline[MAX_LENGTH];

   int x, i;
   while (fgets (line, sizeof (line), stdin) != NULL)
   {

      x = (strlen (line) - 1);
      for (i = 0; i < (strlen (line) -1); i++)
      {
         invertline[x--] = line[i];
      }
      printf ("line size: %i\n", strlen (invertline));
      printf ("inverted line: %s\n", invertline);
      invertline[0] = '\0';
   }

   return 0;
}