Use u64's for internal file offsets.

These are better aligned with Rust's APIs, and lay the groundwork for more
convenient support of Zip64 files.

src/read.rs

@@ -54,7 +54,7 @@ pub struct ZipArchive<R: Read + io::Seek>
     reader: R,
     files: Vec<ZipFileData>,
     names_map: HashMap<String, usize>,
-    offset: u32,
+    offset: u64,
 }
 
 enum ZipFileReader<'a> {
@@ -85,11 +85,11 @@ impl<R: Read+io::Seek> ZipArchive<R>
 
         // Some zip files have data prepended to them, resulting in the offsets all being too small. Get the amount of
         // error by comparing the actual file position we found the CDE at with the offset recorded in the CDE.
-        let archive_offset = cde_start_pos.checked_sub(footer.central_directory_size)
+        let archive_offset = cde_start_pos.checked_sub(footer.central_directory_size as u64)
-            .and_then(|x| x.checked_sub(footer.central_directory_offset))
+            .and_then(|x| x.checked_sub(footer.central_directory_offset as u64))
             .ok_or(ZipError::InvalidArchive("Invalid central directory size or offset"))?;
 
-        let directory_start = (footer.central_directory_offset + archive_offset) as u64;
+        let directory_start = footer.central_directory_offset as u64 + archive_offset;
         let number_of_files = footer.number_of_files_on_this_disk as usize;
 
         let mut files = Vec::with_capacity(number_of_files);
@@ -132,7 +132,7 @@ impl<R: Read+io::Seek> ZipArchive<R>
     ///
     /// Normally this value is zero, but if the zip has arbitrary data prepended to it, then this value will be the size
     /// of that prepended data.
-    pub fn offset(&self) -> u32 {
+    pub fn offset(&self) -> u64 {
         self.offset
     }
 
@@ -198,7 +198,7 @@ impl<R: Read+io::Seek> ZipArchive<R>
     }
 }
 
-fn central_header_to_zip_file<R: Read+io::Seek>(reader: &mut R, archive_offset: u32) -> ZipResult<ZipFileData>
+fn central_header_to_zip_file<R: Read+io::Seek>(reader: &mut R, archive_offset: u64) -> ZipResult<ZipFileData>
 {
     // Parse central header
     let signature = try!(reader.read_u32::<LittleEndian>());
@@ -230,7 +230,7 @@ fn central_header_to_zip_file<R: Read+io::Seek>(reader: &mut R, archive_offset:
     let file_comment_raw  = try!(ReadPodExt::read_exact(reader, file_comment_length));
 
     // Account for shifted zip offsets.
-    offset += archive_offset as u64;
+    offset += archive_offset;
 
     let file_name = match is_utf8
     {

src/spec.rs

@@ -48,29 +48,32 @@ impl CentralDirectoryEnd
            })
     }
 
-    pub fn find_and_parse<T: Read+io::Seek>(reader: &mut T) -> ZipResult<(CentralDirectoryEnd, u32)>
+    pub fn find_and_parse<T: Read+io::Seek>(reader: &mut T) -> ZipResult<(CentralDirectoryEnd, u64)>
     {
-        let header_size = 22;
+        const HEADER_SIZE: u64 = 22;
-        let bytes_between_magic_and_comment_size = header_size - 6;
+        const BYTES_BETWEEN_MAGIC_AND_COMMENT_SIZE: u64 = HEADER_SIZE - 6;
-        let file_length = try!(reader.seek(io::SeekFrom::End(0))) as i64;
+        let file_length = try!(reader.seek(io::SeekFrom::End(0)));
 
-        let search_upper_bound = ::std::cmp::max(0, file_length - header_size - ::std::u16::MAX as i64);
+        let search_upper_bound = file_length.checked_sub(HEADER_SIZE + ::std::u16::MAX as u64).unwrap_or(0);
 
-        let mut pos = file_length - header_size;
+        let mut pos = file_length - HEADER_SIZE;
         while pos >= search_upper_bound
         {
             try!(reader.seek(io::SeekFrom::Start(pos as u64)));
             if try!(reader.read_u32::<LittleEndian>()) == CENTRAL_DIRECTORY_END_SIGNATURE
             {
-                try!(reader.seek(io::SeekFrom::Current(bytes_between_magic_and_comment_size)));
+                try!(reader.seek(io::SeekFrom::Current(BYTES_BETWEEN_MAGIC_AND_COMMENT_SIZE as i64)));
-                let comment_length = try!(reader.read_u16::<LittleEndian>()) as i64;
+                let comment_length = try!(reader.read_u16::<LittleEndian>()) as u64;
-                if file_length - pos - header_size == comment_length
+                if file_length - pos - HEADER_SIZE == comment_length
                 {
-                    let cde_start_pos = try!(reader.seek(io::SeekFrom::Start(pos as u64))) as u32;
+                    let cde_start_pos = try!(reader.seek(io::SeekFrom::Start(pos as u64)));
                     return CentralDirectoryEnd::parse(reader).map(|cde| (cde, cde_start_pos));
                 }
             }
-            pos -= 1;
+            pos = match pos.checked_sub(1) {
+                Some(p) => p,
+                None => break,
+            };
         }
         Err(ZipError::InvalidArchive("Could not find central directory end"))
     }