adler32-1.0.3/.gitignore 0100664 0001750 0001750 00000000022 13311755423 0013160 0 ustar 00 0000000 0000000 target
Cargo.lock
adler32-1.0.3/.travis.yml 0100664 0001750 0001750 00000001020 13311755423 0013300 0 ustar 00 0000000 0000000 language: rust
rust:
- stable
- beta
- nightly
sudo: false
script: |
cargo build --verbose && \
cargo test --verbose && \
cargo doc
after_success: |
[ $TRAVIS_BRANCH = master ] &&
[ $TRAVIS_RUST_VERSION = nightly ] &&
[ $TRAVIS_PULL_REQUEST = false ] &&
echo '' > target/doc/index.html &&
pip install --user ghp-import &&
$HOME/.local/bin/ghp-import -n target/doc &&
git push -qf https://${GH_TOKEN}@github.com/${TRAVIS_REPO_SLUG}.git gh-pages
adler32-1.0.3/Cargo.toml.orig 0100664 0001750 0001750 00000000622 13312024031 0014046 0 ustar 00 0000000 0000000 [package]
name = "adler32"
version = "1.0.3"
authors = ["Remi Rampin "]
description = "Minimal Adler32 implementation for Rust."
documentation = "https://remram44.github.io/adler32-rs/index.html"
repository = "https://github.com/remram44/adler32-rs"
readme = "README.md"
keywords = ["adler32", "hash", "rolling"]
license = "BSD-3-Clause AND Zlib"
[dev-dependencies]
rand = "0.4"
adler32-1.0.3/Cargo.toml 0000644 00000001645 00000000000 0010334 0 ustar 00 # THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
#
# When uploading crates to the registry Cargo will automatically
# "normalize" Cargo.toml files for maximal compatibility
# with all versions of Cargo and also rewrite `path` dependencies
# to registry (e.g. crates.io) dependencies
#
# If you believe there's an error in this file please file an
# issue against the rust-lang/cargo repository. If you're
# editing this file be aware that the upstream Cargo.toml
# will likely look very different (and much more reasonable)
[package]
name = "adler32"
version = "1.0.3"
authors = ["Remi Rampin "]
description = "Minimal Adler32 implementation for Rust."
documentation = "https://remram44.github.io/adler32-rs/index.html"
readme = "README.md"
keywords = ["adler32", "hash", "rolling"]
license = "BSD-3-Clause AND Zlib"
repository = "https://github.com/remram44/adler32-rs"
[dev-dependencies.rand]
version = "0.4"
adler32-1.0.3/LICENSE 0100664 0001750 0001750 00000002731 13312005022 0012166 0 ustar 00 0000000 0000000 Copyright (C) 2015, Remi Rampin
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
3. Neither the name of the copyright holder nor the names of its contributors
may be used to endorse or promote products derived from this software
without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
adler32-1.0.3/LICENSE-ZLIB 0100664 0001750 0001750 00000001752 13312024014 0012730 0 ustar 00 0000000 0000000 Copyright notice:
(C) 1995-2017 Jean-loup Gailly and Mark Adler
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
Jean-loup Gailly Mark Adler
jloup@gzip.org madler@alumni.caltech.edu
adler32-1.0.3/README.md 0100664 0001750 0001750 00000001760 13312024014 0012443 0 ustar 00 0000000 0000000 [](https://travis-ci.org/remram44/adler32-rs/builds)
[](https://ci.appveyor.com/project/remram44/adler32-rs)
[](https://crates.io/crates/adler32)
[](https://saythanks.io/to/remram44)
What is this?
=============
It is an implementation of the [Adler32 rolling hash algorithm](https://en.wikipedia.org/wiki/Adler-32) in the [Rust programming language](https://www.rust-lang.org/).
It is adapted from Jean-Loup Gailly's and Mark Adler's [original implementation in zlib](https://github.com/madler/zlib/blob/2fa463bacfff79181df1a5270fb67cc679a53e71/adler32.c). A copy of the zlib copyright and license can be found in LICENSE-ZLIB.
[Generated documentation](https://remram44.github.io/adler32-rs/index.html)
adler32-1.0.3/appveyor.yml 0100664 0001750 0001750 00000000555 13311755423 0013573 0 ustar 00 0000000 0000000 install:
- ps: Start-FileDownload 'https://static.rust-lang.org/dist/rust-nightly-i686-pc-windows-gnu.exe'
- rust-nightly-i686-pc-windows-gnu.exe /VERYSILENT /NORESTART /DIR="C:\Program Files (x86)\Rust"
- set PATH=%PATH%;C:\Program Files (x86)\Rust\bin
- rustc -V
- cargo -V
build: false
test_script:
- cargo build --verbose
- cargo test --verbose
adler32-1.0.3/src/lib.rs 0100664 0001750 0001750 00000022354 13311755423 0013107 0 ustar 00 0000000 0000000 //! A minimal implementation of Adler32 for Rust.
//!
//! This provides the simple method adler32(), that exhausts a Read and
//! computes the Adler32 hash, as well as the RollingAdler32 struct, that can
//! build a hash byte-by-byte, allowing to 'forget' past bytes in a rolling
//! fashion.
//!
//! The adler32 code has been translated (as accurately as I could manage) from
//! the zlib implementation.
#[cfg(test)]
extern crate rand;
use std::io;
// adler32 algorithm and implementation taken from zlib; http://www.zlib.net/
// It was translated into Rust as accurately as I could manage
// The (slow) reference was taken from Wikipedia; https://en.wikipedia.org/
/* zlib.h -- interface of the 'zlib' general purpose compression library
version 1.2.8, April 28th, 2013
Copyright (C) 1995-2013 Jean-loup Gailly and Mark Adler
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
Jean-loup Gailly Mark Adler
jloup@gzip.org madler@alumni.caltech.edu
*/
// largest prime smaller than 65536
const BASE: u32 = 65521;
// NMAX is the largest n such that 255n(n+1)/2 + (n+1)(BASE-1) <= 2^32-1
const NMAX: usize = 5552;
#[inline(always)]
fn do1(adler: &mut u32, sum2: &mut u32, buf: &[u8]) {
*adler += buf[0] as u32;
*sum2 += *adler;
}
#[inline(always)]
fn do2(adler: &mut u32, sum2: &mut u32, buf: &[u8]) {
do1(adler, sum2, &buf[0..1]);
do1(adler, sum2, &buf[1..2]);
}
#[inline(always)]
fn do4(adler: &mut u32, sum2: &mut u32, buf: &[u8]) {
do2(adler, sum2, &buf[0..2]);
do2(adler, sum2, &buf[2..4]);
}
#[inline(always)]
fn do8(adler: &mut u32, sum2: &mut u32, buf: &[u8]) {
do4(adler, sum2, &buf[0..4]);
do4(adler, sum2, &buf[4..8]);
}
#[inline(always)]
fn do16(adler: &mut u32, sum2: &mut u32, buf: &[u8]) {
do8(adler, sum2, &buf[0..8]);
do8(adler, sum2, &buf[8..16]);
}
/// A rolling version of the Adler32 hash, which can 'forget' past bytes.
///
/// Calling remove() will update the hash to the value it would have if that
/// past byte had never been fed to the algorithm. This allows you to get the
/// hash of a rolling window very efficiently.
pub struct RollingAdler32 {
a: u32,
b: u32,
}
impl RollingAdler32 {
/// Creates an empty Adler32 context (with hash 1).
pub fn new() -> RollingAdler32 {
Self::from_value(1)
}
/// Creates an Adler32 context with the given initial value.
pub fn from_value(adler32: u32) -> RollingAdler32 {
let a = adler32 & 0xFFFF;
let b = adler32 >> 16;
RollingAdler32 { a: a, b: b }
}
/// Convenience function initializing a context from the hash of a buffer.
pub fn from_buffer(buffer: &[u8]) -> RollingAdler32 {
let mut hash = RollingAdler32::new();
hash.update_buffer(buffer);
hash
}
/// Returns the current hash.
pub fn hash(&self) -> u32 {
(self.b << 16) | self.a
}
/// Removes the given `byte` that was fed to the algorithm `size` bytes ago.
pub fn remove(&mut self, size: usize, byte: u8) {
let byte = byte as u32;
self.a = (self.a + BASE - byte) % BASE;
self.b = ((self.b + BASE - 1)
.wrapping_add(BASE.wrapping_sub(size as u32)
.wrapping_mul(byte))) % BASE;
}
/// Feeds a new `byte` to the algorithm to update the hash.
pub fn update(&mut self, byte: u8) {
let byte = byte as u32;
self.a = (self.a + byte) % BASE;
self.b = (self.b + self.a) % BASE;
}
/// Feeds a vector of bytes to the algorithm to update the hash.
pub fn update_buffer(&mut self, buffer: &[u8]) {
let len = buffer.len();
// in case user likes doing a byte at a time, keep it fast
if len == 1 {
self.update(buffer[0]);
return;
}
// in case short lengths are provided, keep it somewhat fast
if len < 16 {
for pos in 0..len {
self.a += buffer[pos] as u32;
self.b += self.a;
}
if self.a >= BASE {
self.a -= BASE;
}
self.b %= BASE;
return;
}
let mut pos = 0;
// do length NMAX blocks -- requires just one modulo operation;
while pos + NMAX <= len {
let end = pos + NMAX;
while pos < end {
// 16 sums unrolled
do16(&mut self.a, &mut self.b, &buffer[pos..pos + 16]);
pos += 16;
}
self.a %= BASE;
self.b %= BASE;
}
// do remaining bytes (less than NMAX, still just one modulo)
if pos < len { // avoid modulos if none remaining
while len - pos >= 16 {
do16(&mut self.a, &mut self.b, &buffer[pos..pos + 16]);
pos += 16;
}
while len - pos > 0 {
self.a += buffer[pos] as u32;
self.b += self.a;
pos += 1;
}
self.a %= BASE;
self.b %= BASE;
}
}
}
/// Consume a Read object and returns the Adler32 hash.
pub fn adler32(mut reader: R) -> io::Result {
let mut hash = RollingAdler32::new();
let mut buffer = [0u8; NMAX];
let mut read = try!(reader.read(&mut buffer));
while read > 0 {
hash.update_buffer(&buffer[..read]);
read = try!(reader.read(&mut buffer));
}
Ok(hash.hash())
}
#[cfg(test)]
mod test {
use rand;
use rand::Rng;
use std::io;
use super::{BASE, adler32, RollingAdler32};
fn adler32_slow(reader: R) -> io::Result {
let mut a: u32 = 1;
let mut b: u32 = 0;
for byte in reader.bytes() {
let byte = try!(byte) as u32;
a = (a + byte) % BASE;
b = (b + a) % BASE;
}
Ok((b << 16) | a)
}
#[test]
fn testvectors() {
fn do_test(v: u32, bytes: &[u8]) {
let mut hash = RollingAdler32::new();
hash.update_buffer(&bytes);
assert_eq!(hash.hash(), v);
let r = io::Cursor::new(bytes);
assert_eq!(adler32(r).unwrap(), v);
}
do_test(0x00000001, b"");
do_test(0x00620062, b"a");
do_test(0x024d0127, b"abc");
do_test(0x29750586, b"message digest");
do_test(0x90860b20, b"abcdefghijklmnopqrstuvwxyz");
do_test(0x8adb150c, b"ABCDEFGHIJKLMNOPQRSTUVWXYZ\
abcdefghijklmnopqrstuvwxyz\
0123456789");
do_test(0x97b61069, b"1234567890123456789012345678901234567890\
1234567890123456789012345678901234567890");
do_test(0xD6251498, &[255; 64000]);
}
#[test]
fn compare() {
let mut rng = rand::thread_rng();
let mut data = vec![0u8; 5589];
for size in [0, 1, 3, 4, 5, 31, 32, 33, 67,
5550, 5552, 5553, 5568, 5584, 5589].iter().cloned() {
rng.fill_bytes(&mut data[..size]);
let r1 = io::Cursor::new(&data[..size]);
let r2 = r1.clone();
if adler32_slow(r1).unwrap() != adler32(r2).unwrap() {
panic!("Comparison failed, size={}", size);
}
}
}
#[test]
fn rolling() {
assert_eq!(RollingAdler32::from_value(0x01020304).hash(), 0x01020304);
fn do_test(a: &[u8], b: &[u8]) {
let mut total = Vec::with_capacity(a.len() + b.len());
total.extend(a);
total.extend(b);
let mut h = RollingAdler32::from_buffer(&total[..(b.len())]);
for i in 0..(a.len()) {
h.remove(b.len(), a[i]);
h.update(total[b.len() + i]);
}
assert_eq!(h.hash(), adler32(b).unwrap());
}
do_test(b"a", b"b");
do_test(b"", b"this a test");
do_test(b"th", b"is a test");
do_test(b"this a ", b"test");
}
#[test]
fn long_window_remove() {
let mut hash = RollingAdler32::new();
let w = 65536;
assert!(w as u32 > BASE);
let mut bytes = vec![0; w*3];
for (i, b) in bytes.iter_mut().enumerate() {
*b = i as u8;
}
for (i, b) in bytes.iter().enumerate() {
if i >= w {
hash.remove(w, bytes[i - w]);
}
hash.update(*b);
if i > 0 && i % w == 0 {
assert_eq!(hash.hash(), 0x433a8772);
}
}
assert_eq!(hash.hash(), 0xbbba8772);
}
}