ztvregister.pas

ziptv为delphi控件

               s.Position := 6867
            Else
               Break;                   // post loop file-positions are greater

         //Arc602.exe
         //  1986-89
         //  Wayne Chin & Vernon D. Buerg
         //  Signattr: $a1a
         //  Becompression support: unsqueeze, uncrunch, unsquash
         //  SFX Size: 7715
         //  Begin offset: 7716
         2:
            If s.Size > 7718 Then       // add 2 for read of sizeof(word) bytes
               s.Position := 7716
            Else
               Break;                   // post loop file-positions are greater

         //pak210.exe
         //  1988-89
         //  NOGATE CONSULTING
         //  Signattr: $a1a, $b1a
         //  Decompression support: expand ?
         //  SFX Size: 8600
         //  Begin offset: 8601
         3:
            If s.Size > 8603 Then       // add 2 for read of sizeof(word) bytes
               s.Position := 8601
            Else
               Break;                   // post loop file-positions are greater

         //pkarc36.exe / pksfx v3.61
         //  1987-88
         //  Pkware, Inc.
         //  Decompression support: unsqueeze, uncrunch, unsquash
         //  SFX Size: 13137
         //  Begin offset: 13138
         4:
            If s.Size > 13140 Then      // add 2 for read of sizeof(word) bytes
               s.Position := 13138
            Else
               Break;                   // post loop file-positions are greater

      End;

      Signattr := 0;
      BytesRead := s.Read(Signattr, SizeOf(Word));
      If (BytesRead = SizeOf(Word)) Then
         If (Signattr = $81A {2074}) Or // pkarc.exe (makesfx.com sfx-stub)
         (Signattr = $91A {2330}) Then  //
         Begin
            fOffsetStart := s.Position - SizeOf(Word);
            Result := atArcExe;
            Exit;
         End
         Else
            If (Signattr = $A1A {2586}) Or // pak151.exe, pak210.exe
            (Signattr = $B1A {2842}) Then // pak151.exe, pak210.exe
            Begin
               fOffsetStart := s.Position - SizeOf(Word);
               Result := atPakExe;
               Exit;
            End;

   End;

   // lha213.exe
   If s.Size > 1949 Then
   Begin
      GetMem(Buffer, 6);
      Try
         Signattr := 0;
         s.Position := 1947;
         BytesRead := s.Read(Buffer[0], 6);
         If BytesRead = 6 Then
            If (Buffer[0] = '-') And
               (Buffer[1] = 'l') And
               (Buffer[2] = 'h') And
               (Buffer[4] = '-') Then
            Begin
               fOffsetStart := 1945;
               Result := atLhaExe;
               Exit;
            End;
      Finally
         FreeMem(Buffer);
      End;
   End;

   (* ********************** *)
   (* Winzip 6.3 16 bit SFX? *)
   (* ********************** *)
   If (s.Size > SixteenBitWinZip + SizeOf(Integer)) Then
   Begin
      s.Position := SixteenBitWinZip;
      BytesRead := s.Read(Signattr, SizeOf(Integer));
      If (BytesRead = SizeOf(Integer)) And
         (Signattr = LOCAL_FILE_HEADER_SIGNATURE) Then
      Begin
         fOffsetStart := SixteenBitWinZip;
         Result := atZipExe;
         Exit;
      End;
   End;

   (* ********************** *)
   (* Winzip 6.3 32 bit SFX? *)
   (* ********************** *)
   If (s.Size > ThirtyTwoBitWinZip + SizeOf(Integer)) Then
   Begin
      s.Position := ThirtyTwoBitWinZip;
      BytesRead := s.Read(Signattr, SizeOf(Integer));
      If (BytesRead = SizeOf(Integer)) And
         (Signattr = LOCAL_FILE_HEADER_SIGNATURE) Then
      Begin
         fOffsetStart := ThirtyTwoBitWinZip;
         Result := atZipExe;
         Exit;
      End;
   End;

   If (Result = atZipExe) Then
   Begin
      GetCentralDirOffset(s);
      HeaderTypeState := [htLocal];
   End
   Else
      Result := atNA;

End;
//-------------------------------------------------------------

Procedure TRegisterZipTV.InitializeVolumeSet;
Var
   Ext: String;
   i: Byte;
