home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 1996 February / PCWK0296.iso / sharewar / os2 / inne / unrar100 / unrar.c < prev    next >
C/C++ Source or Header  |  1994-12-23  |  20KB  |  852 lines
  1. /******    *****   ******
  2.  **   **  **   **  **   **      unRAR utility version 1.00e
  3.  ******   *******  ******       ~~~~~~~~~~~~~~~~~~~~~~~~~~~
  4.  **   **  **   **  **   **         FREE portable version
  5.  **   **  **   **  **   **         ~~~~~~~~~~~~~~~~~~~~~
  6.  
  7.          Main code
  8.  
  9.    YOU CAN CHANGE FOLLOWING CODE IN ORDER TO ACHIEVE
  10.    COMPATIBILITY WITH YOUR OPERATING MEDIA.
  11.  
  12.    PLEASE SEND ALL NOTES, PATCHES TO ANY RAR SITE (SEE RAR_SITE.TXT IN RAR)
  13.    OR DIRECTLY TO THE AUTHOR CONTACT SITE: andrey@vybor.chel.su
  14.                                   FIDOnet: Andrey Spasibozhko, 2:5010/23
  15.    VOICE REPORTS: +7-3512-130-231
  16.  
  17. */
  18.  
  19. #include "unrar.h"          /* definitions */
  20. #include "unpack.c"         /* unpacking procedures */
  21.  
  22. void   SplitCommandLine();  /* parses command string */
  23. int    CmpName();           /* checks name for mask */
  24. char*  PointToName();       /* returns pathname */
  25. void   NextVolumeName();    /* gets next volume name */
  26. void   SplitName();         /* splits pathname */
  27. void   ExecuteCommand();    /* executes extr. command */
  28. void   ListArchive();       /* lists archive contents */
  29. int    ExtrFile();          /* extracts single file */
  30. void   Help();              /* prints usage help */
  31. void   ShutDown();          /* stops working */
  32. void   ErrExit();           /* exits with error code */
  33. void   CreatePath();        /* creates path */
  34. int    tread();             /* reads with checking */
  35. void   tclose();            /* closes with checking */
  36. void   MergeArc();          /* to next volume */
  37. void   UnstoreFile();       /* unpacks non-compressed file */
  38. int    IsArchive();         /* checks for RAR archive signature */
  39. void   CheckArc();          /* similar but with exit */
  40. int    strnicomp();         /* compares strings */
  41. char*  strtolwr();          /* convert string to lowercase */
  42. int    ToPercent();         /* calculates percentage */
  43. int    ReadBlock();         /* reads archive block */
  44. int    IsProcessFile();     /* should file be processed */
  45. int    UnpRead();           /* reading while unpacking */
  46. int    UnpWrite();          /* writing while unpacking */
  47. void   InitCRC();           /* initializes CRC table */
  48. UDWORD CRC();               /* calculates CRC */
  49.  
  50. struct MarkHeader MarkHead;
  51. struct ArchiveHeader Mhd;
  52. struct FileHeader Lhd;
  53.  
  54. UDWORD CRC32_Table[256],UnpFileCRC;
  55. HPBYTE TmpMemory;
  56.  
  57. int ArgCount=0;
  58. char ArgNames[16][80],MainCommand;
  59. char CurExtrFile[80]={0},ArcName[80],ArcFileName[80],ExtrPath[80];
  60. int SolidType,UnpVolume,TestMode,ExitCode=0;
  61. FILE *ArcFPtr=NULL,*FileFPtr=NULL,*RdUnpFPtr,*WrUnpFPtr;
  62. long NextBlockPos,UnpPackedSize;
  63.  
  64.  
  65. main(Argc,Argv)
  66. int Argc;
  67. char *Argv[];
  68. {
  69.   printf("\n UNRAR 1.00e freeware portable version      (C) 1994 Eugene Roshal\n");
  70.   if ((TmpMemory=(HPBYTE)MEMALLOC(UNP_MEMORY))==NULL)
  71.     ErrExit(EMEMORY,MEMORY_ERROR);
  72.   MakeTbl();
  73.   SplitCommandLine(Argc,Argv);
  74.   ExecuteCommand();
  75.   ShutDown(SD_MEMORY);
  76.   exit(ExitCode);
  77. }
  78.  
  79.  
  80. int CmpName(Mask,Name)
  81. char *Mask;
  82. char *Name;
  83. {
  84.   while (1)
  85.   {
  86.     if (*Mask=='*')
  87.     {
  88.       while (*Mask!='.' && *Mask!=0)
  89.         Mask++;
  90.       while (*Name!='.' && *Name!=0)
  91.         Name++;
  92.     }
  93.     if (*Mask==0)
  94.       return(*Name==0);
  95.     if (*Name==0 && *Mask=='.')
  96.     {
  97.       Mask++;
  98.       continue;
  99.     }
  100.     if (toupper(*Mask)==toupper(*Name) || *Mask=='?' && *Name!=0)
  101.     {
  102.       Mask++;
  103.       Name++;
  104.     }
  105.     else
  106.       return(0);
  107.   }
  108. }
  109.  
  110.  
  111. void ErrExit(ErrCode,Code)
  112. int ErrCode;
  113. int Code;
  114. {
  115.   char ErrMsg[80];
  116.   switch(ErrCode)
  117.   {
  118.     case EEMPTY:
  119.       strcpy(ErrMsg,"");
  120.       break;
  121.     case EWRITE:
  122.       strcpy(ErrMsg,"Write error. Disk full ?");
  123.       break;
  124.     case EREAD:
  125.       strcpy(ErrMsg,"Read error");
  126.       break;
  127.     case EOPEN:
  128.       strcpy(ErrMsg,"File open error");
  129.       break;
  130.     case ECLOSE:
  131.       strcpy(ErrMsg,"File close error");
  132.       break;
  133.     case EMEMORY:
  134.       strcpy(ErrMsg,"Not enough memory");
  135.       break;
  136.     case EARCH:
  137.       strcpy(ErrMsg,"Broken archive");
  138.       break;
  139.   }
  140.   if (ErrCode!=EEMPTY)
  141.     printf("\n Program aborted\n %s",ErrMsg);
  142.   ShutDown(SD_FILES | SD_MEMORY);
  143.   exit(Code);
  144. }
  145.  
  146.  
  147. void CreatePath(fpath)
  148. char *fpath;
  149. {
  150.   char *ChPtr;
  151.   ChPtr=fpath;
  152.   while(*ChPtr!=0 && (ChPtr=strchr(ChPtr,PATHDIV))!=NULL)
  153.   {
  154.     *ChPtr=0;
  155.     if (MAKEDIR(fpath)==0)
  156.       printf("\n Creating    %-55s",fpath);
  157.     *ChPtr=PATHDIV;
  158.     ChPtr++;
  159.   }
  160. }
  161.  
  162.  
  163. void NextVolumeName()
  164. {
  165.   char *ChPtr;
  166.   ChPtr=strrchr(ArcName,'.');
  167.   if (!isdigit(*(ChPtr+2)) || !isdigit(*(ChPtr+3)))
  168.     strcpy(ChPtr+2,"00");
  169.   else
  170.   {
  171.     ChPtr+=3;
  172.     while ((++(*ChPtr))=='9'+1)
  173.     {
  174.       if (*(ChPtr-1)=='.')
  175.       {
  176.         *ChPtr='A';
  177.         break;
  178.       }
  179.       else
  180.       {
  181.         *ChPtr='0';
  182.         ChPtr--;
  183.       }
  184.     }
  185.   }
  186. }
  187.  
  188.  
  189. void MergeArc(ShowFileName)
  190. int ShowFileName;
  191. {
  192.   int Ch;
  193.   tclose(ArcFPtr);
  194.   NextVolumeName();
  195.   while ((ArcFPtr=fopen(ArcName,"r"))==NULL)
  196.   {
  197.     printf("\n Disk with %s required. Continue ? ",ArcName);
  198.     Ch=getchar();
  199.     if (toupper(Ch)=='N')
  200.       ErrExit(EEMPTY,USER_BREAK);
  201.   }
  202.   if (MainCommand=='T')
  203.     printf("\n\n Testing archive %s",ArcName);
  204.   else
  205.     if (MainCommand!='P')
  206.       printf("\n\n Extracting from %s",ArcName);
  207.   CheckArc();
  208.   ReadBlock(FILE_HEAD);
  209.   if (ShowFileName)
  210.     printf("\n     ...     %-55s",ArcFileName);
  211.   UnpVolume=(Lhd.Flags & LHD_SPLIT_AFTER);
  212.   fseek(ArcFPtr,NextBlockPos-Lhd.PackSize,SEEK_SET);
  213.   UnpPackedSize=Lhd.PackSize;
  214.   RdUnpFPtr=ArcFPtr;
  215. }
  216.  
  217.  
  218. void UnstoreFile()
  219. {
  220.   int Code;
  221.   while ( 1 )
  222.   {
  223.     if ((Code=UnpRead((UBYTE *)TmpMemory,0x7f00))==-1)
  224.       ErrExit(EWRITE,WRITE_ERROR);
  225.     if (Code==0)
  226.       break;
  227.     if (UnpWrite((UBYTE *)TmpMemory,(UWORD)Code)==-1)
  228.       ErrExit(EWRITE,WRITE_ERROR);
  229.   }
  230. }
  231.  
  232.  
  233. int IsArchive()
  234. {
  235.   UBYTE Mark[7],Header[13];
  236.   SolidType=0;
  237.   if (tread(ArcFPtr,Mark,7)!=7)
  238.     return(0);
  239.   if (Mark[0]!=0x52 || Mark[1]!=0x61 || Mark[2]!=0x72 || Mark[3]!=0x21 ||
  240.       Mark[4]!=0x1a || Mark[5]!=0x07 || Mark[6]!=0x00)
  241.     return(0);
  242.   if (tread(ArcFPtr,Header,13) != 13)
  243.     return(0);
  244.   Mhd.HeadCRC  = Header[0]+(UWORD)Header[1]*0x100;
  245.   Mhd.HeadType = Header[2];
  246.   Mhd.Flags    = Header[3]+(UWORD)Header[4]*0x100;
  247.   Mhd.HeadSize = Header[5]+(UWORD)Header[6]*0x100;
  248.   if (!(Mhd.HeadCRC==(UWORD)~CRC(0xFFFFFFFFL,&Header[2],11)))
  249.     printf("\n Archive header broken");
  250.   SolidType=(Mhd.Flags & MHD_SOLID);
  251.   fseek(ArcFPtr,Mhd.HeadSize-13,SEEK_CUR);
  252.   return(1);
  253. }
  254.  
  255.  
  256. void CheckArc()
  257. {
  258.   if (!IsArchive())
  259.   {
  260.     printf("\nBad archive %s",ArcName);
  261.     ErrExit(EEMPTY,FATAL_ERROR);
  262.   }
  263. }
  264.  
  265.  
  266. int tread(FPtr,buf,len)
  267. FILE *FPtr;
  268. void *buf;
  269. unsigned len;
  270. {
  271.   int Code;
  272.   Code=fread(buf,1,len,FPtr);
  273.   if (Code==-1)
  274.     ErrExit(EREAD,FATAL_ERROR);
  275.   return(Code);
  276. }
  277.  
  278.  
  279. void tclose(FPtr)
  280. FILE *FPtr;
  281. {
  282.   if (fclose(FPtr)==EOF)
  283.     ErrExit(ECLOSE,FATAL_ERROR);
  284. }
  285.  
  286.  
  287. char* PointToName(Path)
  288. char *Path;
  289. {
  290.   char *ChPtr;
  291.   if ((ChPtr=strrchr(Path,PATHDIV))!=NULL)
  292.     return(ChPtr+1);
  293.   else
  294.     if ((ChPtr=strrchr(Path,':'))!=NULL)
  295.       return(ChPtr+1);
  296.     else
  297.       return(Path);
  298. }
  299.  
  300.  
  301. int strnicomp(Str1,Str2,MaxLen)
  302. char *Str1;
  303. char *Str2;
  304. int MaxLen;
  305. {
  306.   if (MaxLen==0)
  307.     return(0);
  308.   while (MaxLen-- > 0)
  309.   {
  310.     if (toupper(*Str1)!=toupper(*Str2))
  311.       return(1);
  312.     if (*Str1==0)
  313.       return(0);
  314.     Str1++;
  315.     Str2++;
  316.   }
  317.   return(0);
  318. }
  319.  
  320.  
  321. char* strtolwr(Str)
  322. char *Str;
  323. {
  324.   char *ChPtr;
  325.   for (ChPtr=Str;*ChPtr!=0;ChPtr++)
  326.     *ChPtr=tolower(*ChPtr);
  327.   return(Str);
  328. }
  329.  
  330.  
  331. void SplitName(Path,Dir,Name)
  332. char *Path;
  333. char *Dir;
  334. char *Name;
  335. {
  336.   char *ChPtr,*ChPtr1;
  337.   if ((ChPtr=strrchr(Path,':'))!=NULL)
  338.     ChPtr++;
  339.   else
  340.     ChPtr=Path;
  341.   if ((ChPtr1=strrchr(ChPtr,PATHDIV))!=NULL)
  342.   {
  343.     *ChPtr1=0;
  344.     strcpy(Dir,ChPtr);
  345.     *ChPtr1=PATHDIV;
  346.     ChPtr=ChPtr1+1;
  347.   }
  348.   else
  349.     *Dir=0;
  350.   strcpy(Name,ChPtr);
  351. }
  352.  
  353.  
  354. int ToPercent(N1,N2)
  355. long N1;
  356. long N2;
  357. {
  358.   if (N1 > 10000)
  359.   {
  360.     N1/=100;
  361.     N2/=100;
  362.   }
  363.   if (N2==0)
  364.     return(0);
  365.   if (N2<N1)
  366.     return(100);
  367.   return((int)(N1*100/N2));
  368. }
  369.  
  370.  
  371. void SplitCommandLine(Argc,Argv)
  372. int Argc;
  373. char *Argv[];
  374. {
  375.   int I,Len;
  376.  
  377.   ArgCount = MainCommand = *ArcName = *ExtrPath = 0;
  378.  
  379.   if (Argc==2)
  380.   {
  381.     MainCommand='X';
  382.     strcpy(ArcName,Argv[1]);
  383.   }
  384.   else
  385.     for (I=1;I<Argc;I++)
  386.     {
  387.       if (MainCommand==0)
  388.         MainCommand=toupper(Argv[I][0]);
  389.       else
  390.       {
  391.         if (*ArcName==0)
  392.           strncpy(ArcName,Argv[I],80);
  393.         else
  394.         {
  395.           Len=strlen(Argv[I]);
  396.           if (Len>0 && (Argv[I][Len-1]==':' || (Argv[I][Len-1]=='\\' || Argv[I][Len-1]=='/')))
  397.           {
  398.             strcpy(ExtrPath,Argv[I]);
  399.             ExtrPath[Len-1]=PATHDIV;
  400.           }
  401.           else
  402.             strncpy(ArgNames[(ArgCount++) & 0x0f],Argv[I],80);
  403.         }
  404.       }
  405.     }
  406.  
  407.   if (ArgCount==0 && *ArcName!=0)
  408.     strcpy(ArgNames[(ArgCount++) & 0x0f],"*.*");
  409.   if (strrchr(PointToName(ArcName),'.')==NULL)
  410.     strcat(ArcName,isupper(*ArcName) ? ".RAR":".rar");
  411.   ArgCount &= 0xF;
  412. }
  413.  
  414.  
  415. void ExecuteCommand()
  416. {
  417.   switch(MainCommand)
  418.   {
  419.     case 'E':
  420.     case 'X':
  421.     case 'T':
  422.       ExtrFile();
  423.       break;
  424.     case 'V':
  425.     case 'L':
  426.       ListArchive();
  427.       break;
  428.     case 0:
  429.       Help();
  430.       exit(0);
  431.     default:
  432.       Help();
  433.       exit(USER_ERROR);
  434.   }
  435. }
  436.  
  437. void ShutDown(Mode)
  438. int Mode;
  439. {
  440.   if (Mode & SD_FILES)
  441.   {
  442.     if (ArcFPtr!=NULL)
  443.       fclose(ArcFPtr);
  444.     if (FileFPtr!=NULL)
  445.       fclose(FileFPtr);
  446.   }
  447.   if (Mode & SD_MEMORY)
  448.   {
  449.     if (TmpMemory!=NULL)
  450.       MEMFREE(TmpMemory);
  451.     printf("\n");
  452.   }
  453. }
  454.  
  455.  
  456. void Help()
  457. {
  458.   printf("\n Usage:     UNRAR <command> <archive> <files...>\n");
  459.   printf("\n <Commands>\n");
  460.   printf("\n x       Extract files with full path");
  461.   printf("\n e       Extract files to current directory");
  462.   printf("\n t       Test archive files");
  463.   printf("\n v       Verbosely list contents of archive");
  464.   printf("\n l       List contents of archive");
  465.   printf("\n");
  466. }
  467.  
  468.  
  469. int ExtrFile()
  470. {
  471.   char DestFileName[80];
  472.   long FileCount=0,TotalFileCount=0,DirCount=0,ErrCount=0;
  473.   int ExtrFile=0,Size,SkipSolid=0,UnpSolid;
  474.  
  475.   if ((ArcFPtr=fopen(ArcName,"r"))==NULL)
  476.     ErrExit(EOPEN,FATAL_ERROR);
  477.  
  478.   CheckArc();
  479.   CreateEncTbl(TmpMemory);
  480.   UnpVolume=UnpSolid=0;
  481.   if (MainCommand=='T')
  482.     printf("\n Testing archive %s\n",ArcName);
  483.   else
  484.     printf("\n Extracting from %s\n",ArcName);
  485.  
  486.   while (1)
  487.   {
  488.     Size=ReadBlock(FILE_HEAD);
  489.  
  490.     if (Size<=0 && UnpVolume==0)
  491.       break;
  492.     if ((Lhd.Flags & LHD_SPLIT_BEFORE) && SolidType)
  493.     {
  494.       printf("\nSolid archive: first volume required");
  495.       ErrExit(EEMPTY,FATAL_ERROR);
  496.     }
  497.     if (UnpVolume && Size==0)
  498.       MergeArc(0);
  499.     UnpVolume=(Lhd.Flags & LHD_SPLIT_AFTER);
  500.     fseek(ArcFPtr,NextBlockPos-Lhd.PackSize,SEEK_SET);
  501.  
  502.     TestMode=0;
  503.     ExtrFile=0;
  504.     SkipSolid=0;
  505.  
  506.     if (IsProcessFile(COMPARE_PATH) && (Lhd.Flags & LHD_SPLIT_BEFORE)==0
  507.         || (SkipSolid=SolidType)!=0)
  508.     {
  509.  
  510.       strcpy(DestFileName,ExtrPath);
  511.       strcat(DestFileName,(MainCommand!='E') ? ArcFileName : PointToName(ArcFileName));
  512.  
  513.       ExtrFile=!SkipSolid;
  514.  
  515.       if (Lhd.UnpVer<15 || Lhd.UnpVer>UNP_VER)
  516.       {
  517.         printf("\n %s: unknown method",ArcFileName);
  518.         ExtrFile=0;
  519.         ErrCount++;
  520.         ExitCode=WARNING;
  521.       }
  522.  
  523.       if (Lhd.Flags & LHD_PASSWORD)
  524.       {
  525.         printf("\n %s: cannot process encrypted file",ArcFileName);
  526.         if (SolidType)
  527.           ErrExit(EEMPTY,FATAL_ERROR);
  528.         ExtrFile=0;
  529.         ErrCount++;
  530.         ExitCode=WARNING;
  531.       }
  532.  
  533.       if (Lhd.HostOS==MS_DOS && (Lhd.FileAttr & DOSFA_DIREC))
  534.       {
  535.         if (MainCommand=='E')
  536.           continue;
  537.         if (SkipSolid)
  538.         {
  539.           printf("\n Skipping    %-55s Ok",ArcFileName);
  540.           continue;
  541.         }
  542.         if (MainCommand=='T')
  543.         {
  544.           printf("\n Testing     %-55s Ok",ArcFileName);
  545.           continue;
  546.         }
  547.         CreatePath(DestFileName);
  548.         if (MAKEDIR(DestFileName)==0)
  549.           printf("\n Creating    %-55s",ArcFileName);
  550.         continue;
  551.       }
  552.       else
  553.       {
  554.         if (MainCommand=='T' && ExtrFile)
  555.           TestMode=1;
  556.         if ((MainCommand=='E' || MainCommand=='X') && ExtrFile)
  557.         {
  558.           CreatePath(DestFileName);
  559.           if ((FileFPtr=fopen(DestFileName,"w"))==NULL)
  560.           {
  561.             printf("\n Cannot create %s",DestFileName);
  562.             ExitCode=WARNING;
  563.             ExtrFile=0;
  564.           }
  565.         }
  566.       }
  567.  
  568.       if (!ExtrFile && SolidType)
  569.         SkipSolid=TestMode=ExtrFile=1;
  570.       if (ExtrFile)
  571.       {
  572.         TotalFileCount++;
  573.         if (SkipSolid)
  574.           printf("\n Skipping    %-55s",ArcFileName);
  575.         else
  576.         {
  577.           FileCount++;
  578.           switch(MainCommand)
  579.           {
  580.             case 'T':
  581.               printf("\n Testing     %-55s",ArcFileName);
  582.               break;
  583.             case 'X':
  584.             case 'E':
  585.               printf("\n Extracting  %-55s",DestFileName);
  586.               break;
  587.           }
  588.         }
  589.         strcpy(CurExtrFile,DestFileName);
  590.         UnpFileCRC=0xFFFFFFFFL;
  591.         UnpPackedSize=Lhd.PackSize;
  592.         DestUnpSize=Lhd.UnpSize;
  593.         RdUnpFPtr=ArcFPtr;
  594.         WrUnpFPtr=FileFPtr;
  595.         if (Lhd.Method==0x30)
  596.           UnstoreFile();
  597.         else
  598.           if (unpack(TmpMemory,UnpRead,UnpWrite,UnpSolid)==-1)
  599.             ErrExit(EWRITE,WRITE_ERROR);
  600.         if (TotalFileCount>0 && SolidType)
  601.           UnpSolid=1;
  602.         if (UnpFileCRC==~Lhd.FileCRC)
  603.         {
  604.           if (MainCommand!='P')
  605.             printf(" Ok");
  606.         }
  607.         else
  608.         {
  609.           fseek(ArcFPtr,NextBlockPos,SEEK_SET);
  610.           printf("\n %-15s : CRC failed",ArcFileName);
  611.           ExitCode=CRC_ERROR;
  612.           ErrCount++;
  613.         }
  614.         if (!TestMode)
  615.         {
  616.           SETFILETIME(FileFPtr,(void *)&Lhd.FileTime);
  617.           tclose(FileFPtr);
  618.         }
  619.         TestMode=0;
  620.         *CurExtrFile=0;
  621.       }
  622.     }
  623.     if (!ExtrFile && !SolidType)
  624.       fseek(ArcFPtr,NextBlockPos,SEEK_SET);
  625.   }
  626.   tclose(ArcFPtr);
  627.   if ((FileCount+DirCount)==0)
  628.   {
  629.     printf("\n No files");
  630.     ExitCode=WARNING;
  631.   }
  632.   else
  633.     if (ErrCount==0)
  634.       printf("\n  All OK");
  635.     else
  636.       printf("\n  Total errors: %ld",ErrCount);
  637.   return(0);
  638. }
  639.  
  640.  
  641. void ListArchive()
  642. {
  643.   unsigned long TotalPackSize,TotalUnpSize,FileCount;
  644.   int I;
  645.   TotalPackSize=TotalUnpSize=FileCount=0;
  646.   if ((ArcFPtr=fopen(ArcName,"r"))==NULL)
  647.     ErrExit(EOPEN,FATAL_ERROR);
  648.   CheckArc();
  649.   printf("\n ");
  650.   if (SolidType)
  651.     printf("Solid ");
  652.   if (Mhd.Flags & MHD_MULT_VOL)
  653.     printf("%colume ",(SolidType) ? 'v':'V');
  654.   else
  655.     printf("%crchive ",(SolidType) ? 'a':'A');
  656.   printf("%s\n",ArcName);
  657.   if (MainCommand=='V')
  658.     printf("\n Pathname/Comment\n%12.12s","");
  659.   else
  660.     printf("\n Name       ");
  661.   printf("      Size   Packed  Ratio   Date   Time  Attr   CRC-32  Meth Ver\n");
  662.   for (I=0;I<77;I++)
  663.     printf("-");
  664.   while(ReadBlock(FILE_HEAD) > 0)
  665.   {
  666.     if (IsProcessFile(NOT_COMPARE_PATH))
  667.     {
  668.       printf("\n%c",(Lhd.Flags & LHD_PASSWORD) ? '*' : ' ');
  669.       if (MainCommand=='V')
  670.       {
  671.         printf("%-s",ArcFileName);
  672.         printf("\n%12s ","");
  673.       }
  674.       else
  675.         printf("%-12s",PointToName(ArcFileName));
  676.  
  677.       printf(" %8ld %8ld ",Lhd.UnpSize,Lhd.PackSize);
  678.       if (Lhd.Flags & (LHD_SPLIT_AFTER | LHD_SPLIT_BEFORE))
  679.         printf(" Split");
  680.       else
  681.         printf(" %3d%% ",ToPercent(Lhd.PackSize,Lhd.UnpSize));
  682.  
  683.       printf(" %02d-%02d-%02d %02d:%02d ",Lhd.FileTime.ft_day,
  684.              Lhd.FileTime.ft_month,(Lhd.FileTime.ft_year+1980)%100,
  685.              Lhd.FileTime.ft_hour,Lhd.FileTime.ft_min);
  686.  
  687.       if (Lhd.HostOS==MS_DOS)
  688.         printf("%c%c%c%c%c",
  689.           (Lhd.FileAttr & DOSFA_DIREC ) ? 'D' : '.',
  690.           (Lhd.FileAttr & DOSFA_RDONLY) ? 'R' : '.',
  691.           (Lhd.FileAttr & DOSFA_HIDDEN) ? 'H' : '.',
  692.           (Lhd.FileAttr & DOSFA_SYSTEM) ? 'S' : '.',
  693.           (Lhd.FileAttr & DOSFA_ARCH  ) ? 'A' : '.');
  694.       else
  695.         printf("     ");
  696.       printf(" %8.8lX  m%d  %d.%d",Lhd.FileCRC,Lhd.Method-0x30,Lhd.UnpVer/10,Lhd.UnpVer%10);
  697.       if (!(Lhd.Flags & LHD_SPLIT_BEFORE))
  698.       {
  699.         TotalUnpSize+=Lhd.UnpSize;
  700.         FileCount++;
  701.       }
  702.       TotalPackSize+=Lhd.PackSize;
  703.     }
  704.     fseek(ArcFPtr,NextBlockPos,SEEK_SET);
  705.   }
  706.   printf("\n");
  707.   for (I=0;I<77;I++)
  708.     printf("-");
  709.   printf("\n%5ld %16ld %8ld %4d%%\n",FileCount,TotalUnpSize,TotalPackSize,ToPercent(TotalPackSize,TotalUnpSize));
  710.   tclose(ArcFPtr);
  711. }
  712.  
  713.  
  714. int IsProcessFile(ComparePath)
  715. int ComparePath;
  716. {
  717.   int NumName,WildCards;
  718.   char ArgName[80],dir1[80],name1[15],dir2[80],name2[15];
  719.   for (NumName=0;NumName<ArgCount;NumName++)
  720.   {
  721.     memcpy((void *)ArgName,(void *)ArgNames[NumName],sizeof(ArgName));
  722.     WildCards=(strchr(ArgName,'?')!=NULL || strchr(ArgName,'*')!=NULL);
  723.     SplitName(ArgName,dir1,name1);
  724.     SplitName(ArcFileName,dir2,name2);
  725.     if (CmpName(name1,name2) && ((ComparePath==NOT_COMPARE_PATH && *dir1==0) ||
  726.           WildCards && strnicomp(dir1,dir2,strlen(dir1))==0 ||
  727.           strnicomp(dir1,dir2,1000)==0))
  728.       return(1);
  729.   }
  730.   return(0);
  731. }
  732.  
  733. int ReadBlock(BlockType)
  734. int BlockType;
  735. {
  736.   UDWORD HeadCRC;
  737.   UBYTE Header[32];
  738.   int Size,I;
  739.   memset(&Lhd,0,sizeof(Lhd));
  740.   memset(Header,0,sizeof(Header));
  741.   while (1)
  742.   {
  743.     Size=tread(ArcFPtr,Header,32);
  744.     Lhd.HeadCRC  = Header[0] +(UWORD)Header[1]*0x100;
  745.     Lhd.HeadType = Header[2];
  746.     Lhd.Flags    = Header[3] +(UWORD)Header[4]*0x100;
  747.     Lhd.HeadSize = Header[5] +(UWORD)Header[6]*0x100;;
  748.     Lhd.PackSize = Header[7] +(UWORD)Header[8]*0x100+(UDWORD)Header[9]*0x10000L+(UDWORD)Header[10]*0x1000000L;
  749.     Lhd.UnpSize  = Header[11]+(UWORD)Header[12]*0x100+(UDWORD)Header[13]*0x10000L+(UDWORD)Header[14]*0x1000000L;
  750.     Lhd.HostOS   = Header[15];
  751.     Lhd.FileCRC  = Header[16]+(UWORD)Header[17]*0x100+(UDWORD)Header[18]*0x10000L+(UDWORD)Header[19]*0x1000000L;
  752.     *(UDWORD *)&Lhd.FileTime=Header[20]+(UWORD)Header[21]*0x100+(UDWORD)Header[22]*0x10000L+(UDWORD)Header[23]*0x1000000L;
  753.     Lhd.UnpVer   = Header[24];
  754.     Lhd.Method   = Header[25];
  755.     Lhd.NameSize = Header[26]+(UWORD)Header[27]*0x100;
  756.     Lhd.FileAttr = Header[28]+(UWORD)Header[29]*0x100+(UDWORD)Header[30]*0x10000L+(UDWORD)Header[31]*0x1000000L;
  757.     if (Size != 0 && (Size<7 || Lhd.HeadSize<7))
  758.       ErrExit(EARCH,FATAL_ERROR);
  759.     NextBlockPos=ftell(ArcFPtr)-Size+Lhd.HeadSize;
  760.     if (Lhd.Flags & LONG_BLOCK)
  761.       NextBlockPos+=Lhd.PackSize;
  762.     if (Size==0 || BlockType==ALL_HEAD || Lhd.HeadType==BlockType)
  763.       break;
  764.     fseek(ArcFPtr,NextBlockPos,SEEK_SET);
  765.   }
  766.   if (Size>0 && BlockType==FILE_HEAD)
  767.   {
  768.     tread(ArcFPtr,ArcFileName,Lhd.NameSize);
  769.     ArcFileName[Lhd.NameSize]=0;
  770.     Size+=Lhd.NameSize;
  771.     HeadCRC=CRC(0xFFFFFFFFL,&Header[2],30);
  772.     if (!(Lhd.HeadCRC==(UWORD)~CRC(HeadCRC,&ArcFileName[0],Lhd.NameSize)))
  773.       printf("\n %s: file header broken\n",ArcFileName);
  774.     for (I=0;ArcFileName[I];I++)
  775.       if (ArcFileName[I]=='\\' || ArcFileName[I]=='/')
  776.         ArcFileName[I]=PATHDIV;
  777.     if (Lhd.HostOS==MS_DOS)
  778.       strtolwr(ArcFileName);
  779.   }
  780.   return(Size);
  781. }
  782.  
  783.  
  784. int UnpRead(Addr,Count)
  785. UBYTE *Addr;
  786. UWORD Count;
  787. {
  788.   int RetCode;
  789.   unsigned int ReadSize,TotalRead=0;
  790.   UBYTE *ReadAddr;
  791.   ReadAddr=Addr;
  792.   while (Count > 0)
  793.   {
  794.     ReadSize=(unsigned int)((Count>UnpPackedSize) ? UnpPackedSize : Count);
  795.     if ((RetCode=fread(ReadAddr,1,ReadSize,RdUnpFPtr))!=ReadSize)
  796.       break;
  797.     TotalRead+=RetCode;
  798.     ReadAddr+=RetCode;
  799.     Count-=RetCode;
  800.     UnpPackedSize-=RetCode;
  801.     if (UnpPackedSize == 0 && UnpVolume)
  802.       MergeArc(1);
  803.     else
  804.       break;
  805.   }
  806.   if (RetCode!=-1)
  807.     RetCode=(int)TotalRead;
  808.   return(RetCode);
  809. }
  810.  
  811.  
  812. int UnpWrite(Addr,Count)
  813. UBYTE *Addr;
  814. UWORD Count;
  815. {
  816.   int RetCode;
  817.   if (TestMode)
  818.     RetCode=(int)Count;
  819.   else
  820.     if ((RetCode=fwrite(Addr,1,Count,WrUnpFPtr))!=Count)
  821.       RetCode = -1;
  822.   if (RetCode!=-1)
  823.     UnpFileCRC=CRC(UnpFileCRC,Addr,(UWORD)RetCode);
  824.   return(RetCode);
  825. }
  826.  
  827.  
  828. UDWORD CRC(StartCRC,Addr,Size)
  829. UDWORD StartCRC;
  830. UBYTE *Addr;
  831. UWORD Size;
  832. {
  833.   UWORD I;
  834.   if (!CRC32_Table[1])
  835.     InitCRC();
  836.   for (I=0;I<Size;I++)
  837.     StartCRC = CRC32_Table[(UBYTE)StartCRC ^ Addr[I]] ^ (StartCRC >> 8);
  838.   return(StartCRC);
  839. }
  840.  
  841. void InitCRC()
  842. {
  843.   int I, J;
  844.   UDWORD C;
  845.   for (I=0;I<256;I++)
  846.   {
  847.     for (C=I,J=0;J<8;J++)
  848.       C=(C & 1) ? (C>>1)^0xEDB88320L : (C>>1);
  849.     CRC32_Table[I]=C;
  850.   }
  851. }
  852.