EIC code displayed by LXR master/​include/​xrootd/​private/​XrdZip/​XrdZipLFH.hh	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2025-01-18 10:15:38

 //------------------------------------------------------------------------------
 // Copyright (c) 2011-2014 by European Organization for Nuclear Research (CERN)
 // Author: Michal Simon <michal.simon@cern.ch>
 //------------------------------------------------------------------------------
 // This file is part of the XRootD software suite.
 //
 // XRootD is free software: you can redistribute it and/or modify
 // it under the terms of the GNU Lesser General Public License as published by
 // the Free Software Foundation, either version 3 of the License, or
 // (at your option) any later version.
 //
 // XRootD is distributed in the hope that it will be useful,
 // but WITHOUT ANY WARRANTY; without even the implied warranty of
 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 // GNU General Public License for more details.
 //
 // You should have received a copy of the GNU Lesser General Public License
 // along with XRootD.  If not, see <http://www.gnu.org/licenses/>.
 //
 // In applying this licence, CERN does not waive the privileges and immunities
 // granted to it by virtue of its status as an Intergovernmental Organization
 // or submit itself to any jurisdiction.
 //------------------------------------------------------------------------------
 
 #ifndef SRC_XRDZIP_XRDZIPLFH_HH_
 #define SRC_XRDZIP_XRDZIPLFH_HH_
 
 #include "XrdZip/XrdZipUtils.hh"
 #include "XrdZip/XrdZipExtra.hh"
 
 #include <string>
 #include <memory>
 #include <algorithm>
 #include <iterator>
 
 namespace XrdZip
 {
   //---------------------------------------------------------------------------
   //! A data structure representing ZIP Local File Header
   //---------------------------------------------------------------------------
   struct LFH
   {
     //-------------------------------------------------------------------------
     //! Convenience function for initializing compressed/uncompressed size
     //-------------------------------------------------------------------------
     inline static uint32_t initSize( const off_t &fileSize )
     {
       return fileSize >= ovrflw<uint32_t>::value ?
              ovrflw<uint32_t>::value : fileSize;
     }
 
     //-------------------------------------------------------------------------
     //! Constructor
     //-------------------------------------------------------------------------
     LFH( const std::string &filename, uint32_t crc, off_t fileSize, time_t time ) :
       generalBitFlag( 0 ), compressionMethod( 0 ), timestmp( time ), ZCRC32( crc ),
       compressedSize( initSize( fileSize ) ), uncompressedSize( initSize( fileSize ) ),
       filenameLength( filename.size() ), filename( filename ), extra( new Extra( fileSize ) )
     {
       extraLength = extra->totalSize;
       if ( extraLength == 0 )
         minZipVersion = 10;
       else
         minZipVersion = 45;
       lfhSize = lfhBaseSize + filenameLength + extraLength;
     }
 
     //-------------------------------------------------------------------------
     //! Constructor from buffer
     //-------------------------------------------------------------------------
     LFH( const char *buffer, const uint64_t bufferSize = 0 )
     {
         if(bufferSize > 0 && bufferSize < (uint64_t)lfhBaseSize)
             throw bad_data();
       // check if the buffer contains a LFH record
       uint32_t signature = 0;
       from_buffer( signature, buffer );
       if( signature != lfhSign ) throw bad_data();
       // parse LFH filds
       from_buffer( minZipVersion, buffer );
       from_buffer( generalBitFlag, buffer );
       from_buffer( compressionMethod, buffer );
       from_buffer( timestmp.time, buffer );
       from_buffer( timestmp.date, buffer );
       from_buffer( ZCRC32, buffer );
       from_buffer( compressedSize, buffer );
       from_buffer( uncompressedSize, buffer );
       from_buffer( filenameLength, buffer );
       from_buffer( extraLength, buffer );
 
       if(bufferSize > 0 && (uint64_t)(lfhBaseSize + filenameLength + extraLength) > bufferSize)
           throw bad_data();
       // parse the filename
       filename.assign( buffer, filenameLength );
       buffer += filenameLength;
       // parse the extra record
       if( extraLength > 0 )
         ParseExtra( buffer, extraLength );
 
       lfhSize = lfhBaseSize + filenameLength + extraLength;
     }
 
     //-------------------------------------------------------------------------
     //! Serialize the object into a buffer
     //-------------------------------------------------------------------------
     void Serialize( buffer_t &buffer )
     {
       copy_bytes( lfhSign, buffer );
       copy_bytes( minZipVersion, buffer );
       copy_bytes( generalBitFlag, buffer );
       copy_bytes( compressionMethod, buffer );
       copy_bytes( timestmp.time, buffer );
       copy_bytes( timestmp.date, buffer );
       copy_bytes( ZCRC32, buffer );
       copy_bytes( compressedSize, buffer );
       copy_bytes( uncompressedSize, buffer );
       copy_bytes( filenameLength, buffer );
       copy_bytes( extraLength , buffer );
       std::copy( filename.begin(), filename.end(), std::back_inserter( buffer ) );
       extra->Serialize( buffer );
     }
 
     //-------------------------------------------------------------------------
     // Parse the extensible data fields
     //-------------------------------------------------------------------------
     void ParseExtra( const char *buffer, uint16_t length)
     {
       uint8_t ovrflws = Extra::NONE;
       uint16_t exsize = 0;
 
       // check if compressed size is overflown
       if( compressedSize == ovrflw<uint32_t>::value)
       {
         ovrflws |= Extra::CPMSIZE;
         exsize  += sizeof( uint64_t );
       }
 
       // check if original size is overflown
       if( uncompressedSize == ovrflw<uint32_t>::value )
       {
         ovrflws |= Extra::UCMPSIZE;
         exsize  += sizeof( uint64_t );
       }
 
       // if the expected size of ZIP64 extension is 0 we
       // can skip parsing of 'extra'
       if( exsize == 0 ) return;
 
       extra.reset( new Extra() );
 
       // Parse the extra part
       buffer = Extra::Find( buffer, length );
       if( buffer )
         extra->FromBuffer( buffer, exsize, ovrflws );
     }
 
     uint16_t               minZipVersion;      //< minimum ZIP version required to read the file
     uint16_t               generalBitFlag;     //< flags
     uint16_t               compressionMethod;  //< compression method
     dos_timestmp           timestmp;           //< DOS time stamp
     uint32_t               ZCRC32;             //< crc32 value
     uint32_t               compressedSize;     //< compressed data size
     uint32_t               uncompressedSize;   //< uncompressed data size
     uint16_t               filenameLength;     //< file name length
     uint16_t               extraLength;        //< size of the ZIP64 extra field
     std::string            filename;           //< file name
     std::unique_ptr<Extra> extra;              //< the ZIP64 extra field
     uint16_t               lfhSize;            //< size of the Local File Header
 
     //-------------------------------------------------------------------------
     //! Local File Header signature
     //-------------------------------------------------------------------------
     static const uint32_t lfhSign     = 0x04034b50;
     static const uint16_t lfhBaseSize = 30;
   };
 }
 
 #endif /* SRC_XRDZIP_XRDZIPLFH_HH_ */

This page was automatically generated by the 2.3.7 LXR engine. The LXR team