Begin
   pVolNum^ := 0;
   Case ArcType Of
      atAce: fVolBegChar := Byte('C');
      atArj: fVolBegChar := Byte('a');
      atRar,
         atRarExe: fVolBegChar := Byte('q');
      atJar,
         atJarExe:
         fVolBegChar := Byte('j');
   Else
      Exit;
   End;

   If fArchiveFile = '' Then
      Exit;

   Ext := ExtractFileExt(fArchiveFile);
   If Ext <> '' Then
      System.Delete(Ext, 1, 1)
   Else
      Case ArcType Of
         atAce: Ext := 'Ace';
         atArj: Ext := 'Arj';
         atRar,
            atRarExe: Ext := 'Rar';
         atZip,
            atZipExe: Ext := 'Zip';
         atJar,
            atJarExe: Ext := 'Jar';
      End;

   pVolNum^ := -1;
   For i := Length(Ext) Downto 1 Do
      If (Byte(Ext[i]) >= 48) And (Byte(Ext[i]) <= 57) Then
      Begin
         pVolNum^ := StrToInt(StrPas(@Ext[i]));
         If i = Length(Ext) Then
            fVolBegChar := Byte(Ext[1]);
      End;

   If pVolNum^ = -1 Then
   Begin
      If (ArcType In [atArj, atArjExe]) Then
         pVolNum^ := 1
      Else
         pVolNum^ := 0;
   End
   Else
      Inc(pVolNum^);

End;
//------------------------------------------------------------

Function TRegisterZipTV.DefSig(HT: THeaderType; Encrypted: Boolean): Integer;
Begin
   Case HT Of

      htLocal:
         If Encrypted Then
         Begin
            If ZipCompatible Then
               Result := LOCAL_FILE_ENCRPT_SIGNATURE
            Else
               Result := LOCAL_CUST_ENCRPT_SIGNATURE;
         End
         Else
         Begin
            If ZipCompatible Then
               Result := LOCAL_FILE_HEADER_SIGNATURE
            Else
               Result := LOCAL_CUST_HEADER_SIGNATURE;
         End;

      htCentral:
         If Encrypted Then
         Begin
            If ZipCompatible Then
               Result := CENTRAL_FILE_ENCRPT_SIGNATURE
            Else
               Result := CENTRAL_CUST_ENCRPT_SIGNATURE
         End
         Else
         Begin
            If ZipCompatible Then
               Result := CENTRAL_FILE_HEADER_SIGNATURE
            Else
               Result := CENTRAL_CUST_HEADER_SIGNATURE;
         End;

      htEnding:
         Result := END_OF_CENTRAL_HEADER_SIGNATURE;
   Else
      Result := MULTIVOL_HEADER_SIGNATURE;
   End;
End;
//------------------------------------------------------------

Function TRegisterZipTV.VerSig(Sig: Integer; HT: THeaderType; Var Encrypted:
	Boolean): THeaderType;
Begin
   Result := htNone;
   Encrypted := False;

   Case HT Of
      htLocal:
         Begin
            Case Sig Of
               LOCAL_FILE_HEADER_SIGNATURE: ; // do not remove
               LOCAL_FILE_ENCRPT_SIGNATURE: Encrypted := True;
               LOCAL_CUST_HEADER_SIGNATURE: ; // do not remove
               LOCAL_CUST_ENCRPT_SIGNATURE: Encrypted := True;
            Else
               Exit;
            End;
            Result := htLocal;
         End;
      htCentral:
         Begin
            Case Sig Of
               CENTRAL_FILE_HEADER_SIGNATURE: ; // do not remove
               CENTRAL_FILE_ENCRPT_SIGNATURE: Encrypted := True;
               CENTRAL_CUST_HEADER_SIGNATURE: ; // do not remove
               CENTRAL_CUST_ENCRPT_SIGNATURE: Encrypted := True;
            Else
               Exit;
            End;
            Result := htCentral;
         End;
      htEnding:
         Begin
            Case Sig Of
               END_OF_CENTRAL_ENCRPT_SIGNATURE  : Encrypted := True;
               END_OF_CENTRAL_HEADER_SIGNATURE  : ; // do not remove
               END_OF_CENTRAL64_ENCRPT_SIGNATURE: Encrypted := True;
               END_OF_CENTRAL64_HEADER_SIGNATURE: ; // do not remove
            Else
               Exit;
            End;
            Result := htEnding;
         End;
   End;
