home *** CD-ROM | disk | FTP | other *** search
/ Dream 52 / Amiga_Dream_52.iso / Amiga / Workbench / Archivers / DeMimeWOS.lha / de-mime.c < prev    next >
C/C++ Source or Header  |  1998-03-25  |  14KB  |  289 lines
  1.  
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <dos.h>
  5. #include <string.h>
  6.  
  7. #define max_line_length 250
  8. #define MAXPATH 1024
  9.  
  10. extern int errno;
  11.  
  12. int ValidMIME (char *);
  13.  
  14. char  * ReadInput( FILE * __stream, char * __s, int _q, int * __n);
  15.  
  16. char char_set[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
  17. int char_table[128];
  18.  
  19. main (int argc, char *argv[])
  20. {
  21.          FILE *inputfile;
  22.          char inputpath[MAXPATH+1];
  23.          char inputfilename[MAXPATH+1];
  24.          char input_string[max_line_length];
  25.          char * tempchar;
  26.          char argoutputfilename[MAXPATH+1];
  27.          int files_processed = 0;
  28.          int ii,jj;
  29.          int line_counter = 0;
  30.  
  31.          for (ii=0 ; ii<128 ; ++ii)
  32.                   char_table[ii] = -1;
  33.          tempchar = char_set;
  34.          for (ii=0 ; ii <= strlen(char_set) ; ii++)
  35.                   {
  36.                         char_table[*tempchar++] = ii;
  37.                   }
  38.  
  39.          if (argc<2 || argc>3)
  40.                  {
  41.                   printf("Invalid number of parameters %u\n",argc-1);
  42.                   printf("Usage: de-mime inputfile [outputfile]\n");
  43.                   return 8;
  44.                  }
  45.          else
  46.                   strcpy(inputfilename,argv[1]);
  47.          if (argc > 2)
  48.                   {
  49.                         strcpy(argoutputfilename,argv[2]);
  50.                   }
  51.  
  52.          inputfile = fopen(inputfilename,"rb");
  53.  
  54.          if (inputfile == NULL)
  55.                   {
  56.                         printf("Input file - %s - could not be opened\n",inputfilename);
  57.                         return 4;
  58.                   }
  59.  
  60.          tempchar = strrchr(inputfilename,'\\') ;
  61.  
  62.          if  (tempchar != NULL)
  63.                   {
  64.                         ii = (int) (tempchar-inputfilename+1);
  65.                         strncpy(inputpath,inputfilename,ii);
  66.                         inputpath[ii] = '\0';
  67.                   }
  68.          else
  69.                   {
  70.                         inputpath[0] = '\0';
  71.                   }
  72.  
  73.          if (ReadInput(inputfile,input_string,max_line_length,&line_counter) == NULL)
  74.                   {
  75.                         printf("File %s is empty\n",argv[1]);
  76.                         fclose(inputfile);
  77.                         return 4;
  78.                   }
  79.  
  80.          for (;feof(inputfile)==0;)
  81.                   {
  82.                         char *nameptr;
  83.                         char suggestedfilename[MAXPATH+1];
  84.                         char outputfilename[MAXPATH+1];
  85.                         FILE *outputfile;
  86.                         int ii;
  87.                         int start_line;
  88.                         long int output_size;
  89.                         char quotechar;
  90.  
  91.                         suggestedfilename[0] = '\0';
  92.  
  93.                         for ( ; (!ValidMIME(input_string) || strlen(input_string) < 12) &&
  94.                                           feof(inputfile)==0 ; )
  95.                                  {
  96.                                   nameptr = strstr(input_string,"name=");
  97.                                   if (nameptr != NULL)
  98.                                                 {
  99.                                                  strcpy(suggestedfilename,nameptr+6);
  100.                                                  nameptr = nameptr+5;
  101.                                                  quotechar = *nameptr;
  102.                                                  for (ii=0 ; suggestedfilename[ii]!=quotechar ; ii++)
  103.                                                           ;
  104.                                                  suggestedfilename[ii] = '\0';
  105.                                                 }
  106.                                   ReadInput(inputfile,input_string,max_line_length,&line_counter);
  107.                                  }
  108.  
  109.                         if (feof(inputfile) != 0)
  110.                                  break;
  111.  
  112.                         if (suggestedfilename[0] != '\0')
  113.                                  {
  114.                                   strcpy(outputfilename,inputpath);
  115.                                   strcat(outputfilename,suggestedfilename);
  116.                                  }
  117.                         else
  118.                                  {
  119.                                   if (argc > 2)
  120.                                                 {
  121.                                                  for (ii = 0; (argoutputfilename[ii] != '\\') &&
  122.                                                                                         (ii < strlen(argoutputfilename)) ; ++ii) ;
  123.                                                  if (argoutputfilename[ii] != '\\')
  124.                                                           {
  125.                                                                 strcpy(outputfilename,inputpath);
  126.                                                                 strcat(outputfilename,argoutputfilename);
  127.                                                           }
  128.                                                  else
  129.                                                           {
  130.                                                                 strcpy(outputfilename,argoutputfilename);
  131.                                                           }
  132.                                                 }
  133.                                   else
  134.                                                 {
  135.                                                  outputfilename[0] = '\0';
  136.                                                 }
  137.                                  }
  138.  
  139.                         for (outputfile = NULL ; outputfile == NULL ; )
  140.                                  {
  141.                                   if (outputfilename[0] != '\0')
  142.                                                 {
  143.                                                  outputfile=fopen(outputfilename,"rb");
  144.                                                  if (outputfile != NULL)
  145.                                                           {
  146.                                                                 printf("Outputfile %s already exists\n",outputfilename);
  147.                                                                 fclose(outputfile);
  148.                                                                 outputfile = NULL;
  149.                                                           }
  150.                                                  else
  151.                                                           {
  152.                                                                 outputfile=fopen(outputfilename,"wb");
  153.                                                                 if (outputfile == NULL)
  154.                                                                          {
  155.                                                                           printf("Error creating output file %s",
  156.                                                                                                                                                          outputfilename);
  157.                                                                           printf(" Errno=%d, _doserrno=%d\n",
  158.                                                                                                                                                         errno,errno);
  159.                                                                          }
  160.                                                           }
  161.                                                 }
  162.                                   else
  163.                                                 {
  164.                                                  printf("Output filename not specified\n");
  165.                                                 }
  166.                                   if (outputfile == NULL)
  167.                                                 {
  168.                                                  printf("Enter outputfile name: ");
  169.                                                  for (ii = 0; ii < 64; ++ii)
  170.                                                           {
  171.                                                                 int GottonChar;
  172.                                                                 GottonChar = getchar();
  173.                                                                 suggestedfilename[ii] = GottonChar;
  174.                                                                 if (GottonChar == '\n' || GottonChar == EOF)
  175.                                                                          {
  176.                                                                           suggestedfilename[ii] = '\0';
  177.                                                                           break;
  178.                                                                          }
  179.                                                           }
  180.                                                  for (ii = 0; (suggestedfilename[ii] != '\\') &&
  181.                                                                                         (ii < strlen(suggestedfilename)) ; ++ii)
  182.                                                           ;
  183.                                                  if (suggestedfilename[ii] != '\\')
  184.                                                           {
  185.                                                                 strcpy(outputfilename,inputpath);
  186.                                                                 strcat(outputfilename,suggestedfilename);
  187.                                                           }
  188.                                                  else
  189.                                                           {
  190.                                                                 strcpy(outputfilename,suggestedfilename);
  191.                                                           }
  192.                                                 }
  193.                                  }
  194.  
  195.                         printf("Creating output file #%d - %s - starting at line %d\n",
  196.                                                                           ++files_processed,outputfilename,line_counter);
  197.  
  198.                         start_line = line_counter;
  199.                         output_size = 0;
  200.  
  201.                         for ( ; feof(inputfile) == 0 ; )
  202.                                  {
  203.                                   char output_buffer[3];
  204.                                   int output_length;
  205.                                   char * charptr;
  206.                                   int ii;
  207.                                   int sextet[4];
  208.  
  209.                                   charptr = &input_string[0];
  210.  
  211.                                   for (ii=0 ; ii<strlen(input_string); ii=ii+4)
  212.                                                 {
  213.                                                  for (jj=0; jj<4; jj++)
  214.                                                           {
  215.                                                                 sextet[jj] = char_table[*charptr++];
  216.                                                           }
  217.                                                  if (sextet[0] < 0)
  218.                                                           {
  219.                                                                 output_length = 0;
  220.                                                                 break;
  221.                                                           }
  222.                                                  if (sextet[2] < 0)
  223.                                                           output_length = 1;
  224.                                                  else
  225.                                                           if (sextet[3] < 0)
  226.                                                                         output_length = 2;
  227.                                                           else
  228.                                                                         output_length = 3;
  229.  
  230.                                                  output_buffer[0] = 4*sextet[0]+sextet[1]/16;
  231.                                                  output_buffer[1] = 16*(sextet[1]%16)+sextet[2]/4;
  232.                                                  output_buffer[2] = 64*(sextet[2]%64)+sextet[3];
  233.  
  234.                                                  fwrite(&output_buffer[0],output_length,1,outputfile);
  235.  
  236.                                                  output_size += output_length;
  237.  
  238.                                                  if (output_length < 3)
  239.                                                           break;
  240.                                                 }
  241.                                   ReadInput(inputfile,input_string,max_line_length,&line_counter);
  242.  
  243.                                   if (output_length < 3)
  244.                                                 break;
  245.                                  }
  246.  
  247.                         printf("%s succesfully created, lines = %d, bytes = %d\n",
  248.                                                  outputfilename,line_counter-start_line+1,output_size);
  249.  
  250.                         fclose(outputfile);
  251.                   }
  252.  
  253.          fclose(inputfile);
  254.  
  255.          if (files_processed == 0)
  256.                   {
  257.                         printf("No valid MIME input was detected\n");
  258.                         return 4;
  259.                   }
  260.          printf("%d output files created\n",files_processed);
  261.          return 0 ;
  262. }
  263.  
  264. int ValidMIME (char *input_string)
  265. {
  266.  if ((strlen(input_string)%4 > 0)  ||  (strlen(input_string)==0))
  267.           {
  268.                 printf("Invalid MIME - %s\n",input_string);
  269.                 return 0;
  270.           }
  271.  return (strspn(input_string,char_set) == strlen(input_string));
  272. }
  273.  
  274. char * ReadInput (FILE * inputfile, char * input_string,
  275.                                                 int input_string_size, int * line_counter)
  276. {
  277.  char * read_result;
  278.  int ii;
  279.  read_result = fgets(input_string,input_string_size,inputfile);
  280.  if (read_result != NULL)
  281.           {
  282.                 ++(*line_counter);
  283.                 ii = strlen(input_string)-1;
  284.                 input_string[ii] = '\0';
  285.           }
  286.  return read_result;
  287. }
  288.  
  289.