home *** CD-ROM | disk | FTP | other *** search
/ Amiga ISO Collection / AmigaUtilCD2.iso / Misc / splon179.lha / Sploin.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-09-03  |  23.3 KB  |  932 lines
  1. /*
  2.     -------------------
  3.     ««« Sploin 1.79 »»»
  4.     -------------------
  5.     - Yves Perrenoud --
  6.     - 02.09.1994 ------
  7.     -------------------
  8. */
  9.  
  10. /* -------------------------Compilation notes--------------------------------
  11. **
  12. ** AMIGA
  13. ** -----
  14. ** This program should be compiled on the Amiga using Matt Dillon's great
  15. ** compiler DICE. I haven't tried compiling it with SAS or Manx. In the
  16. ** next release, I will have tried compiling it with SAS 6.51 ;-)
  17. **
  18. ** UNIX (SUN, Amix, MIPS)
  19. ** ----------------------
  20. ** I have only tested the program compiling it with cc (the default compiler).
  21. ** In a future release I will try compiling it with gcc.
  22. **
  23. ** VAX/VMS
  24. ** -------
  25. ** I compiled the program using VAXC under VMS 5.5-2.
  26. **
  27. */
  28.  
  29. /*
  30. ------------------------------------------------------------------------------
  31. ----------------------------------- History ----------------------------------
  32. ------------------------------------------------------------------------------
  33. -  V1.0  :  Base version, which only lets you extract and not really split,  -
  34. -           no bugs found.                                                   -
  35. ------------------------------------------------------------------------------
  36. -  V1.1  :  Added the option to split the file in x parts of a size          -
  37. -           specified by the user, or in a specified number of parts.        -
  38. ------------------------------------------------------------------------------
  39. -  V1.2  :  Added multi file join.                                           -
  40. ------------------------------------------------------------------------------
  41. -  V1.3  :  Added an option which tells Sploin to use an input file          -
  42. -           containing the names of files to join together. Removed a few    -
  43. -           little bugs.                                                     -
  44. ------------------------------------------------------------------------------
  45. -  V1.4  :  Wildcards are now supported. You can specify an destination dir. -
  46. -           when splitting in several parts.                                 -
  47. ------------------------------------------------------------------------------
  48. -  V1.45 :  Fixed an ugly bug which didn't accept subdirectories in the      -
  49. -           original path when using the -d option.                          -
  50. ------------------------------------------------------------------------------
  51. -  V1.5  :  Changed the program so it would no longer use the arp library    -
  52. -           for pattern matching and for break detection, but DICE routines  -
  53. -           instead. Also changed everything to Ansi-C (increased the binary -
  54. -           by 6k). Removed stupid options. Found bugs in the removed        -
  55. -           options (Hey hey!)                                               -
  56. ------------------------------------------------------------------------------
  57. -  V1.6  :  Added an option to reconstruct a previously split file.          -
  58. -           Corrected a bug in the input file option. Can now be compiled    -
  59. -           under UNIX.                                                      -
  60. ------------------------------------------------------------------------------
  61. -  V1.61 :  Fixed an Enforcer hit!                                           -
  62. ------------------------------------------------------------------------------
  63. -  V1.62 :  Changed the spliting size character from "$" to "=". The dollar  -
  64. -           sign is used by UNIX for specifying things like the last word    -
  65. -           on the previous line ("!$"). Due to this, on UNIX the program    -
  66. -           wouldn't split big files in smaller files of a specified size;   -
  67. -           which is my main use of the program.                             -
  68. ------------------------------------------------------------------------------
  69. -  V1.65 :  Removed a bug which didn't set the right protections on the      -
  70. -           created files under UNIX. Added VAX/VMS compatibility, but       -
  71. -           without wildcard support (until I find out how it works).        -
  72. ------------------------------------------------------------------------------
  73. -  V1.70 :  Added the "-m{l|h}" feature to greatly ease the transport on     -
  74. -           MS-DOS format disks by setting default sizes and truncating      -
  75. -           filenames to 8.3 chars when using the multiple file split/join   -
  76. -           options. Added the ']' in StripPath for VMS support.             -
  77. ------------------------------------------------------------------------------
  78. -  V1.76 :  Added VMS wildcard support thanks to some source code written by -
  79. -           Karl-Jose Filler. Now asks the user for confirmation if the      -
  80. -           number of chunks exceeds 150. Converts filenames to lowercase    -
  81. -           when using MS-DOS 8.3 format (apparently caused problems). Fixed -
  82. -           a bug which caused VMS overwrites to simply go to void.          -
  83. ------------------------------------------------------------------------------
  84. -  V1.78 :  Changed the syntax of the multiple files spliting from "-sN"     -
  85. -           where N is the number of parts to "-pN", and "-s=N" where N is   -
  86. -           the size of each part to "-sN". The program complains if "-s="   -
  87. -           is used. Fixed a bug which could cause a division by zero.       -
  88. -           Complains if the buffer size is set to zero. Displays a warning  -
  89. -           if the size to extract is set to zero.                           -
  90. ------------------------------------------------------------------------------
  91. -  V1.79 :  Fixed a problem on VMS introduced with the wildcard support, the -
  92. -           filename of a non existing file had a ";" appended so the "-g"   -
  93. -           option never found anything to open.                             -
  94. ------------------------------------------------------------------------------
  95. */
  96.  
  97. /* ---------------------------- To Do ----------------------------------------
  98. **
  99. ** 1. Add an option to specify a format string for the multiple files names.
  100. **
  101. ** 2. Enable the extended GNU parameter passing syntax : "-o" = "--offset".
  102. **
  103. ** 3. Optimize VMS open flags :-( or distribute the binary compiled with
  104. **    VMS GCC... whatever
  105. **
  106. ** 4. Strip all non uuencoded, VMS shared, shiped, etc... code from file(s)
  107. **    and create one file ready to be decoded.
  108. **
  109. */
  110.  
  111. #ifndef VAX
  112. #include <fcntl.h>
  113. #endif
  114.  
  115. #include <stdio.h>
  116. #include <stdlib.h>
  117. #include <string.h>
  118. #include <ctype.h>
  119.  
  120. #ifdef VAX
  121. #include <unixlib.h>
  122. #include <file.h>
  123. #endif
  124.  
  125. #ifdef MSDOS
  126. #define Name "  << Sploin 1.79 >>  Copyright (c) 1991-94  Yves Perrenoud\n"
  127. #else
  128. #define Name "  «« Sploin 1.79 »»  Copyright (c) 1991-94  Yves Perrenoud\n"
  129. #endif
  130.  
  131. #ifdef AMIGA
  132. static unsigned char *version_string = "$VER: Sploin 1.79 (02.09.94)";
  133. #endif
  134.  
  135. int hf1,hf2,hmain;                    /* les handles pour les 3 fichiers */
  136. FILE *hinp;                            /* le handle pour le fichier d'"input" */
  137.  
  138. unsigned char *memblock;            /* le pointeur sur la mémoire */
  139. size_t smain;                        /* la taille pour la mémoire en question */
  140.  
  141. unsigned char *inpmem;                /* le pointeur sur le inputfile */
  142.  
  143.  
  144. /* ------------------------------------------------------------------endprg
  145. ** Close open files and free memory.
  146. */
  147.  
  148. void endprg(val)
  149.     int val;
  150. {
  151.     if (hf1)
  152.         close(hf1);
  153.     if (hf2)
  154.         close(hf2);
  155.     if (hmain)
  156.         close(hmain);
  157.     if (hinp)
  158.         fclose(hinp);
  159.     if (memblock)
  160.         free(memblock);
  161.     if (inpmem)
  162.         free(inpmem);
  163.  
  164.     exit(val);
  165. }
  166.  
  167.  
  168. /* ------------------------------------------------------------------error
  169. ** In case of error output the string passed as an argument to
  170. ** the subroutine and call endprg with an exit code of 20.
  171. */
  172.  
  173. void error(msg,str)
  174.     char *msg,*str;
  175. {
  176.     printf("ERROR : %s%s!\n",msg,str);
  177.     endprg(20);
  178. }
  179.  
  180.  
  181. /* ------------------------------------------------------------------brk
  182. ** Jump to this subroutine in case the user has hit ^C.
  183. */
  184.  
  185. #ifdef AMIGA
  186. int brk()
  187. {
  188.     error("***BREAK","");
  189.     return 0;                    /* let me take care of exiting */
  190. }
  191. #endif
  192.  
  193.  
  194. /* ------------------------------------------------------------------GetConfirm
  195. ** Asks the user if it's ok to over write a file passed as an
  196. ** argument to the subroutine.
  197. */
  198.  
  199. int GetConfirm(filename)
  200.     char *filename;
  201. {
  202.     char buff[4];
  203.  
  204.     printf("\nDo you realy want to replace %s (y/N) : ",filename);
  205.  
  206.     fgets(buff,4,stdin);
  207.  
  208.     if ((buff[0] == 'y') || (buff[0] == 'Y'))
  209.         return 1;
  210.  
  211.     return 0;
  212. }
  213.  
  214.  
  215. /* ------------------------------------------------------------------GetConfirmSize
  216. ** Asks the user if he's sure he wants to create that many files.
  217. */
  218.  
  219. int GetConfirmSize(nb)
  220.     int nb;
  221. {
  222.     char buff[4];
  223.  
  224.     printf("\nDo you realy want to create %ld files (y/N) : ",nb);
  225.  
  226.     fgets(buff,4,stdin);
  227.  
  228.     if ((buff[0] == 'y') || (buff[0] == 'Y'))
  229.         return 1;
  230.  
  231.     return 0;
  232. }
  233.  
  234.  
  235. /* ------------------------------------------------------------------GetSize
  236. ** Get the size of <filename>.
  237. */
  238.  
  239. int GetSize(filename)
  240.     char *filename;
  241. {
  242.     int hdsize;
  243.     int size;
  244.  
  245.     if ((hdsize = open(filename,O_RDONLY)) < 0)
  246.         error("Can't access file : ",filename);
  247.     
  248.     if ((size = lseek(hdsize,0,2)) < 0)
  249.         error("Can't examine file : ",filename);
  250.     
  251.     close(hdsize);
  252.     return size;
  253. }
  254.  
  255.  
  256. /* ------------------------------------------------------------------Copyright
  257. ** Output copyright message.
  258. */
  259.  
  260. void Copyright()
  261. {
  262.     puts(Name);
  263. }
  264.  
  265.  
  266. /* ------------------------------------------------------------------Message
  267. ** Output the help message.
  268. */
  269.  
  270. void Message()
  271. {
  272.     Copyright();
  273.  
  274.     puts("USAGE : Sploin <Mainfile> {<FileN>} [<options>]\n");
  275.  
  276.     puts("<Mainfile>  : The file to split or the joined file.");
  277.  
  278.     puts("<File1>     : The File in which to save the extracted data");
  279.     puts("              or the first file to be joined. Wildcards are supported.");
  280.  
  281.     puts("<File2>     : The file in which to save the rest of the splited file");
  282.     puts("              or the second file to be joined.\n");
  283.  
  284.     puts("[Options]");
  285.  
  286.     puts("-j          : Join File1,...,FileN into Mainfile.");
  287.  
  288.     puts("-s[<size>]  : Split Mainfile into File1 and optionaly File2.");
  289.     puts("              If you specify <size> then Mainfile will be splited in several");
  290.     puts("              files of size <size>.\n");
  291.  
  292.     puts("-p[<nb>]    : Split Mainfile into File1 and optionaly File2.");
  293.     puts("              If you specify <nb> then Mainfile will be splited into <nb>");
  294.     puts("              different smaller files.\n");
  295.  
  296.     puts("-b<size>    : Buffer size (default 50000 bytes).");
  297.  
  298.     puts("-o<offst>   : Offset at which to start extracting data.");
  299.  
  300.     puts("-n<size>    : Number of bytes to extract.");
  301.  
  302.     puts("-r          : Saves what rests of the file after extraction (to EOF).");
  303.  
  304.     puts("-i<file>    : Tells Sploin to use <file> as input for the files to join.");
  305.  
  306.     puts("-g          : Reconstruct a file from the splited files (opposite of -sX or -pY).");
  307.  
  308.     puts("-d<dir>     : Specify the destination dir when spliting in several parts.");
  309.  
  310.     puts("-m{l|h}     : Use MS-DOS settings - filename size of 8.3 chars and disk size");
  311.     puts("              of l:720KB (DD) or h:1.44MB (HD).\n");
  312. }
  313.  
  314.  
  315. /* ------------------------------------------------------------------GetSep
  316. **  Takes as an argument the number of chunks the user desires
  317. **  and returns the size of each individual chunk.
  318. */
  319.  
  320. int GetSep(nb)
  321.     int nb;
  322. {
  323.     if (nb == 0)        /* ceci pour éviter la division par zéro */
  324.         return 0;
  325.  
  326.     if (!(smain%nb))
  327.         return (smain/nb);
  328.     else
  329.         return (smain/nb + 1);
  330. }
  331.  
  332.  
  333. /* ------------------------------------------------------------------TestOldSep
  334. **  Tests if the user has used the old size syntax ("-s=") and if
  335. **  this is the case, exits and displays an error.
  336. */
  337.  
  338. void TestOldSep(car)
  339.     int car;
  340. {
  341.     if (car == '=')
  342.         error("The syntax for the size of the chunks has changed","");
  343. }
  344.  
  345.  
  346. /* ------------------------------------------------------------------OpenF1
  347. ** Open file 1 for output with the name passed as an argument. Check
  348. ** if the file already exists and take the appropriate action if it
  349. ** does.
  350. */
  351.  
  352. void OpenF1(filename)
  353.     char *filename;
  354. {
  355.     if (Exists(filename))                            /* si le fichier existe */
  356.     {                                                   /* déja, alors on demande */
  357.         if (!GetConfirm(filename))                    /* une confirmation */
  358.             error("User aborted","");
  359.     }
  360.  
  361. #ifdef unix
  362.     if ((hf1 = open(filename,O_WRONLY|O_CREAT,0600)) < 0)    /* 600 : owner RW */
  363. #else
  364. #ifdef VAX
  365.     if ((hf1 = open(filename,O_WRONLY|O_CREAT|O_TRUNC,0)) < 0)    /* 0 : default prot. */
  366. #else
  367.     if ((hf1 = open(filename,O_WRONLY|O_CREAT)) < 0)
  368. #endif
  369. #endif
  370.         error ("Couldn't open file : ",filename);
  371. }
  372.  
  373.  
  374. /* ------------------------------------------------------------------RemVersion
  375. ** If under VMS, remove the ";" and everything following it.
  376. */
  377.  
  378. void *RemVersion(bef)
  379.     char *bef;
  380. {
  381.     char aft[250];
  382. #ifdef VAX
  383.     int i;
  384. #endif
  385.  
  386.     strcpy(aft,bef);
  387.  
  388. #ifdef VAX
  389.     for (i=strlen(aft);!((aft[i] == ';') || (i < 0));i--);
  390.     
  391.     if (i >= 0)
  392.         aft[i] = '\0';
  393. #endif
  394.  
  395.     return((void *)aft);
  396. }
  397.  
  398.  
  399. /* ------------------------------------------------------------------StripPath
  400. ** Takes a filename with its path as input, and returns a pointer
  401. ** on a string containing the filename without its path.
  402. */
  403.  
  404. void *StripPath(bef)
  405.     char *bef;
  406. {
  407.     char aft[250];
  408.     int i;
  409.     
  410.     for (i=strlen(bef);!((bef[i] == ':') || (bef[i] == '/') || (bef[i] == ']') || (i < 0));i--);
  411.  
  412.     if (i < 0)
  413.         strcpy(aft,bef);
  414.     else
  415.         strcpy(aft,&bef[i+1]);
  416.  
  417.     return((void *)aft);
  418. }
  419.  
  420.  
  421. /* ----------------------------------------------------------------Truncate
  422. ** returns a pointer on a filename in MS-DOS format consisting of
  423. ** 8.3 characters including a number passed as an argument in the
  424. ** following format <name>_1.{xxx}
  425. */
  426.  
  427. void *Truncate(full,num)
  428.     char *full;
  429.     int num;
  430. {
  431.     char trunc[250],anum[10];
  432.     int i,j,k;
  433.     
  434.     sprintf(anum,"%ld",num);
  435.     if (strlen(anum) > 4)
  436.         error("You have exceeded the maximum number of files possible in -m mode","");
  437.  
  438.     for (i=0;i < (8 - (1+strlen(anum)));i++)
  439.     {
  440.         switch (full[i])
  441.         {
  442.             case '.' :
  443.             case ' ' :
  444.                 trunc[i] = '_';
  445.                 break;
  446.             default :
  447.                 trunc[i] = full[i];
  448.                 break;
  449.         }
  450.     }
  451.  
  452.     trunc[i] = '\0';
  453.     sprintf(trunc,"%s_%s",trunc,anum);
  454.     k = strlen(trunc);
  455.  
  456.     for (i=strlen(full);(full[i] != '.') && (i >= 0);i--);
  457.  
  458.     if (i >= 0)
  459.     {
  460.         for(j=0;(j <= 3) && (j <= strlen(full)-i+1);j++)
  461.             trunc[k++] = full[j+i];
  462.         
  463.         trunc[k] = '\0';
  464.     }
  465.  
  466.     for (i=0;i <= strlen(trunc);i++)
  467.         trunc[i] = tolower(trunc[i]);
  468.  
  469.     return((void *)trunc);
  470. }
  471.  
  472.  
  473. /* ------------------------------------------------------------------MyCeil
  474. ** This is a division only ceil ;-), it takes two ints as an
  475. ** argument and returns the ceil.
  476. */
  477.  
  478. int MyCeil(numerateur,denominateur)
  479.     int numerateur,denominateur;
  480. {
  481.     if (numerateur%denominateur)
  482.         return (numerateur/denominateur + 1);
  483.     else
  484.         return (numerateur/denominateur);
  485. }
  486.  
  487.  
  488. /* ------------------------------------------------------------------Exists
  489. ** Check if a file already exists and return TRUE if it does, FALSE
  490. ** otherwise.
  491. */
  492.  
  493. int Exists(filename)
  494.     char *filename;
  495. {
  496.     int exhd;
  497.  
  498.     if ((exhd = open(filename,O_RDONLY)) >= 0)
  499.     {
  500.         close(exhd);
  501.         return 1;
  502.     }
  503.     else
  504.         return 0;
  505. }
  506.  
  507.  
  508. /* ------------------------------------------------------------------main
  509. ** The main routine.
  510. */
  511.  
  512. #ifdef AMIGA
  513. void main(xargc,xargv)
  514.     int xargc;
  515.     char **xargv;
  516. #else
  517. main(argc,argv)
  518.     int argc;
  519.     char **argv;
  520. #endif
  521. {
  522. #ifdef AMIGA
  523.     int argc;               /* les version expanded des arguments */
  524.     char **argv;            /* ceci est à supprimer sous UNIX et VMS */
  525. #endif
  526.  
  527.     int i,posi,                /* entier pour les boucles */
  528.  
  529.     type=1;                 /* type : 1 pour Join, 2 pour Split.
  530.                                Split : MaineFile   ->   File1 + File2
  531.                                Join  : File1 + File2   ->    MainFile */
  532.  
  533.     size_t bufsize=50000;    /* taille du buffer de travail, 50000 bytes*/
  534.  
  535.     int offset=0,            /* pour split, debut de l'extraction */
  536.  
  537.     size=0,                    /* taille à extraire */
  538.  
  539.     rest=0,                    /* Faut-il sauver le rebut après extraction?
  540.                                par défaut non. */
  541.  
  542.     inp=0,                    /* Faut-il utiliser un fichier comme input */
  543.  
  544.     group=0,                /* Faut-il regrouper des fichiers */
  545.     
  546.     msdos=0,                /* configuration MS-DOS */
  547.  
  548.     temp=0,endit=0,sep=0,        /* variable pour diverse utilisations */
  549.     allocsize=0,readsize=0,nbleft=0,total=0,iter=0;
  550.  
  551.     char Mainfile[250],File1[250],File2[250];    /* Fichier sus-mentionnés */
  552.     char path[250];            /* le répertoire de destination */
  553.     char Mainstriped[250];        /* le nom de fichier tronqué */
  554.     char versionless[250];        /* temporary filename with VMS version removed */
  555.  
  556. #ifdef AMIGA
  557.     if (expand_args(xargc,xargv,&argc,&argv))        /* expand arguments */
  558.         error("Couldn't expand arguments","");
  559.  
  560.     onbreak(brk);                    /* if a ^C is detected jump to brk */
  561. #endif
  562. #ifdef VAX
  563.     vms_expand_args(&argc,&argv);    /* expand arguments using some source code */
  564.                                     /* written by Karl-Jose Filler */
  565. #endif
  566.  
  567.     if (argc < 3)
  568.     {
  569.         Message();
  570.         error("Not enough arguments","");
  571.     }
  572.  
  573.     Mainfile[0] = '*';
  574.     File1[0] = '*';
  575.     File2[0] = '*';
  576.     path[0] = '*';
  577.         
  578.     for (i=1;i <= (argc-1);i++)
  579.     {
  580.         if (argv[i][0] == '-')
  581.         {
  582.             switch (argv[i][1])
  583.             {
  584.                 case 'j' : type = 1; break;
  585.                 case 's' : type = 2; TestOldSep(argv[i][2]); if (!sep) sep = (argv[i][2] != 0) ? atoi(&argv[i][2]) : 0; break;
  586.                 case 'p' : type = 2; if (!sep) sep = (argv[i][2] != 0) ? -1*atoi(&argv[i][2]) : 0; break;
  587.                 case 'b' : bufsize = atoi(&argv[i][2]); break;
  588.                 case 'o' : offset = atoi(&argv[i][2]); break;
  589.                 case 'n' : size = atoi(&argv[i][2]); break;
  590.                 case 'r' : rest = 1; break;
  591.                 case 'i' : inp = 1; strcpy(File2,&argv[i][2]); break;
  592.                 case 'd' : strcpy(path,&argv[i][2]); break;
  593.                 case 'g' : group = 1; break;
  594.                 case 'm' : msdos = 1; type = 2; sep = (argv[i][2] == 'h') ? 1456000 : 728000; break;
  595.                 default  : error("Uknown type of OPTION","");
  596.             }
  597.         }
  598.         else if (Mainfile[0] == '*')
  599.         {
  600.             strcpy(Mainfile,argv[i]);
  601.             posi = i;
  602.         }
  603.         else if (File1[0] == '*')
  604.             strcpy(File1,argv[i]);
  605.         else if (File2[0] == '*')
  606.             strcpy(File2,argv[i]);
  607.     }
  608.  
  609.     if ((sep != 0) || (type == 1))
  610.     {
  611.         offset = 0;
  612.         size = 0;
  613.         rest = 0;
  614.  
  615.         if (Mainfile[0] == '*')
  616.             error("You must specify all the filenames","");
  617.     }
  618.     else if ((Mainfile[0] == '*') || (File1[0] == '*') || ((rest == 1) && (File2[0] == '*')))
  619.         error("You must specify all the filenames","");
  620.  
  621.     strcpy(Mainstriped,StripPath(Mainfile));    /* on extrait le nom lui-même */
  622.  
  623.  
  624.  
  625.  
  626.  
  627.  
  628.  
  629. /* First of all the Join part of the program */
  630.  
  631.     if (type == 1)
  632.     {
  633.         if (!bufsize)
  634.             error("There isn't any sense in using a buffer size of zero","");
  635.  
  636.         Copyright();
  637.         printf("Joining the files into %s ...\n",Mainfile);
  638.  
  639.         if (Exists(Mainfile))                            /* si le fichier existe */
  640.         {                                                /* déja, alors on demande */
  641.             if (!GetConfirm(Mainfile))                    /* une confirmation */
  642.                 error("User aborted","");
  643.         }
  644.  
  645. #ifdef unix
  646.         if ((hmain = open(Mainfile,O_WRONLY|O_CREAT,0600)) < 0)    /* 600 : owner RW */
  647. #else
  648. #ifdef VAX
  649.         if ((hmain = open(Mainfile,O_WRONLY|O_CREAT|O_TRUNC,0)) < 0)    /* 0 : default prot. */
  650. #else
  651.         if ((hmain = open(Mainfile,O_WRONLY|O_CREAT)) < 0)
  652. #endif
  653. #endif
  654.             error ("Couldn't open file : ",Mainfile);
  655.  
  656.         if (!(memblock = calloc(bufsize,1)))
  657.             error("Not enough memory, reduce buffer size","");
  658.  
  659.         if (inp)
  660.         {
  661.             if (!(hinp = fopen(File2,"r")))
  662.                 error("Couldn't open input file : ",File2);
  663.  
  664.             if (feof(hinp))
  665.                 error("Input file is empty","");
  666.         }
  667.  
  668.         i = posi;
  669.         posi = 1;
  670.  
  671.         while (!total)
  672.         {
  673. #ifdef AMIGA
  674.             chkabort();            /* check if a ^C was pressed */
  675. #endif
  676.  
  677.             if (inp)
  678.             {
  679.                 /* taking the next file from the input file */
  680.  
  681.                 if (fgets(File1,255,hinp))            /* get the line */
  682.                 {
  683.                     size = strlen(File1);
  684.                     File1[size-1] = '\0';            /* remove the \n */
  685.                 }
  686.                 else
  687.                 {
  688.                     total = 1;                /* if we have reached the end of file */
  689.                     continue;
  690.                 }
  691.             }
  692.             else if (group)
  693.             {
  694.                 /* reconstruct a file splited with -sxxxx */
  695.                 
  696.                 strcpy(versionless,RemVersion(Mainstriped));
  697.                 strcpy(File1,Truncate(versionless,posi));
  698.  
  699.                 if (!Exists(File1))
  700.                 {
  701.                     sprintf(File1,"%s_%ld",versionless,posi);
  702.  
  703.                     if (!Exists(File1))
  704.                     {
  705.                         total = 1;
  706.                         continue;
  707.                     }
  708.                 }
  709.                 
  710.                 posi++;
  711.             }
  712.             else
  713.             {
  714.                 i++;                            /* go to next entry */
  715.  
  716.                 if (i > (argc-1))
  717.                 {
  718.                     total = 1;
  719.                     continue;
  720.                 }
  721.  
  722.                 if (argv[i][0] != '-')
  723.                     strcpy(File1,argv[i]);
  724.                 else
  725.                     continue;
  726.             }
  727.  
  728.             if ((hf1 = open(File1,O_RDONLY)) < 0)
  729.                 error("Couldn't open file : ",File1);
  730.  
  731.             do
  732.             {
  733.                 if((temp = read(hf1,memblock,bufsize)) < 0)
  734.                     error("Couldn't read file ",File1);
  735.  
  736.                 if (temp != bufsize)
  737.                     endit = 1;
  738.                 else
  739.                     temp = bufsize;
  740.  
  741.                 if(write(hmain,memblock,temp) < 0)
  742.                     error("Couldn't write into file ",Mainfile);
  743.             }
  744.             while (!endit);
  745.             endit = 0;
  746.  
  747.             close(hf1);
  748.             hf1 = 0;
  749.         }
  750.     }
  751.  
  752.  
  753.  
  754.  
  755.  
  756.  
  757.  
  758.  
  759.  
  760. /* Here comes the Split part of the program */
  761.  
  762.     else
  763.     {
  764.         Copyright();
  765.         printf("Spliting %s ",Mainfile);
  766.  
  767.         if (rest)
  768.             printf("into %s and %s ...\n",File1,File2);
  769.         else if (sep != 0)
  770.             puts("...");
  771.         else
  772.             printf("into %s ...\n",File1);
  773.  
  774.         if ((!size) && (!sep))
  775.             printf("Warning: extract size set to zero, so %s will be empty!\n",File1);
  776.  
  777.         if ((hmain = open(Mainfile,O_RDONLY)) < 0)
  778.             error("Couldn't open file : ",Mainfile);
  779.  
  780.         smain = GetSize(Mainfile);
  781.  
  782.         if (sep < 0)                /* sep représente donc le nombre de morceaux */
  783.             sep = GetSep(-1*sep);
  784.  
  785.         if (MyCeil(smain,sep) > 150)                        /* si la taille est */
  786.         {                                                    /* supérieure à 150 */
  787.             if (!GetConfirmSize(MyCeil(smain,sep)))            /* alors on vérifie */
  788.                 error("User aborted","");                    /* avec l'utilisateur */
  789.         }
  790.  
  791.         if (sep == 0)
  792.         {
  793.             if ((offset+size) > smain)
  794.                 error("Can't extract more bytes than the file contains","");
  795.  
  796.             OpenF1(File1);
  797.  
  798.             if (rest)
  799.             {
  800.                 if (Exists(File2))                        /* si le fichier existe */
  801.                 {                                        /* déja, alors on demande */
  802.                     if (!GetConfirm(File2))                /* une confirmation */
  803.                         error("User aborted","");
  804.                 }
  805.  
  806. #ifdef unix
  807.                 if ((hf2 = open(File2,O_WRONLY|O_CREAT,0600)) < 0)    /* 600 : owner RW */
  808. #else
  809. #ifdef VAX
  810.                 if ((hf2 = open(File2,O_WRONLY|O_CREAT|O_TRUNC,0)) < 0)    /* 0 : default prot. */
  811. #else
  812.                 if ((hf2 = open(File2,O_WRONLY|O_CREAT)) < 0)
  813. #endif
  814. #endif
  815.                     error ("Couldn't open file : ",File2);
  816.             }
  817.  
  818.             allocsize = rest ? smain-offset : size;
  819.             iter = 1;
  820.         }
  821.         else
  822.         {
  823.             allocsize = sep;
  824.             if (allocsize < bufsize)
  825.                 bufsize = allocsize;
  826.             if (smain%sep)
  827.                 iter = (smain/sep) + 1;
  828.             else
  829.                 iter = smain/sep;
  830.         }
  831.  
  832.         if (bufsize == 0)
  833.             bufsize = allocsize;
  834.  
  835.         if (!(memblock = calloc(bufsize,1)))
  836.             error("Not enough memory, reduce buffer size","");
  837.  
  838.         if (offset)
  839.         {
  840.             if (lseek(hmain,offset,0) < 0)
  841.                 error("Couldn't browse through file ",Mainfile);
  842.         }
  843.  
  844.         for (i=1;i <= iter;i++)
  845.         {
  846. #ifdef AMIGA
  847.             chkabort();
  848. #endif
  849.  
  850.             if (sep != 0)
  851.             {
  852.                 if (hf1)
  853.                     close(hf1);
  854.  
  855.                 total += sep;
  856.                 if (total > smain)
  857.                     nbleft = smain%sep;
  858.                 else
  859.                     nbleft = sep;
  860.  
  861.                 if (path[0] == '*')
  862.                     strcpy(versionless,RemVersion(Mainfile));
  863.                 else
  864.                     strcpy(versionless,RemVersion(Mainstriped));
  865.  
  866.                 if (msdos)
  867.                 {
  868.                     if (path[0] == '*')
  869.                         strcpy(File1,Truncate(versionless,i));
  870.                     else
  871.                     {
  872.                         strcpy(versionless,Truncate(versionless,i));
  873.                         sprintf(File1,"%s%s",path,versionless);
  874.                     }
  875.                 }
  876.                 else
  877.                 {
  878.                     if (path[0] == '*')
  879.                         sprintf(File1,"%s_%ld",versionless,i);
  880.                     else
  881.                         sprintf(File1,"%s%s_%ld",path,versionless,i);
  882.                 }
  883.                 OpenF1(File1);
  884.             }
  885.             else
  886.                 nbleft = size;
  887.  
  888.             do
  889.             {
  890.                 if (nbleft < bufsize)
  891.                 {
  892.                     readsize = nbleft;
  893.                     endit = 1;
  894.                 }
  895.                 else
  896.                     readsize = bufsize;
  897.  
  898.                 if(read(hmain,memblock,readsize) < 0)
  899.                     error("Couldn't read file ",Mainfile);
  900.  
  901.                 if(write(hf1,memblock,readsize) < 0)
  902.                     error("Couldn't write into file ",File1);
  903.  
  904.                 nbleft -= bufsize;
  905.             }
  906.             while (!endit);
  907.             endit = 0;
  908.         }
  909.  
  910.         if (rest)
  911.         {
  912.             do
  913.             {
  914.                 if((temp = read(hmain,memblock,bufsize)) < 0)
  915.                     error("Couldn't read file ",Mainfile);
  916.  
  917.                 if (temp != bufsize)
  918.                     endit = 1;
  919.                 else
  920.                     temp = bufsize;
  921.  
  922.                 if(write(hf2,memblock,temp) < 0)
  923.                     error("Couldn't write into file ",Mainfile);
  924.             }
  925.             while (!endit);
  926.         }
  927.     }
  928.  
  929.     puts("Done.");
  930.     endprg(0);
  931. }
  932.