End;
//-------------------------------------------------------------

Procedure TRegisterZipTV.DecodeFilename(p: Pointer; Len: Integer);
Begin
   ztvDecodeBuf(p, Len);
End;
//-------------------------------------------------------------

Procedure TRegisterZipTV.DecodeComment(p: Pointer; Len: Integer);
Begin
   ztvDecodeBuf(p, Len);
End;
//-------------------------------------------------------------

Function GetCryptHeadLen(p: Pointer; HType: THeaderType): Integer;
Begin
   Case HType Of
      htLocal: Result := SizeOf(TLocal);
      htCentral: Result := SizeOf(TCentral);
      htEnding:
         Begin
            If (TEnd(p^).SignAtr = END_OF_CENTRAL_HEADER_SIGNATURE) Or
               (TEnd(p^).SignAtr = END_OF_CENTRAL_ENCRPT_SIGNATURE) Then
               Result := SizeOf(TEnd)
            Else
               Result := SizeOf(TZipTV_End64);
         End;
   Else
      Result := 0;
      Exit;
   End;
   dec(Result, SizeOf(Integer));
End;
//-------------------------------------------------------------

Procedure TRegisterZipTV.DecodeHeader(p: Pointer; HType: THeaderType);
Begin
   k := HKeyed;
   p := Pointer(ptr2int(p) + SizeOf(Integer));
   ztvDecodeBuf(p, GetCryptHeadLen(p, HType));
End;
//-------------------------------------------------------------

Procedure TRegisterZipTV.EncodeFilename(p: Pointer; Len: Integer);
Begin
   ztvEncodeBuf(p, Len);
End;
//-------------------------------------------------------------

Procedure TRegisterZipTV.EncodeComment(p: Pointer; Len: Integer);
Begin
   ztvEncodeBuf(p, Len);
End;
//-------------------------------------------------------------

Procedure TRegisterZipTV.EncodeHeader(p: Pointer; HType: THeaderType);
Begin
   k := HKeyed;
   p := Pointer(ptr2int(p) + SizeOf(Integer));
   ztvEncodeBuf(p, GetCryptHeadLen(p, HType));
End;
//-------------------------------------------------------------
(* Returns true if able to open the archive, else false *)

Function TRegisterZipTV.GetArcType(s: TStream32): TArcType;

Type
   Header = Packed Record
      HeadId: Word;                     { 60000 }
      SIG1: Word;                       { Basic Header Size }
   End;

   ImageInfo = Packed Record
      ExeId: Array[0..1] Of Char;
      Remainder,
         Size: Word
   End;

Var
   h: Header;
   p, c: Pchar;
   Buffer: Pchar;
   hLib: THandle;
   BytesRead: DWord;
   IInfo: ImageInfo;
   Signattr: ^Integer;
   DiskManager: TDiskManager;
   i, code, aOffset: Integer;

   Function GetZipVolumeStatus: TArcType;
   Begin
      DiskManager := TDiskManager.Create();
      With DiskManager Do
      Try
         If GetDriveInfo(fArchiveFile, Nil, Nil, Nil, Nil) Then
         Begin
            If (DriveType = dtFloppy) And
               (UpperCase(ztvGbls.GetToken(DiskLabel,
               ' ')) = TrimRight(PKBACK)) Then
               Result := atZipDS
            Else
               Result := atZipMV;
         End
         Else
            Result := atNA;

      Finally
         DiskManager.Free();
      End;
   End;

   Function TAT(method: Byte; Signattr: Integer): TArcType;
   Begin

      Result := atNA;

      Case Signattr Of
         DCP_SIGNATURE:
            Result := atUnknown;

         CAB_SIGNATURE:
            Case method Of
               0: Result := atCabExe;
               1: Result := atCab;
            End;

         BLAKHOLE_SIGNATURE:
            Case method Of
               0: Result := atBhExe;
               1: Result := atBh;
            End;

         MS_GZ_HEADER_SIGNATURE:
            Case method Of
               0: Result := atUnsupported;
               1: Result := atMSGZ;
            End;