Download page:

    https://sourceforge.net/projects/rhash/files/rhash/1.3.6/

/dist/rhash.spec
/dist/rhash.1.*
/dist/librhash.pc
/librhash/exports.sym
po/*.gmo
/rhash
/rhash_shared
/rhash_static
/librhash/test_shared
/librhash/test_static
config.mak
*.[ao]
*.exe
*.dll
*.def
*.so
*.so.0
*.log

                                RHash License

Copyright (c) 2005-2014 Aleksey Kravchenko <rhash.admin@gmail.com>

Permission is hereby granted, free of charge,  to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction,  including without limitation the rights
to  use,  copy,  modify,  merge, publish, distribute, sublicense, and/or sell
copies  of  the Software,  and  to permit  persons  to whom  the Software  is
furnished to do so.

The Software  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.  Use  this  program  at  your  own  risk!

Wed 14 Mar 2018 Aleksey
	* === Version 1.3.6 ===
	* support --file-list option

Sun 11 Mar 2018 And Sch
	* librhash: speedup sha3

Sun Feb 18 2018 Aleksey
	* Bugfix: fix --follow option

Mon Jan 29 2018 J. Peter Mugaas
	* better MSYS and CygWin support

Fri Jan 26 2018 Aleksey
	* configuration script

Mon Sep  4 2017 Aleksey
	* Bugfix: broken binary hash output

Mon Aug 28 2017 Aleksey
	* Bugfix: fix running on WinXP

Mon Aug 14 2017 Aleksey
	* === Version 1.3.5 ===
	* look for locales directory at PROGRAM_DIRECTORY\locale on Windows
	* look for config at PROGRAM_DIRECTORY\rhashrc on Windows

Fri Aug  4 2017 Aleksey
	* support LibRhash bindings to PHP7

Sun Jul 30 2017 Aleksey
	* Bugfix: illegal instruction error on macOS

Sat Jul 29 2017 Aleksey
	* improve utf-8 support on Windows

Thu Jul 27 2017 Aleksey
	* Bugfix: fix access to long paths on Windows

Mon Jul 17 2017 Aleksey
	* add ca, fr, ro translations

Sun Jul 16 2017  Darío Hereñú
	* full Spanish translation

Mon Jul 10 2017 James Le Cuirot
	* correct build/install command for freebsd

Mon Jul 10 2017 Przemyslaw Pawelczyk
	* compilation fixes for aarch64 and musl

Mon Jul 10 2017 Aleksey
	* improve support of clang on macOS

Sun Nov  6 2016 Aleksey
	* === Version 1.3.4 ===

Tue Nov 17 2015 Alexey Dokuchaev, Kurt Jaeger
	* compilation fixes for FreeBSD

Sat Aug  9 2014 Aleksey
	* return non zero exit code if a file was not found

Tue Aug  5 2014 Aleksey
	* === Version 1.3.3 ===

Mon Aug  4 2014 And Sch, Aleksey
	* librhash: small optimization of Whirlpool

Sat Aug  2 2014 Aleksey
	* option --exclude for skipping some files during recursive scanning

Fri Aug  1 2014 Aleksey
	* update the SHA3 algorithm to follow the changes of the FIPS 202 draft

Wed Jul 30 2014 Aleksey
	* support torrents with more than one announce url

Tue Jul 29 2014 Aleksey
	* LibRHash now exports torrent functions

Mon Jul 21 2014 Tsukasa Oi
	* fixed test_rhash.sh script failing on the en_US.UTF-8 locale

Wed Jul 16 2014 Aleksey
	* changed the `-p' format names of sha* families, see manpage
	* set a boolean in config to true by a string `true', `on' or `yes'

Sun Jul 13 2014 Aleksey
	* Ctrl-C now interrupts benchmarking

Wed Jul  2 2014 Aleksey
	* === Version 1.3.2 ===

Sat Jun 21 2014 Aleksey
	* report warnings on files locked by some processes

Thu Jun 19 2014 Brad Campbell
	* ignore non-regular files while scanning directories recursively

Wed Jun 18 2014 Aleksey
	* option --follow for following symlinks to directories

Sun Apr 13 2014 ZinnKid
	* BTIH piece length calculation updated to follow the uTorrent algorithm change

Wed Jan  8 2014 Aleksey
	* === Version 1.3.1 ===
	* Exclude the files specified by -o and -l from processing

Sat Jan  4 2014 Aleksey
	* Improved directory scanning

Sat Dec 28 2013 Aleksey
	* Bugfix: suppress the R6034 error popup on Windows

Fri Oct 25 2013 Aleksey
	* Fixed 'value too large' error on 32-bit Linux

Thu Sep 19 2013 Aleksey
	* Bugfix: corrected sha3-224 for big-endian processors

Tue Sep 17 2013 Aleksey
	* === Version 1.3.0 ===

Tue May 21 2013 Aleksey
	* Fixed output of percents when two or more files are hashed

Mon Apr 29 2013 Aleksey
	* Supported SHA3 (Keccak) hash function

Sat Apr 27 2013 Aleksey
	* Fixed memory leaks

Tue Apr 23 2013 Aleksey
	* Bugfix: %{mtime} formatting option was broken

Mon Dec 31 2012 Aleksey
	* imported translations from Launchpad: de, es, gl, it

Tue Dec 25 2012 Aleksey
	* === Version 1.2.10 ===

Mon Nov  5 2012 Aleksey
	* Bugfix: incorrect GOST hash for ("\FF" x 64) on non-x86 CPU

Mon Oct  8 2012 Aleksey
	* Shortcut -k for --check-embedded

Thu Sep 27 2012 Aleksey
	* Bugfix: non-zero exit code if some files were not found
	* improved Ctrl-C processing

Sat Aug  4 2012 Aleksey
	* Bugfix: path issue with verification of hash files

Mon Jun 25 2012 Aleksey
	* Bugfix: different BTIH were generated for the same file

Sun May 13 2012 Aleksey
	* BugFix: python crashed on ia64

Tue Apr 17 2012 Aleksey
	* PHP bindings for librhash

Sat Apr 14 2012 Aleksey
	* === Version 1.2.9 ===

Fri Apr 13 2012 Aleksey, Sergey Basalaev
	* translations: de, en_AU, es, gl, it

Sun Apr 08 2012 Aleksey
	* Bugfix: handling UNC filenames on Windows
	* option --bt-batch for batch torrents

Sat Jan  7 2012 Aleksey
	* librhash: rhash_print_magnet function

Sun Nov 06 2011 Sergey Basalaev
	* .NET/Mono bindings to librhash

Wed Sep 14 2011 Aleksey
	* === Version 1.2.8 ===

Wed Sep 14 2011 Aleksey, SBasalaev
	* LibRHash bindings to Java, Perl, Python, Ruby

Tue Sep  6 2011 Aleksey
	* librhash: implemented auto-final feature, turned on by default

Tue Sep  6 2011 Aleksey, SBasalaev
	* Russian translation

Sat Sep  3 2011 Aleksey
	* Bugfix: not enough trailing '=' in a base64-encoded hash

Sat Aug 20 2011 Aleksey
	* Bugfix: fix broken --openssl option parsing
	* Bugfix: buffer overflow when using --embed-crc-delimiter
	* Bugfix: segmentation fault on SUSE Linux

Sun Aug 14 2011 Aleksey
	* === Version 1.2.7 ===

Sun Aug  7 2011 Aleksey
	* Bugfix: percents option was broken in v1.2.6

Fri Aug  5 2011 Aleksey
	* supported verification of sha256, sha512 and other hash sums

Mon Jul 11 2011 Aleksey
	* librhash: rhash_cancel() macro to cancel hashing from another thread

Fri Jun 24 2011 Aleksey
	* Bugfix: repaired default output encoding to be UTF-8 on Windows

Wed Jun 22 2011 Aleksey
	* Bugfix: crash on WinXP

Thu Jun 16 2011 Aleksey
	* === Version 1.2.6 ===

Sat Jun 11 2011 Aleksey
	* allowed options to be intermixed with file names in arbitrary order
	* switched option -G and the '%G' printf pattern to print GOST hash
	* Bugfix: --output failed for cyrillic file name

Wed Jun  8 2011 Aleksey
	* librhash: better shared library compilation/testing support

Mon Jun  6 2011 Aleksey
	* librhash: exported benchmarking functions in the shared library
	* librhash: added prefix to all functions to avoid poluting linker namespace
	* librhash: fixed rare alignment bugs in rhash_print and EDON-R 512

Sat May 28 2011 Aleksey
	* librhash: loading openssl at runtime if it is present
	* Bugfix: LLVM GOST amd64 asm compilation error

Wed May 18 2011 Aleksey
	* === Version 1.2.5 ===
	* option --openssl allows to replace some algorithms by the OpenSSL ones
	* Bugfix: incorrect recursive traversing of very long UTF-8 filepaths

Wed Apr 27 2011 Aleksey
	* Bugfix: corrected calculation of BTIH hash and torrent files

Fri Apr 15 2011 Aleksey
	* === Version 1.2.4 ===
	* option --benchmark-raw for machine-readable benchmark output format
	* on Intel/AMD CPUs benchmark now prints the clocks-per-byte value

Tue Apr  5 2011 Aleksey
	* changed config file locations

Fri Apr  1 2011 Aleksey
	* Bugfix: repaired --path-separator on linux/unix

Sun Mar 27 2011 Aleksey
	* === Version 1.2.3 ===

Fri Mar 25 2011 Aleksey
	* one-line percent for linux/unix

Mon Mar 14 2011 Aleksey
	* added printf modificator %{mtime} to print the last modified date of a file

Thu Feb 17 2011 Aleksey
	* Bugfix: verification of base2-like formatted md5 hash sums

Fri Jan 14 2011 Aleksey
	* === Version 1.2.2 ===
	* one-line percents (windows only)

Tue Jan 11 2011 Aleksey
	* supported EDON-R 256/512 hash sums

Sun Dec 19 2010 Aleksey
	* increased process priority when benchmarking on windows

Thu Dec 16 2010 Aleksey
	* Bugfix: eight hash sums were broken on PowerPC
	* Bugfix: --accept/--crc-accept were not working since 1.1.9

Tue Dec 14 2010 Aleksey
	* === Version 1.2.1 ===
	* Bugfix: GOST broken on OpenSolaris since 1.2.0
	* option --list-hashes: list names of all supported hashes, one per line

Mon Nov 29 2010 Aleksey
	* SHA 224/256/384/512 hash functions supported
	* Bugfix: broken asm compilation on openbsd and freebsd

Wed Nov 24 2010 Aleksey
	* option --path-separator=<character> for directories scanning

Sun Nov 14 2010 Aleksey
	* === Version 1.2.0 ===
	* --gost-cryptopro option: calculate GOST with CryptoPro parameters
	* --gost-reverse option: reverse bytes in GOST hash sum
	* Bugfix: btih/gost/ripemd/has160/snefru were not verified correctly in bsd and magnet formats

Fri Oct 29 2010 Aleksey
	* Bugfix: rhash compiled by MS VC skipped files of size >4Gb

Fri Oct 15 2010 Aleksey
	* === Version 1.1.9 ===
	* new interface for internal library librhash

Mon Jul  5 2010 Ruslan Nikolaev
	* GOST algorithm x86-64 assembler optimization

Sun Apr 25 2010 Aleksey
	* new options --uppercase and --lowercase
	* Bugfix: GOST worked incorrectly when compiled by GCC with `-O0'

Wed Apr 21 2010 Aleksey
	* windows distribution updated

Fri Apr 16 2010 Aleksey
	* BugFix: options with string values were incorrectly loaded from config

Wed Apr 14 2010 Aleksey
	* === Version 1.1.8 ===
	* option --template=<file> to read printf-like template from <file>

Mon Apr 12 2010 Xiangli Huang
	* BugFix: `--recursive *' traversed parent directory .. under windows
	* BugFix: `--check <dirname>' reported strange warning for dirs

Mon Apr 12 2010 Aleksey
	* printf-directives starting with capital letter print upper-cased hashes, e.g. %{Gost}
	* %u directive switched to print url-encoded filename (alias for %{urlname})
	* ed2k links verification supported

Fri Apr  9 2010 Aleksey
	* BugFix: linking problem on OpenSolaris
	* filenames in urls are now always utf8-encoded (Windows only fix)

Wed Apr  7 2010 Aleksey
	* '%B','%@' modifiers to print base64/raw representation of any hash (e.g. '%BM')

Wed Mar 31 2010 Aleksey
	* === Version 1.1.7 ===
	* option --btih to print BitTorrent infohash
	* option --torrent to create torrent file
	* option --bt-private for private torrents
	* option --bt-piece-length to change torrent piece length
	* option --bt-announce to set torrent announcement url

Tue Mar 30 2010 Aleksey
	* the -m option made to be an alias for --magnet

Mon Mar 29 2010 Xiangli Huang
	* print program version, when benchmarking

Fri Mar 26 2010 Aleksey
	* Bugfix: infite loop while recursively updating hash files under Windows

Thu Mar  4 2010 Aleksey
	* maxdepth parameter now is checked to be a number

Thu Feb 25 2010 Aleksey
	* output tiger hash in the big-endian order

Wed Feb 24 2010 Aleksey
	* === Version 1.1.6 ===
	* man page updated
	* now all supported hashes are verified when cheking magnet links
	* benchmark now reports the size of the hashed message

Fri Feb 19 2010 Aleksey
	* Bugfix: fixed GOST for big-endian systems

Wed Feb 17 2010 Aleksey
	* Bugfix: buffer owerflow while parsing long command line under Windows

Sun Feb 14 2010 Aleksey
	* Bugfix: fixed HAS-160 for big-endian systems

Wed Feb  3 2010 Aleksey
	* Bugfix: crash while printing sfv header for files modified before 1970

Fri Jan 29 2010 Aleksey
	* Bugfix: sfv-hash symlink now sets default print format to SFV
	* Bugfix: ed2k-link symlink did not work as expected

Thu Jan 28 2010 Aleksey
	* === Version 1.1.5 ===
	* option --utf8 under Windows, also UTF8 now is the default encoding
	* Bugfix: non-existing files were reported twice in `-r --sfv' mode

Wed Jan 27 2010 Aleksey
	* option --embed-crc-delimiter=<char> to insert <char> before a crc sum in -e mode
	* alias -e for --embed-crc
	* alias -B for --benchmark

Mon Jan 11 2010 Aleksey
	* Bugfix: percents output fixed for files of more than 4Gb of data

Fri Dec 18 2009 Aleksey
	* AICH algorithm has been re-written to process files of unknown size like stdin, pipes, sockets
	* ED2K switched to use eMule algorithm when filesize is an exact multiple of 9728000 bytes

Thu Dec 17 2009 Aleksey
	* Bugfix: buffer overflow when printing eDonkey links for 0-sized files
	* Bugfix: --ripemd160 and --md4 option were broken
	* added `%R' printf entity for RIPEMD-160

Mon Dec 14 2009 Aleksey
	* === Version 1.1.4 ===
	* supported algorithms: RIPEMD-160, HAS-160, GOST, MD4, SNEFRU-128, SNEFRU-256
	* long printf format entities, e.g. %{md4}, %{has160}, %{gost}, %{snefru256}
	* `u' printf modifier for uppercase hashes, e.g. %u{gost}
	* switched to %{urlname} printf-entity for url-encoded file name
	* useful symlinks are installed by `make install-symlinks'

Sun Dec  6 2009 Aleksey
	* WHIRLPOOL hash function supported, option --whirlpool

Wed Dec  2 2009 Aleksey
	* print file checking statistics when --check-embedded specified

Sun Nov 29 2009 Aleksey
	* === Version 1.1.3 ===
	* forbid simultaneous usage of --check, --update and --check-embedded options

Sun Nov 22 2009 Aleksey
	* Bugfix: Checking of md5 file always reported OK
	* --check-embedded option to verify files by crc32 sum embedded in their names.
	* --embed-crc option to rename processed files by embedding crc32 sum into name.

Mon Nov  9 2009 Aleksey
	* --benchmark option now prints names of tested hash sums
	* use magnet format as default if the program name contains 'magnet'

Wed Jun 24 2009 Aleksey
	* supported checking of files containing a single hash sum without a filename

Mon Jun 15 2009 Aleksey
	* === Version 1.1.2 ===
	* verification of files with magnet links supported

Wed May 20 2009 Aleksey
	* Bugfix: --skip-ok was broken since 1.1.0

Fri May 15 2009 Aleksey
	* Bugfix: checking of ed2k hashes was broken since version 1.1.0
	* Bugfix: --verbose lead to crash under OpenSolaris when config file not present

Mon Mar 23 2009 Aleksey
	* === Version 1.1.1 ===
	* config file described in the man page
	* Bugfix: buffer owerflow when printing tiger hash

Sat Mar 21 2009 Aleksey
	* Bugfix: some options couldn't be read from config file

Sat Mar 14 2009 Aleksey
	* === Version 1.1.0 ===
	* various small changes and refactoring

Tue Mar 10 2009 Aleksey
	* option --speed to print per-file and total speed statistics

Thu Mar  5 2009 Aleksey
	* option --output to write calculation and check results to a file
	* option --log to log percents, speed and verbose messages

Wed Mar  4 2009 Aleksey
	* option --percents to show wget-like percents

Tue Feb 26 2009 Aleksey
	* Bugfix: fixed processing of unaligned messages in the get_crc32() function

Sat Feb 14 2009 Aleksey
	* === Version 1.0.8 ===
	* --magnet option supported to format sums as a magnet link
	* Bugfix: printf option from config conflicted with command line

Sun Dec 14 2008 Aleksey
	* === Version 1.0.7 ===
	* config file supported to load default options values
	* if --verbose, report verification errors as "sum is XXXXXXXX, should be YYYYYYYY"
	* '%h' modifier changed to '%x'

Fri Nov 14 2008 Aleksey
	* === Version 1.0.6 ===
	* reg-file for FAR user menu

Thu Oct  9 2008 Aleksey
	* interpret '#' symbol as a comment

Sat Sep 20 2008 ivan386
	* under windows skip files openned for writing
	* Bugfix: printf arguments %p and %f corrected

Sun Sep 14 2008 Aleksey
	* === Version 1.0.5 ===

Wed Aug  6 2008 Aleksey
	* '%b','%h' modifiers to print base32/hex representation of any hash (e.g. '%bH')
	* supported -p '\0' symbol
	* supported setting width for filesizes (e.g. -p '%12s')

Tue Jul 22 2008 Aleksey
	* --verbose prints read speed statistics to stderr after each file
	* read buffer increased to 2 MiB

Wed Jul 9 2008 Aleksey
	* === Version 1.0.4 ===
	* '%u' prints URL-encoded filename
	* EDonkey links now have URL-encoded filename and contain AICH hash

Mon Jul 7 2008 Aleksey
	* AICH hashsums supported, option --aich

Sat Jun 28 2008 Aleksey
	* === Version 1.0.3 ===
	* ed2k calculation fixed for files with 9728000 < filesize <= 9732096
	* Big-endian processors supported for all sums

Sat Jun 14 2008 Aleksey
	* === Version 1.0.2 ===

Fri Jun 6 2008 Aleksey
	* --benchmark option added
	* skip locked files under win32 when calculating 'em sums

Tue May 20 2008 Aleksey
	* Bugfix: updating of md5 files was broken
	* Bugfix: more rigid parsing of base32/hex hash sums

Wed May 15 2008 Aleksey
	* === Version 1.0.1 ===
	* Bugfix: last line without '\n' couldn't be parsed

Wed May 14 2008 Aleksey
	* Bugfix: empty lines were not skipped, when verifying a crc file
	* option '--skip-ok' to skip OK messages for successfuly verified files

Tue Jan 22 2008 Aleksey
	* option '-a' to print all supported hash sums
	* Changed default behavior: if no formatting option are set, sfv header is printed only for --crc32

Wed Dec 19 2007 Aleksey
	* Bugfix: fixed buffer overflow for command line -p '%%%%d'
	* Bugfix: fixed size calculation for stdin (rhash -p '%s' - <file)

Fri Dec 14 2007 Aleksey
	* === Version 1.0 ===
	* large files (more then 4Gb) supported

Thu Sep 13 2007 Aleksey
	* === Version 0.9.2 ===

Tue Sep 11 2007 Aleksey
	* Checking of TTH sums supported

Mon Sep 10 2007 Aleksey
	* Bugfix: ignore path delimiters at the end of filenames under win32

Sun May 27 2007 Aleksey
	* === Version 0.9.1 ===
	* Tiger option changed to -G
	* Supported parsing of windows-style paths in crc files under linux

Sat May 26 2007 Aleksey
	* TTH hash function supported (see -T option)

Thu May 17 2007 Aleksey
	* Bugfix: --printf="%f" under Windows printed paths instead of filenames

Sun May 13 2007 Aleksey
	* === Version 0.9 ===
	* program renamed to rhash
	* md5/sha1/ed2k code rewrited and slightly optimized
	* Bugfix: repaired parsing of crc files with tiger hash

Fri May 11 2007 Aleksey
	* === Version 0.8.9 ===
	* Bugfix: fixed broken md5 and ed2k sums verification

Sun May 06 2007 Aleksey
	* Bugfix: fixed wrong Tiger hash calculation for files with (file_size % 64) >= 56
	* Tiger hash optimised to be 5% faster

Wed May 02 2007 Aleksey
	* === Version 0.8.8 ===

Sun Apr 22 2007 Aleksey
	* added options --accept and --crc-accept
	* added --verbose option
	* added --maxdepth option
	* added check before verifying a crc file that it isn't a binary file

Mon Apr 16 2007 Aleksey
	* === Version 0.8.7 ===
	* Tiger hash sum optimised for IA32

Tue Apr 10 2007 Aleksey
	* Bugfix: --update of sfv files worked incorrectly under windows

Mon Apr 09 2007 Aleksey
	* implemented Tiger hash function

Sun Apr 01 2007 Aleksey
	* added check before updating a crc file that it isn't a binary file

Mon Mar 26 2007 Aleksey
	* === Version 0.8.6 ===
	* Ctrl+C now prints a message and partitial statistics

Sat Mar 24 2007 Aleksey
	* default format changed to SFV

Mon Mar 19 2007 Aleksey
	* updating of crc files supported

Wed Jan 31 2007 Aleksey
	* === Version 0.8.5 ===
	* supported many short options as one argument, e.g. '-MCEr'
	* option -S (--sha1) changed to -H
	* Bugfix: program crashed under BSD while printing SFV file header

Sun Nov 05 2006 Aleksey
	* === Version 0.8.4 ===
	* Bugfix: errors/miss stats calculation corrected

Sun Oct 29 2006 Aleksey
	* supported "-c -" option to check hash sums from stdin
	* added stdout flushing after each processed file
	* the program returns exit code 0 on success and 1 if an error occurred

Fri Sep 08 2006 Aleksey
	* corrected parsing of md5-like files with star-prepended filenames

Wed Apr 19 2006 Aleksey
	* checking of md5/sha1 files in *BSD format supported
	* improved I/O errors handling

Mon Apr 10 2006 Aleksey
	* === Version 0.8.3 ===
	* cheking of files in standard md5sum/sha1sum format supported
	* default output format for md5/sha1/ed2k sums changed
	* man page rewrited

Thu Mar 30 2006 Aleksey
	* === Version 0.8.2 ===
	* GCC 2.96 supported

Thu Feb 23 2006 Aleksey
	* Bugfix: files with .SFV extension (in uppercase) were skiped while recursive checking

Wed Jan 25 2006 Aleksey
	* === Version 0.8.1 ===
	* option --check now works with --recursive
	* Bugfix: corrected output format when checking files
	* Bugfix: files wasn't opened as binary on Windows when checking sums

Mon Jan 23 2006 Aleksey
	* === Version 0.8 ===
	* documentation now distributed with windows version
	* some *.bat files added to windows version

Sun Jan 22 2006 Aleksey
	* --check option added, to check hash sums files
	* --ansi option added (for Windows version only)
	* program name is parsed now to specify default sums to compute

Sat Jan 14 2006 Aleksey
	* Bugfix: console windows version now uses OEM (DOS) character set for output
	
	* === Version 0.7 ===
	* some fixes in sfv format output

Fri Sep 16 2005 Aleksey
	* --recursive option added
	* --ed2k-link option added

Fri Sep 02 2005 Aleksey
	* === Version 0.6 ===

Sun Aug 28 2005 Aleksey
	* Bugfix: files wasn't opened as binary on win32
	* --sfv format now implies uppercase hashes

Wed Aug 24 2005 Aleksey
	* added .spec file and Makefile 'rpm' target

Sun Aug 14 2005 Aleksey
	* === Version 0.5 ===
	* the first public version
	* win32 platform supported

Mon Aug 08 2005 Aleksey
	* Bugfix: fixed calculation of md5/ed2k hashes for AMD64

Fri Aug 05 2005 Aleksey
	* === Version 0.06 ===
	* initial linux version supporting crc32, md5, ed2k and sha1

Installation
============

Build Prerequisites
-------------------
  - GCC or Intel Compiler for Linux / macOS / Unix.
  - MinGW or MS VC++ for Windows.
  - (optionally) gettext library for internationalization
  - (optionally) OpenSSL for optimized algorithms

Build and install
-----------------
To compile and install the program use command
```sh
./configure && make && make install
```

The compiled program and library can be tested by command `make test test-lib`

To compile using MS VC++, take the project file from /win32/vc-2010/ directory.

Enabling features
-----------------
RHash can use optimized algorithms of MD5, SHA1, SHA2 from the OpenSSL library.
To link OpenSSL at run-time (preffered way), configure RHash as
```sh
./configure --enable-openssl-runtime
```
To link it at load-time, use options
```sh
./configure --enable-openssl --disable-openssl-runtime
```

Internationalization support can be compiled and installed by commands
```sh
./configure --enable-gettext
make install install-gmo
```

Run `./configure --help` for a full list of configuration options.

Building an OS native package
-----------------------------
When building a package for an OS Repository, one should correctly specify system directories, e.g.:
```sh
./configure --sysconfdir=/etc --exec-prefix=/usr
```

Example of installing RHash with shared and static LibRHash library:
```sh
./configure --enable-lib-static
make install install-lib-so-link
```

include config.mak

HEADERS = calc_sums.h hash_print.h common_func.h hash_update.h file.h file_mask.h file_set.h find_file.h hash_check.h output.h parse_cmdline.h rhash_main.h win_utils.h platform.h version.h
SOURCES = calc_sums.c hash_print.c common_func.c hash_update.c file.c file_mask.c file_set.c find_file.c hash_check.c output.c parse_cmdline.c rhash_main.c win_utils.c
OBJECTS = calc_sums.o hash_print.o common_func.o hash_update.o file.o file_mask.o file_set.o find_file.o hash_check.o output.o parse_cmdline.o rhash_main.o win_utils.o
WIN_DIST_FILES = dist/MD5.bat dist/magnet.bat dist/rhashrc.sample
OTHER_FILES = configure Makefile ChangeLog INSTALL.md COPYING README \
  dist/rhash.spec.in dist/rhash.1 dist/rhash.1.win.sed \
  tests/test_rhash.sh tests/test1K.data win32/vc-2010/rhash.vcxproj
LIBRHASH_FILES  = librhash/algorithms.c librhash/algorithms.h \
  librhash/byte_order.c librhash/byte_order.h librhash/plug_openssl.c librhash/plug_openssl.h \
  librhash/rhash.c librhash/rhash.h librhash/rhash_torrent.c librhash/rhash_torrent.h \
  librhash/rhash_timing.c librhash/rhash_timing.h \
  librhash/aich.c librhash/aich.h librhash/crc32.c librhash/crc32.h \
  librhash/ed2k.c librhash/ed2k.h librhash/edonr.c librhash/edonr.h \
  librhash/gost.c librhash/gost.h librhash/has160.c librhash/has160.h \
  librhash/hex.c librhash/hex.h librhash/md4.c librhash/md4.h \
  librhash/md5.c librhash/md5.h librhash/ripemd-160.c librhash/ripemd-160.h \
  librhash/sha1.c librhash/sha1.h librhash/sha3.c librhash/sha3.h \
  librhash/sha256.c librhash/sha256.h librhash/sha512.c librhash/sha512.h \
  librhash/snefru.c librhash/snefru.h librhash/tiger.c librhash/tiger.h \
  librhash/tiger_sbox.c librhash/tth.c librhash/tth.h librhash/whirlpool.c \
  librhash/whirlpool.h librhash/whirlpool_sbox.c librhash/test_hashes.c \
  librhash/test_hashes.h librhash/torrent.h librhash/torrent.c librhash/ustd.h \
  librhash/util.h librhash/Makefile
I18N_FILES  = po/ca.po po/de.po po/en_AU.po po/es.po po/fr.po po/gl.po po/it.po po/ro.po po/ru.po
ALL_FILES   = $(SOURCES) $(HEADERS) $(LIBRHASH_FILES) $(OTHER_FILES) $(WIN_DIST_FILES) $(I18N_FILES)
SPECFILE    = dist/rhash.spec
LIBRHASH_PC = dist/librhash.pc
RHASH_NAME     = rhash
RHASH_BINARY   = rhash$(EXEC_EXT)
CONFDIR_MACRO  = -DSYSCONFDIR=\"$(SYSCONFDIR)\"
RPMTOP  = rpms
RPMDIRS = SOURCES SPECS BUILD SRPMS RPMS
INSTALL_PROGRAM = $(INSTALL) -m 755
INSTALL_DATA    = $(INSTALL) -m 644

all: $(BUILD_TARGETS)
install: build-install-binary install-data install-symlinks $(EXTRA_INSTALL)
build-static: $(RHASH_STATIC)
build-shared: $(RHASH_SHARED)
lib-shared: $(LIBRHASH_SHARED)
lib-static: $(LIBRHASH_STATIC)
install-data: install-man install-conf
uninstall: uninstall-binary uninstall-data uninstall-symlinks uninstall-lib uninstall-gmo uninstall-pkg-config

config.mak:
	echo "Run the ./configure script first" && false

# creating archives
WIN_SUFFIX     = win32
PACKAGE_NAME   = $(RHASH_NAME)-$(VERSION)
ARCHIVE_BZIP   = $(PACKAGE_NAME)-src.tar.bz2
ARCHIVE_GZIP   = $(PACKAGE_NAME)-src.tar.gz
ARCHIVE_FULL   = $(PACKAGE_NAME)-full-src.tar.gz
ARCHIVE_DEB_GZ = $(RHASH_NAME)_$(VERSION).orig.tar.gz
ARCHIVE_7Z     = $(PACKAGE_NAME)-src.tar.7z
ARCHIVE_ZIP    = $(PACKAGE_NAME)-$(WIN_SUFFIX).zip
WIN_ZIP_DIR    = RHash-$(VERSION)-$(WIN_SUFFIX)
dist: gzip gzip-bindings
dist-full: gzip-full
win-dist: zip
zip: $(ARCHIVE_ZIP)
dgz: check $(ARCHIVE_DEB_GZ)

build-install-binary: $(BUILD_TARGETS)
	+$(MAKE) install-binary

mkdir-bin:
	$(INSTALL) -d $(BINDIR)

# install binary without (re-)compilation
install-binary: mkdir-bin
	$(INSTALL_PROGRAM) $(RHASH_BINARY) $(BINDIR)/$(RHASH_BINARY)

install-man:
	$(INSTALL) -d $(MANDIR)/man1
	$(INSTALL_DATA) dist/rhash.1 $(MANDIR)/man1/rhash.1

install-conf:
	$(INSTALL) -d $(SYSCONFDIR)
	tr -d \\r < dist/rhashrc.sample > rc.tmp && $(INSTALL_DATA) rc.tmp $(SYSCONFDIR)/rhashrc
	rm -f rc.tmp

# dependencies should be properly set, otherwise 'make -j<n>' can fail
install-symlinks: mkdir-bin install-man install-binary
	cd $(BINDIR) && for f in $(SYMLINKS); do ln -fs $(RHASH_BINARY) $$f$(EXEC_EXT); done
	cd $(MANDIR)/man1 && for f in $(SYMLINKS); do ln -fs rhash.1* $$f.1; done

install-pkg-config:
	$(INSTALL) -d $(PKGCONFIGDIR)
	$(INSTALL_DATA) $(LIBRHASH_PC) $(PKGCONFIGDIR)/

uninstall-binary:
	rm -f $(BINDIR)/$(RHASH_BINARY)

uninstall-data:
	rm -f $(MANDIR)/man1/rhash.1

uninstall-symlinks:
	for f in $(SYMLINKS); do rm -f $(BINDIR)/$$f$(EXEC_EXT) $(MANDIR)/man1/$$f.1; done

uninstall-pkg-config:
	rm -f $(PKGCONFIGDIR)/librhash.pc

uninstall-lib:
	+cd librhash && $(MAKE) uninstall-lib

install-lib-static: $(LIBRHASH_STATIC)
	+cd librhash && $(MAKE) install-lib-static

install-lib-shared: $(LIBRHASH_SHARED)
	+cd librhash && $(MAKE) install-lib-shared

install-lib-so-link:
	+cd librhash && $(MAKE) install-so-link

$(LIBRHASH_SHARED): $(LIBRHASH_FILES)
	+cd librhash && $(MAKE) lib-shared

$(LIBRHASH_STATIC): $(LIBRHASH_FILES)
	+cd librhash && $(MAKE) lib-static

test-lib: test-lib-$(BUILD_TYPE)
test-lib-static: $(LIBRHASH_STATIC)
	+cd librhash && $(MAKE) test-static

test-lib-shared: $(LIBRHASH_SHARED)
	+cd librhash && $(MAKE) test-shared

test-libs: $(LIBRHASH_STATIC) $(LIBRHASH_SHARED)
	+cd librhash && $(MAKE) test-static test-shared

test: test-$(BUILD_TYPE)
test-static: $(RHASH_STATIC)
	chmod +x tests/test_rhash.sh
	tests/test_rhash.sh ./$(RHASH_STATIC)

test-shared: $(RHASH_SHARED)
	chmod +x tests/test_rhash.sh
	tests/test_rhash.sh --shared ./$(RHASH_SHARED)

print-info: lib-$(BUILD_TYPE)
	+cd librhash && $(MAKE) print-info

# check that source tree is consistent
check:
	grep -q '\* === Version $(VERSION) ===' ChangeLog
	grep -q '^#define VERSION "$(VERSION)"' version.h
	test ! -f bindings/version.properties || grep -q '^version=$(VERSION)$$' bindings/version.properties

$(RHASH_STATIC): $(OBJECTS) $(LIBRHASH_STATIC)
	$(CC) $(OBJECTS) $(LIBRHASH_STATIC) $(BIN_STATIC_LDFLAGS) -o $@

$(RHASH_SHARED): $(OBJECTS) $(LIBRHASH_SHARED)
	$(CC) $(OBJECTS) $(LIBRHASH_SHARED) $(LDFLAGS) -o $@

# NOTE: dependences were generated by 'gcc -Ilibrhash -MM *.c'
# we are using plain old makefile style to support BSD make
calc_sums.o: calc_sums.c platform.h calc_sums.h common_func.h \
 hash_check.h file.h hash_print.h output.h parse_cmdline.h rhash_main.h \
 win_utils.h librhash/rhash.h librhash/rhash_torrent.h
	$(CC) -c $(CFLAGS) $< -o $@

common_func.o: common_func.c common_func.h parse_cmdline.h version.h \
 win_utils.h
	$(CC) -c $(CFLAGS) $< -o $@

file.o: file.c file.h common_func.h win_utils.h
	$(CC) -c $(CFLAGS) $< -o $@

file_mask.o: file_mask.c file_mask.h common_func.h
	$(CC) -c $(CFLAGS) $< -o $@

file_set.o: file_set.c file_set.h calc_sums.h common_func.h hash_check.h \
 hash_print.h output.h parse_cmdline.h rhash_main.h librhash/rhash.h
	$(CC) -c $(CFLAGS) $< -o $@

find_file.o: find_file.c platform.h find_file.h common_func.h file.h \
 output.h win_utils.h
	$(CC) -c $(CFLAGS) $< -o $@

hash_check.o: hash_check.c hash_check.h hash_print.h common_func.h \
 output.h parse_cmdline.h librhash/rhash.h
	$(CC) -c $(CFLAGS) $< -o $@

hash_print.o: hash_print.c hash_print.h calc_sums.h common_func.h \
 hash_check.h file.h parse_cmdline.h win_utils.h librhash/rhash.h
	$(CC) -c $(CFLAGS) $< -o $@

hash_update.o: hash_update.c common_func.h calc_sums.h hash_check.h \
 file.h file_set.h file_mask.h hash_print.h hash_update.h output.h \
 parse_cmdline.h rhash_main.h win_utils.h
	$(CC) -c $(CFLAGS) $< -o $@

output.o: output.c platform.h output.h calc_sums.h common_func.h \
 hash_check.h parse_cmdline.h rhash_main.h win_utils.h librhash/rhash.h
	$(CC) -c $(CFLAGS) $< -o $@

parse_cmdline.o: parse_cmdline.c parse_cmdline.h common_func.h \
 file_mask.h find_file.h file.h hash_print.h output.h rhash_main.h \
 win_utils.h librhash/rhash.h
	$(CC) -c $(CFLAGS) $< -o $@

rhash_main.o: rhash_main.c rhash_main.h calc_sums.h common_func.h \
 hash_check.h file_mask.h find_file.h file.h hash_print.h hash_update.h \
 parse_cmdline.h output.h win_utils.h librhash/rhash.h
	$(CC) -c $(CFLAGS) $< -o $@

win_utils.o: win_utils.c win_utils.h common_func.h file.h parse_cmdline.h \
 rhash_main.h
	$(CC) -c $(CFLAGS) $< -o $@

dist/rhash.1.win.html: dist/rhash.1 dist/rhash.1.win.sed
	sed -f dist/rhash.1.win.sed dist/rhash.1 | rman -fHTML -roff | \
	sed -e '/<BODY/s/\(bgcolor=\)"[^"]*"/\1"white"/i' > dist/rhash.1.win.html
#	verify the result
	grep -q "utf8" dist/rhash.1.win.html
	grep -q "APPDATA" dist/rhash.1.win.html

dist/rhash.1.html: dist/rhash.1
	-which rman 2>/dev/null && (rman -fHTML -roff dist/rhash.1 | sed -e '/<BODY/s/\(bgcolor=\)"[^"]*"/\1"white"/i' > $@)

dist/rhash.1.txt: dist/rhash.1
	-which groff &>/dev/null && (groff -t -e -mandoc -Tascii dist/rhash.1 | sed -e 's/.\[[0-9]*m//g' > $@)

cpp-doc:
	cppdoc_cmd -title=RHash -company=Akademgorodok -classdir=classdoc -module="cppdoc-standard" -overwrite -extensions="c,h" -languages="c=cpp,h=cpp" -generate-deprecations-list=false $(SOURCES) $(HEADERS) ./Documentation/CppDoc/index.html

permissions:
	find . dist librhash po win32 win32/vc-2010 -maxdepth 1 -type f -exec chmod -x '{}' \;
	chmod +x configure tests/test_rhash.sh

copy-dist: $(ALL_FILES) permissions
	rm -rf $(PACKAGE_NAME)
	mkdir $(PACKAGE_NAME)
	cp -rl --parents $(ALL_FILES) $(PACKAGE_NAME)/

gzip: check
	+$(MAKE) copy-dist
	tar czf $(ARCHIVE_GZIP) --owner=root --group=root $(PACKAGE_NAME)/
	rm -rf $(PACKAGE_NAME)

gzip-bindings:
	+cd bindings && $(MAKE) gzip ARCHIVE_GZIP=../rhash-bindings-$(VERSION)-src.tar.gz

gzip-full: check clean-bindings
	+$(MAKE) copy-dist
	+cd bindings && $(MAKE) copy-dist COPYDIR=../$(PACKAGE_NAME)/bindings
	tar czf $(ARCHIVE_FULL) --owner=root:0 --group=root:0 $(PACKAGE_NAME)/
	rm -rf $(PACKAGE_NAME)

bzip: check
	+$(MAKE) copy-dist
	tar cjf $(ARCHIVE_BZIP) --owner=root:0 --group=root:0 $(PACKAGE_NAME)/
	rm -rf $(PACKAGE_NAME)

7z: check
	+$(MAKE) copy-dist
	tar cf - --owner=root:0 --group=root:0 $(PACKAGE_NAME)/ | 7zr a -si $(ARCHIVE_7Z)
	rm -rf $(PACKAGE_NAME)

$(ARCHIVE_ZIP): $(WIN_DIST_FILES) dist/rhash.1.win.html
	test -s dist/rhash.1.win.html && test -x $(RHASH_BINARY)
	-rm -rf $(WIN_ZIP_DIR)
	mkdir $(WIN_ZIP_DIR)
	cp $(RHASH_BINARY) ChangeLog $(WIN_DIST_FILES) $(WIN_ZIP_DIR)/
	cp dist/rhash.1.win.html $(WIN_ZIP_DIR)/rhash-doc.html
	zip -9r $(ARCHIVE_ZIP) $(WIN_ZIP_DIR)
	rm -rf $(WIN_ZIP_DIR)

$(ARCHIVE_DEB_GZ) : $(ALL_FILES)
	+$(MAKE) $(ARCHIVE_GZIP)
	mv -f $(ARCHIVE_GZIP) $(ARCHIVE_DEB_GZ)

# rpm packaging
$(SPECFILE): $(SPECFILE).in config.mak
	sed -e 's/@VERSION@/$(VERSION)/' $(SPECFILE).in > $(SPECFILE)

rpm: gzip
	-for i in $(RPMDIRS); do mkdir -p $(RPMTOP)/$$i; done
	cp -f $(ARCHIVE_GZIP) $(RPMTOP)/SOURCES
	rpmbuild -ba --clean --define "_topdir `pwd`/$(RPMTOP)" $(SPECFILE)
	mv -f `find $(RPMTOP) -name "*rhash*-$(VERSION)*.rpm"` .
	rm -rf $(RPMTOP)

clean-bindings:
	+cd bindings && $(MAKE) clean

clean-local:
	rm -f *.o $(RHASH_SHARED) $(RHASH_STATIC)
	rm -f po/*.gmo po/*.po~

distclean: clean-local
	rm -f config.log config.mak $(SPECFILE) $(LIBRHASH_PC)
	+cd librhash && $(MAKE) distclean

clean: clean-local
	+cd librhash && $(MAKE) clean

update-po:
	xgettext *.c -k_ -cTRANSLATORS -o po/rhash.pot \
		--msgid-bugs-address='Aleksey <rhash.admin@gmail.com>' --package-name='RHash'
	for f in $(I18N_FILES); do \
		msgmerge -U $$f po/rhash.pot; \
	done

compile-gmo:
	for f in $(I18N_FILES); do \
		g=`basename $$f .po`; \
		msgfmt $$f -o po/$$g.gmo; \
	done

install-gmo: compile-gmo
	for f in $(I18N_FILES); do \
		l=`basename $$f .po`; \
		$(INSTALL) -d $(LOCALEDIR)/$$l/LC_MESSAGES; \
		$(INSTALL_DATA) po/$$l.gmo $(LOCALEDIR)/$$l/LC_MESSAGES/rhash.mo; \
	done

uninstall-gmo:
	for f in $(I18N_FILES); do \
		rm -f $(LOCALEDIR)/`basename $$f .po`/LC_MESSAGES/rhash.mo; \
	done

.PHONY: all build-shared build-static lib-shared lib-static clean clean-bindings distclean clean-local \
	test test-shared test-static test-lib test-libs test-lib-shared test-lib-static \
	install build-install-binary install-binary install-lib-shared install-lib-static \
	install-lib-so-link install-conf install-data install-gmo install-man \
	install-symlinks install-pkg-config uninstall-gmo uninstall-pkg-config \
	uninstall uninstall-binary uninstall-data uninstall-lib uninstall-symlinks \
	print-info check copy-dist update-po compile-gmo cpp-doc mkdir-bin permissions \
	bzip dgz dist dist-full gzip gzip-bindings gzip-full rpm win-dist zip

                           === RHash program ===

RHash is a console utility for calculation  and verification of magnet links
and a wide range of hash sums like  CRC32,  MD4, MD5,  SHA1, SHA256, SHA512,
SHA3,   AICH,  ED2K,  Tiger,  DC++ TTH,  BitTorrent BTIH,   GOST R 34.11-94,
RIPEMD-160, HAS-160, EDON-R, Whirlpool and Snefru.

Hash sums are used to  ensure and verify integrity  of large volumes of data
for a long-term storing or transferring.

Program features:
 * Output in a predefined (SFV, BSD-like) or a user-defined format.
 * Calculation of Magnet links.
 * Ability to process directories recursively.
 * Updating hash files (adding hash sums of files missing in the hash file).
 * Calculates several hash sums in one pass.
 * Portability: the program works the same on Linux, Unix, macOS or Windows.


                        === The LibRHash library ===

LibRHash is a professional,  portable,  thread-safe  C library for computing
a wide variety of hash sums, such as  CRC32, MD4, MD5, SHA1, SHA256, SHA512,
SHA3,   AICH,  ED2K,  Tiger,  DC++ TTH,  BitTorrent BTIH,   GOST R 34.11-94,
RIPEMD-160, HAS-160, EDON-R, Whirlpool and Snefru.
Hash sums are used  to ensure and verify integrity of  large volumes of data
for a long-term storing or transferring.

Features:
 * Small and easy to learn interface.
 * Hi-level and Low-level API.
 * Allows calculating of several hash functions simultaneously.
 * Portability: the library works on Linux, *BSD and Windows.


                               === Links ===

 * Project Home Page: http://rhash.sourceforge.net/
 * Official Releases: http://sf.net/projects/rhash/files/rhash/

 * RHash hash functions descriptions http://rhash.anz.ru/hashes.php
 * The table of the hash functions supported by RHash
   https://sf.net/p/rhash/wiki/HashFunctions/
 * ECRYPT: The Hash Function Zoo
   http://ehash.iaik.tugraz.at/wiki/The_Hash_Function_Zoo


                     === Getting latest source code ===

The latest source code can be obtained from Git repository by command:

  git clone git://github.com/rhash/RHash.git


                       === Notes on RHash License ===

The RHash program and LibRHash library are distributed under  RHash License,
see the COPYING file for details.  In particular,  the program,  the library
and  source code  can be  used  free of charge  under  the  MIT,  BSD,  GPL,
commercial or freeware license without additional restrictions.  In the case
the OSI-approved license is required the  MIT license should be used.

                                RHash License

Copyright (c) 2011-2014 Aleksey Kravchenko <rhash.admin@gmail.com>
Copyright (c) 2011-2012 Sergey Basalaev

Permission is hereby granted, free of charge,  to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction,  including without limitation the rights
to  use,  copy,  modify,  merge, publish, distribute, sublicense, and/or sell
copies  of  the Software,  and  to permit  persons  to whom  the Software  is
furnished to do so.

The Software  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.  Use  this  program  at  your  own  risk!

Fri Aug  1 2014 Aleksey
	* python 3 support
	* update SHA3 test vectors to follow the changes of the spec

Sun Jan 19 2014 Aleksey
	* renamed perl module to the Crypt::Rhash

Tue Sep 17 2013 Aleksey
	* === Version 1.3.0 ===

Tue Dec 25 2012 Aleksey
	* === Version 1.2.10 ===

Sun May 13 2012 Aleksey
	* BugFix: python crashed on ia64

Tue Apr 17 2012 Aleksey
	* PHP bindings for librhash

Sat Apr 14 2012 Aleksey
	* === Version 1.2.9 ===

Sun Nov 06 2011 Sergey Basalaev
	* .NET/Mono bindings to librhash

Wed Sep 14 2011 Aleksey
	* === Version 1.2.8 ===

Wed Sep 14 2011 Aleksey
	* Perl bindings

Sat Jul  9 2011 Sergey Basalaev
	* Ruby bindings

Thu Jun 16 2011 Sergey Basalaev
	* Python bindings

Sun Jun 12 2011 Sergey Basalaev
	* LibRHash Java bindings

VERSION := $(shell sed -ne 's/^version=\(.*\)/\1/p' version.properties)
BINDINGS = java mono perl python ruby php
FILES = Makefile version.properties ChangeLog COPYING
DESTDIR =
PREFIX = /usr/local
RUBY ?= ruby
PYTHON ?= python
PERL ?= perl
CP = cp -l --parents
PERL_OPTIMIZE = -O2 -g -Wall
ARCHIVE_GZIP = rhash-bindings-$(VERSION)-src.tar.gz
COPYDIR = rhash-bindings-$(VERSION)

all: configure build test
clean: distclean

configure: $(patsubst %, configure-%, $(filter perl ruby php, $(BINDINGS)))
build: $(patsubst %, build-%, $(BINDINGS))
test: $(patsubst %, test-%, $(BINDINGS))
install: $(patsubst %, install-%, $(filter perl ruby php, $(BINDINGS)))

configure-perl: perl/Makefile
configure-ruby: ruby/Makefile
configure-php: php/Makefile

perl/Makefile: perl/Makefile.PL
	cd perl && USE_SYSTEM_LIBRHASH=1 $(PERL) Makefile.PL INSTALLDIRS=vendor

php/Makefile: php/config.m4
	cd php && phpize && ./configure --with-rhash

ruby/Makefile: ruby/extconf.rb
	$(RUBY) -C ruby extconf.rb

build-java:
	+$(MAKE) -C java build-binary

build-perl: configure-perl
	+$(MAKE) -C perl OPTIMIZE="$(PERL_OPTIMIZE)"

build-php: configure-php
	+$(MAKE) -C php

build-python:
# not required

build-ruby: configure-ruby
	+$(MAKE) -C ruby

build-mono:
	+$(MAKE) -C mono

test-java:
	+$(MAKE) -C java test

test-perl:
	+$(MAKE) -C perl test

test-php:
	+$(MAKE) -C php test TEST_PHP_ARGS=-q

test-ruby:
	$(RUBY) -C ruby -I. test_rhash.rb

test-mono:
	+$(MAKE) -C mono test

test-python:
	$(PYTHON) python/test_rhash.py

install-ruby:
# clear MAKEFLAGS to overcome ruby1.8 mkmf concurrency bug
	+MAKEFLAGS= $(MAKE) -C ruby install DESTDIR=$(DESTDIR) sitedir=$(DESTDIR)/usr/lib/ruby

install-perl:
	+$(MAKE) -C perl install DESTDIR=$(DESTDIR)

install-php:
	+$(MAKE) -C php install INSTALL_ROOT=$(DESTDIR)

copy-dist:
	mkdir -p $(COPYDIR)
	find java ruby python -type f -regex '.*\(\.\([hc]\|java\|py\|rb\|txt\)\|Makefile\)' -exec $(CP) '{}' $(COPYDIR)/ \;
	find mono -type f -regex '.*\(\.\([hc]\|cs\|xml\|txt\|snk\|sln\|csproj\|config\)\|Makefile\)' -exec $(CP) '{}' "$(COPYDIR)/" \;
	$(CP) $(shell sed -e 's/\([^ ]*\).*/perl\/\1/' perl/MANIFEST) "$(COPYDIR)/"
	find php -type f -regex '.*\.\(m4\|c\|h\|phpt\)' -exec $(CP) '{}' "$(COPYDIR)/" \;
	$(CP) $(FILES) "$(COPYDIR)/"

gzip: distclean
	rm -rf "$(COPYDIR)" $(ARCHIVE_GZIP)
	+$(MAKE) copy-dist
	tar -czf $(ARCHIVE_GZIP) --owner=root:0 --group=root:0 "$(COPYDIR)"
	rm -rf "$(COPYDIR)"

PERL_PKG_VER = $(shell [ -f perl/Rhash.pm ] && sed -ne "s/^our \+.VERSION *= *'\([0-9\.]*\)';/\1/p;" perl/Rhash.pm)
PERL_PKG = Crypt-RHash-$(PERL_PKG_VER)

cpan:
	[ -f ../librhash/rhash.h ]
	echo "$(PERL_PKG_VER)" | grep -q '^[0-9\.]\+$$'
	rm -rf $(PERL_PKG)/ $(PERL_PKG).tar.gz
	mkdir -p $(PERL_PKG)/librhash/
	grep -q / perl/MANIFEST && mkdir -p `sed -ne '/\//s/\([^\/]*\/\).*/$(PERL_PKG)\/\1/p' perl/MANIFEST | sort -u`
	sed -e 's/^\([^ ]*\)\( .*\)\?/cp perl\/\1 $(PERL_PKG)\/\1/' perl/MANIFEST > _cpy.sh
	sh _cpy.sh && rm -f _cpy.sh
	cp ../librhash/*.[hc] $(PERL_PKG)/librhash/
	cp perl/MANIFEST $(PERL_PKG)/
	find $(PERL_PKG)/librhash/ -type f -printf "librhash/%f\n" | sort >> $(PERL_PKG)/MANIFEST
	tar -czf $(PERL_PKG).tar.gz --owner=root:0 --group=root:0 $(PERL_PKG)/
	rm -rf $(PERL_PKG)/

distclean:
	+$(MAKE) -C java distclean
	+$(MAKE) -C mono clean
	+[ ! -f ruby/Makefile ] || $(MAKE) -C ruby distclean
	+[ ! -f perl/Makefile ] || $(MAKE) -C perl distclean
	[ ! -f php/configure ] || (cd php && phpize --clean)
	rm -f python/*.pyc

classes/*
dist/*
*.so
*.class

#!/usr/bin/make -f

# This file is a part of Java Bindings for Librhash
# Copyright (c) 2011-2012, Sergey Basalaev <sbasalaev@gmail.com>
# Librhash is (c) 2011-2012, Aleksey Kravchenko <rhash.admin@gmail.com>
# 
# Permission is hereby granted, free of charge,  to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction,  including without limitation the rights
# to  use,  copy,  modify,  merge, publish, distribute, sublicense, and/or sell
# copies  of  the Software,  and  to permit  persons  to whom  the Software  is
# furnished to do so.
# 
# This library  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. Use it at your own risk!


JAVA = java
JAVAC = javac
JAVADOC = javadoc
JAVAH = javah
JAR = jar
JUNIT_CLASSPATH = /usr/share/java/junit4.jar

VERSION = $(shell sed -ne 's/^version=\(.*\)/\1/p' ../version.properties)

JAVASRC_DIR = src
CSRC_DIR    = native
DEST_DIR    = dist
CLASSES_DIR = classes
JAVADOC_DIR = javadoc
TEST_DIR    = test

JAVA_FILES := $(shell find $(JAVASRC_DIR) -name '*.java')
JNI_FILES := $(shell find $(CSRC_DIR) -name '*.c' -o -name '*.h')
LIB_PREFIX = lib
LIB_SUFFIX = .so
JNI_LIBRARY = $(LIB_PREFIX)rhash-jni$(LIB_SUFFIX)
JARFILE = $(DEST_DIR)/rhash-$(VERSION).jar
JAVADOC_FILE = $(DEST_DIR)/rhash-$(VERSION)-javadoc.zip
JAVADOC_API_URL = http://download.oracle.com/javase/6/docs/api/


all: build-binary javadoc
build-binary: jar jar-symlink jni
jar: $(JARFILE)
jni: $(DEST_DIR)/$(JNI_LIBRARY)
zip-javadoc: $(JAVADOC_FILE)

jar-symlink:
	mkdir -p $(DEST_DIR)
	ln -fs rhash-$(VERSION).jar $(DEST_DIR)/rhash.jar

$(JARFILE): $(JAVA_FILES)
	+$(MAKE) compile-classes
	mkdir -p $(DEST_DIR)
	$(JAR) cf $(JARFILE) -C $(CLASSES_DIR) org/

compile-classes:
	mkdir -p $(CLASSES_DIR)
	$(JAVAC) -d $(CLASSES_DIR) -sourcepath $(JAVASRC_DIR) $(JAVA_FILES)

update-header: compile-classes
	$(JAVAH) -o $(CSRC_DIR)/bindings.h -classpath $(CLASSES_DIR)  org.sf.rhash.Bindings

$(DEST_DIR)/$(JNI_LIBRARY): $(JNI_FILES)
	+$(MAKE) -C $(CSRC_DIR)
	mkdir -p $(DEST_DIR)
	cp $(CSRC_DIR)/$(JNI_LIBRARY) $(DEST_DIR)

javadoc: clean-javadoc
	$(JAVADOC) -windowtitle 'RHash' \
	           -sourcepath $(JAVASRC_DIR) \
	           -subpackages org \
	           -d $(JAVADOC_DIR) \
	           -link $(JAVADOC_API_URL)

$(JAVADOC_FILE): $(JAVA_FILES)
	+$(MAKE) javadoc
	jar -cMf $(JAVADOC_FILE) $(JAVADOC_DIR)

$(TEST_DIR)/RHashTest.class: $(JARFILE) $(TEST_DIR)/RHashTest.java
	$(JAVAC) -classpath $(JARFILE):$(JUNIT_CLASSPATH) $(TEST_DIR)/RHashTest.java

test: $(TEST_DIR)/RHashTest.class jni
	$(JAVA) -classpath $(TEST_DIR):$(JARFILE):$(JUNIT_CLASSPATH) -Djava.library.path=$(DEST_DIR) junit.textui.TestRunner RHashTest

clean: clean-javadoc clean-jni clean-classes clean-test

clean-javadoc:
	rm -rf $(JAVADOC_DIR)

clean-classes:
	rm -rf $(CLASSES_DIR)

clean-jni:
	+$(MAKE) -C $(CSRC_DIR) clean

clean-test:
	rm -f $(TEST_DIR)/*.class

distclean: clean
	rm -rf $(DEST_DIR)

.PHONY: jar jni javadoc test clean clean-javadoc distclean

#!/usr/bin/make -f

# This file is a part of Java Bindings for Librhash
# Copyright (c) 2011-2012, Sergey Basalaev <sbasalaev@gmail.com>
# Librhash is (c) 2011-2012, Aleksey Kravchenko <rhash.admin@gmail.com>
# 
# Permission is hereby granted, free of charge,  to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction,  including without limitation the rights
# to  use,  copy,  modify,  merge, publish, distribute, sublicense, and/or sell
# copies  of  the Software,  and  to permit  persons  to whom  the Software  is
# furnished to do so.
# 
# This library  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. Use it at your own risk!


CC = gcc
CFLAGS = -g -O2
LDFLAGS =
LIBRHASH_INC =
LIBRHASH_LD  =
ALLLDFLAGS = $(LDFLAGS) -lrhash $(LIBRHASH_LD)
ALLCFLAGS = $(CFLAGS) $(LIBRHASH_INC) -fPIC

#Platform dependent
JNI_CFLAGS = -I/usr/lib/jvm/default-java/include
LIB_PREFIX = lib
LIB_SUFFIX = .so

OBJECTS = bindings.o digest.o
LIBRARY = $(LIB_PREFIX)rhash-jni$(LIB_SUFFIX)

all: $(LIBRARY)

bindings.o: bindings.c bindings.h
	$(CC) $(ALLCFLAGS) $(JNI_CFLAGS) -c $< -o $@

digest.o: digest.c digest.h
	$(CC) $(ALLCFLAGS) -c $< -o $@

$(LIBRARY): $(OBJECTS)
	$(CC) -shared -o $@ $(OBJECTS) $(ALLLDFLAGS)

clean:
	rm -f *.o $(LIBRARY)

/*
 * This file is a part of Java Bindings for Librhash
 * Copyright (c) 2011-2012, Sergey Basalaev <sbasalaev@gmail.com>
 * Librhash is (c) 2011-2012, Aleksey Kravchenko <rhash.admin@gmail.com>
 * 
 * Permission is hereby granted, free of charge,  to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction,  including without limitation the rights
 * to  use,  copy,  modify,  merge, publish, distribute, sublicense, and/or sell
 * copies  of  the Software,  and  to permit  persons  to whom  the Software  is
 * furnished to do so.
 * 
 * This library  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. Use it at your own risk!
 */

#include <rhash.h>
#include <stdlib.h>

#ifdef __GNUC__
#include <stdint.h>
#define TO_RHASH(a)   ((rhash)(intptr_t)(a))
#define TO_DIGEST(a)  ((Digest)(intptr_t)(a))
#define TO_JLONG(a)   ((jlong)(intptr_t)(a))
#else
#define TO_RHASH(a)   ((rhash)(a))
#define TO_DIGEST(a)  ((Digest)(a))
#define TO_JLONG(a)   ((jlong)(a))
#endif /* __GNUC__ */


#include "bindings.h"
#include "digest.h"

/*
 * Class:     org_sf_rhash_Bindings
 * Method:    rhash_library_init
 * Signature: ()V
 */
JNIEXPORT void JNICALL Java_org_sf_rhash_Bindings_rhash_1library_1init
(JNIEnv *env, jclass clz) {
	rhash_library_init();
}

/*
 * Class:     org_sf_rhash_Bindings
 * Method:    rhash_count
 * Signature: ()I
 */
JNIEXPORT jint JNICALL Java_org_sf_rhash_Bindings_rhash_1count
(JNIEnv *env, jclass clz) {
	return rhash_count();
}

/*
 * Class:     org_sf_rhash_Bindings
 * Method:    rhash_msg
 * Signature: (I[BII)J
 */
JNIEXPORT jlong JNICALL Java_org_sf_rhash_Bindings_rhash_1msg
(JNIEnv *env, jclass clz, jint hash_id, jbyteArray buf, jint ofs, jint len) {
	// reading data
	void* msg = malloc(len);
	(*env)->GetByteArrayRegion(env, buf, ofs, len, msg);
	// creating and populating Digest
	Digest obj = malloc(sizeof(DigestStruct));
	obj->hash_len  = rhash_get_digest_size(hash_id);
	obj->hash_data = calloc(obj->hash_len, sizeof(unsigned char));
	rhash_msg(hash_id, msg, len, obj->hash_data);
	//cleaning
	free(msg);
	//returning
	return TO_JLONG(obj);
}

/*
 * Class:     org_sf_rhash_Bindings
 * Method:    rhash_print_bytes
 * Signature: (JI)[B
 */
JNIEXPORT jbyteArray JNICALL Java_org_sf_rhash_Bindings_rhash_1print_1bytes
(JNIEnv *env, jclass clz, jlong ptr, jint flags) {
	Digest obj = TO_DIGEST(ptr);
	char output[130];
	int len = rhash_print_bytes(output, obj->hash_data, obj->hash_len, flags);
	jbyteArray arr = (*env)->NewByteArray(env, len);
	(*env)->SetByteArrayRegion(env, arr, 0, len, (jbyte*)output);
	return arr;
}


/*
 * Class:     org_sf_rhash_Bindings
 * Method:    rhash_print_magnet
 * Signature: (JLjava/lang/String;I)Ljava/lang/String;
 */
JNIEXPORT jstring JNICALL Java_org_sf_rhash_Bindings_rhash_1print_1magnet
(JNIEnv *env, jclass clz, jlong context, jstring filepath, jint flags) {
	const char* fpath = (filepath != NULL) ?
			(*env)->GetStringUTFChars(env, filepath, NULL) : NULL;
	size_t len = rhash_print_magnet(NULL, fpath, TO_RHASH(context), flags, RHPR_FILESIZE);
	char *buf = (char*)malloc(len);
	rhash_print_magnet(buf, fpath, TO_RHASH(context), flags, RHPR_FILESIZE);
	if (filepath != NULL) {
		(*env)->ReleaseStringUTFChars(env, filepath, fpath);
	}
	jstring str = (*env)->NewStringUTF(env, buf);
	free(buf);
	return str;
}

/*
 * Class:     org_sf_rhash_Bindings
 * Method:    rhash_is_base32
 * Signature: (I)Z
 */
JNIEXPORT jboolean JNICALL Java_org_sf_rhash_Bindings_rhash_1is_1base32
(JNIEnv *env, jclass clz, jint hash_id) {
	return rhash_is_base32(hash_id);
}

/*
 * Class:     org_sf_rhash_Bindings
 * Method:    rhash_get_digest_size
 * Signature: (I)I
 */
JNIEXPORT jint JNICALL Java_org_sf_rhash_Bindings_rhash_1get_1digest_1size
(JNIEnv *env, jclass clz, jint hash_id) {
	return rhash_get_digest_size(hash_id);
}

/*
 * Class:     org_sf_rhash_Bindings
 * Method:    rhash_init
 * Signature: (I)J
 */
JNIEXPORT jlong JNICALL Java_org_sf_rhash_Bindings_rhash_1init
(JNIEnv *env, jclass clz, jint hash_flags) {
	rhash ctx = rhash_init(hash_flags);
	rhash_set_autofinal(ctx, 0);
	return TO_JLONG(ctx);
}

/*
 * Class:     org_sf_rhash_Bindings
 * Method:    rhash_update
 * Signature: (J[BII)V
 */
JNIEXPORT void JNICALL Java_org_sf_rhash_Bindings_rhash_1update
(JNIEnv *env, jclass clz, jlong context, jbyteArray data, jint ofs, jint len) {
	void* msg = malloc(len);
	(*env)->GetByteArrayRegion(env, data, ofs, len, msg);
	rhash_update(TO_RHASH(context), msg, len);
	free(msg);
}

/*
 * Class:     org_sf_rhash_Bindings
 * Method:    rhash_final
 * Signature: (J)V
 */
JNIEXPORT void JNICALL Java_org_sf_rhash_Bindings_rhash_1final
(JNIEnv *env, jclass clz, jlong context) {
	rhash_final(TO_RHASH(context), NULL);
}

/*
 * Class:     org_sf_rhash_Bindings
 * Method:    rhash_reset
 * Signature: (J)V
 */
JNIEXPORT void JNICALL Java_org_sf_rhash_Bindings_rhash_1reset
(JNIEnv *env, jclass clz, jlong context) {
	rhash_reset(TO_RHASH(context));
}

/*
 * Class:     org_sf_rhash_Bindings
 * Method:    rhash_print
 * Signature: (JI)J
 */
JNIEXPORT jlong JNICALL Java_org_sf_rhash_Bindings_rhash_1print
(JNIEnv *env, jclass clz, jlong context, jint hash_id) {
	Digest obj = malloc(sizeof(DigestStruct));
	obj->hash_len  = rhash_get_digest_size(hash_id);
	obj->hash_data = calloc(obj->hash_len, sizeof(unsigned char));
	rhash_print((char*)obj->hash_data, TO_RHASH(context), hash_id, RHPR_RAW);
	return TO_JLONG(obj);
}

/*
 * Class:     org_sf_rhash_Bindings
 * Method:    rhash_free
 * Signature: (J)V
 */
JNIEXPORT void JNICALL Java_org_sf_rhash_Bindings_rhash_1free
(JNIEnv *env, jclass clz, jlong context) {
	rhash_free(TO_RHASH(context));
}

/*
 * Class:     org_sf_rhash_Bindings
 * Method:    compareDigests
 * Signature: (JJ)Z
 */
JNIEXPORT jboolean JNICALL Java_org_sf_rhash_Bindings_compareDigests
(JNIEnv *env, jclass clz, jlong ptr1, jlong ptr2) {
	return compareDigests(TO_DIGEST(ptr1), TO_DIGEST(ptr2));
}

/*
 * Class:     org_sf_rhash_Bindings
 * Method:    hashcodeForDigest
 * Signature: (J)I
 */
JNIEXPORT jint JNICALL Java_org_sf_rhash_Bindings_hashcodeForDigest
(JNIEnv *env, jclass clz, jlong ptr) {
	return hashcodeForDigest(TO_DIGEST(ptr));
}

/*
 * Class:     org_sf_rhash_Bindings
 * Method:    freeDigest
 * Signature: (J)V
 */
JNIEXPORT void JNICALL Java_org_sf_rhash_Bindings_freeDigest
(JNIEnv *env, jclass clz, jlong ptr) {
	freeDigest(TO_DIGEST(ptr));
}

/* DO NOT EDIT THIS FILE - it is machine generated */
#include <jni.h>
/* Header for class org_sf_rhash_Bindings */

#ifndef _Included_org_sf_rhash_Bindings
#define _Included_org_sf_rhash_Bindings
#ifdef __cplusplus
extern "C" {
#endif
/*
 * Class:     org_sf_rhash_Bindings
 * Method:    rhash_library_init
 * Signature: ()V
 */
JNIEXPORT void JNICALL Java_org_sf_rhash_Bindings_rhash_1library_1init
  (JNIEnv *, jclass);

/*
 * Class:     org_sf_rhash_Bindings
 * Method:    rhash_count
 * Signature: ()I
 */
JNIEXPORT jint JNICALL Java_org_sf_rhash_Bindings_rhash_1count
  (JNIEnv *, jclass);

/*
 * Class:     org_sf_rhash_Bindings
 * Method:    rhash_msg
 * Signature: (I[BII)J
 */
JNIEXPORT jlong JNICALL Java_org_sf_rhash_Bindings_rhash_1msg
  (JNIEnv *, jclass, jint, jbyteArray, jint, jint);

/*
 * Class:     org_sf_rhash_Bindings
 * Method:    rhash_print_bytes
 * Signature: (JI)[B
 */
JNIEXPORT jbyteArray JNICALL Java_org_sf_rhash_Bindings_rhash_1print_1bytes
  (JNIEnv *, jclass, jlong, jint);

/*
 * Class:     org_sf_rhash_Bindings
 * Method:    rhash_print_magnet
 * Signature: (JLjava/lang/String;I)Ljava/lang/String;
 */
JNIEXPORT jstring JNICALL Java_org_sf_rhash_Bindings_rhash_1print_1magnet
  (JNIEnv *, jclass, jlong, jstring, jint);

/*
 * Class:     org_sf_rhash_Bindings
 * Method:    rhash_is_base32
 * Signature: (I)Z
 */
JNIEXPORT jboolean JNICALL Java_org_sf_rhash_Bindings_rhash_1is_1base32
  (JNIEnv *, jclass, jint);

/*
 * Class:     org_sf_rhash_Bindings
 * Method:    rhash_get_digest_size
 * Signature: (I)I
 */
JNIEXPORT jint JNICALL Java_org_sf_rhash_Bindings_rhash_1get_1digest_1size
  (JNIEnv *, jclass, jint);

/*
 * Class:     org_sf_rhash_Bindings
 * Method:    rhash_init
 * Signature: (I)J
 */
JNIEXPORT jlong JNICALL Java_org_sf_rhash_Bindings_rhash_1init
  (JNIEnv *, jclass, jint);

/*
 * Class:     org_sf_rhash_Bindings
 * Method:    rhash_update
 * Signature: (J[BII)V
 */
JNIEXPORT void JNICALL Java_org_sf_rhash_Bindings_rhash_1update
  (JNIEnv *, jclass, jlong, jbyteArray, jint, jint);

/*
 * Class:     org_sf_rhash_Bindings
 * Method:    rhash_final
 * Signature: (J)V
 */
JNIEXPORT void JNICALL Java_org_sf_rhash_Bindings_rhash_1final
  (JNIEnv *, jclass, jlong);

/*
 * Class:     org_sf_rhash_Bindings
 * Method:    rhash_reset
 * Signature: (J)V
 */
JNIEXPORT void JNICALL Java_org_sf_rhash_Bindings_rhash_1reset
  (JNIEnv *, jclass, jlong);

/*
 * Class:     org_sf_rhash_Bindings
 * Method:    rhash_print
 * Signature: (JI)J
 */
JNIEXPORT jlong JNICALL Java_org_sf_rhash_Bindings_rhash_1print
  (JNIEnv *, jclass, jlong, jint);

/*
 * Class:     org_sf_rhash_Bindings
 * Method:    rhash_free
 * Signature: (J)V
 */
JNIEXPORT void JNICALL Java_org_sf_rhash_Bindings_rhash_1free
  (JNIEnv *, jclass, jlong);

/*
 * Class:     org_sf_rhash_Bindings
 * Method:    compareDigests
 * Signature: (JJ)Z
 */
JNIEXPORT jboolean JNICALL Java_org_sf_rhash_Bindings_compareDigests
  (JNIEnv *, jclass, jlong, jlong);

/*
 * Class:     org_sf_rhash_Bindings
 * Method:    hashcodeForDigest
 * Signature: (J)I
 */
JNIEXPORT jint JNICALL Java_org_sf_rhash_Bindings_hashcodeForDigest
  (JNIEnv *, jclass, jlong);

/*
 * Class:     org_sf_rhash_Bindings
 * Method:    freeDigest
 * Signature: (J)V
 */
JNIEXPORT void JNICALL Java_org_sf_rhash_Bindings_freeDigest
  (JNIEnv *, jclass, jlong);

#ifdef __cplusplus
}
#endif
#endif

/*
 * This file is a part of Java Bindings for Librhash
 * Copyright (c) 2011-2012, Sergey Basalaev <sbasalaev@gmail.com>
 * Librhash is (c) 2011-2012, Aleksey Kravchenko <rhash.admin@gmail.com>
 * 
 * Permission is hereby granted, free of charge,  to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction,  including without limitation the rights
 * to  use,  copy,  modify,  merge, publish, distribute, sublicense, and/or sell
 * copies  of  the Software,  and  to permit  persons  to whom  the Software  is
 * furnished to do so.
 * 
 * This library  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. Use it at your own risk!
 */

#include <stdlib.h>
#include <string.h>

#include "digest.h"

void freeDigest(Digest obj) {
	free(obj->hash_data);
	free(obj);
}

int compareDigests(Digest o1, Digest o2) {
	if (o1->hash_len != o2->hash_len) return 0;
	return memcmp(o1->hash_data, o2->hash_data, o1->hash_len) == 0;
}

int hashcodeForDigest(Digest obj) {
	int hash = 123321, i;
	for (i = 0; i < obj->hash_len; i++) {
		switch (i % 3) {
			case 0: hash ^= obj->hash_data[i];
			case 1: hash ^= obj->hash_data[i] << 8;
			case 2: hash ^= obj->hash_data[i] << 16;
			case 3: hash ^= obj->hash_data[i] << 24;
		}
	}
	return hash ^ (obj->hash_id + obj->hash_len);
}

/*
 * This file is a part of Java Bindings for Librhash
 * Copyright (c) 2011-2012, Sergey Basalaev <sbasalaev@gmail.com>
 * Librhash is (c) 2011-2012, Aleksey Kravchenko <rhash.admin@gmail.com>
 * 
 * Permission is hereby granted, free of charge,  to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction,  including without limitation the rights
 * to  use,  copy,  modify,  merge, publish, distribute, sublicense, and/or sell
 * copies  of  the Software,  and  to permit  persons  to whom  the Software  is
 * furnished to do so.
 * 
 * This library  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. Use it at your own risk!
 */

/* This is convenient structure to hold message digest. */

#ifndef DIGEST_H
#define DIGEST_H

typedef struct {
	int hash_id;
	size_t hash_len;
	unsigned char *hash_data;
} DigestStruct;

typedef DigestStruct* Digest;

/**
 * Frees memory occupated by Digest.
 * @param  obj  object to free
 */
void freeDigest(Digest obj);

/**
 * Compares two Digest instances.
 * @param  obj1  first object to compare
 * @param  obj2  second object to compare
 * @return  1 if objects are equal, 0 otherwise
 */
int compareDigests(Digest obj1, Digest obj2);

/**
 * Calculates hashcode for Digest.
 * @param  obj  object to calculate hash code
 */
int hashcodeForDigest(Digest obj);

#endif /* DIGEST_H */

/*
 * This file is a part of Java Bindings for Librhash
 * Copyright (c) 2011-2012, Sergey Basalaev <sbasalaev@gmail.com>
 * Librhash is (c) 2011-2012, Aleksey Kravchenko <rhash.admin@gmail.com>
 * 
 * Permission is hereby granted, free of charge,  to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction,  including without limitation the rights
 * to  use,  copy,  modify,  merge, publish, distribute, sublicense, and/or sell
 * copies  of  the Software,  and  to permit  persons  to whom  the Software  is
 * furnished to do so.
 * 
 * This library  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. Use it at your own risk!
 */

package org.sf.rhash;

/**
 * Glue to the native API.
 */
final class Bindings {

	/** This class is not instantiable. */
	private Bindings() { }

	/**
	 * Initializes library.
	 */
	static native void rhash_library_init();
	
	/**
	 * Returns the number of supported hash algorithms.
	 */
	static native int rhash_count();

	/**
	 * Computes a hash of the given data.
	 *
	 * @param  hash_id  id of hash function
	 * @param  data     the data to process
	 * @param  ofs      offset in data array from which to start processing
	 * @param  len      data length
	 * @return  pointer to the native digest object
	 */
	static native long rhash_msg(int hash_id, byte[] data, int ofs, int len);
	
	/**
	 * Prints text representation of a given digest.
	 *
	 * @param  rhash  pointer to native digest object
	 * @param  flags  output flags
	 * @return  text representation as byte array
	 */
	static native byte[] rhash_print_bytes(long rhash, int flags);

	/**
	 * Returns magnet link for given hash context and hashing algorithms.
	 * 
	 * @param  rhash     pointer to native digest object
	 * @param  filename  the name of the file to incorporate in magnet
	 * @param  flags     mask of hash_id values
	 * @return  magnet string
	 */
	static native String rhash_print_magnet(long rhash, String filename, int flags);

	/**
	 * Tests whether given default hash algorithm output is base32.
	 * @param  hash_id  id of hash function
	 * @return <code>true</code> if default output for hash algorithm is base32,
	 *         <code>false</code> otherwise
	 */
	static native boolean rhash_is_base32(int hash_id);

	/**
	 * Returns size of binary message digest.
	 * @param hash_id  id of hash function
	 * @return  size of message digest
	 */
	static native int rhash_get_digest_size(int hash_id);

	/**
	 * Creates new hash context.
	 * @param  flags  mask of hash_id values
	 * @return  pointer to the native hash context
	 */
	static native long rhash_init(int flags);

	/**
	 * Updates hash context with given data.
	 * @param rhash  pointer to native hash context
	 * @param data   data to process
	 * @param ofs    index of the first byte to process
	 * @param len    count of bytes to process
	 */
	static native void rhash_update(long rhash, byte[] data, int ofs, int len);

	/**
	 * Finalizes hash context.
	 * @param rhash  pointer to native hash context
	 */
	static native void rhash_final(long rhash);

	/**
	 * Resets hash context.
	 * @param rhash  pointer to native hash context
	 */
	static native void rhash_reset(long rhash);

	/**
	 * Generates message digest for given context and hash_id.
	 * @param  rhash    pointer to native hash context
	 * @param  hash_id  id of hashing algorithm
	 * @return  pointer to native digest
	 */
	static native long rhash_print(long rhash, int hash_id);

	/**
	 * Frees hash context.
	 * @param rhash  pointer to native hash context
	 */
	static native void rhash_free(long rhash);

	/**
	 * Compares two native hash objects.
	 * @param  hash1  pointer to first object
	 * @param  hash2  pointer to second object
	 * @return  <code>true</code> if objects are the same,
	 *          <code>false</code> otherwise
	 */
	static native boolean compareDigests(long hash1, long hash2);

	/**
	 * Computes hashcode for native digest object.
	 * @param hash  pointer to first object
	 * @return  hash code for the object
	 */
	static native int hashcodeForDigest(long hash);

	/**
	 * Frees previously created native digest object.
	 */
	static native void freeDigest(long hash);

	static {
		System.loadLibrary("rhash-jni");
		rhash_library_init();
	}
}

/*
 * This file is a part of Java Bindings for Librhash
 * Copyright (c) 2011-2012, Sergey Basalaev <sbasalaev@gmail.com>
 * Librhash is (c) 2011-2012, Aleksey Kravchenko <rhash.admin@gmail.com>
 * 
 * Permission is hereby granted, free of charge,  to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction,  including without limitation the rights
 * to  use,  copy,  modify,  merge, publish, distribute, sublicense, and/or sell
 * copies  of  the Software,  and  to permit  persons  to whom  the Software  is
 * furnished to do so.
 * 
 * This library  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. Use it at your own risk!
 */

package org.sf.rhash;

/**
 * Message digest.
 */
public final class Digest {

	static final int RAW = 0x1;
	static final int HEX = 0x2;
	static final int BASE32 = 0x3;
	static final int BASE64 = 0x4;
	static final int UPPERCASE = 0x8;
	static final int REVERSE   = 0x10;

	private final HashType type;

	/** Pointer to native structure. */
	private final long digest_ptr;

	/**
	 * Creates new <code>Digest</code>.
	 * @param ptr   pointer to the native object
	 * @param type  hash type
	 */
	Digest(long ptr, HashType type) {
		this.digest_ptr = ptr;
		this.type = type;
	}
	
	/**
	 * Returns type of hashing algorithm that produced
	 * this digest.
	 * 
	 * @return type of hashing algorithm
	 */
	public HashType hashType() {
		return type;
	}

	/**
	 * Returns value of this digest as raw bytes.
	 * This method allocates new byte array, modifying it
	 * has no effect on this <code>Digest</code>.
	 *
	 * @return  value of this digest as raw bytes
	 * @see #hex()
	 * @see #base32()
	 * @see #base64() 
	 */
	public byte[] raw() {
		return Bindings.rhash_print_bytes(digest_ptr, RAW);
	}

	/**
	 * Returns value of this digest as hexadecimal string.
	 *
	 * @return value of the digest as hexadecimal string
	 * @see #raw()
	 * @see #base32()
	 * @see #base64() 
	 */
	public String hex() {
		return new String(Bindings.rhash_print_bytes(digest_ptr, HEX));
	}

	/**
	 * Returns value of this digest as base32 string.
	 *
	 * @return value of the digest as base32 string
	 * @see #raw()
	 * @see #hex()
	 * @see #base64()
	 */
	public String base32() {
		return new String(Bindings.rhash_print_bytes(digest_ptr, BASE32));
	}

	/**
	 * Returns value of this digest as base64 string.
	 *
	 * @return value of the digest as base64 string
	 * @see #raw()
	 * @see #hex()
	 * @see #base32()
	 */
	public String base64() {
		return new String(Bindings.rhash_print_bytes(digest_ptr, BASE64));
	}
	
	/**
	 * Called by garbage collector to free native resources.
	 */
	@Override
	protected void finalize() {
		Bindings.freeDigest(digest_ptr);
	}

	/**
	 * Returns string representation of this object.
	 * If default output for hashing algorithm is base32 then
	 * returned value is the same as if <code>base32()</code>
	 * method was called; otherwise value is the same as returned
	 * by <code>hex()</code> method.
	 *
	 * @return string representation of this object
	 * @see #base32()
	 * @see #hex() 
	 */
	@Override
	public String toString() {
		return (Bindings.rhash_is_base32(type.hashId())) ? base32() : hex();
	}

	/**
	 * Tests whether this object equals to another one
	 * @param  obj  object to compare to
	 * @return
	 *   <code>true</code> if <code>obj</code> is <code>Digest</code>
	 *   instance with the same <code>HashType</code> and value;
	 *   otherwise <code>false</code>
	 */
	@Override
	public boolean equals(Object obj) {
		if (!(obj instanceof Digest)) return false;
		final Digest other = (Digest)obj;
		if (!this.hashType().equals(other.hashType())) return false;
		if (this.digest_ptr == other.digest_ptr) return true;
		return Bindings.compareDigests(this.digest_ptr, other.digest_ptr);
	}

	/**
	 * Returns hash code for this object.
	 * @return hash code for the object
	 */
	@Override
	public int hashCode() {
		return Bindings.hashcodeForDigest(digest_ptr);
	}
}

/*
 * This file is a part of Java Bindings for Librhash
 * Copyright (c) 2011-2012, 2014, Sergey Basalaev <sbasalaev@gmail.com>
 * Librhash is (c) 2011-2014, Aleksey Kravchenko <rhash.admin@gmail.com>
 * 
 * Permission is hereby granted, free of charge,  to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction,  including without limitation the rights
 * to  use,  copy,  modify,  merge, publish, distribute, sublicense, and/or sell
 * copies  of  the Software,  and  to permit  persons  to whom  the Software  is
 * furnished to do so.
 * 
 * This library  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. Use it at your own risk!
 */

package org.sf.rhash;

/**
 * Type of hashing algorithm.
 * Supported algorithms are MD4, MD5, SHA1/SHA2, Tiger,
 * DC++ TTH, BitTorrent BTIH, AICH, EDonkey 2000 hash, GOST R 34.11-94,
 * RIPEMD-160, HAS-160, EDON-R 256/512, Whirlpool and Snefru-128/256.
 */
public enum HashType {
	/** CRC32 checksum. */
	CRC32(1),
	/** MD4 hash. */
	MD4(1 << 1),
	/** MD5 hash. */
	MD5(1 << 2),
	/** SHA-1 hash. */
	SHA1(1 << 3),
	/** Tiger hash. */
	TIGER(1 << 4),
	/** Tiger tree hash */
	TTH(1 << 5),
	/** BitTorrent info hash. */
	BTIH(1 << 6),
	/** EDonkey 2000 hash. */
	ED2K(1 << 7),
	/** eMule AICH. */
	AICH(1 << 8),
	/** Whirlpool hash. */
	WHIRLPOOL(1 << 9),
	/** RIPEMD-160 hash. */
	RIPEMD160(1 << 10),
	/** GOST R 34.11-94. */
	GOST(1 << 11),
	GOST_CRYPTOPRO(1 << 12),
	/** HAS-160 hash. */
	HAS160(1 << 13),
	/** Snefru-128 hash. */
	SNEFRU128(1 << 14),
	/** Snefru-256 hash. */
	SNEFRU256(1 << 15),
	/** SHA-224 hash. */
	SHA224(1 << 16),
	/** SHA-256 hash. */
	SHA256(1 << 17),
	/** SHA-384 hash. */
	SHA384(1 << 18),
	/** SHA-512 hash. */
	SHA512(1 << 19),
	/** EDON-R 256. */
	EDONR256(1 << 20),
	/** EDON-R 512. */
	EDONR512(1 << 21),
	/** SHA3-224 hash. */
	SHA3_224(1 << 22),
	/** SHA3-256 hash. */
	SHA3_256(1 << 23),
	/** SHA3-384 hash. */
	SHA3_384(1 << 24),
	/** SHA3-512 hash. */
	SHA3_512(1 << 25);

	/** hash_id for the native API */
    private int hashId;

    /**
     * Construct HashType for specified native hash_id
     * @param hashId hash identifier for native API
     */
    private HashType(int hashId) {
        this.hashId = hashId;
    }

	/**
	 * Returns hash_id for the native API.
     * @return hash identifier
     */
	int hashId() {
	    return hashId;
	}

	/**
	 * Returns lowest <code>HashType</code> for given id mask.
	 * Used by <code>RHash.getDigest()</code>.
	 * @param flags  mask of hash identifiers
	 * @return  <code>HashType</code> object or <code>null</code>
	 *   if no <code>HashType</code> for given mask exists
	 */
	static HashType forHashFlags(int flags) {
		if (flags == 0) return null;
		int lowest = 0;
		while ((flags % 2) == 0) {
			flags >>>= 1;
			lowest++;
		}
		for (HashType t : HashType.values()) {
			if (t.hashId == (1 << lowest)) return t;
		}
		return null;
	}

	/**
	 * Returns size of binary digest for this type.
	 * @return size of binary digest, in bytes
	 */
	public int getDigestSize() {
		//TODO: rhash_get_digest_size
		return -1;
	}
}

/*
 * This file is a part of Java Bindings for Librhash
 * Copyright (c) 2011-2012, Sergey Basalaev <sbasalaev@gmail.com>
 * Librhash is (c) 2011-2012, Aleksey Kravchenko <rhash.admin@gmail.com>
 * 
 * Permission is hereby granted, free of charge,  to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction,  including without limitation the rights
 * to  use,  copy,  modify,  merge, publish, distribute, sublicense, and/or sell
 * copies  of  the Software,  and  to permit  persons  to whom  the Software  is
 * furnished to do so.
 * 
 * This library  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. Use it at your own risk!
 */

package org.sf.rhash;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.UnsupportedEncodingException;
import java.util.Set;

/**
 * Incremental hasher.
 * This class allows you to do incremental hashing for set
 * of hashing algorithms.
 * <p>
 * To do hashing <code>RHash</code> instance is first created
 * and then filled with message chunks using <code>update()</code>
 * methods. Finally, <code>finish()</code> should be called to end
 * all calculations and generate digests, which then can be obtained
 * with <code>getDigest()</code> method. Note, that trying to update
 * finished <code>RHash</code> has no effect other than throwing
 * <code>IllegalStateException</code> though you can reuse this class
 * by calling <code>reset()</code> method, returning it to the state
 * which was immediately after creating.
 * </p><p>
 * To quickly produce message digest for a single message/file
 * and a single algorithm you may use convenience methods
 * <code>RHash.computeHash()</code>.
 * </p><p>
 * This class is thread safe.
 * </p>
 */
public final class RHash {

	/* == EXCEPTION MESSAGES == */

	static private final String ERR_FINISHED   = "RHash is finished, data update is not possible";
	static private final String ERR_NOHASH     = "No HashTypes specified";
	static private final String ERR_UNFINISHED = "RHash should be finished before generating Digest";
	static private final String ERR_WRONGTYPE  = "RHash was not created to generate Digest for ";

	/**
	 * Computes hash of given range in data.
	 * This method calculates message digest for byte subsequence
	 * in array <code>data</code> starting from <code>data[ofs]</code>
	 * and ending at <code>data[ofs+len-1]</code>.
	 * 
	 * @param  type  type of hash algorithm
	 * @param  data  the bytes to process
	 * @param  ofs   index of the first byte in array to process
	 * @param  len   count of bytes to process
	 * @return  message digest for specified subarray
	 * @throws NullPointerException
	 *   if either <code>type</code> or <code>data</code>
	 *   is <code>null</code>
	 * @throws IndexOutOfBoundsException
	 *   if <code>ofs &lt; 0</code>, <code>len &lt; 0</code> or
	 *   <code>ofs+len &gt; data.length</code>
	 */
	static public Digest computeHash(HashType type, byte[] data, int ofs, int len) {
		if (type == null || data == null) {
			throw new NullPointerException();
		}
		if (ofs < 0 || len < 0 || ofs+len > data.length) {
			throw new IndexOutOfBoundsException();
		}
		return new Digest(Bindings.rhash_msg(type.hashId(), data, ofs, len), type);
	}
	
	/**
	 * Computes hash of given data.
	 * 
	 * @param  type  type of hash algorithm
	 * @param  data  the bytes to process
	 * @return  message digest for specified array
	 * @throws NullPointerException
	 *   if either <code>type</code> or <code>data</code>
	 *   is <code>null</code>
	 */
	static public Digest computeHash(HashType type, byte[] data) {
		return computeHash(type, data, 0, data.length);
	}

	/**
	 * Computes hash of given string.
	 * String is encoded into a sequence of bytes
	 * using the specified charset.
	 *
	 * @param  type      type of hash algorithm
	 * @param  str       the string to process
	 * @param  encoding  encoding to use
	 * @return  message digest for specified string
	 * @throws NullPointerException if any of arguments is <code>null</code>
	 * @throws UnsupportedEncodingException if specified encoding is not supported
	 */
	static public Digest computeHash(HashType type, String str, String encoding)
			throws UnsupportedEncodingException {
		if (type == null || str == null || encoding == null) {
			throw new NullPointerException();
		}
		return computeHash(type, str.getBytes(encoding));
	}

	/**
	 * Computes hash of given string.
	 * String is encoded into a sequence of bytes using the
	 * default platform encoding.
	 *
	 * @param  type  type of hash algorithm
	 * @param  str   the string to process
	 * @return  message digest for specified string
	 * @throws NullPointerException if any of arguments is <code>null</code>
	 */
	static public Digest computeHash(HashType type, String str) {
		if (type == null || str == null) throw new NullPointerException();
		return computeHash(type, str.getBytes());
	}

	/**
	 * Computes hash of given string.
	 * @param  type  type of hash algorithm
	 * @param  file  the file to process
	 * @return  data hash
	 * @throws NullPointerException if any of arguments is <code>null</code>
	 * @throws IOException
	 *   if an I/O error occurs while hashing
	 */
	static public Digest computeHash(HashType type, File file) throws IOException {
		if (type == null || file == null) {
			throw new NullPointerException();
		}
		RHash hasher = new RHash(type);
		hasher.update(file).finish();
		return hasher.getDigest();
	}
	
	/**
	 * Produces magnet link for specified file with given hashes.
	 *
	 * @param  filename   the file to generate magnet for
	 * @param  types      types of hashing algorithms
	 */
	static public String getMagnetFor(String filename, HashType... types) throws IOException {
		RHash hasher = new RHash(types);
		hasher.update(new File(filename)).finish();
		return hasher.getMagnet(filename);
	}
	
	/**
	 * Produces magnet link for specified file with given hashes.
	 *
	 * @param  filename   the file to generate magnet for
	 * @param  types      set of hashing types
	 */
	static public String getMagnetFor(String filename, Set<HashType> types) throws IOException {
		RHash hasher = new RHash(types);
		hasher.update(new File(filename)).finish();
		return hasher.getMagnet(filename);
	}

	/** Indicates whether this <code>RHash</code> is finished. */
	private boolean finished = false;

	/** Mask of hash_id values. */
	private final int hash_flags;

	/** Pointer to the native hash context. */
	private final long context_ptr;

	/** Default hash type used in <code>getDigest()</code>. */
	private final HashType deftype;

	/**
	 * Creates new <code>RHash</code> to compute
	 * message digests for given types.
	 * @param  types  types of hashing algorithms
	 * @throws NullPointerException
	 *   if any of arguments is <code>null</code>
	 * @throws IllegalArgumentException
	 *   if zero hash types specified
	 */
	public RHash(HashType... types) {
		if (types.length == 0) {
			throw new IllegalArgumentException(ERR_NOHASH);
		}
		int flags = 0;
		HashType def = types[0];
		for (HashType t : types) {
			flags |= t.hashId();
			if (def.compareTo(t) > 0) def = t;
		}
		this.deftype = def;
		this.hash_flags = flags;
		this.context_ptr = Bindings.rhash_init(flags);
	}

	/**
	 * Creates new <code>RHash</code> to compute
	 * message digests for given types.
	 * @param  types  set of hashing types
	 * @throws NullPointerException
	 *   if argument is <code>null</code>
	 * @throws IllegalArgumentException
	 *   if argument is empty set
	 */
	public RHash(Set<HashType> types) {
		if (types.isEmpty()) {
			throw new IllegalArgumentException(ERR_NOHASH);
		}
		int flags = 0;
		HashType def = null;
		for (HashType t : types) {
			flags |= t.hashId();
			if (def == null || def.compareTo(t) > 0) def = t;
		}
		this.deftype = def;
		this.hash_flags = flags;
		this.context_ptr = Bindings.rhash_init(flags);
	}

	/**
	 * Updates this <code>RHash</code> with new data chunk.
	 * This method hashes bytes from <code>data[ofs]</code>
	 * through <code>data[ofs+len-1]</code>.
	 * 
	 * @param  data  data to be hashed
	 * @param  ofs   index of the first byte to hash
	 * @param  len   number of bytes to hash
	 * @return  this object
	 * @throws NullPointerException
	 *   if <code>data</code> is <code>null</code>
	 * @throws IndexOutOfBoundsException
	 *   if <code>ofs &lt; 0</code>, <code>len &lt; 0</code> or
	 *   <code>ofs+len &gt; data.length</code>
	 * @throws IllegalStateException
	 *   if <code>finish()</code> was called and there were no
	 *   subsequent calls of <code>reset()</code>
	 */
	public synchronized RHash update(byte[] data, int ofs, int len) {
		if (finished) {
			throw new IllegalStateException(ERR_FINISHED);
		}
		if (ofs < 0 || len < 0 || ofs+len > data.length) {
			throw new IndexOutOfBoundsException();
		}
		Bindings.rhash_update(context_ptr, data, ofs, len);
		return this;
	}

	/**
	 * Updates this <code>RHash</code> with new data chunk.
	 * This method has the same effect as
	 * <pre>update(data, 0, data.length)</pre>
	 *
	 * @param  data  data to be hashed
	 * @return  this object
	 * @throws NullPointerException
	 *   if <code>data</code> is <code>null</code>
	 * @throws IllegalStateException
	 *   if <code>finish()</code> was called and there were no
	 *   subsequent calls of <code>reset()</code>
	 */
	public RHash update(byte[] data) {
		return update(data, 0, data.length);
	}

	/**
	 * Updates this <code>RHash</code> with new data chunk.
	 * String is encoded into a sequence of bytes using the
	 * default platform encoding.
	 * 
	 * @param str  string to be hashed
	 * @return this object
	 * @throws NullPointerException
	 *   if <code>str</code> is <code>null</code>
	 * @throws IllegalStateException
	 *   if <code>finish()</code> was called and there were no
	 *   subsequent calls of <code>reset()</code>
	 */
	public RHash update(String str) {
		return update(str.getBytes());
	}

	/**
	 * Updates this <code>RHash</code> with data from given file.
	 * 
	 * @param  file  file to be hashed
	 * @return this object
	 * @throws IOException if an I/O error occurs
	 * @throws NullPointerException
	 *   if <code>file</code> is <code>null</code>
	 * @throws IllegalStateException
	 *   if <code>finish()</code> was called and there were no
	 *   subsequent calls of <code>reset()</code>
	 */
	public synchronized RHash update(File file) throws IOException {
		if (finished) {
			throw new IllegalStateException(ERR_FINISHED);
		}
		InputStream in = new FileInputStream(file);
		byte[] buf = new byte[8192];  //shouldn't we avoid magic numbers?
		int len = in.read(buf);
		while (len > 0) {
			this.update(buf, 0, len);
			len = in.read(buf);
		}
		in.close();
		return this;
	}

	/**
	 * Finishes calculation of hash codes.
	 * Does nothing if <code>RHash</code> is already finished.
	 */
	public synchronized void finish() {
		if (!finished) {
			Bindings.rhash_final(context_ptr);
			finished = true;
		}
	}

	/**
	 * Resets this <code>RHash</code> to initial state.
	 * The <code>RHash</code> becomes available to process
	 * new data chunks. Note, that this method returns
	 * <code>RHash</code> to the state after creating the
	 * object, NOT the state when hashing continues.
	 * Therefore, all previously calculated hashes are lost
	 * and process starts from the very beginning.
	 */
	public synchronized void reset() {
		Bindings.rhash_reset(context_ptr);
		finished = false;
	}

	/**
	 * Tests whether this <code>RHash</code> is finished or not.
	 * @return
	 *   <code>false</code> if this <code>RHash</code> is ready to
	 *   receive new data for hashing;
	 *   <code>true</code> if hash calculations are finished
	 */
	public boolean isFinished() {
		return finished;
	}

	/**
	 * Returns digest for given hash type.
	 * 
	 * @param type  hash type
	 * @return  <code>Digest</code> for processed data
	 * @throws NullPointerException
	 *   if <code>type</code> is <code>null</code>
	 * @throws IllegalStateException
	 *   if this <code>RHash</code> is not finished
	 * @throws IllegalArgumentException
	 *   if this <code>RHash</code> was not created to calculate
	 *   hash for specified algorithm
	 */
	public Digest getDigest(HashType type) {
		if (type == null) {
			throw new NullPointerException();
		}
		if (!finished) {
			throw new IllegalStateException(ERR_UNFINISHED);
		}
		if ((hash_flags & type.hashId()) == 0) {
			throw new IllegalArgumentException(ERR_WRONGTYPE+type);
		}
		return new Digest(Bindings.rhash_print(context_ptr, type.hashId()), type);
	}

	/**
	 * Returns digest for processed data.
	 * If more than one hashing type was passed to the
	 * <code>RHash</code> constructor, then the least
	 * hash type (in the order induced by
	 * {@link Enum#compareTo(Enum) compareTo()}) is used.
	 * 
	 * @return <code>Digest</code> for processed data
	 * @throws IllegalStateException
	 *   if this <code>RHash</code> is not finished
	 */
	public Digest getDigest() {
		return getDigest(deftype);
	}
	
	/**
	 * Returns magnet link that includes specified filename
	 * and hashes for given algorithms. Only hashes that were
	 * computed by this <code>RHash</code> are included.
	 *
	 * @param  filename  file name to include in magnet, may be <code>null</code>
	 * @return magnet link
	 * @throws IllegalStateException
	 *   if this <code>RHash</code> is not finished
	 */
	public String getMagnet(String filename, HashType... types) {
		if (!finished) {
			throw new IllegalStateException(ERR_UNFINISHED);
		}
		int flags = 0;
		for (HashType t : types) {
			flags |= t.hashId();
		}
		return Bindings.rhash_print_magnet(context_ptr, filename, flags);
	}

	/**
	 * Returns magnet link for given filename.
	 * Magnet includes all hashes that were computed
	 * by this <code>RHash</code>.
	 * 
	 * @param  filename  file name to include in magnet, may be <code>null</code>
	 * @return magnet link
	 * @throws IllegalStateException
	 *   if this <code>RHash</code> is not finished
	 */
	public String getMagnet(String filename) {
		if (!finished) {
			throw new IllegalStateException(ERR_UNFINISHED);
		}
		return Bindings.rhash_print_magnet(context_ptr, filename, hash_flags);
	}
	
	/**
	 * Called by garbage collector to free native resources.
	 */
	@Override
	protected void finalize() {
		Bindings.rhash_free(context_ptr);
	}
}

/*
 * This file is a part of Java Bindings for Librhash
 * Copyright (c) 2011-2012, Sergey Basalaev <sbasalaev@gmail.com>
 * Librhash is (c) 2011-2012, Aleksey Kravchenko <rhash.admin@gmail.com>
 * 
 * Permission is hereby granted, free of charge,  to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction,  including without limitation the rights
 * to  use,  copy,  modify,  merge, publish, distribute, sublicense, and/or sell
 * copies  of  the Software,  and  to permit  persons  to whom  the Software  is
 * furnished to do so.
 * 
 * This library  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. Use it at your own risk!
 */

/**
 * Java bindings for librhash.
 * Librhash is a library for computing and verifying hash sums.
 * List of all supported hash functions can be found in
 * {@link org.sf.rhash.HashType} class description.
 * <p>
 * In its simplest usage to calculate a hash for message or file
 * you just need to use one of <code>RHash.computeHash()</code>
 * methods:
 * <pre>
 *     RHash.computeHash("Hello, world!");
 *     RHash.computeHash(new byte[] { 0, 1, 2, 3});
 *     RHash.computeHash(new File("SomeFile.txt"));</pre>
 * These methods return value of type <code>Digest</code> which is
 * a message digest. To convert <code>Digest</code> in human readable
 * format you might use one of methods
 * {@link org.sf.rhash.Digest#hex() hex()},
 * {@link org.sf.rhash.Digest#base32() base32()},
 * {@link org.sf.rhash.Digest#base64() base64()} or
 * {@link org.sf.rhash.Digest#raw() raw()}.
 * </p><p>
 * Next, <code>RHash</code> allows you to do incremental hashing,
 * processing data given in portions like it was one big byte sequence.
 * To do this you first need to create <code>RHash</code> instance
 * with a set of needed hash algorithms and then to fill it using
 * <code>update()</code>:
 * <pre>
 *     RHash hasher = new RHash(HashType.MD5);
 *     hasher.update("Foo").update(new File("Bar.zip")).finish();
 *     Digest result = hasher.getDigest();</pre>
 * Method <code>finish()</code> should be called before obtaining
 * digest to end all calculations and generate result.
 * </p><p>
 * You can setup <code>RHash</code> to calculate several digests
 * at once, passing corresponding <code>HashType</code>s in
 * constructor. Specifically, you can calculate all of them creating
 * <code>RHash</code> like
 * <pre>
 *     new Rhash(EnumSet.allOf(HashType.class));</pre>
 * In this case to obtain digest for particular hash type use
 * {@link org.sf.rhash.RHash#getDigest(HashType) }
 * method.
 * </p>
 */
package org.sf.rhash;

import java.io.File;
import java.io.IOException;
import java.io.PrintStream;
import java.util.EnumSet;

import org.sf.rhash.*;
import static org.sf.rhash.HashType.*;

import org.junit.Test;
import junit.framework.JUnit4TestAdapter;
import static junit.framework.TestCase.*;

public class RHashTest {

	@Test
	public void testAllHashes() {
		RHash r = new RHash(EnumSet.allOf(HashType.class));
		r.update("a").finish();
		
		assertEquals("e8b7be43", r.getDigest(CRC32).toString());
		assertEquals("bde52cb31de33e46245e05fbdbd6fb24", r.getDigest(MD4).toString());
		assertEquals("0cc175b9c0f1b6a831c399e269772661", r.getDigest(MD5).toString());
		assertEquals("86f7e437faa5a7fce15d1ddcb9eaeaea377667b8", r.getDigest(SHA1).toString());
		assertEquals("77befbef2e7ef8ab2ec8f93bf587a7fc613e247f5f247809", r.getDigest(TIGER).toString());
		assertEquals("czquwh3iyxbf5l3bgyugzhassmxu647ip2ike4y", r.getDigest(TTH).toString());
		assertEquals(40, r.getDigest(BTIH).toString().length());
		assertEquals("bde52cb31de33e46245e05fbdbd6fb24", r.getDigest(ED2K).toString());
		assertEquals("q336in72uwt7zyk5dxolt2xk5i3xmz5y", r.getDigest(AICH).toString());
		assertEquals("8aca2602792aec6f11a67206531fb7d7f0dff59413145e6973c45001d0087b42d11bc645413aeff63a42391a39145a591a92200d560195e53b478584fdae231a", r.getDigest(WHIRLPOOL).toString());
		assertEquals("0bdc9d2d256b3ee9daae347be6f4dc835a467ffe", r.getDigest(RIPEMD160).toString());
		assertEquals("d42c539e367c66e9c88a801f6649349c21871b4344c6a573f849fdce62f314dd", r.getDigest(GOST).toString());
		assertEquals("e74c52dd282183bf37af0079c9f78055715a103f17e3133ceff1aacf2f403011", r.getDigest(GOST_CRYPTOPRO).toString());
		assertEquals("4872bcbc4cd0f0a9dc7c2f7045e5b43b6c830db8", r.getDigest(HAS160).toString());
		assertEquals("bf5ce540ae51bc50399f96746c5a15bd", r.getDigest(SNEFRU128).toString());
		assertEquals("45161589ac317be0ceba70db2573ddda6e668a31984b39bf65e4b664b584c63d", r.getDigest(SNEFRU256).toString());
		assertEquals("abd37534c7d9a2efb9465de931cd7055ffdb8879563ae98078d6d6d5", r.getDigest(SHA224).toString());
		assertEquals("ca978112ca1bbdcafac231b39a23dc4da786eff8147c4e72b9807785afee48bb", r.getDigest(SHA256).toString());
		assertEquals("54a59b9f22b0b80880d8427e548b7c23abd873486e1f035dce9cd697e85175033caa88e6d57bc35efae0b5afd3145f31", r.getDigest(SHA384).toString());
		assertEquals("1f40fc92da241694750979ee6cf582f2d5d7d28e18335de05abc54d0560e0f5302860c652bf08d560252aa5e74210546f369fbbbce8c12cfc7957b2652fe9a75", r.getDigest(SHA512).toString());
		assertEquals("943aa9225a2cf154ec2e4dd81237720ba538ca8df2fd83c0b893c5d265f353a0", r.getDigest(EDONR256).toString());
		assertEquals("b59ec44f7beef8a04ceed38a973d77c65e22e9458d5f67b497948da34986c093b5efc5483fbee55f2f740fcad31f18d80db44bb6b8843e7fd599188e7c07233b", r.getDigest(EDONR512).toString());
		assertEquals("9e86ff69557ca95f405f081269685b38e3a819b309ee942f482b6a8b", r.getDigest(SHA3_224).toString());
		assertEquals("80084bf2fba02475726feb2cab2d8215eab14bc6bdd8bfb2c8151257032ecd8b", r.getDigest(SHA3_256).toString());
		assertEquals("1815f774f320491b48569efec794d249eeb59aae46d22bf77dafe25c5edc28d7ea44f93ee1234aa88f61c91912a4ccd9", r.getDigest(SHA3_384).toString());
		assertEquals("697f2d856172cb8309d6b8b97dac4de344b549d4dee61edfb4962d8698b7fa803f4f93ff24393586e28b5b957ac3d1d369420ce53332712f997bd336d09ab02a", r.getDigest(SHA3_512).toString());

		r.reset();
		r.finish();
		assertEquals("d41d8cd98f00b204e9800998ecf8427e", r.getDigest(MD5).toString()); // MD5 of ""
	}

	@Test
	public void testMagnet() {
		RHash r = new RHash(MD5, TTH);
		r.update("abc").finish();
		assertEquals("magnet:?xl=3&dn=file.txt&xt=urn:md5:900150983cd24fb0d6963f7d28e17f72&xt=urn:tree:tiger:asd4ujseh5m47pdyb46kbtsqtsgdklbhyxomuia", r.getMagnet("file.txt"));
    }

	@Test
	public void testUpdateFile() throws IOException {
		File f = new File("java_test_input_123.txt");
		PrintStream out = new PrintStream(f);
		out.println("\0\1\2");
		out.flush();
		out.close();
		assertEquals("e3869ec477661fad6b9fc25914bb2eee5455b483", RHash.computeHash(SHA1, f).toString());
		f.delete();
    }

	public static junit.framework.Test suite(){
		return new JUnit4TestAdapter(RHashTest.class);
	}
}

bin
RHash.dll
RHash.dll.mdb
RHash.pidb
RHash.tree
RHash.userprefs
RHash.zip
html

/*
 * This file is a part of Mono Bindings for Librhash
 * Copyright (c) 2011-2012, Sergey Basalaev <sbasalaev@gmail.com>
 * Librhash is (c) 2011-2012, Aleksey Kravchenko <rhash.admin@gmail.com>
 * 
 * Permission is hereby granted, free of charge,  to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction,  including without limitation the rights
 * to  use,  copy,  modify,  merge, publish, distribute, sublicense, and/or sell
 * copies  of  the Software,  and  to permit  persons  to whom  the Software  is
 * furnished to do so.
 * 
 * This library  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. Use it at your own risk!
 */

using System.Reflection;
using System.Runtime.CompilerServices;

// Information about this assembly is defined by the following attributes. 
// Change them to the values specific to your project.

[assembly: AssemblyTitle("RHash")]
[assembly: AssemblyDescription(".NET/Mono bindings for librhash")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("")]
[assembly: AssemblyCopyright("(c) 2011, Sergey Basalaev")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")]

// The assembly version has the format "{Major}.{Minor}.{Build}.{Revision}".
// The form "{Major}.{Minor}.*" will automatically update the build and revision,
// and "{Major}.{Minor}.{Build}.*" will update just the revision.

[assembly: AssemblyVersion("1.0.1.1")]

// The following attributes are used to specify the signing key for the assembly, 
// if desired. See the Mono documentation for more information about signing.

[assembly: AssemblyDelaySign(false)]
//[assembly: AssemblyKeyFile("RHash.snk")]

/*
 * This file is a part of Mono Bindings for Librhash
 * Copyright (c) 2011-2012, Sergey Basalaev <sbasalaev@gmail.com>
 * Librhash is (c) 2011-2012, Aleksey Kravchenko <rhash.admin@gmail.com>
 * 
 * Permission is hereby granted, free of charge,  to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction,  including without limitation the rights
 * to  use,  copy,  modify,  merge, publish, distribute, sublicense, and/or sell
 * copies  of  the Software,  and  to permit  persons  to whom  the Software  is
 * furnished to do so.
 * 
 * This library  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. Use it at your own risk!
 */

using System;
using System.Runtime.InteropServices;
using System.Text;

namespace RHash {
	/* Pointer to native structure. */
	sealed class Bindings {
		
		private const string librhash = "librhash.dll";

		private Bindings() { }
		
		static Bindings() {
			rhash_library_init();
		}

		[DllImport (librhash)]
		public static extern
			void rhash_library_init();
		
		[DllImport (librhash)]
		public static extern
			IntPtr rhash_init(uint hash_ids);
		
		[DllImport (librhash)]
		public static extern
			void rhash_update(IntPtr ctx, byte[] message, int length);
		
		//may crash, rhash_final actually have 2 arguments
		[DllImport (librhash)]
		public static extern
			void rhash_final(IntPtr ctx, IntPtr unused);

		[DllImport (librhash)]
		public static extern
			void rhash_reset(IntPtr ctx);
		
		[DllImport (librhash)]
		public static extern
			void rhash_free(IntPtr ctx);
		
		[DllImport (librhash, CharSet=CharSet.Ansi)]
		public static extern
			void rhash_print(StringBuilder output, IntPtr ctx, uint hash_id, int flags);

		[DllImport (librhash)]
		public static extern
			int rhash_print_magnet(StringBuilder output, String filepath, IntPtr ctx, uint hash_mask, int flags);
	}
}

/*
 * This file is a part of Java Bindings for Librhash
 * Copyright (c) 2011-2012, 2014, Sergey Basalaev <sbasalaev@gmail.com>
 * Librhash is (c) 2011-2012, Aleksey Kravchenko <rhash.admin@gmail.com>
 * 
 * Permission is hereby granted, free of charge,  to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction,  including without limitation the rights
 * to  use,  copy,  modify,  merge, publish, distribute, sublicense, and/or sell
 * copies  of  the Software,  and  to permit  persons  to whom  the Software  is
 * furnished to do so.
 * 
 * This library  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. Use it at your own risk!
 */

using System;

namespace RHash {
	
	/*
	 * Type of hashing algorithm.
	 * Supported algorithms are MD4, MD5, SHA1/SHA2, Tiger,
	 * DC++ TTH, BitTorrent BTIH, AICH, EDonkey 2000 hash, GOST R 34.11-94,
	 * RIPEMD-160, HAS-160, EDON-R 256/512, Whirlpool and Snefru-128/256.
	 */
	public enum HashType : uint {
		/* CRC32 checksum. */
		CRC32 = 1,
		/* MD4 hash. */
		MD4 = 1 << 1,
		/* MD5 hash. */
		MD5 = 1 << 2,
		/* SHA-1 hash. */
		SHA1 = 1 << 3,
		/* Tiger hash. */
		TIGER = 1 << 4,
		/* Tiger tree hash */
		TTH = 1 << 5,
		/* BitTorrent info hash. */
		BTIH = 1 << 6,
		/* EDonkey 2000 hash. */
		ED2K = 1 << 7,
		/* eMule AICH. */
		AICH = 1 << 8,
		/* Whirlpool hash. */
		WHIRLPOOL = 1 << 9,
		/* RIPEMD-160 hash. */
		RIPEMD160 = 1 << 10,
		/* GOST R 34.11-94. */
		GOST = 1 << 11,
		GOST_CRYPTOPRO = 1 << 12,
		/* HAS-160 hash. */
		HAS160 = 1 << 13,
		/* Snefru-128 hash. */
		SNEFRU128 = 1 << 14,
		/* Snefru-256 hash. */
		SNEFRU256 = 1 << 15,
		/* SHA-224 hash. */
		SHA224 = 1 << 16,
		/* SHA-256 hash. */
		SHA256 = 1 << 17,
		/* SHA-384 hash. */
		SHA384 = 1 << 18,
		/* SHA-512 hash. */
		SHA512 = 1 << 19,
		/* EDON-R 256. */
		EDONR256 = 1 << 20,
		/* EDON-R 512. */
		EDONR512 = 1 << 21,
		/** SHA3-224 hash. */
		SHA3_224 = 1 << 22,
		/** SHA3-256 hash. */
		SHA3_256 = 1 << 23,
		/** SHA3-384 hash. */
		SHA3_384 = 1 << 24,
		/** SHA3-512 hash. */
		SHA3_512 = 1 << 25
	}
}

/*
 * This file is a part of Java Bindings for Librhash
 * Copyright (c) 2011-2012, Sergey Basalaev <sbasalaev@gmail.com>
 * Librhash is (c) 2011-2012, Aleksey Kravchenko <rhash.admin@gmail.com>
 * 
 * Permission is hereby granted, free of charge,  to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction,  including without limitation the rights
 * to  use,  copy,  modify,  merge, publish, distribute, sublicense, and/or sell
 * copies  of  the Software,  and  to permit  persons  to whom  the Software  is
 * furnished to do so.
 * 
 * This library  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. Use it at your own risk!
 */

using System;
using System.IO;
using System.Text;

namespace RHash {
		
	public sealed class Hasher {

		private const int DEFAULT   = 0x0;
		/* output as binary message digest */
		private const int RAW       = 0x1;
		/* print as a hexadecimal string */
		private const int HEX       = 0x2;
		/* print as a base32-encoded string */
		private const int BASE32    = 0x3;
		/* print as a base64-encoded string */
		private const int BASE64    = 0x4;
		/* Print as an uppercase string. */
		private const int UPPERCASE = 0x8;
		/* Reverse hash bytes. */
		private const int REVERSE   = 0x10;
		/* Print file size. */
		private const int FILESIZE  = 0x40;
		
		private uint hash_ids;
		/* Pointer to the native structure. */
		private IntPtr ptr;
		
		public Hasher (HashType hashtype) {
			this.hash_ids = (uint)hashtype;
			this.ptr = Bindings.rhash_init(hash_ids);
		}
		
		public Hasher (uint hashmask) {
			this.hash_ids = hashmask;
			this.ptr = Bindings.rhash_init(hash_ids);
			if (ptr == IntPtr.Zero) throw new ArgumentException("Invalid mask of hashes", "hashmask");
		}
		
		~Hasher() {
			if (ptr != IntPtr.Zero) {
				Bindings.rhash_free(ptr);
				ptr = IntPtr.Zero;
			}
		}
		
		public Hasher Update(byte[] buf) {
			Bindings.rhash_update(ptr, buf, buf.Length);
			return this;
		}

		public Hasher Update(byte[] buf, int len) {
			if (len < 0 || len >= buf.Length) {
				throw new IndexOutOfRangeException();
			}
			Bindings.rhash_update(ptr, buf, len);
			return this;
		}
		
		public Hasher UpdateFile(string filename) {
			Stream file = new FileStream(filename, FileMode.Open);
			byte[] buf = new byte[8192];
			int len = file.Read(buf, 0, 8192);
			while (len > 0) {
				Bindings.rhash_update(ptr, buf, len);
				len = file.Read(buf, 0, 8192);
			}
			file.Close();
			return this;
		}
		
		public void Finish() {
			Bindings.rhash_final(ptr, IntPtr.Zero);
		}
		
		public void Reset() {
			Bindings.rhash_reset(ptr);
		}
		
		public override string ToString() {
			StringBuilder sb = new StringBuilder(130);
			Bindings.rhash_print(sb, ptr, 0, 0);
			return sb.ToString();
		}
		
		public string ToString(HashType type) {
			if ((hash_ids & (uint)type) == 0) {
				throw new ArgumentException("This hasher does not support hash type "+type, "type");
			}
			StringBuilder sb = new StringBuilder(130);
			Bindings.rhash_print(sb, ptr, (uint)type, 0);
			return sb.ToString();
		}
		
		public string ToHex(HashType type) {
			if ((hash_ids & (uint)type) == 0) {
				throw new ArgumentException("This hasher does not support hash type "+type, "type");
			}
			StringBuilder sb = new StringBuilder(130);
			Bindings.rhash_print(sb, ptr, (uint)type, HEX);
			return sb.ToString();
		}

		public string ToBase32(HashType type) {
			if ((hash_ids & (uint)type) == 0) {
				throw new ArgumentException("This hasher does not support hash type "+type, "type");
			}
			StringBuilder sb = new StringBuilder(130);
			Bindings.rhash_print(sb, ptr, (uint)type, BASE32);
			return sb.ToString();
		}

		public string ToBase64(HashType type) {
			if ((hash_ids & (uint)type) == 0) {
				throw new ArgumentException("This hasher does not support hash type "+type, "type");
			}
			StringBuilder sb = new StringBuilder(130);
			Bindings.rhash_print(sb, ptr, (uint)type, BASE32);
			return sb.ToString();
		}

		public string ToRaw(HashType type) {
			if ((hash_ids & (uint)type) == 0) {
				throw new ArgumentException("This hasher does not support hash type "+type, "type");
			}
			StringBuilder sb = new StringBuilder(130);
			Bindings.rhash_print(sb, ptr, (uint)type, RAW);
			return sb.ToString();
		}

		public string GetMagnet(string filepath) {
			return GetMagnet(filepath, hash_ids);
		}

		public string GetMagnet(string filepath, uint hashmask) {
			int len = Bindings.rhash_print_magnet(null, filepath, ptr, hashmask, FILESIZE);
			StringBuilder sb = new StringBuilder(len);
			Bindings.rhash_print_magnet(sb, filepath, ptr, hashmask, FILESIZE);
			return sb.ToString();
		}
		
		public static string GetHashForMsg(byte[] buf, HashType type) {
			return new Hasher(type).Update(buf).ToString(type);
		}
		
		public static string GetHashForFile(string filename, HashType type) {
			return new Hasher(type).UpdateFile(filename).ToString(type);
		}
		
		public static string GetMagnetFor(string filepath, uint hashmask) {
			return new Hasher(hashmask).UpdateFile(filepath).GetMagnet(filepath);
		}
	}
}

#!/usr/bin/make -f

# This file is a part of Mono Bindings for Librhash
# Copyright (c) 2011-2012, Sergey Basalaev <sbasalaev@gmail.com>
# Librhash is (c) 2011-2012, Aleksey Kravchenko <rhash.admin@gmail.com>
# 
# Permission is hereby granted, free of charge,  to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction,  including without limitation the rights
# to  use,  copy,  modify,  merge, publish, distribute, sublicense, and/or sell
# copies  of  the Software,  and  to permit  persons  to whom  the Software  is
# furnished to do so.
# 
# This library  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. Use it at your own risk!

CS?=mcs
MDOC?=mdoc
SOURCES=AssemblyInfo.cs Bindings.cs Hasher.cs HashType.cs

all: assembly assemble-doc html

assembly: RHash.dll RHash.dll.mdb

RHash.dll RHash.dll.mdb: $(SOURCES)
	$(CS) -target:library -out:RHash.dll -debug -keyfile:RHash.snk $(SOURCES)

update-doc: RHash.dll
	$(MDOC) update RHash.dll -o doc

assemble-doc: RHash.tree RHash.zip

RHash.tree RHash.zip:
	$(MDOC) assemble -o RHash doc

html:
	$(MDOC) export-html -o html doc

test: RHash.dll
	+$(MAKE) -C test

clean:
	rm -f RHash.dll RHash.dll.mdb
	rm -f RHash.tree RHash.zip
	rm -rf html
	+$(MAKE) -C test clean

.PHONY : clean html test

<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <PropertyGroup>
    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
    <ProductVersion>10.0.0</ProductVersion>
    <SchemaVersion>2.0</SchemaVersion>
    <ProjectGuid>{2EC1635A-308E-46E4-B016-017C2AF3CDD9}</ProjectGuid>
    <OutputType>Library</OutputType>
    <RootNamespace>RHash</RootNamespace>
    <AssemblyName>RHash</AssemblyName>
    <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
    <Description>.NET/Mono bindings for librhash</Description>
    <ReleaseVersion>1.0</ReleaseVersion>
  </PropertyGroup>
  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
    <DebugSymbols>true</DebugSymbols>
    <DebugType>full</DebugType>
    <Optimize>false</Optimize>
    <OutputPath>bin\Debug</OutputPath>
    <DefineConstants>DEBUG</DefineConstants>
    <ErrorReport>prompt</ErrorReport>
    <WarningLevel>4</WarningLevel>
    <ConsolePause>false</ConsolePause>
  </PropertyGroup>
  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
    <DebugType>none</DebugType>
    <Optimize>false</Optimize>
    <OutputPath>bin\Release</OutputPath>
    <ErrorReport>prompt</ErrorReport>
    <WarningLevel>4</WarningLevel>
    <ConsolePause>false</ConsolePause>
  </PropertyGroup>
  <ItemGroup>
    <Reference Include="System" />
  </ItemGroup>
  <ItemGroup>
    <Compile Include="AssemblyInfo.cs" />
    <Compile Include="HashType.cs" />
    <Compile Include="Bindings.cs" />
    <Compile Include="Hasher.cs" />
  </ItemGroup>
  <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
</Project>

<configuration>
        <dllmap dll="librhash.dll" os="!windows" target="librhash.so.0" />
        <dllmap dll="librhash.dll" os="osx" target="librhash.0.dylib" />
</configuration>

Microsoft Visual Studio Solution File, Format Version 11.00
# Visual Studio 2010
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "RHash", "RHash.csproj", "{2EC1635A-308E-46E4-B016-017C2AF3CDD9}"
EndProject
Global
	GlobalSection(SolutionConfigurationPlatforms) = preSolution
		Debug|Any CPU = Debug|Any CPU
		Release|Any CPU = Release|Any CPU
	EndGlobalSection
	GlobalSection(ProjectConfigurationPlatforms) = postSolution
		{2EC1635A-308E-46E4-B016-017C2AF3CDD9}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{2EC1635A-308E-46E4-B016-017C2AF3CDD9}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{2EC1635A-308E-46E4-B016-017C2AF3CDD9}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{2EC1635A-308E-46E4-B016-017C2AF3CDD9}.Release|Any CPU.Build.0 = Release|Any CPU
	EndGlobalSection
	GlobalSection(MonoDevelopProperties) = preSolution
		StartupItem = RHash.csproj
		Policies = $0
		$0.DotNetNamingPolicy = $1
		$1.DirectoryNamespaceAssociation = None
		$1.ResourceNamePolicy = FileFormatDefault
		$0.StandardHeader = $2
		$2.Text = 
		$2.IncludeInNewFiles = True
		description = .NET/Mono bindings for librhash
		version = 1.0
	EndGlobalSection
EndGlobal

<Type Name="HashType" FullName="RHash.HashType">
  <TypeSignature Language="C#" Value="public enum HashType" />
  <TypeSignature Language="ILAsm" Value=".class public auto ansi sealed HashType extends System.Enum" />
  <AssemblyInfo>
    <AssemblyName>RHash</AssemblyName>
    <AssemblyVersion>1.0.1.1</AssemblyVersion>
  </AssemblyInfo>
  <Base>
    <BaseTypeName>System.Enum</BaseTypeName>
  </Base>
  <Docs>
    <summary>Type of hashing algorithm.</summary>
    <remarks>
      <para>
Supported algorithms are MD4, MD5, SHA1/SHA2, Tiger,
DC++ TTH, BitTorrent BTIH, AICH, EDonkey 2000 hash, GOST R 34.11-94,
RIPEMD-160, HAS-160, EDON-R 256/512, Whirlpool and Snefru-128/256.
</para>
      <para>
Constants may be OR-combined to form <see cref="T:System.UInt32" /> mask of hashes.
</para>
    </remarks>
  </Docs>
  <Members>
    <Member MemberName="AICH">
      <MemberSignature Language="C#" Value="AICH" />
      <MemberSignature Language="ILAsm" Value=".field public static literal valuetype RHash.HashType AICH = unsigned int32(256)" />
      <MemberType>Field</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>1.0.1.1</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>RHash.HashType</ReturnType>
      </ReturnValue>
      <Docs>
        <summary>eMule AICH.</summary>
      </Docs>
    </Member>
    <Member MemberName="BTIH">
      <MemberSignature Language="C#" Value="BTIH" />
      <MemberSignature Language="ILAsm" Value=".field public static literal valuetype RHash.HashType BTIH = unsigned int32(64)" />
      <MemberType>Field</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>1.0.1.1</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>RHash.HashType</ReturnType>
      </ReturnValue>
      <Docs>
        <summary>BitTorrent info hash.</summary>
      </Docs>
    </Member>
    <Member MemberName="CRC32">
      <MemberSignature Language="C#" Value="CRC32" />
      <MemberSignature Language="ILAsm" Value=".field public static literal valuetype RHash.HashType CRC32 = unsigned int32(1)" />
      <MemberType>Field</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>1.0.1.1</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>RHash.HashType</ReturnType>
      </ReturnValue>
      <Docs>
        <summary>CRC32 checksum.</summary>
      </Docs>
    </Member>
    <Member MemberName="ED2K">
      <MemberSignature Language="C#" Value="ED2K" />
      <MemberSignature Language="ILAsm" Value=".field public static literal valuetype RHash.HashType ED2K = unsigned int32(128)" />
      <MemberType>Field</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>1.0.1.1</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>RHash.HashType</ReturnType>
      </ReturnValue>
      <Docs>
        <summary>EDonkey 2000 hash.</summary>
      </Docs>
    </Member>
    <Member MemberName="EDONR256">
      <MemberSignature Language="C#" Value="EDONR256" />
      <MemberSignature Language="ILAsm" Value=".field public static literal valuetype RHash.HashType EDONR256 = unsigned int32(1048576)" />
      <MemberType>Field</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>1.0.1.1</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>RHash.HashType</ReturnType>
      </ReturnValue>
      <Docs>
        <summary>EDON-R 256.</summary>
      </Docs>
    </Member>
    <Member MemberName="EDONR512">
      <MemberSignature Language="C#" Value="EDONR512" />
      <MemberSignature Language="ILAsm" Value=".field public static literal valuetype RHash.HashType EDONR512 = unsigned int32(2097152)" />
      <MemberType>Field</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>1.0.1.1</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>RHash.HashType</ReturnType>
      </ReturnValue>
      <Docs>
        <summary>EDON-R 512.</summary>
      </Docs>
    </Member>
    <Member MemberName="GOST">
      <MemberSignature Language="C#" Value="GOST" />
      <MemberSignature Language="ILAsm" Value=".field public static literal valuetype RHash.HashType GOST = unsigned int32(2048)" />
      <MemberType>Field</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>1.0.1.1</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>RHash.HashType</ReturnType>
      </ReturnValue>
      <Docs>
        <summary>GOST R 34.11-94.</summary>
      </Docs>
    </Member>
    <Member MemberName="GOST_CRYPTOPRO">
      <MemberSignature Language="C#" Value="GOST_CRYPTOPRO" />
      <MemberSignature Language="ILAsm" Value=".field public static literal valuetype RHash.HashType GOST_CRYPTOPRO = unsigned int32(4096)" />
      <MemberType>Field</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>1.0.1.1</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>RHash.HashType</ReturnType>
      </ReturnValue>
      <Docs>
        <summary>GOST R 34.11-94, CryptoPro version.</summary>
      </Docs>
    </Member>
    <Member MemberName="HAS160">
      <MemberSignature Language="C#" Value="HAS160" />
      <MemberSignature Language="ILAsm" Value=".field public static literal valuetype RHash.HashType HAS160 = unsigned int32(8192)" />
      <MemberType>Field</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>1.0.1.1</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>RHash.HashType</ReturnType>
      </ReturnValue>
      <Docs>
        <summary>HAS-160 hash.</summary>
      </Docs>
    </Member>
    <Member MemberName="MD4">
      <MemberSignature Language="C#" Value="MD4" />
      <MemberSignature Language="ILAsm" Value=".field public static literal valuetype RHash.HashType MD4 = unsigned int32(2)" />
      <MemberType>Field</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>1.0.1.1</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>RHash.HashType</ReturnType>
      </ReturnValue>
      <Docs>
        <summary>MD4 hash.</summary>
      </Docs>
    </Member>
    <Member MemberName="MD5">
      <MemberSignature Language="C#" Value="MD5" />
      <MemberSignature Language="ILAsm" Value=".field public static literal valuetype RHash.HashType MD5 = unsigned int32(4)" />
      <MemberType>Field</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>1.0.1.1</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>RHash.HashType</ReturnType>
      </ReturnValue>
      <Docs>
        <summary>MD5 hash.</summary>
      </Docs>
    </Member>
    <Member MemberName="RIPEMD160">
      <MemberSignature Language="C#" Value="RIPEMD160" />
      <MemberSignature Language="ILAsm" Value=".field public static literal valuetype RHash.HashType RIPEMD160 = unsigned int32(1024)" />
      <MemberType>Field</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>1.0.1.1</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>RHash.HashType</ReturnType>
      </ReturnValue>
      <Docs>
        <summary>RIPEMD-160 hash.</summary>
      </Docs>
    </Member>
    <Member MemberName="SHA1">
      <MemberSignature Language="C#" Value="SHA1" />
      <MemberSignature Language="ILAsm" Value=".field public static literal valuetype RHash.HashType SHA1 = unsigned int32(8)" />
      <MemberType>Field</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>1.0.1.1</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>RHash.HashType</ReturnType>
      </ReturnValue>
      <Docs>
        <summary>SHA-1 hash.</summary>
      </Docs>
    </Member>
    <Member MemberName="SHA224">
      <MemberSignature Language="C#" Value="SHA224" />
      <MemberSignature Language="ILAsm" Value=".field public static literal valuetype RHash.HashType SHA224 = unsigned int32(65536)" />
      <MemberType>Field</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>1.0.1.1</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>RHash.HashType</ReturnType>
      </ReturnValue>
      <Docs>
        <summary>SHA-224 hash.</summary>
      </Docs>
    </Member>
    <Member MemberName="SHA256">
      <MemberSignature Language="C#" Value="SHA256" />
      <MemberSignature Language="ILAsm" Value=".field public static literal valuetype RHash.HashType SHA256 = unsigned int32(131072)" />
      <MemberType>Field</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>1.0.1.1</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>RHash.HashType</ReturnType>
      </ReturnValue>
      <Docs>
        <summary>SHA-256 hash.</summary>
      </Docs>
    </Member>
    <Member MemberName="SHA3_224">
      <MemberSignature Language="C#" Value="SHA3_224" />
      <MemberSignature Language="ILAsm" Value=".field public static literal valuetype RHash.HashType SHA3_224 = unsigned int32(4194304)" />
      <MemberType>Field</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>1.0.1.1</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>RHash.HashType</ReturnType>
      </ReturnValue>
      <Docs>
        <summary>SHA3-224 hash.</summary>
      </Docs>
    </Member>
    <Member MemberName="SHA3_256">
      <MemberSignature Language="C#" Value="SHA3_256" />
      <MemberSignature Language="ILAsm" Value=".field public static literal valuetype RHash.HashType SHA3_256 = unsigned int32(8388608)" />
      <MemberType>Field</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>1.0.1.1</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>RHash.HashType</ReturnType>
      </ReturnValue>
      <Docs>
        <summary>SHA3-256 hash.</summary>
      </Docs>
    </Member>
    <Member MemberName="SHA3_384">
      <MemberSignature Language="C#" Value="SHA3_384" />
      <MemberSignature Language="ILAsm" Value=".field public static literal valuetype RHash.HashType SHA3_384 = unsigned int32(16777216)" />
      <MemberType>Field</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>1.0.1.1</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>RHash.HashType</ReturnType>
      </ReturnValue>
      <Docs>
        <summary>SHA3-384 hash.</summary>
      </Docs>
    </Member>
    <Member MemberName="SHA3_512">
      <MemberSignature Language="C#" Value="SHA3_512" />
      <MemberSignature Language="ILAsm" Value=".field public static literal valuetype RHash.HashType SHA3_512 = unsigned int32(33554432)" />
      <MemberType>Field</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>1.0.1.1</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>RHash.HashType</ReturnType>
      </ReturnValue>
      <Docs>
        <summary>SHA3-512 hash.</summary>
      </Docs>
    </Member>
    <Member MemberName="SHA384">
      <MemberSignature Language="C#" Value="SHA384" />
      <MemberSignature Language="ILAsm" Value=".field public static literal valuetype RHash.HashType SHA384 = unsigned int32(262144)" />
      <MemberType>Field</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>1.0.1.1</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>RHash.HashType</ReturnType>
      </ReturnValue>
      <Docs>
        <summary>SHA-384 hash.</summary>
      </Docs>
    </Member>
    <Member MemberName="SHA512">
      <MemberSignature Language="C#" Value="SHA512" />
      <MemberSignature Language="ILAsm" Value=".field public static literal valuetype RHash.HashType SHA512 = unsigned int32(524288)" />
      <MemberType>Field</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>1.0.1.1</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>RHash.HashType</ReturnType>
      </ReturnValue>
      <Docs>
        <summary>SHA-512 hash.</summary>
      </Docs>
    </Member>
    <Member MemberName="SNEFRU128">
      <MemberSignature Language="C#" Value="SNEFRU128" />
      <MemberSignature Language="ILAsm" Value=".field public static literal valuetype RHash.HashType SNEFRU128 = unsigned int32(16384)" />
      <MemberType>Field</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>1.0.1.1</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>RHash.HashType</ReturnType>
      </ReturnValue>
      <Docs>
        <summary>Snefru-128 hash.</summary>
      </Docs>
    </Member>
    <Member MemberName="SNEFRU256">
      <MemberSignature Language="C#" Value="SNEFRU256" />
      <MemberSignature Language="ILAsm" Value=".field public static literal valuetype RHash.HashType SNEFRU256 = unsigned int32(32768)" />
      <MemberType>Field</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>1.0.1.1</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>RHash.HashType</ReturnType>
      </ReturnValue>
      <Docs>
        <summary>Snefru-256 hash.</summary>
      </Docs>
    </Member>
    <Member MemberName="TIGER">
      <MemberSignature Language="C#" Value="TIGER" />
      <MemberSignature Language="ILAsm" Value=".field public static literal valuetype RHash.HashType TIGER = unsigned int32(16)" />
      <MemberType>Field</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>1.0.1.1</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>RHash.HashType</ReturnType>
      </ReturnValue>
      <Docs>
        <summary>Tiger hash.</summary>
      </Docs>
    </Member>
    <Member MemberName="TTH">
      <MemberSignature Language="C#" Value="TTH" />
      <MemberSignature Language="ILAsm" Value=".field public static literal valuetype RHash.HashType TTH = unsigned int32(32)" />
      <MemberType>Field</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>1.0.1.1</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>RHash.HashType</ReturnType>
      </ReturnValue>
      <Docs>
        <summary>Tiger tree hash.</summary>
      </Docs>
    </Member>
    <Member MemberName="WHIRLPOOL">
      <MemberSignature Language="C#" Value="WHIRLPOOL" />
      <MemberSignature Language="ILAsm" Value=".field public static literal valuetype RHash.HashType WHIRLPOOL = unsigned int32(512)" />
      <MemberType>Field</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>1.0.1.1</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>RHash.HashType</ReturnType>
      </ReturnValue>
      <Docs>
        <summary>Whirlpool hash.</summary>
      </Docs>
    </Member>
  </Members>
</Type>

<Type Name="Hasher" FullName="RHash.Hasher">
  <TypeSignature Language="C#" Value="public sealed class Hasher" />
  <TypeSignature Language="ILAsm" Value=".class public auto ansi sealed beforefieldinit Hasher extends System.Object" />
  <AssemblyInfo>
    <AssemblyName>RHash</AssemblyName>
    <AssemblyVersion>1.0.1.1</AssemblyVersion>
  </AssemblyInfo>
  <Base>
    <BaseTypeName>System.Object</BaseTypeName>
  </Base>
  <Interfaces />
  <Docs>
    <summary>Incremental hasher.</summary>
    <remarks>This class allows you to do incremental hashing for set of hashing algorithms.</remarks>
  </Docs>
  <Members>
    <Member MemberName=".ctor">
      <MemberSignature Language="C#" Value="public Hasher (RHash.HashType hashtype);" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig specialname rtspecialname instance void .ctor(valuetype RHash.HashType hashtype) cil managed" />
      <MemberType>Constructor</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>1.0.1.1</AssemblyVersion>
      </AssemblyInfo>
      <Parameters>
        <Parameter Name="hashtype" Type="RHash.HashType" />
      </Parameters>
      <Docs>
        <param name="hashtype">Type of hashing algorithm.</param>
        <summary>Creates new Hasher to compute message digest for given type.</summary>
        <remarks>To be added.</remarks>
      </Docs>
    </Member>
    <Member MemberName=".ctor">
      <MemberSignature Language="C#" Value="public Hasher (uint hashmask);" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig specialname rtspecialname instance void .ctor(unsigned int32 hashmask) cil managed" />
      <MemberType>Constructor</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>1.0.1.1</AssemblyVersion>
      </AssemblyInfo>
      <Parameters>
        <Parameter Name="hashmask" Type="System.UInt32" />
      </Parameters>
      <Docs>
        <param name="hashmask">Mask created of one or more <see cref="T:RHash.HashType" /> values.</param>
        <summary>Creates new Hasher to compute message digests for given set of hashing algorithms.</summary>
        <remarks>Mask should be created from ORed HashType values. The next example will create Hasher that computes both CRC32 and MD5 sums:

<example><code lang="C#">
  new Hasher((uint)HashType.CRC32 | (uint)HashType.MD5);</code></example></remarks>
        <exception cref="T:System.ArgumentException">Argument is zero or contains invalid bits.</exception>
      </Docs>
    </Member>
    <Member MemberName="Finalize">
      <MemberSignature Language="C#" Value="~Hasher ();" />
      <MemberSignature Language="ILAsm" Value=".method familyhidebysig virtual instance void Finalize() cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>1.0.1.1</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Void</ReturnType>
      </ReturnValue>
      <Parameters />
      <Docs>
        <summary>Called by garbage collector to free native resources.</summary>
        <remarks>To be added.</remarks>
      </Docs>
    </Member>
    <Member MemberName="Finish">
      <MemberSignature Language="C#" Value="public void Finish ();" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig instance void Finish() cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>1.0.1.1</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Void</ReturnType>
      </ReturnValue>
      <Parameters />
      <Docs>
        <summary>Finishes calculation of hashes.</summary>
        <remarks>Processes any buffered data and finishes computation of hash sums.</remarks>
      </Docs>
    </Member>
    <Member MemberName="GetHashForFile">
      <MemberSignature Language="C#" Value="public static string GetHashForFile (string filename, RHash.HashType type);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig string GetHashForFile(string filename, valuetype RHash.HashType type) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>1.0.1.1</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.String</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="filename" Type="System.String" />
        <Parameter Name="type" Type="RHash.HashType" />
      </Parameters>
      <Docs>
        <param name="filename">File to compute hash for.</param>
        <param name="type">Type of hash to compute.</param>
        <summary>Computes message digest for given file.</summary>
        <returns>Message digest as returned by <see cref="M:RHash.Hasher.ToString(RHash.HashType)" />.</returns>
        <remarks>To be added.</remarks>
      </Docs>
    </Member>
    <Member MemberName="GetHashForMsg">
      <MemberSignature Language="C#" Value="public static string GetHashForMsg (byte[] buf, RHash.HashType type);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig string GetHashForMsg(unsigned int8[] buf, valuetype RHash.HashType type) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>1.0.1.1</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.String</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="buf" Type="System.Byte[]" />
        <Parameter Name="type" Type="RHash.HashType" />
      </Parameters>
      <Docs>
        <param name="buf">Binary message to compute hash for.</param>
        <param name="type">Type of hash to compute.</param>
        <summary>Computes message digest for given binary message.</summary>
        <returns>Message digest, as returned by <see cref="M:RHash.Hasher.ToString(RHash.HashType)" />.</returns>
        <remarks>To be added.</remarks>
      </Docs>
    </Member>
    <Member MemberName="GetMagnet">
      <MemberSignature Language="C#" Value="public string GetMagnet (string filepath);" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig instance string GetMagnet(string filepath) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>1.0.1.1</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.String</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="filepath" Type="System.String" />
      </Parameters>
      <Docs>
        <param name="filepath">File path to be included in magnet. May be null.</param>
        <summary>Generates magnet link with given filename.</summary>
        <returns>Magnet link.</returns>
        <remarks>Magnet includes all hashes computed by this hasher. If filepath is null then returned magnet does not contain a filename.</remarks>
      </Docs>
    </Member>
    <Member MemberName="GetMagnet">
      <MemberSignature Language="C#" Value="public string GetMagnet (string filepath, uint hashmask);" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig instance string GetMagnet(string filepath, unsigned int32 hashmask) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>1.0.1.1</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.String</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="filepath" Type="System.String" />
        <Parameter Name="hashmask" Type="System.UInt32" />
      </Parameters>
      <Docs>
        <param name="filepath">File path to be included in magnet. May be null.</param>
        <param name="hashmask">Mask created from one or more <see cref="T:RHash.HashType" /> values.</param>
        <summary>Generates magnet link with given filename and hashes.</summary>
        <returns>Magnet link.</returns>
        <remarks>Only hashes that were computed by this Hasher are included in the output. If filepath is null then returned magnet does not contain a filename.</remarks>
      </Docs>
    </Member>
    <Member MemberName="GetMagnetFor">
      <MemberSignature Language="C#" Value="public static string GetMagnetFor (string filepath, uint hashmask);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig string GetMagnetFor(string filepath, unsigned int32 hashmask) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>1.0.1.1</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.String</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="filepath" Type="System.String" />
        <Parameter Name="hashmask" Type="System.UInt32" />
      </Parameters>
      <Docs>
        <param name="filepath">File to process.</param>
        <param name="hashmask">Mask created of one or more <see cref="T:RHash.HashType" /> values.</param>
        <summary>Generates magnet for specified file with given hashes.</summary>
        <returns>Magnet link.</returns>
        <remarks>Returned magnet includes file name and all computed hashes.</remarks>
      </Docs>
    </Member>
    <Member MemberName="Reset">
      <MemberSignature Language="C#" Value="public void Reset ();" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig instance void Reset() cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>1.0.1.1</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Void</ReturnType>
      </ReturnValue>
      <Parameters />
      <Docs>
        <summary>Resets this Hasher to initial state.</summary>
        <remarks>The Hasher becomes available to process new data chunks.
Note, that this method returns Hasher to the state after creating
the object, NOT the state when hashing continues.
Therefore, all previously calculated hashes are lost
and process starts from the very beginning.</remarks>
      </Docs>
    </Member>
    <Member MemberName="ToBase32">
      <MemberSignature Language="C#" Value="public string ToBase32 (RHash.HashType type);" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig instance string ToBase32(valuetype RHash.HashType type) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>1.0.1.1</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.String</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="type" Type="RHash.HashType" />
      </Parameters>
      <Docs>
        <param name="type">Type of hashing algorithm.</param>
        <summary>Returns value of computed digest as base32 string.</summary>
        <returns>Message digest in form of base32 string.</returns>
        <remarks>To be added.</remarks>
        <exception cref="T:System.ArgumentException">This Hasher does not compute hash of given type.</exception>
      </Docs>
    </Member>
    <Member MemberName="ToBase64">
      <MemberSignature Language="C#" Value="public string ToBase64 (RHash.HashType type);" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig instance string ToBase64(valuetype RHash.HashType type) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>1.0.1.1</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.String</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="type" Type="RHash.HashType" />
      </Parameters>
      <Docs>
        <param name="type">Type of hashing algorithm.</param>
        <summary>Returns value of computed digest as base64 string.</summary>
        <returns>Message digest in form of base64 string.</returns>
        <remarks>To be added.</remarks>
        <exception cref="T:System.ArgumentException">This Hasher does not compute hash of given type.</exception>
      </Docs>
    </Member>
    <Member MemberName="ToHex">
      <MemberSignature Language="C#" Value="public string ToHex (RHash.HashType type);" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig instance string ToHex(valuetype RHash.HashType type) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>1.0.1.1</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.String</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="type" Type="RHash.HashType" />
      </Parameters>
      <Docs>
        <param name="type">Type of hashing algorithm.</param>
        <summary>Returns value of computed digest as hexadecimal string.</summary>
        <returns>Message digest in form of hexadecimal string.</returns>
        <remarks>To be added.</remarks>
        <exception cref="T:System.ArgumentException">This Hasher does not compute hash of given type.</exception>
      </Docs>
    </Member>
    <Member MemberName="ToRaw">
      <MemberSignature Language="C#" Value="public string ToRaw (RHash.HashType type);" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig instance string ToRaw(valuetype RHash.HashType type) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>1.0.1.1</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.String</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="type" Type="RHash.HashType" />
      </Parameters>
      <Docs>
        <param name="type">Type of hashing algorithm.</param>
        <summary>Returns value of computed digest as raw bytes encoded in ANSI string.</summary>
        <returns>Message digest as raw bytes encoded in an ANSI string.</returns>
        <remarks>To be added.</remarks>
        <exception cref="T:System.ArgumentException">This Hasher does not compute hash of given type.</exception>
      </Docs>
    </Member>
    <Member MemberName="ToString">
      <MemberSignature Language="C#" Value="public override string ToString ();" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance string ToString() cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>1.0.1.1</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.String</ReturnType>
      </ReturnValue>
      <Parameters />
      <Docs>
        <summary>Returns value of computed digest as string in default format.</summary>
        <returns>Message digest as string.</returns>
        <remarks>For Hasher created using <see cref="C:RHash.Hasher(RHash.HashType)" /> constructor, this method returns the same string as <see cref="M:RHash.Hasher.ToString(RHash.HashType)" /> method with the hash type used in constructor.</remarks>
      </Docs>
    </Member>
    <Member MemberName="ToString">
      <MemberSignature Language="C#" Value="public string ToString (RHash.HashType type);" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig instance string ToString(valuetype RHash.HashType type) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>1.0.1.1</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.String</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="type" Type="RHash.HashType" />
      </Parameters>
      <Docs>
        <param name="type">Type of hashing algorithm.</param>
        <summary>Returns value of computed digest as string in default format.</summary>
        <returns>Message digest for given hashing algorithm.</returns>
        <remarks>If default output for hashing algorithm is base32 then
returned value is the same as if <see cref="M:RHash.Hasher.ToBase32(RHash.HashType)" /> method was called;
otherwise value is the same as returned by <see cref="M:RHash.Hasher.ToHex(RHash.HashType)" /> method.</remarks>
        <exception cref="T:System.ArgumentException">This Hasher does not compute hash of given type.</exception>
      </Docs>
    </Member>
    <Member MemberName="Update">
      <MemberSignature Language="C#" Value="public RHash.Hasher Update (byte[] buf);" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig instance class RHash.Hasher Update(unsigned int8[] buf) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>1.0.1.1</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>RHash.Hasher</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="buf" Type="System.Byte[]" />
      </Parameters>
      <Docs>
        <param name="buf">Data for hashing.</param>
        <summary>Updates this Hasher with new data chunk.</summary>
        <returns>This hasher.</returns>
        <remarks>To be added.</remarks>
      </Docs>
    </Member>
    <Member MemberName="Update">
      <MemberSignature Language="C#" Value="public RHash.Hasher Update (byte[] buf, int len);" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig instance class RHash.Hasher Update(unsigned int8[] buf, int32 len) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>1.0.1.1</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>RHash.Hasher</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="buf" Type="System.Byte[]" />
        <Parameter Name="len" Type="System.Int32" />
      </Parameters>
      <Docs>
        <param name="buf">Data for hashing.</param>
        <param name="len">Number of bytes in array to hash.</param>
        <summary>Updates this Hasher with new data chunk.</summary>
        <returns>This Hasher.</returns>
        <remarks>To be added.</remarks>
        <exception cref="T:System.IndexOutOfRangeException">Argument len is negative or greater than buffer length.</exception>
      </Docs>
    </Member>
    <Member MemberName="UpdateFile">
      <MemberSignature Language="C#" Value="public RHash.Hasher UpdateFile (string filename);" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig instance class RHash.Hasher UpdateFile(string filename) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>1.0.1.1</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>RHash.Hasher</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="filename" Type="System.String" />
      </Parameters>
      <Docs>
        <param name="filename">Name of the file to process.</param>
        <summary>Updates this Hasher with data from given file.</summary>
        <returns>This Hasher.</returns>
        <remarks>To be added.</remarks>
      </Docs>
    </Member>
  </Members>
</Type>

<Overview>
  <Assemblies>
    <Assembly Name="RHash" Version="1.0.1.1">
      <AssemblyPublicKey>[00 24 00 00 04 80 00 00 94 00 00 00 06 02 00 00 00 24 00 00 52 53 41 31 00 04 00 00 11 00 00 00 2f cc 17 f0 6f bb a5 89 23 fa 26 a6 d9 a2 2a 73 c1 0f 82 84 6c e3 b5 d2 ba a3 82 ef 40 c8 88 8d 16 98 9d 5f a5 ce a5 a8 7c 4e 3d 9f 3a f9 ff 99 a4 d8 c2 51 a8 45 ca a7 df 00 7c 92 07 50 44 60 2a 2f 9c 08 76 6c 4d 61 1a 51 4f 46 44 ff 8f 52 98 25 e8 04 08 35 ee a5 ac 32 b2 eb 4b d6 b0 b0 c5 9b 39 48 0f c7 c9 6e 16 9d b9 33 aa 9e f4 54 21 a2 8d 0a 47 9b fd 15 5f c2 17 b6 09 9f 52 8f ]</AssemblyPublicKey>
      <Attributes>
        <Attribute>
          <AttributeName>System.Reflection.AssemblyCompany("")</AttributeName>
        </Attribute>
        <Attribute>
          <AttributeName>System.Reflection.AssemblyConfiguration("")</AttributeName>
        </Attribute>
        <Attribute>
          <AttributeName>System.Reflection.AssemblyCopyright("(c) 2011, Sergey Basalaev")</AttributeName>
        </Attribute>
        <Attribute>
          <AttributeName>System.Reflection.AssemblyDescription(".NET/Mono bindings for librhash")</AttributeName>
        </Attribute>
        <Attribute>
          <AttributeName>System.Reflection.AssemblyProduct("")</AttributeName>
        </Attribute>
        <Attribute>
          <AttributeName>System.Reflection.AssemblyTitle("RHash")</AttributeName>
        </Attribute>
        <Attribute>
          <AttributeName>System.Reflection.AssemblyTrademark("")</AttributeName>
        </Attribute>
        <Attribute>
          <AttributeName>System.Runtime.CompilerServices.RuntimeCompatibility(WrapNonExceptionThrows=true)</AttributeName>
        </Attribute>
      </Attributes>
    </Assembly>
  </Assemblies>
  <Remarks>To be added.</Remarks>
  <Copyright>(c) 2011, Sergey Basalaev</Copyright>
  <Types>
    <Namespace Name="RHash">
      <Type Name="Hasher" Kind="Class" />
      <Type Name="HashType" Kind="Enumeration" />
    </Namespace>
  </Types>
  <Title>RHash</Title>
</Overview>

<Namespace Name="RHash">
  <Docs>
    <summary>.NET/Mono bindings to librhash.</summary>
    <remarks>
<para>Librhash is a library for computing and verifying hash sums
that supports many hashing algorithms. This module provides
class for incremental hashing that utilizes the library.
Sample usage of it you can see from the following example:
<example><code lang="C#">
  Hasher hasher = new Hasher((uint)HashType.CRC32 | (uint)HashType.MD5);
  hasher.Update(bytebuffer).UpdateFile("SomeFile.txt");
  hasher.Finish();
  Console.WriteLine(hasher.ToHex(HashType.CRC32));
  Console.WriteLine(hasher.ToBase32(HashType.MD5));</code></example>
</para><para>
 In this example <see cref="T:RHash.Hasher" /> object is first
 created for a set of hashing algorithms.
</para><para>
 Next, data for hashing is  given  in  chunks  with  methods
 Update() and UpdateFile(). Finally, call Finish() to end up
 all remaining calculations.
</para><para>
 To receive text represenation of the message digest use one
 of methods ToHex(), ToBase32() and ToBase64(). Binary message
 digest may be obtained with ToRaw(). All of these methods accept
 algorithm  value as argument. It may be omitted if Hasher was
 created to compute hash for only a single hashing algorithm.
</para>
</remarks>
  </Docs>
</Namespace>

12345

#!/usr/bin/make -f

# This file is a part of Mono Bindings for Librhash
# Copyright (c) 2011-2012, Sergey Basalaev <sbasalaev@gmail.com>
# Librhash is (c) 2011-2012, Aleksey Kravchenko <rhash.admin@gmail.com>
# 
# Permission is hereby granted, free of charge,  to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction,  including without limitation the rights
# to  use,  copy,  modify,  merge, publish, distribute, sublicense, and/or sell
# copies  of  the Software,  and  to permit  persons  to whom  the Software  is
# furnished to do so.
# 
# This library  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. Use it at your own risk!

MONO?=mono
CS?=mcs
MONO_PATH?=..

test: Test.exe
	MONO_PATH="$(MONO_PATH)" $(MONO) Test.exe

Test.exe: Test.cs
	$(CS) -r:RHash.dll -lib:.. Test.cs

clean:
	rm -f Test.exe

/*
 * This file is a part of Mono Bindings for Librhash
 * Copyright (c) 2011-2012, Sergey Basalaev <sbasalaev@gmail.com>
 * Librhash is (c) 2011-2012, Aleksey Kravchenko <rhash.admin@gmail.com>
 * 
 * Permission is hereby granted, free of charge,  to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction,  including without limitation the rights
 * to  use,  copy,  modify,  merge, publish, distribute, sublicense, and/or sell
 * copies  of  the Software,  and  to permit  persons  to whom  the Software  is
 * furnished to do so.
 * 
 * This library  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. Use it at your own risk!
 */

using System;
using System.Collections.Generic;
using RHash;

class Test {
	static void Main(string[] args) {
		byte[] testbytes = {(byte)'1', (byte)'2', (byte)'3', (byte)'4', (byte)'5', (byte)'\n'};
	
		Dictionary<HashType,string> hashes = new Dictionary<HashType,string>();
		hashes.Add(HashType.CRC32,     "261dafe6");
		hashes.Add(HashType.MD4,       "b1a45cdad19cb02482323fac9cea9b9f");
		hashes.Add(HashType.MD5,       "d577273ff885c3f84dadb8578bb41399");
		hashes.Add(HashType.SHA1,      "2672275fe0c456fb671e4f417fb2f9892c7573ba");
		hashes.Add(HashType.SHA224,    "ea2fa9708c96b4acb281be31fa98827addc5017305b7a038a3fca413");
		hashes.Add(HashType.SHA256,    "f33ae3bc9a22cd7564990a794789954409977013966fb1a8f43c35776b833a95");
		hashes.Add(HashType.SHA384,    "4e1cbb008acaa65ba788e3f150f7a8689c8fca289a57a65ef65b28f11ba61e59c3f4ddf069ca9521a9ac0e02eade4dae");
		hashes.Add(HashType.SHA512,    "f2dc0119c9dac46f49d3b7d0be1f61adf7619b770ff076fb11a2f61ff3fcba6b68d224588c4983670da31b33b4efabd448e38a2fda508622cc33ff8304ddf49c");
		hashes.Add(HashType.TIGER,     "6a31f8b7b80bab8b45263f56b5f609f93daf47d0a086bda5");
		hashes.Add(HashType.TTH,       "dctamcmte5tqwam5afghps2xpx3yeozwj2odzcq");
		//hashes.Add(HashType.BTIH,      "d4344cf79b89e4732c6241e730ac3f945d7a774c");
		hashes.Add(HashType.AICH,      "ezzcox7ayrlpwzy6j5ax7mxzrewhk452");
		hashes.Add(HashType.ED2K,      "b1a45cdad19cb02482323fac9cea9b9f");
		hashes.Add(HashType.WHIRLPOOL, "0e8ce019c9d5185d2103a4ff015ec92587da9b22e77ad34f2eddbba9705b3602bc6ede67f5b5e4dd225e7762208ea54895b26c39fc550914d6eca9604b724d11");
		hashes.Add(HashType.GOST,      "0aaaf17200323d024437837d6f6f6384a4a108474cff03cd349ac12776713f5f");
		hashes.Add(HashType.GOST_CRYPTOPRO, "2ed45a995ffdd7a2e5d9ab212c91cec5c65448e6a0840749a00f326ccb0c936d");
		hashes.Add(HashType.RIPEMD160, "ead888178685c5d3a0400befba9188e4da3d5144");
		hashes.Add(HashType.HAS160,    "c7589afd23462e76703b1f7a031010eec70180d4");
		hashes.Add(HashType.SNEFRU128, "d559a2b62f6f44111324f85208723707");
		hashes.Add(HashType.SNEFRU256, "1b59927d85a9349a87796620fe2ff401a06a7ba48794498ebab978efc3a68912");
		hashes.Add(HashType.EDONR256,  "c3d2bbfd63f7461a806f756bf4efeb224036331a9c1d867d251e9e480b18e6fb");
		hashes.Add(HashType.EDONR512,  "a040056378fbd1f9a528677defd141c964fab9c429003fecf2eadfc20c8980cf2e083a1b4e74d5369af3cc0537bcf9b386fedf3613c9ee6c44f54f11bcf3feae");
		hashes.Add(HashType.SHA3_224,  "952f55abd73d0efd9656982f65c4dc837a6a129de02464b85d04cb18");
		hashes.Add(HashType.SHA3_256,  "f627c8f9355399ef45e1a6b6e5a9e6a3abcb3e1b6255603357bffa9f2211ba7e");
		hashes.Add(HashType.SHA3_384,  "0529075e85bcdc06da94cbc83c53b7402c5032440210a1a24d9ccca481ddbd6c1309ae0ef23741f13352a4f3382dee51");
		hashes.Add(HashType.SHA3_512,  "fdd7e7b9655f4f0ef89056e864a2d2dce3602404480281c88455e3a98f728aa08b3f116e6b434200a035e0780d9237ca367c976c5506f7c6f367e6b65447d97c");

		Console.WriteLine("\nTests: hashes for message");
		int errcount1 = 0;
		foreach (HashType t in hashes.Keys) {
			string mustbe = hashes[t];
			string got    = Hasher.GetHashForMsg(testbytes, t);
			if (!got.Equals(mustbe)) {
				Console.WriteLine("Test for {0} failed: expected '{1}', got '{2}'\n", t, mustbe, got);
				errcount1++;
			}
		}
		Console.WriteLine("{0} tests / {1} failed\n", hashes.Count, errcount1);

		Console.WriteLine("\nTests: hashes for file");
		int errcount2 = 0;
		foreach (HashType t in hashes.Keys) {
			string mustbe = hashes[t];
			string got    = Hasher.GetHashForFile("12345.txt", t);
			if (!got.Equals(mustbe)) {
				Console.WriteLine("Test for {0} failed: expected '{1}', got '{2}'\n", t, mustbe, got);
				errcount2++;
			}
		}
		Console.WriteLine("{0} tests / {1} failed\n", hashes.Count, errcount2);
		
        Console.WriteLine("\nTests: magnet links");
        int errcount3 = 0;
		{
	        // magnet by static method
    	    string mustbe = "magnet:?xl=6&dn=12345.txt&xt=urn:crc32:261dafe6&xt=urn:md5:d577273ff885c3f84dadb8578bb41399";
        	string got = Hasher.GetMagnetFor("12345.txt", (uint)HashType.CRC32 | (uint)HashType.MD5);
	        if (!got.Equals(mustbe)) {
    	        Console.WriteLine("Magnet by static method test failed: expected '{0}', got '{1}'\n", mustbe, got);
        	    errcount3++;
	        }
    	    // magnet with null argument
	        Hasher hasher = new Hasher((uint)HashType.CRC32 | (uint)HashType.MD5);
	        hasher.UpdateFile("12345.txt").Finish();
	        mustbe = "magnet:?xl=6&xt=urn:crc32:261dafe6";
	        got = hasher.GetMagnet(null, (uint)HashType.CRC32 | (uint)HashType.AICH);
	        if (!got.Equals(mustbe)) {
	            Console.WriteLine("Magnet with null argument test failed: expected '{0}', got '{1}'\n", mustbe, got);
	            errcount3++;
	        }
		}
        Console.WriteLine("{0} tests / {1} failed\n", 2, errcount3);

		System.Environment.ExitCode = errcount1 + errcount2 + errcount3;
	}
}

blib/
Makefile
Rhash.c
Rhash.bs
pm_to_blib
MYMETA.*

Makefile.PL
README
Rhash.pm
Rhash.xs
t/1test_hash_calculation.t
t/2test_static_functions.t
t/3test_all_hash_functions.t
typemap
MANIFEST
META.yml                                 Module YAML meta-data (added by MakeMaker)
META.json                                Module JSON meta-data (added by MakeMaker)

{
   "abstract" : "Library for computing hash sums and magnet links",
   "author" : [
      "Aleksey Kravchenko"
   ],
   "dynamic_config" : 0,
   "generated_by" : "ExtUtils::MakeMaker version 6.84, CPAN::Meta::Converter version 2.133380",
   "license" : [
      "unrestricted"
   ],
   "meta-spec" : {
      "url" : "http://search.cpan.org/perldoc?CPAN::Meta::Spec",
      "version" : "2"
   },
   "name" : "Crypt-Rhash",
   "no_index" : {
      "directory" : [
         "t",
         "inc"
      ]
   },
   "prereqs" : {
      "build" : {
         "requires" : {
            "ExtUtils::MakeMaker" : "0"
         }
      },
      "configure" : {
         "requires" : {
            "ExtUtils::MakeMaker" : "0"
         }
      },
      "runtime" : {
         "requires" : {}
      }
   },
   "release_status" : "stable",
   "resources" : {
      "bugtracker" : {
         "web" : "https://sourceforge.net/p/rhash/bugs/"
      },
      "homepage" : "http://rhash.sf.net/",
      "license" : [
         "http://rhash.anz.ru/license.php"
      ],
      "repository" : {
         "url" : "https://github.com/rhash/RHash"
      }
   },
   "version" : "0.94"
}

---
abstract: 'Library for computing hash sums and magnet links'
author:
  - 'Aleksey Kravchenko'
build_requires:
  ExtUtils::MakeMaker: 0
configure_requires:
  ExtUtils::MakeMaker: 0
dynamic_config: 0
generated_by: 'ExtUtils::MakeMaker version 6.84, CPAN::Meta::Converter version 2.133380'
license: unrestricted
meta-spec:
  url: http://module-build.sourceforge.net/META-spec-v1.4.html
  version: 1.4
name: Crypt-Rhash
no_index:
  directory:
    - t
    - inc
requires: {}
resources:
  bugtracker: https://sourceforge.net/p/rhash/bugs/
  homepage: http://rhash.sf.net/
  license: http://rhash.anz.ru/license.php
  repository: https://github.com/rhash/RHash
version: 0.94

use strict;
use warnings;
use ExtUtils::MakeMaker;
use File::Copy;

my $libs  = '';
my $inc   = '';
my $obj   = '';
my $clean = '';

# set the location of LibRHash headers and the linking flags
$inc = $ENV{'LIBRHASH_INC'} if defined($ENV{'LIBRHASH_INC'});
if(defined($ENV{'LIBRHASH_LD'}) && $ENV{'LIBRHASH_LD'} =~ /-L/) {
    $libs = $ENV{'LIBRHASH_LD'} . ' ' . $libs;
}

# use a system-wide librhash
$libs = '-lrhash' if (defined($ENV{'USE_SYSTEM_LIBRHASH'}));

# copy and rename *.c files by prepending underscore '_'
sub copy_c_files($) {
	my $from_dir = $_[0];
	my @result = ();
	(opendir my($dh), $from_dir) or die "Can't open $from_dir: $!";
	my @files = grep { /(?<!\Atest_hashes)\.c$/ } readdir $dh;
	closedir $dh;
	for (@files) {
		my ($from, $to) = ("$from_dir/$_", "_$_");
		push @result, $to;

		my ($df, $dt) = ((stat($from))[9], (stat($to))[9]);
		next if(defined($dt) && defined($df) && $dt >= $df);
		#print "copy $from -> $to\n";
		copy($from, $to)
			or die "Can't copy $from to $to: $!";
	}
	return @result;
}

my $local_dir = 'librhash';
if($inc eq '' && $libs eq '' && -f $local_dir . '/rhash.h') {
	# use the local version of librhash
	print "Using builtin LibRHash\n";
	$inc = '-I' . $local_dir;
	my @c_files = copy_c_files($local_dir);
	$clean = join(' ', @c_files);
	$obj = join(' ', map { s/\.c$/\$(OBJ_EXT)/; $_ } @c_files) . ' ';
}

# make setting optional MakeMaker parameters more readable
sub OPTIONAL {
	return () unless $ExtUtils::MakeMaker::VERSION ge shift;
	return @_;
}

# see ExtUtils::MakeMaker.pm for details of how to influence
# the contents of the Makefile that is written
WriteMakefile(
    NAME         => 'Crypt::Rhash',
    ABSTRACT     => 'Library for computing hash sums and magnet links',
    AUTHOR       => 'Aleksey Kravchenko',
    VERSION_FROM => 'Rhash.pm', # finds $VERSION
    OPTIONAL( '6.31',
        LICENSE => 'unrestricted',
    ),
    OPTIONAL( '6.46',
        # Use META_ADD instead of META_MERGE so that we can remove
        # any build-time dependencies that MakeMaker will put into
        # the requires field.
        META_ADD => {
            resources => {
                homepage    => 'http://rhash.sf.net/',
                license     => 'http://rhash.anz.ru/license.php',
                bugtracker  => 'https://sourceforge.net/p/rhash/bugs/',
                repository  => 'https://github.com/rhash/RHash',
            },
        },
    ),

    LIBS         => [ $libs ],
    DEFINE       => '',       # e.g., '-DHAVE_SOMETHING'
    INC          => $inc,     # e.g., '-I/usr/include/other'
    OBJECT       => $obj . 'Rhash$(OBJ_EXT)',
    clean        => {
        FILES => $clean,
    },
);

Crypt::Rhash module allows to compute various hash sums and magnet links.

The following hash sums are supported: CRC32, MD4, MD5, SHA1,
SHA256, SHA512, SHA3, Tiger, TTH, Torrent BTIH, AICH, ED2K,
GOST R 34.11-94, RIPEMD-160, HAS-160, EDON-R 256/512, WHIRLPOOL
and SNEFRU.

BUILDING THE MODULE
-------------------

The module can be built using the sequence of commands:

    perl Makefile.PL
    make
    make test

INSTALLATION
------------

To install Crypt::Rhash, run the following command:

    make install

LICENSE
-------

Permission is hereby granted, free of charge,  to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction,  including without limitation the rights
to  use,  copy,  modify,  merge, publish, distribute, sublicense, and/or sell
copies  of  the Software,  and  to permit  persons  to whom  the Software  is
furnished to do so.

This program  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.  Use  this  program  at  your  own  risk!

package Crypt::Rhash;

use 5.008008;
use strict;
use warnings;

require Exporter;
our @ISA = (qw(Exporter));

# possible tags for export
our %EXPORT_TAGS = (
	Functions => [qw(raw2hex raw2base32 raw2base64)],
	Constants => [qw(RHASH_CRC32 RHASH_MD4 RHASH_MD5 RHASH_SHA1 RHASH_TIGER
		RHASH_TTH RHASH_BTIH RHASH_ED2K RHASH_AICH RHASH_WHIRLPOOL
		RHASH_RIPEMD160 RHASH_GOST RHASH_GOST_CRYPTOPRO RHASH_HAS160
		RHASH_SNEFRU128 RHASH_SNEFRU256 RHASH_SHA224 RHASH_SHA256
		RHASH_SHA384 RHASH_SHA512 RHASH_EDONR256 RHASH_EDONR512
		RHASH_SHA3_224 RHASH_SHA3_256 RHASH_SHA3_384 RHASH_SHA3_512 RHASH_ALL)]
);

Exporter::export_tags( );
Exporter::export_ok_tags( qw(Functions Constants) );

our $VERSION = '0.94';

require XSLoader;
XSLoader::load('Crypt::Rhash', $VERSION);

##############################################################################
# ids of hash functions
use constant RHASH_CRC32 => 0x01;
use constant RHASH_MD4   => 0x02;
use constant RHASH_MD5   => 0x04;
use constant RHASH_SHA1  => 0x08;
use constant RHASH_TIGER => 0x10;
use constant RHASH_TTH   => 0x20;
use constant RHASH_BTIH  => 0x40;
use constant RHASH_ED2K  => 0x80;
use constant RHASH_AICH  => 0x100;
use constant RHASH_WHIRLPOOL => 0x200;
use constant RHASH_RIPEMD160 => 0x400;
use constant RHASH_GOST      => 0x800;
use constant RHASH_GOST_CRYPTOPRO => 0x1000;
use constant RHASH_HAS160    => 0x2000;
use constant RHASH_SNEFRU128 => 0x4000;
use constant RHASH_SNEFRU256 => 0x8000;
use constant RHASH_SHA224    => 0x10000;
use constant RHASH_SHA256    => 0x20000;
use constant RHASH_SHA384    => 0x40000;
use constant RHASH_SHA512    => 0x80000;
use constant RHASH_EDONR256  => 0x100000;
use constant RHASH_EDONR512  => 0x200000;
use constant RHASH_SHA3_224  => 0x0400000;
use constant RHASH_SHA3_256  => 0x0800000;
use constant RHASH_SHA3_384  => 0x1000000;
use constant RHASH_SHA3_512  => 0x2000000;
use constant RHASH_ALL       => 0x3FFFFFF;

##############################################################################
# Rhash class methods

# Rhash object constructor
sub new
{
	my $hash_id = $_[1] or die "hash_id not specified";
	my $context = rhash_init(scalar($hash_id)) or return undef;
	my $self = {
		context => $context,
	};
	return bless $self;
}

# destructor
sub DESTROY($)
{
	my $self = shift;
	# the 'if' added as workaround for perl 'global destruction' bug
	# ($self->{context} can disappear on global destruction)
	rhash_free($self->{context}) if $self->{context};
}

sub update($$)
{
	my $self = shift;
	my $message = shift;
	rhash_update($self->{context}, $message);
	return $self;
}

sub update_fd($$;$$)
{
	my ($self, $fd, $start, $size) = @_;
	my $res = 0;
	my $num = 0;

	binmode($fd);
	if(defined($start)) {
		seek($fd, scalar($start), 0) or return undef;
	}

	my $data;
	if(defined($size)) {
		for(my $left = scalar($size); $left > 0; $left -= 8192) {
			($res = read($fd, $data,
				($left < 8192 ? $left : 8192))) || last;
			rhash_update($self->{context}, $data);
			$num += $res;
		}
	} else {
		while( ($res = read($fd, $data, 8192)) ) {
			rhash_update($self->{context}, $data);
			$num += $res;
		}
	}

	return (defined($res) ? $num : undef); # return undef on read error
}

sub update_file($$;$$)
{
	my ($self, $file, $start, $size) = @_;
	open(my $fd, "<", $file) or return undef;
	my $res = $self->update_fd($fd, $start, $size);
	close($fd);
	return $res;
}

sub final($)
{
	my $self = shift;
	rhash_final($self->{context});
	return $self;
}

sub reset($)
{
	my $self = shift;
	rhash_reset($self->{context});
	return $self;
}

sub hashed_length($)
{
	my $self = shift;
	return rhash_get_hashed_length($self->{context});
}

sub hash_id($)
{
	my $self = shift;
	return rhash_get_hash_id($self->{context});
}

##############################################################################
# Hash formatting functions

# printing constants
use constant RHPR_DEFAULT   => 0x0;
use constant RHPR_RAW       => 0x1;
use constant RHPR_HEX       => 0x2;
use constant RHPR_BASE32    => 0x3;
use constant RHPR_BASE64    => 0x4;
use constant RHPR_UPPERCASE => 0x8;
use constant RHPR_REVERSE   => 0x10;

sub hash($;$$)
{
	my $self = shift;
	my $hash_id = scalar(shift) || 0;
	my $print_flags = scalar(shift) || RHPR_DEFAULT;
	return rhash_print($self->{context}, $hash_id, $print_flags);
}

sub hash_base32($;$)
{
	hash($_[0], $_[1], RHPR_BASE32);
}

sub hash_base64($;$)
{
	hash($_[0], $_[1], RHPR_BASE64);
}

sub hash_hex($;$)
{
	hash($_[0], $_[1], RHPR_HEX);
}

sub hash_rhex($;$)
{
	hash($_[0], $_[1], RHPR_HEX | RHPR_REVERSE);
}

sub hash_raw($;$)
{
	hash($_[0], $_[1], RHPR_RAW);
}

sub magnet_link($;$$)
{
	my ($self, $filename, $hash_mask) = @_;
	return rhash_print_magnet($self->{context}, $filename, $hash_mask);
}

our $AUTOLOAD;

# report error if a script called unexisting method/field
sub AUTOLOAD
{
	my ($self, $field, $type, $pkg) = ($_[0], $AUTOLOAD, undef, __PACKAGE__);
	$field =~ s/.*://;
	die "function $field does not exist" if $field =~ /^(rhash_|raw2)/;
	die "no arguments specified to $field()" if !@_;
	die "the $field() argument is undefined" if !defined $self;

	($type = ref($self)) && $type eq $pkg || die "the $field() argument is not a $pkg reference";
	my $text = (exists $self->{$field} ? "is not accessible" : "does not exist");
	die "the method $field() $text in the class $pkg";
}

# static functions

sub msg($$)
{
	my ($hash_id, $msg) = @_;
	my $raw = rhash_msg_raw($hash_id, $msg); # get binary hash
	return (is_base32($hash_id) ? raw2base32($raw) : raw2hex($raw));
}

1;
__END__
# Below is Rhash module documentation in the standard POD format

=head1 NAME

Crypt::Rhash - Compute hash sums and magnet links

=head1 SYNOPSIS

  use Crypt::Rhash;
  
  my $msg = "a message text";
  print "MD5 = " . Crypt::Rhash::msg(RHASH_MD5, $msg) . "\n";
  
  # Calculate two hash functions simultaneously
  my $r = Crypt::Rhash->new(RHASH_MD5 | RHASH_SHA1);
  $r->update("a message text")->update(" another message");
  print  "MD5  = " . $r->hash(RHASH_MD5) . "\n";
  print  "SHA1 = " . $r->hash(RHASH_SHA1) . "\n";

=head1 DESCRIPTION

Crypt::Rhash module is an object-oriented interface to the LibRHash library,
allowing simultaneous calculation of several hash functions for a file  or a
text message.

Resulting hash digest can be obtained in hexadecimal, BASE32, BASE64, raw
binary format or as a magnet link.

=head1 SUPPORTED ALGORITHMS

The module supports the following hashing algorithms:
CRC32,  MD4, MD5,  SHA1, SHA256, SHA512, SHA3,
AICH, ED2K, Tiger,  DC++ TTH,  BitTorrent BTIH, GOST R 34.11-94, RIPEMD-160,
HAS-160, EDON-R 256/512, Whirlpool and Snefru-128/256.

=head1 CONSTRUCTOR

Creates and returns new Crypt::Rhash object.

  my $r = Crypt::Rhash->new($hash_id);
  my $p = new Crypt::Rhash($hash_id); # alternative way to call the constructor

The $hash_id parameter can be union (via bitwise OR) of any of the following bit-flags:

  RHASH_CRC32,
  RHASH_MD4,
  RHASH_MD5,
  RHASH_SHA1,
  RHASH_TIGER,
  RHASH_TTH,
  RHASH_BTIH,
  RHASH_ED2K,
  RHASH_AICH,
  RHASH_WHIRLPOOL,
  RHASH_RIPEMD160,
  RHASH_GOST,
  RHASH_GOST_CRYPTOPRO,
  RHASH_HAS160,
  RHASH_SNEFRU128,
  RHASH_SNEFRU256,
  RHASH_SHA224,
  RHASH_SHA256,
  RHASH_SHA384,
  RHASH_SHA512,
  RHASH_SHA3_224,
  RHASH_SHA3_256,
  RHASH_SHA3_384,
  RHASH_SHA3_512,
  RHASH_EDONR256,
  RHASH_EDONR512

Also the RHASH_ALL bit mask is the union of all listed bit-flags.
So the object created via Crypt::Rhash->new(RHASH_ALL) calculates all
supported hash functions for the same data.

=head1 COMPUTING HASHES

=over

=item $rhash->update( $msg )

Calculates hashes of the $msg string.
The method can be called repeatedly with chunks of the message to be hashed.
It returns the $rhash object itself allowing the following construction:

  $rhash = Crypt::Rhash->new(RHASH_MD5)->update( $chunk1 )->update( $chunk2 );

=item $rhash->update_file( $file_path, $start, $size )

=item $rhash->update_fd( $fd, $start, $size )

Calculate a hash of the file (or its part) specified by $file_path or a file descriptor $fd.
The update_fd method doesn't close the $fd, leaving the file position after the hashed block.
The optional $start and $size specify the block of the file to hash.
No error is reported if the $size is greater than the number of the unread bytes left in the file.

Returns the number of characters actually read, 0 at end of file, 
or undef if there was an error (in the latter case $! is also set).

  use Crypt::Rhash;
  my $r = new Crypt::Rhash(RHASH_SHA1);
  open(my $fd, "<", "input.txt") or die "cannot open < input.txt: $!";
  while ((my $n = $r->update_fd($fd, undef, 1024) != 0)) {
      print "$n bytes hashed. The SHA1 hash is " . $r->final()->hash() . "\n";
      $r->reset();
  }
  defined($n) or die "read error for input.txt: $!";
  close($fd);

=item $rhash->final()

Finishes calculation for all data buffered by updating methods and stops hash
calculation. The function is called automatically by any of the 
$rhash->hash*() methods if the final() call was skipped.

=item $rhash->reset()

Resets the $rhash object to the initial state.

=item $rhash->hashed_length()

Returns the total length of the hashed message.

=item $rhash->hash_id()

Returns the hash mask, the $rhash object was constructed with.

=back

=head1 FORMATTING HASH VALUE

Computed hash can be formatted as a hexadecimal string (in the forward or
reverse byte order), a base32/base64-encoded string or as raw binary data.

=over

=item $rhash->hash( $hash_id )

Returns the hash string in the default format,
which can be hexadecimal or base32. Actually the method is equivalent of

  (Crypt::Rhash::is_base32($hash_id) ? $rhash->hash_base32($hash_id) :
    $rhash->hash_hex($hash_id))

If the optional $hash_id parameter is omitted or zero, then the method returns the hash
for the algorithm contained in $rhash with the lowest identifier.

=item $rhash->hash_hex( $hash_id )

Returns the specified hash in the hexadecimal format.

  use Crypt::Rhash;
  my $msg = "abc";
  print "MD5 = " . Crypt::Rhash->new(RHASH_MD5)->update($msg)->hash_hex() . "\n";

=item $rhash->hash_rhex( $hash_id )

Returns the specified hash in the hexadecimal format with reversed order of bytes.
Some programs prefer to output the GOST R 34.11-94 hash in this format.

=item $rhash->hash_base32( $hash_id )

Returns the specified hash in the base32 format.

=item $rhash->hash_base64( $hash_id )

Returns the specified hash in the base64 format.

=item $rhash->magnet_link( $filename, $hash_mask )

Returns the magnet link containing the computed hashes, filesize, and,
optionaly, $filename. The $filename (if specified) is URL-encoded,
by converting special characters into the %<hexadecimal-code> form.
The optional parameter $hash_mask can limit which hash values to put
into the link.

=back

=head1 STATIC METHODS

=over

=item Crypt::Rhash::count()

Returns the number of supported hash algorithms

=item Crypt::Rhash::is_base32($hash_id)

Returns nonzero if default output format is Base32 for the hash function specified by $hash_id.
Returns zero if default format is hexadecimal.

=item Crypt::Rhash::get_digest_size($hash_id)

Returns the size in bytes of raw binary hash of the specified hash algorithm.

=item Crypt::Rhash::get_hash_length($hash_id)

Returns the length of a hash string in default output format for the specified hash algorithm.

=item Crypt::Rhash::get_name($hash_id)

Returns the name of the specified hash algorithm.

=back

=head1 ALTERNATIVE WAY TO COMPUTE HASH

=over

=item Crypt::Rhash::msg($hash_id, $message)

Computes and returns a single hash (in its default format) of the $message by the selected hash algorithm.

  use Crypt::Rhash;
  print "SHA1( 'abc' ) = " . Crypt::Rhash::msg(RHASH_SHA1, "abc") . "\n";

=back

=head1 LICENSE

 Permission is hereby granted, free of charge,  to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
 in the Software without restriction,  including without limitation the rights
 to  use,  copy,  modify,  merge, publish, distribute, sublicense, and/or sell
 copies  of  the Software,  and  to permit  persons  to whom  the Software  is
 furnished to do so.

 The Software  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.  Use  this  program  at  your  own  risk!

=cut

#include "EXTERN.h"
#include "perl.h"
#include "XSUB.h"

#include <rhash.h>

typedef unsigned long long ulonglong;

/* helper macros and functions */
#define BASE32_LENGTH(size) (((size) * 8 + 4) / 5)
#define BASE64_LENGTH(size) ((((size) + 2) / 3) * 4)

void verify_single_bit_hash_id(unsigned hash_id, CV* cv)
{
	const char* error;
	const GV *gv;
	const char *func_name;

	if(0 == (hash_id & RHASH_ALL_HASHES)) {
		error = "%s: unknown hash hash_id = %d";
	} else if(0 != (hash_id & (hash_id - 1))) {
		error = "%s: hash_id is not a single bit: %d";
	} else {
		return; /* success */
	}

	gv = CvGV(cv);
	func_name = (gv ? GvNAME(gv) : "Rhash");
	croak(error, func_name, hash_id);
}

/* allocate a perl string scalar variable, containing str_len + 1 bytes */
SV * allocate_string_buffer(STRLEN str_len)
{
	SV * sv = newSV(str_len); /* allocates (str_len + 1) bytes */
	SvPOK_only(sv);
	SvCUR_set(sv, str_len);
	return sv;
}

MODULE = Crypt::Rhash      PACKAGE = Crypt::Rhash

##############################################################################
# Initialize LibRHash in the module bootstrap function

BOOT:
	rhash_library_init();

##############################################################################
# perl bindings for Hi-level functions

SV *
rhash_msg_raw(hash_id, message)
		unsigned	hash_id
	PROTOTYPE: $$
	PREINIT:
		STRLEN length;
		unsigned char out[264];
		int res;
	INPUT:
		char* message = SvPV(ST(1), length);
	CODE:
		verify_single_bit_hash_id(hash_id, cv);
		res = rhash_msg(hash_id, message, length, out);
		if(res < 0) {
			croak("%s: %s", "rhash_msg_raw", strerror(errno));
		}
		RETVAL = newSVpv((char*)out, rhash_get_digest_size(hash_id));
	OUTPUT:
		RETVAL

SV *
rhash_file_raw(hash_id, filepath)
		unsigned hash_id
		char * filepath
	PROTOTYPE: $$
	PREINIT:
		int res;
		unsigned char out[264];
	CODE:
		verify_single_bit_hash_id(hash_id, cv);
		res = rhash_file(hash_id, filepath, out);
		if(res < 0) {
			croak("%s: %s: %s", "rhash_file", filepath, strerror(errno));
		}
		RETVAL = newSVpv((char*)out, rhash_get_digest_size(hash_id));
	OUTPUT:
		RETVAL

##############################################################################
# perl bindings for Low-level functions

rhash_context *
rhash_init(hash_id)
		unsigned hash_id
	PROTOTYPE: $

int
rhash_update(ctx, message)
		rhash_context * ctx
	PROTOTYPE: $$
	PREINIT:
		STRLEN length;
	INPUT:
		char* message = SvPV(ST(1), length);
	CODE:
		RETVAL = rhash_update(ctx, message, length);
	OUTPUT:
		RETVAL

int
rhash_final(ctx)
		rhash_context * ctx
	PROTOTYPE: $
	CODE:
		RETVAL = rhash_final(ctx, 0);
	OUTPUT:
		RETVAL

void
rhash_reset(ctx)
		rhash_context * ctx
	PROTOTYPE: $

void
rhash_free(ctx)
		rhash_context * ctx
	PROTOTYPE: $

SV *
rhash_print(ctx, hash_id, flags = 0)
		rhash_context * ctx
		unsigned hash_id
		int flags
	PROTOTYPE: $$;$
	PREINIT:
		int len;
		char out[264];
	CODE:
		if(hash_id != 0) verify_single_bit_hash_id(hash_id, cv);

		len = rhash_print(out, ctx, hash_id, flags);

		/* set exact length to support raw output (RHPR_RAW) */
		RETVAL = newSVpv(out, len);
	OUTPUT:
		RETVAL

SV *
rhash_print_magnet(ctx, filename, hash_mask)
		rhash_context * ctx
		SV * filename
		SV * hash_mask
	PROTOTYPE: $;$$
	PREINIT:
		/* process undefined values */
		char * name = (SvOK(filename) ? SvPV_nolen(filename) : 0);
		unsigned mask = (SvOK(hash_mask) ? (unsigned)SvUV(hash_mask) : RHASH_ALL_HASHES);
		size_t buf_size;
	CODE:
		/* allocate a string buffer and print magnet link into it */
		buf_size = rhash_print_magnet(0, name, ctx, mask, RHPR_FILESIZE);
		RETVAL = allocate_string_buffer(buf_size - 1);
		rhash_print_magnet(SvPVX(RETVAL), name, ctx, mask, RHPR_FILESIZE);

		/* note: length(RETVAL) = (buf_size - 1),
		 * so the following call is not required:
		 * SvCUR_set(RETVAL, strlen(SvPVX(RETVAL))); */
	OUTPUT:
		RETVAL

unsigned
rhash_get_hash_id(ctx)
		rhash_context * ctx
	PROTOTYPE: $
	CODE:
		RETVAL = ctx->hash_id;
	OUTPUT:
		RETVAL

ulonglong
rhash_get_hashed_length(ctx)
		rhash_context * ctx
	PROTOTYPE: $
	CODE:
		RETVAL = ctx->msg_size;
	OUTPUT:
		RETVAL

##############################################################################
# Hash information functions

int
count()
	CODE:
		RETVAL = rhash_count();
	OUTPUT:
		RETVAL

int
is_base32(hash_id)
		unsigned hash_id
	PROTOTYPE: $
	CODE:
		RETVAL = rhash_is_base32(hash_id);
	OUTPUT:
		RETVAL

int
get_digest_size(hash_id)
		unsigned hash_id
	PROTOTYPE: $
	CODE:
		RETVAL = rhash_get_digest_size(hash_id);
	OUTPUT:
		RETVAL

int
get_hash_length(hash_id)
		unsigned hash_id
	PROTOTYPE: $
	CODE:
		RETVAL = rhash_get_hash_length(hash_id);
	OUTPUT:
		RETVAL

const char *
get_name(hash_id)
		unsigned hash_id
	PROTOTYPE: $
	CODE:
		RETVAL = rhash_get_name(hash_id);
	OUTPUT:
		RETVAL

##############################################################################
# Hash printing functions

##############################################################################
# Hash conversion functions

SV *
raw2hex(bytes)
	PROTOTYPE: $
	PREINIT:
		STRLEN size;
	INPUT:
		unsigned char * bytes = (unsigned char*)SvPV(ST(0), size);
	CODE:
		RETVAL = allocate_string_buffer(size * 2);
		rhash_print_bytes(SvPVX(RETVAL), bytes, size, RHPR_HEX);
	OUTPUT:
		RETVAL

SV *
raw2base32(bytes)
	PROTOTYPE: $
	PREINIT:
		STRLEN size;
	INPUT:
		unsigned char * bytes = (unsigned char*)SvPV(ST(0), size);
	CODE:
		RETVAL = allocate_string_buffer(BASE32_LENGTH(size));
		rhash_print_bytes(SvPVX(RETVAL), bytes, size, RHPR_BASE32);
	OUTPUT:
		RETVAL

SV *
raw2base64(bytes)
	PROTOTYPE: $
	PREINIT:
		STRLEN size;
	INPUT:
		unsigned char * bytes = (unsigned char*)SvPV(ST(0), size);
	CODE:
		RETVAL = allocate_string_buffer(BASE64_LENGTH(size));
		rhash_print_bytes(SvPVX(RETVAL), bytes, size, RHPR_BASE64);
	OUTPUT:
		RETVAL

# rhash_print_bytes should not be used directly
#SV *
#rhash_print_bytes(bytes, flags)
#	PROTOTYPE: $;$
#	PREINIT:
#		STRLEN size;
#	INPUT:
#		unsigned char * bytes = SvPV(ST(0), size);
#		int flags
#	CODE:
#		RETVAL = allocate_string_buffer(size * 2);
#		rhash_print_bytes(SvPVX(RETVAL), bytes, size, flags);
#	OUTPUT:
#		RETVAL

#rhash_uptr_t
#rhash_transmit(msg_id, dst, ldata, rdata)
#	unsigned msg_id
#	void * dst
#	rhash_uptr_t ldata
#	rhash_uptr_t rdata

##############################################################################
# BTIH / BitTorrent support functions

void
rhash_bt_add_filename(ctx, filename, filesize)
		rhash_context * ctx
		char * filename
		ulonglong filesize
	PROTOTYPE: $$$
	CODE:
		rhash_transmit(RMSG_BT_ADD_FILE, ctx, RHASH_STR2UPTR(filename), (rhash_uptr_t)&filesize);

void
rhash_bt_set_piece_length(ctx, piece_length)
		rhash_context * ctx
		unsigned piece_length
	PROTOTYPE: $$
	CODE:
		rhash_transmit(RMSG_BT_SET_PIECE_LENGTH, ctx, RHASH_STR2UPTR(piece_length), 0);

void
rhash_bt_set_private(ctx)
		rhash_context * ctx
	PROTOTYPE: $
	CODE:
		rhash_transmit(RMSG_BT_SET_OPTIONS, ctx, RHASH_BT_OPT_PRIVATE, 0);

SV *
rhash_bt_get_torrent_text(ctx)
		rhash_context * ctx
	PROTOTYPE: $
	PREINIT:
		size_t len;
		char *text;
	CODE:
		len = rhash_transmit(RMSG_BT_GET_TEXT, ctx, RHASH_STR2UPTR(&text), 0);
		if(len == RHASH_ERROR) {
			XSRETURN_UNDEF;
		}
		RETVAL = newSVpv(text, len);
	OUTPUT:
		RETVAL

use Test::More tests => 22;
BEGIN { use_ok('Crypt::Rhash') };

#########################
# test script

$msg = "message digest";

ok( $r = new Crypt::Rhash(RHASH_MD5 | RHASH_TTH));
ok( $r->update($msg) );

is( $r->hash(), "f96b697d7cb7938d525a2f31aaf161d0"); # prints the first hash by default
is( $r->hash(RHASH_TTH), "ym432msox5qilih2l4tno62e3o35wygwsbsjoba");
is( $r->hash_hex(RHASH_TTH), "c339bd324ebf6085a0fa5f26d77b44dbb7db60d690649704");
is( $r->hash_hex(RHASH_MD5), "f96b697d7cb7938d525a2f31aaf161d0");
is( $r->hash_rhex(RHASH_MD5), "d061f1aa312f5a528d93b77c7d696bf9");
is( $r->hash_base32(RHASH_MD5), "7fvws7l4w6jy2us2f4y2v4lb2a");
#is( $r->hash_base64(RHASH_MD5), "+WtpfXy3k41SWi8xqvFh0A=");
is( $r->hash_raw(RHASH_MD5), "\xf9\x6b\x69\x7d\x7c\xb7\x93\x8d\x52\x5a\x2f\x31\xaa\xf1\x61\xd0");
is( $r->reset()->hash(), "d41d8cd98f00b204e9800998ecf8427e");

is( $r->hashed_length(), length($msg));
is( $r->hash_id(), (RHASH_MD5 | RHASH_TTH));
$r = undef; # destruct the Rhash object

#########################
# test hashing a file

$file = "msg.txt";
open FILE, ">$file" or die $!;
binmode FILE;
print FILE $msg;
close FILE;

$r = new Crypt::Rhash(RHASH_MD5);
is( $r->update_file($file), 14);
is( $r->hash(), "f96b697d7cb7938d525a2f31aaf161d0");
#print  "MD5 (\"$msg\") = ". $r->update_file($file)->hash() . "\n";

is( $r->reset()->update_file($file, 4, 1), 1);
is( $r->hash(), "0cc175b9c0f1b6a831c399e269772661");

open $fd, "<$file" or die $!;
binmode $fd;
is( $r->reset()->update_fd($fd), 14);
is( $r->hash(), "f96b697d7cb7938d525a2f31aaf161d0");
close $fd;
unlink($file);

#########################
# test magnet_link() method
$r = new Crypt::Rhash(RHASH_ALL);
$r->update("a")->final();
is( $r->magnet_link("test.txt", RHASH_MD5 | RHASH_SHA1), "magnet:?xl=1&dn=test.txt&xt=urn:md5:0cc175b9c0f1b6a831c399e269772661&xt=urn:sha1:q336in72uwt7zyk5dxolt2xk5i3xmz5y");
is( $r->magnet_link(undef, RHASH_ED2K | RHASH_AICH | RHASH_TTH), "magnet:?xl=1&xt=urn:ed2k:bde52cb31de33e46245e05fbdbd6fb24&xt=urn:aich:q336in72uwt7zyk5dxolt2xk5i3xmz5y&xt=urn:tree:tiger:czquwh3iyxbf5l3bgyugzhassmxu647ip2ike4y");

$r = new Crypt::Rhash(RHASH_CRC32 | RHASH_MD4);
$r->update("abc")->final();
is( $r->magnet_link(), "magnet:?xl=3&xt=urn:crc32:352441c2&xt=urn:md4:a448017aaf21d8525fc10ae87aa6729d");

__END__

use Test::More tests => 11;
use Crypt::Rhash;# qw( :Functions );

#########################
# Rhash module static functions

ok(RHASH_CRC32 > 0);
ok(&Crypt::Rhash::count() > 0);
is(&Crypt::Rhash::get_digest_size(RHASH_CRC32), 4);
is(&Crypt::Rhash::get_hash_length(RHASH_CRC32), 8);
is(&Crypt::Rhash::is_base32(RHASH_CRC32), 0);
is(&Crypt::Rhash::is_base32(RHASH_TTH), 1);
is(&Crypt::Rhash::get_name(RHASH_CRC32), "CRC32");

# test conversion functions
is(&raw2hex("test msg"), "74657374206d7367");
is(&raw2base32("test msg"), "orsxg5banvzwo");
is(&raw2base64("test msg"), "dGVzdCBtc2c=");

$msg = "message digest";

# test msg() hashing method
is(&Crypt::Rhash::msg(RHASH_MD5, $msg), "f96b697d7cb7938d525a2f31aaf161d0");

use Test::More tests => 26;
use Crypt::Rhash;

#########################

$r = new Crypt::Rhash(RHASH_ALL);
$r->update("a")->final();

is( $r->hash(RHASH_CRC32), "e8b7be43");
is( $r->hash(RHASH_MD4),   "bde52cb31de33e46245e05fbdbd6fb24");
is( $r->hash(RHASH_MD5),   "0cc175b9c0f1b6a831c399e269772661");
is( $r->hash(RHASH_SHA1),  "86f7e437faa5a7fce15d1ddcb9eaeaea377667b8");
is( $r->hash(RHASH_TIGER), "77befbef2e7ef8ab2ec8f93bf587a7fc613e247f5f247809");
is( $r->hash(RHASH_TTH),   "czquwh3iyxbf5l3bgyugzhassmxu647ip2ike4y");
is( length($r->hash(RHASH_BTIH)),  40);
is( $r->hash(RHASH_ED2K),  "bde52cb31de33e46245e05fbdbd6fb24");
is( $r->hash(RHASH_AICH),  "q336in72uwt7zyk5dxolt2xk5i3xmz5y");
is( $r->hash(RHASH_WHIRLPOOL), "8aca2602792aec6f11a67206531fb7d7f0dff59413145e6973c45001d0087b42d11bc645413aeff63a42391a39145a591a92200d560195e53b478584fdae231a");
is( $r->hash(RHASH_RIPEMD160), "0bdc9d2d256b3ee9daae347be6f4dc835a467ffe");
is( $r->hash(RHASH_GOST),  "d42c539e367c66e9c88a801f6649349c21871b4344c6a573f849fdce62f314dd");
is( $r->hash(RHASH_GOST_CRYPTOPRO), "e74c52dd282183bf37af0079c9f78055715a103f17e3133ceff1aacf2f403011");
is( $r->hash(RHASH_HAS160), "4872bcbc4cd0f0a9dc7c2f7045e5b43b6c830db8");
is( $r->hash(RHASH_SNEFRU128), "bf5ce540ae51bc50399f96746c5a15bd");
is( $r->hash(RHASH_SNEFRU256), "45161589ac317be0ceba70db2573ddda6e668a31984b39bf65e4b664b584c63d");
is( $r->hash(RHASH_SHA224),   "abd37534c7d9a2efb9465de931cd7055ffdb8879563ae98078d6d6d5");
is( $r->hash(RHASH_SHA256),   "ca978112ca1bbdcafac231b39a23dc4da786eff8147c4e72b9807785afee48bb");
is( $r->hash(RHASH_SHA384),   "54a59b9f22b0b80880d8427e548b7c23abd873486e1f035dce9cd697e85175033caa88e6d57bc35efae0b5afd3145f31");
is( $r->hash(RHASH_SHA512),   "1f40fc92da241694750979ee6cf582f2d5d7d28e18335de05abc54d0560e0f5302860c652bf08d560252aa5e74210546f369fbbbce8c12cfc7957b2652fe9a75");
is( $r->hash(RHASH_EDONR256), "943aa9225a2cf154ec2e4dd81237720ba538ca8df2fd83c0b893c5d265f353a0");
is( $r->hash(RHASH_EDONR512), "b59ec44f7beef8a04ceed38a973d77c65e22e9458d5f67b497948da34986c093b5efc5483fbee55f2f740fcad31f18d80db44bb6b8843e7fd599188e7c07233b");
is( $r->hash(RHASH_SHA3_224), "9e86ff69557ca95f405f081269685b38e3a819b309ee942f482b6a8b");
is( $r->hash(RHASH_SHA3_256), "80084bf2fba02475726feb2cab2d8215eab14bc6bdd8bfb2c8151257032ecd8b");
is( $r->hash(RHASH_SHA3_384), "1815f774f320491b48569efec794d249eeb59aae46d22bf77dafe25c5edc28d7ea44f93ee1234aa88f61c91912a4ccd9");
is( $r->hash(RHASH_SHA3_512), "697f2d856172cb8309d6b8b97dac4de344b549d4dee61edfb4962d8698b7fa803f4f93ff24393586e28b5b957ac3d1d369420ce53332712f997bd336d09ab02a");

__END__

rhash_context *					T_PTROBJ
rhash_uptr_t					T_NV
ulonglong					T_NV

dnl
dnl config.m4 for RHash extension
dnl

PHP_ARG_WITH(rhash, for RHash support,
[  --with-rhash[=DIR]        Include RHash support.])

if test "$PHP_RHASH" != "no"; then
  if test -r $PHP_RHASH/include/rhash.h; then
    RHASH_INCLUDE_DIR=$PHP_RHASH/include
    RHASH_LIB_DIR=$PHP_RHASH/lib
  elif test -r $PHP_RHASH/rhash.h; then
    RHASH_INCLUDE_DIR=$PHP_RHASH
    RHASH_LIB_DIR=$PHP_RHASH
  else
    AC_MSG_CHECKING(for RHash in default path)
    for i in /usr/local /usr; do
      if test -r $i/include/rhash.h; then
        RHASH_INCLUDE_DIR=$i/include
        RHASH_LIB_DIR=$i/lib
        AC_MSG_RESULT(found at $i)
        break
      fi
    done
  fi

  if test -z "$RHASH_INCLUDE_DIR" -a -r ../../librhash/rhash.h; then
    RHASH_INCLUDE_DIR=$(pwd)/../../librhash
    RHASH_LIB_DIR=$RHASH_INCLUDE_DIR
    AC_MSG_RESULT(found at $RHASH_INCLUDE_DIR)
  fi

  if test -z "$RHASH_INCLUDE_DIR"; then
    AC_MSG_RESULT(not found)
    AC_MSG_ERROR(Please reinstall the librhash -
    rhash.h should be in <rhash-dir>/include/)
  fi

  AC_DEFINE(HAVE_RHASH, 1, [Whether you have RHash])
  PHP_ADD_INCLUDE($RHASH_INCLUDE_DIR)
  PHP_ADD_LIBRARY_WITH_PATH(rhash, $RHASH_LIB_DIR, RHASH_SHARED_LIBADD)
  PHP_NEW_EXTENSION(rhash, php_rhash.c, $ext_shared)
  PHP_SUBST(RHASH_SHARED_LIBADD)
fi

#ifndef PHP_PORTABLE_H
#define PHP_PORTABLE_H

#if PHP_MAJOR_VERSION < 7

struct _zend_string {
	char *val;
	int len;
	int persistent;
};
typedef struct _zend_string zend_string;

#define RETURN_NEW_STR(s)     RETURN_STRINGL(s->val,s->len,0);

static zend_always_inline zend_string *zend_string_alloc(int len, int persistent)
{
	/* aligned to 8 bytes size of buffer to hold (len + 1) characters */
	int alligned_size = (len + 1 + 7) & ~7;
	/* single alloc, so free the buf, will also free the struct */
	char *buf = safe_pemalloc(sizeof(zend_string) + alligned_size, 1, 0, persistent);
	zend_string *str = (zend_string *)(buf + alligned_size);
	str->val = buf;
	str->len = len;
	str->persistent = persistent;
	return str;
}

/* compatibility macros */
# define _RETURN_STRING(str) RETURN_STRING(str, 1)
# define _RETURN_STRINGL(str, l) RETURN_STRINGL(str, l, 1)
typedef long zend_long;
typedef int strsize_t;

#else

# define _RETURN_STRING(str) RETURN_STRING(str)
# define _RETURN_STRINGL(str, l) RETURN_STRINGL(str, l)
typedef size_t strsize_t;

#endif

#endif /* PHP_PORTABLE_H */

/* php_rhash.c */
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include <rhash.h>
#include "php.h"
#include "php_ini.h"
#include "ext/standard/info.h"
#include "php_streams.h"
#include "php_rhash.h"
#include "php_compatibility.h"

#define PHP_RHASH_VERSION "1.2.9"

/* {{{ arginfo */
ZEND_BEGIN_ARG_INFO(arginfo_rhash_count, 0)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_rhash_get_digest_size, 0)
	ZEND_ARG_INFO(0, hash_id)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_rhash_is_base32, 0)
	ZEND_ARG_INFO(0, hash_id)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_rhash_get_name, 0)
	ZEND_ARG_INFO(0, hash_id)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_rhash_msg, 0)
	ZEND_ARG_INFO(0, hash_id)
	ZEND_ARG_INFO(0, message)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_rhash_file, 0)
	ZEND_ARG_INFO(0, hash_id)
	ZEND_ARG_INFO(0, path)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_rhash_magnet_func, 0)
	ZEND_ARG_INFO(0, hash_id)
	ZEND_ARG_INFO(0, path)
ZEND_END_ARG_INFO()
/* }}} */

/* {{{ The table of global functions
*/
static zend_function_entry rhash_functions[] = {
	PHP_FE(rhash_count, arginfo_rhash_count)
	PHP_FE(rhash_get_digest_size, arginfo_rhash_get_digest_size)
	PHP_FE(rhash_is_base32, arginfo_rhash_is_base32)
	PHP_FE(rhash_get_name, arginfo_rhash_get_name)
	PHP_FE(rhash_msg, arginfo_rhash_msg)
	PHP_FE(rhash_file, arginfo_rhash_file)
	PHP_FE(rhash_magnet, arginfo_rhash_magnet_func)
	PHP_FE_END
};
/* }}} */


/* {{{ arginfo */
ZEND_BEGIN_ARG_INFO_EX(arginfo_rhash__construct, 0, 0, 0)
	ZEND_ARG_INFO(0, hash_id)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_rhash_update, 0)
	ZEND_ARG_INFO(0, message)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_rhash_update_stream, 0, 0, 1)
	ZEND_ARG_INFO(0, handle)
	ZEND_ARG_INFO(0, start)
	ZEND_ARG_INFO(0, size)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_rhash_update_file, 0, 0, 1)
	ZEND_ARG_INFO(0, path)
	ZEND_ARG_INFO(0, start)
	ZEND_ARG_INFO(0, size)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_rhash_final, 0)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_rhash_reset, 0)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_rhash_hashed_length, 0)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_rhash_hash, 0, 0, 0)
	ZEND_ARG_INFO(0, hash_id)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_rhash_raw, 0, 0, 0)
	ZEND_ARG_INFO(0, hash_id)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_rhash_hex, 0, 0, 0)
	ZEND_ARG_INFO(0, hash_id)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_rhash_base32, 0, 0, 0)
	ZEND_ARG_INFO(0, hash_id)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_rhash_base64, 0, 0, 0)
	ZEND_ARG_INFO(0, hash_id)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_rhash_magnet, 0, 0, 0)
	ZEND_ARG_INFO(0, filename)
ZEND_END_ARG_INFO()
/* }}} */

/* {{{ The table of the RHash class methods
*/
zend_function_entry rhash_methods[] = {
	PHP_ME(RHash,  __construct,     arginfo_rhash__construct, ZEND_ACC_PUBLIC | ZEND_ACC_CTOR)
	PHP_ME(RHash,  update,          arginfo_rhash_update, ZEND_ACC_PUBLIC)
	PHP_ME(RHash,  update_stream,   arginfo_rhash_update_stream, ZEND_ACC_PUBLIC)
	PHP_ME(RHash,  update_file,     arginfo_rhash_update_file, ZEND_ACC_PUBLIC)
	PHP_ME(RHash,  final,           arginfo_rhash_final, ZEND_ACC_PUBLIC)
	PHP_ME(RHash,  reset,           arginfo_rhash_reset, ZEND_ACC_PUBLIC)
	PHP_ME(RHash,  hashed_length,   arginfo_rhash_hashed_length, ZEND_ACC_PUBLIC)
	PHP_ME(RHash,  hash,            arginfo_rhash_hash, ZEND_ACC_PUBLIC)
	PHP_ME(RHash,  raw,             arginfo_rhash_raw, ZEND_ACC_PUBLIC)
	PHP_ME(RHash,  hex,             arginfo_rhash_hex, ZEND_ACC_PUBLIC)
	PHP_ME(RHash,  base32,          arginfo_rhash_base32, ZEND_ACC_PUBLIC)
	PHP_ME(RHash,  base64,          arginfo_rhash_base64, ZEND_ACC_PUBLIC)
	PHP_ME(RHash,  magnet,          arginfo_rhash_magnet, ZEND_ACC_PUBLIC)
	PHP_FE_END
};
/* }}} */

zend_class_entry *rhash_ce;
zend_object_handlers rhash_object_handlers;

/* {{{ Module struct
*/
zend_module_entry rhash_module_entry = {
#if ZEND_MODULE_API_NO >= 20010901
	STANDARD_MODULE_HEADER,
#endif
	"rhash",                   /* extension name */
	rhash_functions,           /* function list */
	PHP_MINIT(rhash),          /* process startup */
	PHP_MSHUTDOWN(rhash),      /* process shutdown */
	NULL,
	NULL,
	PHP_MINFO(rhash),          /* extension info */
#if ZEND_MODULE_API_NO >= 20010901
	PHP_RHASH_VERSION,         /* extension version */
#endif
	STANDARD_MODULE_PROPERTIES
};
/* }}} */

#ifdef COMPILE_DL_RHASH
ZEND_GET_MODULE(rhash)
#endif

#define REGISTER_RHASH_CONSTANT(c) REGISTER_LONG_CONSTANT(#c, c, CONST_CS | CONST_PERSISTENT)
#define RHASH_ALL RHASH_ALL_HASHES


#if PHP_MAJOR_VERSION < 7
typedef struct _rhash_object {
	zend_object     zobj;
	rhash           rhash;
} rhash_object;

# define get_rhash_object(this_zval) ((rhash_object*)zend_object_store_get_object(this_zval TSRMLS_CC))
# define get_rhash_object_from_zend_object(object) (rhash_object *)(object)
#else
typedef struct _rhash_object {
	rhash           rhash;
	zend_object     zobj;
} rhash_object;

static rhash_object * get_rhash_object(zval *this_zval)
{
	zend_object *zobj = Z_OBJ_P(this_zval);
	return (rhash_object *)((char *)zobj - XtOffsetOf(rhash_object, zobj));
}
# define get_rhash_object_from_zend_object(object) (rhash_object *)((char *)object - XtOffsetOf(rhash_object, zobj));
#endif

static void rhash_free_object(zend_object *object TSRMLS_DC)
{
	rhash_object *obj = get_rhash_object_from_zend_object(object);
	if (obj->rhash)
		rhash_free(obj->rhash);

	/* call Zend's free handler, which will free object properties */
	zend_object_std_dtor(object TSRMLS_CC);
#if PHP_MAJOR_VERSION < 7
	efree(object);
#endif
}

/* Allocate memory for new rhash_object */
#if PHP_MAJOR_VERSION < 7
static zend_object_value rhash_create_object(zend_class_entry *ce TSRMLS_DC)
{
	zend_object_value retval;

	rhash_object *obj = (rhash_object *)emalloc(sizeof(rhash_object));
	memset(obj, 0, sizeof(rhash_object));
	zend_object_std_init(&obj->zobj, ce TSRMLS_CC);
	obj->rhash = NULL;

	/* call object_properties_init(), because extending classes may use properties. */
	object_properties_init(&obj->zobj, ce);

	retval.handle = zend_objects_store_put(obj,
		(zend_objects_store_dtor_t) zend_objects_destroy_object,
		(zend_objects_free_object_storage_t)rhash_free_object, NULL TSRMLS_CC);
	retval.handlers = &rhash_object_handlers;
	return retval;
}
#else
static zend_object *rhash_create_object(zend_class_entry *ce TSRMLS_DC)
{
	rhash_object *obj = ecalloc(1, sizeof(*obj) + zend_object_properties_size(ce));
	zend_object_std_init(&obj->zobj, ce TSRMLS_CC);

	obj->zobj.handlers = &rhash_object_handlers;
	return &obj->zobj;
}
#endif

/* {{{ PHP_MINIT_FUNCTION(rhash) */
PHP_MINIT_FUNCTION(rhash)
{
	zend_class_entry ce;
	rhash_library_init(); /* initialize LibRHash */

	/* register RHash class, its methods and handlers */
	INIT_CLASS_ENTRY(ce, "RHash", rhash_methods);
	rhash_ce = zend_register_internal_class(&ce TSRMLS_CC);
	rhash_ce->create_object = rhash_create_object;

	memcpy(&rhash_object_handlers,
		zend_get_std_object_handlers(), sizeof(zend_object_handlers));
	rhash_object_handlers.clone_obj = NULL;
#if PHP_MAJOR_VERSION >= 7
	rhash_object_handlers.free_obj = rhash_free_object; /* This is the free handler */
	rhash_object_handlers.offset   = XtOffsetOf(rhash_object, zobj);
#endif

	REGISTER_RHASH_CONSTANT(RHASH_CRC32);
	REGISTER_RHASH_CONSTANT(RHASH_MD4);
	REGISTER_RHASH_CONSTANT(RHASH_MD5);
	REGISTER_RHASH_CONSTANT(RHASH_SHA1);
	REGISTER_RHASH_CONSTANT(RHASH_TIGER);
	REGISTER_RHASH_CONSTANT(RHASH_TTH);
	REGISTER_RHASH_CONSTANT(RHASH_BTIH);
	REGISTER_RHASH_CONSTANT(RHASH_ED2K);
	REGISTER_RHASH_CONSTANT(RHASH_AICH);
	REGISTER_RHASH_CONSTANT(RHASH_WHIRLPOOL);
	REGISTER_RHASH_CONSTANT(RHASH_RIPEMD160);
	REGISTER_RHASH_CONSTANT(RHASH_GOST);
	REGISTER_RHASH_CONSTANT(RHASH_GOST_CRYPTOPRO);
	REGISTER_RHASH_CONSTANT(RHASH_HAS160);
	REGISTER_RHASH_CONSTANT(RHASH_SNEFRU128);
	REGISTER_RHASH_CONSTANT(RHASH_SNEFRU256);
	REGISTER_RHASH_CONSTANT(RHASH_SHA224);
	REGISTER_RHASH_CONSTANT(RHASH_SHA256);
	REGISTER_RHASH_CONSTANT(RHASH_SHA384);
	REGISTER_RHASH_CONSTANT(RHASH_SHA512);
	REGISTER_RHASH_CONSTANT(RHASH_EDONR256);
	REGISTER_RHASH_CONSTANT(RHASH_EDONR512);
	REGISTER_RHASH_CONSTANT(RHASH_SHA3_224);
	REGISTER_RHASH_CONSTANT(RHASH_SHA3_256);
	REGISTER_RHASH_CONSTANT(RHASH_SHA3_384);
	REGISTER_RHASH_CONSTANT(RHASH_SHA3_512);
	REGISTER_RHASH_CONSTANT(RHASH_ALL);

	return SUCCESS;
}
/* }}} */

/* {{{ PHP_MSHUTDOWN_FUNCTION(rhash) */
PHP_MSHUTDOWN_FUNCTION(rhash)
{
	return SUCCESS;
}
/* }}} */

/* {{{ PHP_MINFO_FUNCTION(rhash) */
PHP_MINFO_FUNCTION(rhash)
{
	php_info_print_table_start();
	php_info_print_table_row(2, "rhash support", "enabled");
	php_info_print_table_end();
}
/* }}} */

/* Global functions */

/* {{{ proto int rhash_count()
   Returns the number of supported hash functions */
PHP_FUNCTION(rhash_count) {
	RETURN_LONG(rhash_count());
}
/* }}} */

/* {{{ proto int rhash_get_digest_size(int hash_id)
   Returns the size in bytes of message digest of the specified hash function */
PHP_FUNCTION(rhash_get_digest_size) {
	zend_long hash_id;

	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &hash_id) == FAILURE) {
		RETURN_FALSE;
	}
	RETURN_LONG(rhash_get_digest_size((unsigned)hash_id));
}
/* }}} */

/* {{{ proto boolean rhash_is_base32(int hash_id)
   Returns true if default format of message digest is base32 and false if it's hexadecimal */
PHP_FUNCTION(rhash_is_base32) {
	zend_long hash_id;

	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &hash_id) == FAILURE) {
		RETURN_FALSE;
	}
	RETURN_BOOL(rhash_is_base32((unsigned)hash_id));
}
/* }}} */

/* {{{ proto string rhash_get_name(int hash_id)
   Returns the name of the specified hash function */
PHP_FUNCTION(rhash_get_name) {
	zend_long hash_id;

	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &hash_id) == FAILURE) {
		RETURN_FALSE;
	}
	_RETURN_STRING(rhash_get_name((unsigned)hash_id));
}
/* }}} */

/* {{{ proto string rhash_msg(int hash_id, string message)
   Returns message digest for the message string */
PHP_FUNCTION(rhash_msg) {
	zend_long hash_id;
	char *s;
	strsize_t s_len;
	strsize_t length;
	rhash context = NULL;
	char buffer[130];

	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ls", &hash_id, &s, &s_len) == FAILURE) {
		RETURN_NULL();
	}

	if (!(context = rhash_init((unsigned)hash_id))) {
		RETURN_NULL();
	}

	rhash_update(context, s, s_len);
	rhash_final(context, 0);
	length = rhash_print(buffer, context, (unsigned)hash_id, 0);
	rhash_free(context);
	_RETURN_STRINGL(buffer, length);
}

/* Calculate hash for a php stream. Returns SUCCESS or FAILURE. */
static strsize_t _php_rhash_stream(INTERNAL_FUNCTION_PARAMETERS, rhash context, php_stream *stream, zend_long start, zend_long size)
{
	char data[8192];
	if (context == NULL) {
		rhash_object *obj = get_rhash_object(getThis());
		if ((context = obj->rhash) == NULL) return FAILURE;
	}

	if (start >= 0) {
		if (php_stream_seek(stream, start, SEEK_SET) < 0) return FAILURE;
	}

	if (size >= 0) {
		while (size > 0 && !php_stream_eof(stream)) {
			int length = php_stream_read(stream, data, (size < 8192 ? size : 8192));
			if (!length) return FAILURE;
			size -= length;
			rhash_update(context, data, length);
		}
	} else {
		while (!php_stream_eof(stream)) {
			int length = php_stream_read(stream, data, 8192);
			if (!length) return FAILURE;
			rhash_update(context, data, length);
		}
	}
	return SUCCESS;
}
/* }}} */

/* Calculate hash of the given file or its part. Returns SUCCESS or FAILURE. */
static strsize_t _php_rhash_file(INTERNAL_FUNCTION_PARAMETERS, rhash context, char* path, zend_long start, zend_long size)
{
	strsize_t res;
	php_stream *stream = php_stream_open_wrapper(path, "rb", 0, 0);
	if (stream == NULL) return FAILURE;

	res = _php_rhash_stream(INTERNAL_FUNCTION_PARAM_PASSTHRU, context, stream, start, size);
	php_stream_close(stream);
	return res;
}
/* }}} */

/* {{{ proto string rhash_file(int hash_id, string path)
   Computes and returns message digest for a file. Returns NULL on failure. */
PHP_FUNCTION(rhash_file) {
	zend_long hash_id = 0;
	char *path;
	strsize_t path_len;
	rhash context = NULL;
	char buffer[130];
	int buffer_length;
	strsize_t res;

	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lp", &hash_id, &path, &path_len) == FAILURE) {
		RETURN_NULL();
	}
	if (!hash_id || !(context = rhash_init(hash_id))) {
		RETURN_NULL()
	}
	res = _php_rhash_file(INTERNAL_FUNCTION_PARAM_PASSTHRU, context, path, -1, -1);
	rhash_final(context, 0);
	buffer_length = rhash_print(buffer, context, hash_id, 0);
	rhash_free(context);

	/* return NULL on failure */
	if (res != SUCCESS) {
		RETURN_NULL();
	}
	_RETURN_STRINGL(buffer, buffer_length);
}
/* }}} */

/* {{{ proto string rhash_magnet(int hash_id, string path)
   Computes and returns magnet link for a file. Returns NULL on failure. */
PHP_FUNCTION(rhash_magnet) {
	zend_long hash_id = 0;
	char *path;
	strsize_t path_len;
	rhash context = NULL;
	zend_string* str;
	size_t buffer_size;
	strsize_t res;

	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lp", &hash_id, &path, &path_len) == FAILURE) {
		RETURN_NULL();
	}
	if (!hash_id || !(context = rhash_init(hash_id))) {
		RETURN_NULL();
	}
	res = _php_rhash_file(INTERNAL_FUNCTION_PARAM_PASSTHRU, context, path, -1, -1);
	if (res != SUCCESS) RETURN_NULL();
	rhash_final(context, 0);

	buffer_size = rhash_print_magnet(0, path, context, hash_id, RHPR_FILESIZE);

	str = zend_string_alloc(buffer_size - 1, 0);
	if (!str) {
		rhash_free(context);
		RETURN_NULL();
	}

	rhash_print_magnet(str->val, path, context, hash_id, RHPR_FILESIZE);
	rhash_free(context);
	RETURN_NEW_STR(str);
}
/* }}} */


/* RHash class methods */

/* {{{ proto RHash::__construct([int hash_id])
   Creates new RHash object */
PHP_METHOD(RHash, __construct)
{
	zend_long hash_id = 0;
	rhash context = NULL;
	rhash_object *obj;

	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &hash_id) == FAILURE) {
		RETURN_NULL();
	}
	if (!hash_id)
		hash_id = RHASH_ALL_HASHES;
	if (!(context = rhash_init(hash_id))) {
		RETURN_NULL();
	}
	rhash_set_autofinal(context, 0);
	obj = get_rhash_object(getThis());
	obj->rhash = context;
}
/* }}} */

/* {{{ proto RHash RHash::update(string message)
   Updates RHash object with new data chunk and returns $this */
PHP_METHOD(RHash, update)
{
	char *s;
	strsize_t s_len;
	zval *object = getThis();
	rhash_object *obj =  get_rhash_object(object);
	
	if (obj->rhash == NULL ||
		zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &s, &s_len) == FAILURE) {
		RETURN_FALSE;
	}
	rhash_update(obj->rhash, s, s_len);
	Z_ADDREF(*object);
	*return_value = *object;
}
/* }}} */

/* {{{ proto boolean RHash::update_stream(resource handle[, int start[, int size]])
   Returns true if successfully calculated hashes for a (part of) stream, false on error */
PHP_METHOD(RHash, update_stream)
{
	zval *handle;
	strsize_t res;
	zend_long start = -1, size = -1;
	php_stream *stream;
	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r|ll", &handle, &start, &size) == FAILURE) {
		RETURN_FALSE;
	}
#if PHP_MAJOR_VERSION < 7
	php_stream_from_zval_no_verify(stream, &handle);
#else
	php_stream_from_zval_no_verify(stream, handle);
#endif
	if (stream == NULL) RETURN_FALSE;
	res = _php_rhash_stream(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0, stream, start, size);
	RETURN_BOOL(res == SUCCESS);
}
/* }}} */

/* {{{ proto boolean RHash::update_file(string path[, int start[, int size]])
   Returns true if successfully calculated hashes for a (part of) file, false on error */
PHP_METHOD(RHash, update_file)
{
	char *path;
	strsize_t len;
	zend_long start = -1, size = -1;
	strsize_t res = zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "p|ll", &path, &len, &start, &size);
	if (res == SUCCESS) {
		res = _php_rhash_file(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0, path, start, size);
	}
	RETURN_BOOL(res == SUCCESS);
}
/* }}} */

/* {{{ proto RHash RHash::final()
   Finalizes calculation for all hashed data and returns $this */
PHP_METHOD(RHash, final)
{
	zval *object = getThis();
	rhash_object *obj = get_rhash_object(object);
	if (obj->rhash == NULL) RETURN_FALSE;
	rhash_final(obj->rhash, NULL);
	Z_ADDREF(*object);
	*return_value = *object;
}
/* }}} */

/* {{{ proto RHash RHash::reset()
   Resets RHash object to initial state and returns $this */
PHP_METHOD(RHash, reset)
{
	zval *object = getThis();
	rhash_object *obj = get_rhash_object(object);
	if (obj->rhash == NULL) RETURN_FALSE;
	rhash_reset(obj->rhash);
	Z_ADDREF(*object);
	*return_value = *object;
}
/* }}} */

/* {{{ proto int RHash::hashed_length()
   Returns length in bytes of the hashed data */
PHP_METHOD(RHash, hashed_length)
{
	rhash_object *obj = get_rhash_object(getThis());
	if (obj->rhash == NULL) RETURN_FALSE;
	RETURN_LONG((long)obj->rhash->msg_size);
}
/* }}} */

/* {{{ _php_get_hash(RHash this_class[, int hash_id], int print_flags)
   Returns calculated hash in the specified format */
static void _php_get_hash(INTERNAL_FUNCTION_PARAMETERS, int print_flags)
{
	zend_long hash_id = 0;
	char buffer[130];
	int length;
	rhash_object *obj = get_rhash_object(getThis());
	if (obj->rhash == NULL ||
		zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &hash_id) == FAILURE) {
		RETURN_FALSE;
	}
	length = rhash_print(buffer, obj->rhash, hash_id, print_flags);
	_RETURN_STRINGL(buffer, length)
}
/* }}} */

/* {{{ proto string RHash::hash([int hash_id])
   Returns hash value in default format */
PHP_METHOD(RHash, hash)
{
	_php_get_hash(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0);
}
/* }}} */

/* {{{ proto string RHash::raw([int hash_id])
   Returns hash value as raw bytes */
PHP_METHOD(RHash, raw)
{
	_php_get_hash(INTERNAL_FUNCTION_PARAM_PASSTHRU, RHPR_RAW);
}
/* }}} */

/* {{{ proto string RHash::hex([int hash_id])
   Returns hash value as hexadecimal string */
PHP_METHOD(RHash, hex)
{
	_php_get_hash(INTERNAL_FUNCTION_PARAM_PASSTHRU, RHPR_HEX);
}
/* }}} */

/* {{{ proto string RHash::base32([int hash_id])
   Returns hash value as base32 string */
PHP_METHOD(RHash, base32)
{
	_php_get_hash(INTERNAL_FUNCTION_PARAM_PASSTHRU, RHPR_BASE32);
}
/* }}} */

/* {{{ proto string RHash::base64([int hash_id])
   Returns hash value as base64 string */
PHP_METHOD(RHash, base64)
{
	_php_get_hash(INTERNAL_FUNCTION_PARAM_PASSTHRU, RHPR_BASE64);
}
/* }}} */

/* {{{ proto string RHash::magnet([string filename])
   Returns magnet link with all hashes computed by the RHash object */
PHP_METHOD(RHash, magnet)
{
	char *s = 0;
	strsize_t s_len;
	size_t buf_size;
	zend_string *magnet_str;
	rhash_object *obj = get_rhash_object(getThis());

	if (obj->rhash == NULL ||
		zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s", &s, &s_len) == FAILURE) {
		RETURN_FALSE;
	}

	buf_size = rhash_print_magnet(0, s, obj->rhash, RHASH_ALL_HASHES, RHPR_FILESIZE);
	magnet_str = zend_string_alloc(buf_size - 1, 0);
	if (!magnet_str) RETURN_FALSE;

	rhash_print_magnet(magnet_str->val, s, obj->rhash, RHASH_ALL_HASHES, RHPR_FILESIZE);
	RETURN_NEW_STR(magnet_str);
}
/* }}} */

#ifndef PHP_RHASH_H
#define PHP_RHASH_H

extern zend_module_entry rhash_module_entry;
#define phpext_rhash_ptr &rhash_module_entry

PHP_MINIT_FUNCTION(rhash);
PHP_MSHUTDOWN_FUNCTION(rhash);
PHP_MINFO_FUNCTION(rhash);

PHP_FUNCTION(rhash_count);
PHP_FUNCTION(rhash_get_digest_size);
PHP_FUNCTION(rhash_get_name);
PHP_FUNCTION(rhash_is_base32);
PHP_FUNCTION(rhash_msg);
PHP_FUNCTION(rhash_file);
PHP_FUNCTION(rhash_magnet);

PHP_METHOD(RHash, __construct);
PHP_METHOD(RHash, update);
PHP_METHOD(RHash, update_stream);
PHP_METHOD(RHash, update_file);
PHP_METHOD(RHash, final);
PHP_METHOD(RHash, reset);
PHP_METHOD(RHash, hashed_length);

PHP_METHOD(RHash, hash);
PHP_METHOD(RHash, raw);
PHP_METHOD(RHash, hex);
PHP_METHOD(RHash, base32);
PHP_METHOD(RHash, base64);
PHP_METHOD(RHash, magnet);

#endif /* PHP_RHASH_H */

--TEST--
test RHash global functions
--FILE--
<?php
echo (rhash_count() >= 26) . "\n";
echo rhash_get_digest_size(RHASH_CRC32) . "\n";
echo (int)rhash_is_base32(RHASH_MD5) . "\n";
echo (int)rhash_is_base32(RHASH_AICH) . "\n";
echo rhash_get_name(RHASH_SHA1) . "\n";
echo rhash_msg(RHASH_TTH, 'abc') . "\n";
echo "Done\n";
?>
--EXPECTF--
1
4
0
1
SHA1
asd4ujseh5m47pdyb46kbtsqtsgdklbhyxomuia
Done

--TEST--
test RHash basic  methods
--FILE--
<?php
$r = new RHash();
$r->update('a')->final();
echo $r->hashed_length() . "\n";

echo $r->hash(RHASH_CRC32) . "\n";
echo $r->hash(RHASH_MD4) . "\n";
echo $r->hash(RHASH_MD5) . "\n";
echo $r->hash(RHASH_SHA1) . "\n";
echo $r->hash(RHASH_TIGER) . "\n";
echo $r->hash(RHASH_TTH) . "\n";
echo strlen($r->hash(RHASH_BTIH)) . "\n";
echo $r->hash(RHASH_ED2K) . "\n";
echo $r->hash(RHASH_AICH) . "\n";
echo $r->hash(RHASH_WHIRLPOOL) . "\n";
echo $r->hash(RHASH_RIPEMD160) . "\n";
echo $r->hash(RHASH_GOST) . "\n";
echo $r->hash(RHASH_GOST_CRYPTOPRO) . "\n";
echo $r->hash(RHASH_HAS160) . "\n";
echo $r->hash(RHASH_SNEFRU128) . "\n";
echo $r->hash(RHASH_SNEFRU256) . "\n";
echo $r->hash(RHASH_SHA224) . "\n";
echo $r->hash(RHASH_SHA256) . "\n";
echo $r->hash(RHASH_SHA384) . "\n";
echo $r->hash(RHASH_SHA512) . "\n";
echo $r->hash(RHASH_SHA3_224) . "\n";
echo $r->hash(RHASH_SHA3_256) . "\n";
echo $r->hash(RHASH_SHA3_384) . "\n";
echo $r->hash(RHASH_SHA3_512) . "\n";
echo $r->hash(RHASH_EDONR256) . "\n";
echo $r->hash(RHASH_EDONR512) . "\n";
echo $r->raw(RHASH_SHA1) . "\n";
echo $r->hex(RHASH_TTH) . "\n";
echo $r->base32(RHASH_SHA1) . "\n";
echo $r->base64(RHASH_SHA1) . "\n";
$r = new RHash(RHASH_CRC32 | RHASH_AICH);
echo $r->update('a')->final()->magnet('file.txt') . "\n";
echo "Done\n";
?>
--EXPECTF--
1
e8b7be43
bde52cb31de33e46245e05fbdbd6fb24
0cc175b9c0f1b6a831c399e269772661
86f7e437faa5a7fce15d1ddcb9eaeaea377667b8
77befbef2e7ef8ab2ec8f93bf587a7fc613e247f5f247809
czquwh3iyxbf5l3bgyugzhassmxu647ip2ike4y
40
bde52cb31de33e46245e05fbdbd6fb24
q336in72uwt7zyk5dxolt2xk5i3xmz5y
8aca2602792aec6f11a67206531fb7d7f0dff59413145e6973c45001d0087b42d11bc645413aeff63a42391a39145a591a92200d560195e53b478584fdae231a
0bdc9d2d256b3ee9daae347be6f4dc835a467ffe
d42c539e367c66e9c88a801f6649349c21871b4344c6a573f849fdce62f314dd
e74c52dd282183bf37af0079c9f78055715a103f17e3133ceff1aacf2f403011
4872bcbc4cd0f0a9dc7c2f7045e5b43b6c830db8
bf5ce540ae51bc50399f96746c5a15bd
45161589ac317be0ceba70db2573ddda6e668a31984b39bf65e4b664b584c63d
abd37534c7d9a2efb9465de931cd7055ffdb8879563ae98078d6d6d5
ca978112ca1bbdcafac231b39a23dc4da786eff8147c4e72b9807785afee48bb
54a59b9f22b0b80880d8427e548b7c23abd873486e1f035dce9cd697e85175033caa88e6d57bc35efae0b5afd3145f31
1f40fc92da241694750979ee6cf582f2d5d7d28e18335de05abc54d0560e0f5302860c652bf08d560252aa5e74210546f369fbbbce8c12cfc7957b2652fe9a75
9e86ff69557ca95f405f081269685b38e3a819b309ee942f482b6a8b
80084bf2fba02475726feb2cab2d8215eab14bc6bdd8bfb2c8151257032ecd8b
1815f774f320491b48569efec794d249eeb59aae46d22bf77dafe25c5edc28d7ea44f93ee1234aa88f61c91912a4ccd9
697f2d856172cb8309d6b8b97dac4de344b549d4dee61edfb4962d8698b7fa803f4f93ff24393586e28b5b957ac3d1d369420ce53332712f997bd336d09ab02a
943aa9225a2cf154ec2e4dd81237720ba538ca8df2fd83c0b893c5d265f353a0
b59ec44f7beef8a04ceed38a973d77c65e22e9458d5f67b497948da34986c093b5efc5483fbee55f2f740fcad31f18d80db44bb6b8843e7fd599188e7c07233b
†÷ä7ú¥§üá]ܹêêê7vg¸
16614b1f68c5c25eaf6136286c9c12932f4f73e87e90a273
q336in72uwt7zyk5dxolt2xk5i3xmz5y
hvfkN/qlp/zhXR3cuerq6jd2Z7g=
magnet:?xl=1&dn=file.txt&xt=urn:aich:q336in72uwt7zyk5dxolt2xk5i3xmz5y&xt=urn:crc32:e8b7be43
Done

--TEST--
test RHash file   methods
--FILE--
<?php
$filename = '003_test.txt';

$handle = fopen($filename, "w+b");
fwrite($handle, "012abc678");
$r = new RHash(RHASH_MD5);
$r->update_stream($handle, 3, 3);
echo $r->final()->magnet($filename) . "\n";
fclose($handle);

$r->reset()->update_file($filename);
echo $r->final()->magnet($filename) . "\n";
$r->reset()->update_file($filename, 2, 1);
echo $r->final()->magnet($filename) . "\n";

// test global file reading functions
echo rhash_file(RHASH_TTH, $filename) . "\n";
echo rhash_magnet(RHASH_TTH, $filename) . "\n";
unlink($filename);
echo "Done\n";
?>
--EXPECTF--
magnet:?xl=3&dn=003_test.txt&xt=urn:md5:900150983cd24fb0d6963f7d28e17f72
magnet:?xl=12&dn=003_test.txt&xt=urn:md5:5a73501e89118bfc45e19f26c0bb2c33
magnet:?xl=13&dn=003_test.txt&xt=urn:md5:c81e728d9d4c2f636f067f89cc14862c
2yu5rdna7qwl6e3ivtgzleuft766u72dxnlzdri
magnet:?xl=9&dn=003_test.txt&xt=urn:tree:tiger:2yu5rdna7qwl6e3ivtgzleuft766u72dxnlzdri
Done

*.pyc

# Python Bindings for Librhash
# Copyright (c) 2011-2012, Sergey Basalaev <sbasalaev@gmail.com>
# Librhash is (c) 2011-2012, Aleksey Kravchenko <rhash.admin@gmail.com>
#
# Permission is hereby granted, free of charge,  to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction,  including without limitation the rights
# to  use,  copy,  modify,  merge, publish, distribute, sublicense, and/or sell
# copies  of  the Software,  and  to permit  persons  to whom  the Software  is
# furnished to do so.
#
# This library  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. Use it at your own risk!

"""Python bindings for librhash

Librhash  is  a library for computing and verifying hash sums
that supports many hashing algorithms. The  simplest  way  to
calculate  hash  of  a message  or  a file is by using one of
the functions:

hash_for_msg(message, hash_id)
hash_for_file(filename, hash_id)
magnet_for_file(filename, hash_ids)

Here  hash_id  is one of the constants CRC32, MD4, MD5, SHA1,
TIGER, TTH, BTIH, ED2K,  AICH,  WHIRLPOOL,  RIPEMD160,  GOST,
GOST_CRYPTOPRO, HAS160, SNEFRU128, SNEFRU256, SHA224, SHA256,
SHA384,  SHA512,   SHA3_224,  SHA3_256,  SHA3_384,  SHA3_512,
EDONR256 or EDONR512.  The first  two functions  will  return
the  default text  representation of  the message digest they
compute.  The latter will return magnet  link  for the  file.
In this function  you can  OR-combine  several hash_ids, like

>>> print magnet_for_file('rhash.py', CRC32 | MD5)
magnet:?xl=6041&dn=rhash.py&xt=urn:crc32:f5866f7a&xt=urn:md5:
f88e6c1620361da9d04e2a2a1c788059

Next, this module provides a class to calculate several hashes
simultaneously in an incremental way. Example of using it:

>>> hasher = RHash(CRC32 | MD5)
>>> hasher.update('Hello, ')
>>> hasher << 'world' << '!'
>>> hasher.finish()
>>> print hasher.HEX(CRC32)
EBE6C6E6
>>> print hasher.hex(MD5)
6cd3556deb0da54bca060b4c39479839

In this example RHash object is first created for  a  set  of
hashing algorithms. Then, data for hashing is given in chunks
with   methods   update(message)  and  update_file(filename).
Finally, call finish() to end up all remaining calculations.

To  receive  text represenation of the message digest use one
of the methods hex(), HEX(), base32(), BASE32(), base64() and
BASE64().  The hash() method  outputs  message digest  in its
default format.  Binary  message digest may be obtained  with
raw().  All of these  methods  accept  hash_id  as  argument.
It may  be omitted  if  RHash  was  created  to  compute hash
for only a single hashing algorithm.

Method  magnet(filename)  will generate magnet link with  all
hashes computed by the RHash object.
"""

# public API
__all__ = [
    'ALL', 'CRC32', 'MD4', 'MD5', 'SHA1', 'TIGER', 'TTH',
    'BTIH', 'ED2K', 'AICH', 'WHIRLPOOL', 'RIPEMD160', 'GOST',
    'GOST_CRYPTOPRO', 'HAS160', 'SNEFRU128', 'SNEFRU256',
    'SHA224', 'SHA256', 'SHA384', 'SHA512', 'EDONR256', 'EDONR512',
    'SHA3_224', 'SHA3_256', 'SHA3_384', 'SHA3_512',
    'RHash', 'hash_for_msg', 'hash_for_file', 'magnet_for_file']

import sys
from ctypes import (
    CDLL, c_char_p, c_int, c_size_t, c_uint, c_void_p, create_string_buffer)

# initialization
if sys.platform == 'win32':
    LIBNAME = 'librhash.dll'
elif sys.platform == 'darwin':
    LIBNAME = 'librhash.0.dylib'
elif sys.platform == 'cygwin':
    LIBNAME = 'cygrhash.dll'
elif sys.platform == 'msys':
    LIBNAME = 'msys-rhash.dll'
else:
    LIBNAME = 'librhash.so.0'
LIBRHASH = CDLL(LIBNAME)
LIBRHASH.rhash_library_init()

# function prototypes
LIBRHASH.rhash_init.argtypes = [c_uint]
LIBRHASH.rhash_init.restype = c_void_p
LIBRHASH.rhash_free.argtypes = [c_void_p]
LIBRHASH.rhash_reset.argtypes = [c_void_p]
LIBRHASH.rhash_update.argtypes = [c_void_p, c_char_p, c_size_t]
LIBRHASH.rhash_final.argtypes = [c_void_p, c_char_p]
LIBRHASH.rhash_print.argtypes = [c_char_p, c_void_p, c_uint, c_int]
LIBRHASH.rhash_print.restype = c_size_t
LIBRHASH.rhash_print_magnet.argtypes = [
    c_char_p, c_char_p, c_void_p, c_uint, c_int]
LIBRHASH.rhash_print_magnet.restype = c_size_t
LIBRHASH.rhash_transmit.argtypes = [c_uint, c_void_p, c_size_t, c_size_t]

# conversion of a string to binary data with Python 2/3 compatibility
if sys.version < '3':
    def _s2b(string):
        """Python 2: just return the string"""
        return string
    def _msg_to_bytes(msg):
        """convert the msg parameter to a string"""
        if isinstance(msg, str):
            return msg
        return str(msg)
else:
    import codecs
    def _s2b(string):
        """Python 3: convert the string to binary data"""
        return codecs.utf_8_encode(string)[0]
    def _msg_to_bytes(msg):
        """convert the msg parameter to binary data"""
        if isinstance(msg, bytes):
            return msg
        if isinstance(msg, str):
            return _s2b(msg)
        return _s2b(str(msg))

# hash_id values
CRC32 = 0x01
MD4 = 0x02
MD5 = 0x04
SHA1 = 0x08
TIGER = 0x10
TTH = 0x20
BTIH = 0x40
ED2K = 0x80
AICH = 0x100
WHIRLPOOL = 0x200
RIPEMD160 = 0x400
GOST = 0x800
GOST_CRYPTOPRO = 0x1000
HAS160 = 0x2000
SNEFRU128 = 0x4000
SNEFRU256 = 0x8000
SHA224 = 0x10000
SHA256 = 0x20000
SHA384 = 0x40000
SHA512 = 0x80000
EDONR256 = 0x100000
EDONR512 = 0x200000
SHA3_224 = 0x0400000
SHA3_256 = 0x0800000
SHA3_384 = 0x1000000
SHA3_512 = 0x2000000
ALL = SHA3_512*2 - 1


#rhash_print values
RHPR_RAW = 1
RHPR_HEX = 2
RHPR_BASE32 = 3
RHPR_BASE64 = 4
RHPR_UPPERCASE = 8
RHPR_NO_MAGNET = 0x20
RHPR_FILESIZE = 0x40

class RHash(object):
    'Incremental hasher'

    def __init__(self, hash_ids):
        if hash_ids == 0:
            self._ctx = None
            raise ValueError('Invalid argument')
        self._ctx = LIBRHASH.rhash_init(hash_ids)
        #switching off the autofinal feature
        LIBRHASH.rhash_transmit(5, self._ctx, 0, 0)

    def __del__(self):
        if self._ctx != None:
            LIBRHASH.rhash_free(self._ctx)

    def reset(self):
        """reset this object to initial state"""
        LIBRHASH.rhash_reset(self._ctx)
        return self

    def update(self, message):
        """update this object with new data chunk"""
        data = _msg_to_bytes(message)
        LIBRHASH.rhash_update(self._ctx, data, len(data))
        return self

    def __lshift__(self, message):
        return self.update(message)

    def update_file(self, filename):
        """Update this object with data from the given file."""
        file = open(filename, 'rb')
        buf = file.read(8192)
        while len(buf) > 0:
            self.update(buf)
            buf = file.read(8192)
        file.close()
        return self

    def finish(self):
        """Calculate hashes for all the data buffered by
        the update() method.
        """
        LIBRHASH.rhash_final(self._ctx, None)
        return self

    def _print(self, hash_id, flags):
        """Retrieve the message hash in required format."""
        buf = create_string_buffer(130)
        size = LIBRHASH.rhash_print(buf, self._ctx, hash_id, flags)
        if (flags & 3) == RHPR_RAW:
            return buf[0:size]
        else:
            return buf[0:size].decode()

    def raw(self, hash_id=0):
        """Returns the message hash as raw binary data."""
        return self._print(hash_id, RHPR_RAW)

    def hex(self, hash_id=0):
        """Returns the message hash as a hexadecimal lower-case string."""
        return self._print(hash_id, RHPR_HEX)

    def base32(self, hash_id=0):
        """Returns the message hash as a Base32 lower-case string."""
        return self._print(hash_id, RHPR_BASE32)

    def base64(self, hash_id=0):
        """Returns the message hash as a Base64 string."""
        return self._print(hash_id, RHPR_BASE64)

    # pylint: disable=invalid-name
    def HEX(self, hash_id=0):
        """Returns the message hash as a hexadecimal upper-case string."""
        return self._print(hash_id, RHPR_HEX | RHPR_UPPERCASE)

    def BASE32(self, hash_id=0):
        """Returns the message hash as a Base32 upper-case string."""
        return self._print(hash_id, RHPR_BASE32 | RHPR_UPPERCASE)
    # pylint: enable=invalid-name

    def magnet(self, filepath):
        """Returns magnet link with all hashes computed by
        this object."""
        size = LIBRHASH.rhash_print_magnet(
            None, _s2b(filepath), self._ctx, ALL, RHPR_FILESIZE)
        buf = create_string_buffer(size)
        LIBRHASH.rhash_print_magnet(
            buf, _s2b(filepath), self._ctx, ALL, RHPR_FILESIZE)
        return buf[0:size-1].decode('utf-8')

    def hash(self, hash_id=0):
        """Returns the message digest for the given hash function
        as a string in the default format."""
        return self._print(hash_id, 0)

    def __str__(self):
        return self._print(0, 0)

def hash_for_msg(message, hash_id):
    """Computes and returns the message digest (in its default format)
    of the message"""
    handle = RHash(hash_id)
    handle.update(message).finish()
    return str(handle)

def hash_for_file(filename, hash_id):
    """Computes and returns the message digest (in its default format)
    of the file content"""
    handle = RHash(hash_id)
    handle.update_file(filename).finish()
    return str(handle)

def magnet_for_file(filename, hash_mask):
    """Computes and returns the magnet link for the file."""
    handle = RHash(hash_mask)
    handle.update_file(filename).finish()
    return handle.magnet(filename)

# UnitTest for Librhash Python Bindings
# Copyright (c) 2011-2012, Aleksey Kravchenko <rhash.admin@gmail.com>
#
# Permission is hereby granted, free of charge,  to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction,  including without limitation the rights
# to  use,  copy,  modify,  merge, publish, distribute, sublicense, and/or sell
# copies  of  the Software,  and  to permit  persons  to whom  the Software  is
# furnished to do so.
#
# This library  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. Use it at your own risk!
"""Unit-tests for the rhash module"""

import rhash
import os
import unittest

# pylint: disable=too-many-public-methods, pointless-statement
class TestRHash(unittest.TestCase):
    """The test-case class for the rhash module"""

    def test_all_hashes(self):
        """Verify all hash functions"""
        ctx = rhash.RHash(rhash.ALL)
        ctx.update('a')
        ctx.finish()
        self.assertEqual('e8b7be43', ctx.hash(rhash.CRC32))
        self.assertEqual('bde52cb31de33e46245e05fbdbd6fb24', ctx.hash(rhash.MD4))
        self.assertEqual('0cc175b9c0f1b6a831c399e269772661', ctx.hash(rhash.MD5))
        self.assertEqual(
            '86f7e437faa5a7fce15d1ddcb9eaeaea377667b8', ctx.hash(rhash.SHA1))
        self.assertEqual(
            '77befbef2e7ef8ab2ec8f93bf587a7fc613e247f5f247809',
            ctx.hash(rhash.TIGER))
        self.assertEqual(
            'czquwh3iyxbf5l3bgyugzhassmxu647ip2ike4y', ctx.hash(rhash.TTH))
        self.assertEqual(40, len(ctx.hash(rhash.BTIH)))
        self.assertEqual('bde52cb31de33e46245e05fbdbd6fb24', ctx.hash(rhash.ED2K))
        self.assertEqual('q336in72uwt7zyk5dxolt2xk5i3xmz5y', ctx.hash(rhash.AICH))
        self.assertEqual(
            '8aca2602792aec6f11a67206531fb7d7f0dff59413145e6973c45001d0087b42d11bc645413aeff63a42391a39145a591a92200d560195e53b478584fdae231a',
            ctx.hash(rhash.WHIRLPOOL))
        self.assertEqual(
            '0bdc9d2d256b3ee9daae347be6f4dc835a467ffe', ctx.hash(rhash.RIPEMD160))
        self.assertEqual(
            'd42c539e367c66e9c88a801f6649349c21871b4344c6a573f849fdce62f314dd',
            ctx.hash(rhash.GOST))
        self.assertEqual(
            'e74c52dd282183bf37af0079c9f78055715a103f17e3133ceff1aacf2f403011',
            ctx.hash(rhash.GOST_CRYPTOPRO))
        self.assertEqual(
            '4872bcbc4cd0f0a9dc7c2f7045e5b43b6c830db8',
            ctx.hash(rhash.HAS160))
        self.assertEqual(
            'bf5ce540ae51bc50399f96746c5a15bd', ctx.hash(rhash.SNEFRU128))
        self.assertEqual(
            '45161589ac317be0ceba70db2573ddda6e668a31984b39bf65e4b664b584c63d',
            ctx.hash(rhash.SNEFRU256))
        self.assertEqual(
            'abd37534c7d9a2efb9465de931cd7055ffdb8879563ae98078d6d6d5',
            ctx.hash(rhash.SHA224))
        self.assertEqual(
            'ca978112ca1bbdcafac231b39a23dc4da786eff8147c4e72b9807785afee48bb',
            ctx.hash(rhash.SHA256))
        self.assertEqual(
            '54a59b9f22b0b80880d8427e548b7c23abd873486e1f035dce9cd697e85175033caa88e6d57bc35efae0b5afd3145f31',
            ctx.hash(rhash.SHA384))
        self.assertEqual(
            '1f40fc92da241694750979ee6cf582f2d5d7d28e18335de05abc54d0560e0f5302860c652bf08d560252aa5e74210546f369fbbbce8c12cfc7957b2652fe9a75',
            ctx.hash(rhash.SHA512))
        self.assertEqual(
            '943aa9225a2cf154ec2e4dd81237720ba538ca8df2fd83c0b893c5d265f353a0',
            ctx.hash(rhash.EDONR256))
        self.assertEqual(
            'b59ec44f7beef8a04ceed38a973d77c65e22e9458d5f67b497948da34986c093b5efc5483fbee55f2f740fcad31f18d80db44bb6b8843e7fd599188e7c07233b',
            ctx.hash(rhash.EDONR512))
        self.assertEqual(
            '9e86ff69557ca95f405f081269685b38e3a819b309ee942f482b6a8b',
            ctx.hash(rhash.SHA3_224))
        self.assertEqual(
            '80084bf2fba02475726feb2cab2d8215eab14bc6bdd8bfb2c8151257032ecd8b',
            ctx.hash(rhash.SHA3_256))
        self.assertEqual(
            '1815f774f320491b48569efec794d249eeb59aae46d22bf77dafe25c5edc28d7ea44f93ee1234aa88f61c91912a4ccd9',
            ctx.hash(rhash.SHA3_384))
        self.assertEqual(
            '697f2d856172cb8309d6b8b97dac4de344b549d4dee61edfb4962d8698b7fa803f4f93ff24393586e28b5b957ac3d1d369420ce53332712f997bd336d09ab02a',
            ctx.hash(rhash.SHA3_512))
        # test reset
        self.assertEqual(
            'd41d8cd98f00b204e9800998ecf8427e',
            ctx.reset().finish().hash(rhash.MD5)) # MD5( '' )

    def test_update(self):
        """Test the sequential update calls"""
        ctx = rhash.RHash(rhash.CRC32 | rhash.MD5)
        ctx.update('Hello, ').update('world!').finish()
        self.assertEqual('EBE6C6E6', ctx.HEX(rhash.CRC32))
        self.assertEqual('6cd3556deb0da54bca060b4c39479839', ctx.hex(rhash.MD5))

    def test_shift_operator(self):
        """Test the << operator"""
        ctx = rhash.RHash(rhash.MD5)
        ctx << 'a' << 'bc'
        # MD5( 'abc' )
        self.assertEqual('900150983cd24fb0d6963f7d28e17f72', str(ctx.finish()))

    def test_hash_for_msg(self):
        """Test the hash_for_msg() function"""
        self.assertEqual(
            '900150983cd24fb0d6963f7d28e17f72',
            rhash.hash_for_msg('abc', rhash.MD5))

    def test_output_formats(self):
        """Test all output formats of a message digest"""
        ctx = rhash.RHash(rhash.MD5 | rhash.TTH).finish()
        self.assertEqual(
            '5d9ed00a030e638bdb753a6a24fb900e5a63b8e73e6c25b6',
            ctx.hex(rhash.TTH))
        self.assertEqual('2qoyzwmpaczaj2mabgmoz6ccpy', ctx.base32(rhash.MD5))
        self.assertEqual('1B2M2Y8AsgTpgAmY7PhCfg==', ctx.base64(rhash.MD5))
        self.assertEqual(
            b'\xd4\x1d\x8c\xd9\x8f\x00\xb2\x04\xe9\x80\x09\x98\xec\xf8\x42\x7e',
            ctx.raw(rhash.MD5))

    def test_magnet(self):
        """Test calculation of a magnet link"""
        ctx = rhash.RHash(rhash.MD5 | rhash.TTH)
        ctx.update('abc').finish()
        self.assertEqual(
            'magnet:?xl=3&dn=file.txt&xt=urn:md5:900150983cd24fb0d6963f7d28e17f72&xt=urn:tree:tiger:asd4ujseh5m47pdyb46kbtsqtsgdklbhyxomuia',
            ctx.magnet('file.txt'))

    def test_update_file(self):
        """Test the update_file() method"""
        path = 'python_test_input_123.txt'
        file = open(path, 'wb')
        file.write(b"\0\1\2\n")
        file.close()

        ctx = rhash.RHash(rhash.SHA1)
        ctx.update_file(path).finish()
        self.assertEqual('e3869ec477661fad6b9fc25914bb2eee5455b483', str(ctx))
        self.assertEqual(
            'e3869ec477661fad6b9fc25914bb2eee5455b483',
            rhash.hash_for_file(path, rhash.SHA1))
        self.assertEqual(
            'magnet:?xl=4&dn=python_test_input_123.txt&xt=urn:tree:tiger:c6docz63fpef5pdfpz35z7mw2iozshxlpr4erza',
            rhash.magnet_for_file(path, rhash.TTH))
        os.remove(path)

if __name__ == '__main__':
    unittest.main()

mkmf.log
rhash.so
Makefile

require 'mkmf'

if ENV['LIBRHASH_INC']
    $CFLAGS  += ENV['LIBRHASH_INC']
else
    have_header('rhash.h')
end

$LDFLAGS += ' ' + ENV['LIBRHASH_LD'] if ENV['LIBRHASH_LD']
$LDFLAGS += ' -lrhash'

dir_config('rhash')
create_makefile('rhash')

/*
 * Ruby Bindings for Librhash
 * Copyright (c) 2011-2012, Sergey Basalaev <sbasalaev@gmail.com>
 * Librhash is (c) 2011-2012, Aleksey Kravchenko <rhash.admin@gmail.com>
 * 
 * Permission is hereby granted, free of charge,  to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction,  including without limitation the rights
 * to  use,  copy,  modify,  merge, publish, distribute, sublicense, and/or sell
 * copies  of  the Software,  and  to permit  persons  to whom  the Software  is
 * furnished to do so.
 * 
 * This library  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. Use it at your own risk!
 */

#include <ruby.h>
#include <rhash.h>

/* RHash class. */
static VALUE cRHash;

static void rh_free(rhash ctx) {
	rhash_free(ctx);
}

/**
 * call-seq:
 *   rhash.update(data) -> RHash
 *   rhash << data      -> RHash
 *
 * Updates this <code>RHash</code> with new data chunk.
 */
static VALUE rh_update(VALUE self, VALUE msg) {
	rhash ctx;
	Data_Get_Struct(self, struct rhash_context, ctx);

	if (TYPE(msg) != T_STRING) {
		msg = rb_obj_as_string(msg); /* convert to string */
	}

	rhash_update(ctx, RSTRING_PTR(msg), RSTRING_LEN(msg));
	return self;
}

/* declaring non-static method to fix a warning on an unused function */
VALUE rh_update_file(VALUE self, VALUE file);

/**
 * call-seq:
 *   rhash.update_file(filename) -> RHash
 * 
 * Updates this <code>RHash</code> with data from given file.
 */
VALUE rh_update_file(VALUE self, VALUE file) {
	// this function is actually implemented in pure Ruby below
	// this allows us to handle files in platform-independent way
	return self;
}

/**
 * call-seq:
 *   rhash.finish
 *
 * Finishes calculation for all data buffered by
 * <code>update</code> and stops calculation of hashes.
 */
static VALUE rh_finish(VALUE self) {
	rhash ctx;
	Data_Get_Struct(self, struct rhash_context, ctx);
	rhash_final(ctx, NULL);
	return self;
}

/**
 * call-seq:
 *   rhash.reset
 *
 * Resets this RHash to initial state.
 * The RHash becomes available to process
 * new data chunks.
 */
static VALUE rh_reset(VALUE self) {
	rhash ctx;
	Data_Get_Struct(self, struct rhash_context, ctx);
	rhash_reset(ctx);
	return self;
}

static VALUE rh_print(VALUE self, VALUE type, int flags) {
	char buf[130];
	rhash ctx;
	Data_Get_Struct(self, struct rhash_context, ctx);
	int len = rhash_print(buf, ctx, type == Qnil ? 0 : FIX2INT(type), flags);
	return rb_str_new(buf, len);
}

/**
 * call-seq:
 *   rhash.to_raw(id)
 *   rhash.to_raw
 *
 * Returns value of the RHash digest as raw bytes.
 * If RHash was created with a single hashing algorithm
 * then argument may be omitted.
 */
static VALUE rh_to_raw(int argc, VALUE* argv, VALUE self) {
	VALUE type;
	rb_scan_args(argc, argv, "01", &type);
	return rh_print(self, type, RHPR_RAW);
}

/**
 * call-seq:
 *   rhash.to_hex(id)
 *   rhash.to_hex
 *
 * Returns value of the RHash digest as hexadecimal string.
 * If RHash was created with a single hashing algorithm
 * then argument may be omitted.
 */
static VALUE rh_to_hex(int argc, VALUE* argv, VALUE self) {
	VALUE type;
	rb_scan_args(argc, argv, "01", &type);
	return rh_print(self, type, RHPR_HEX);
}

/**
 * call-seq:
 *   rhash.to_base32(id)
 *   rhash.to_base32
 *
 * Returns value of the RHash digest as base32 string.
 * If RHash was created with a single hashing algorithm
 * then argument may be omitted.
 */
static VALUE rh_to_base32(int argc, VALUE* argv, VALUE self) {
	VALUE type;
	rb_scan_args(argc, argv, "01", &type);
	return rh_print(self, type, RHPR_BASE32);
}

/**
 * call-seq:
 *   rhash.magnet(filepath)
 *   rhash.magnet
 *
 * Returns magnet link with all hashes computed by
 * the RHash object.
 * if filepath is specified, then it is url-encoded
 * and included into the resulting magnet link.
 */
static VALUE rh_magnet(int argc, VALUE* argv, VALUE self) {
	VALUE value;
	const char* filepath = 0;
	char* buf;
	size_t buf_size;
	rhash ctx;

	Data_Get_Struct(self, struct rhash_context, ctx);

	rb_scan_args(argc, argv, "01", &value);
	if (value != Qnil) {
		if (TYPE(value) != T_STRING) value = rb_obj_as_string(value);
		filepath = RSTRING_PTR(value);
	}

	buf_size = rhash_print_magnet(0, filepath, ctx, RHASH_ALL_HASHES, RHPR_FILESIZE);
	buf = (char*)malloc(buf_size);
	if (!buf) return Qnil;

	rhash_print_magnet(buf, filepath, ctx, RHASH_ALL_HASHES, RHPR_FILESIZE);
	value = rb_str_new2(buf);
	free(buf);
	return value;
}

/**
 * call-seq:
 *   rhash.to_base64(id)
 *   rhash.to_base64
 *
 * Returns value of the RHash digest as base64 string.
 * If RHash was created with a single hashing algorithm
 * then argument may be omitted.
 */
static VALUE rh_to_base64(int argc, VALUE* argv, VALUE self) {
	VALUE type;
	rb_scan_args(argc, argv, "01", &type);
	return rh_print(self, type, RHPR_BASE64);
}

/**
 * call-seq:
 *   rhash.to_s(id)
 *   rhash.to_s
 *
 * Returns value of the RHash digest for given algorithm
 * as string in default format. If RHash was created with
 * a single hashing algorithm then argument may be omitted.
 */
static VALUE rh_to_s(int argc, VALUE* argv, VALUE self) {
	VALUE type;
	rb_scan_args(argc, argv, "01", &type);
	return rh_print(self, type, 0);
}

/**
 * call-seq:
 *   RHash.base32?(id) -> true or false
 *
 * Returns true if default format for given hash algorithm is
 * base32 and false if it is hexadecimal.
 */
static VALUE rh_is_base32(VALUE self, VALUE type) {
	return rhash_is_base32(FIX2INT(type)) ? Qtrue : Qfalse;
}

static VALUE rh_init(int argc, VALUE *argv, VALUE self) {
	return self;
}

/**
 * call-seq:
 *   RHash.new(id, ...)
 *
 * Creates RHash object to calculate hashes for given algorithms.
 * Parameters should be constants defined in this class.
 */
VALUE rh_new(int argc, VALUE* argv, VALUE clz) {
	int flags = 0, i;
	for (i=0; i<argc; i++) {
		flags |= FIX2INT(argv[i]);
	}
	if (!flags) flags = RHASH_ALL_HASHES;
	rhash ctx = rhash_init(flags);
	rhash_set_autofinal(ctx, 0);
	VALUE newobj = Data_Wrap_Struct(clz, NULL, rh_free, ctx);
	rb_obj_call_init(newobj, argc, argv);
	return newobj;
}

/**
 * Librhash is a library for computing and verifying hash sums
 * that supports many hashing algorithms. This module provides
 * class for incremental hashing that utilizes the library.
 * Sample usage of it you can see from the following example:
 * 
 *   hasher = RHash.new(RHash::CRC32, RHash::MD5)
 *   hasher.update('Hello, ')
 *   hasher << 'world' << '!'
 *   hasher.finish
 *   puts hasher.to_hex RHash::CRC32
 *   puts hasher.to_base32 RHash::MD5
 *
 * which produces
 *
 *   ebe6c6e6
 *   ntjvk3plbwsuxsqgbngdsr4yhe
 *
 * In this example <code>RHash</code> object is first created
 * for a set of hashing algorithms.
 *
 * Next, data for hashing is  given  in  chunks  with  methods
 * <code>update</code> and <code>update_file</code>. Finally,
 * call <code>finish</code> to end up all remaining calculations.
 *
 * To receive text represenation of the message digest use one
 * of methods <code>to_hex</code>, <code>to_base32</code> and
 * <code>to_base64</code>. Binary message digest may be obtained
 * with <code>to_raw</code>. All of these methods accept algorithm
 * value as argument. It may be omitted if <code>RHash</code> was
 * created to compute hash for only a single hashing algorithm.
 */
void Init_rhash() {
	rhash_library_init();
	
	cRHash = rb_define_class("RHash", rb_cObject);
	
	rb_define_singleton_method(cRHash, "new", rh_new, -1);
	rb_define_singleton_method(cRHash, "base32?", rh_is_base32, 1);
	
	rb_define_method(cRHash, "initialize", rh_init,  -1);
	rb_define_method(cRHash, "update",     rh_update, 1);
	rb_define_method(cRHash, "<<",         rh_update, 1);
	rb_define_method(cRHash, "finish",     rh_finish, 0);
	rb_define_method(cRHash, "reset",      rh_reset,  0);
	rb_define_method(cRHash, "to_raw",     rh_to_raw, -1);
	rb_define_method(cRHash, "to_hex",     rh_to_hex, -1);
	rb_define_method(cRHash, "to_base32",  rh_to_base32, -1);
	rb_define_method(cRHash, "to_base64",  rh_to_base64, -1);
	rb_define_method(cRHash, "to_s",       rh_to_s, -1);
	rb_define_method(cRHash, "magnet",     rh_magnet, -1);
	
	rb_eval_string(
"class RHash \n\
  def update_file(filename) \n\
    f = File.open(filename, 'rb') \n\
    while block = f.read(4096) \n\
      self.update(block) \n\
    end \n\
    f.close \n\
    self \n\
  end \n\
end\n\
\n\
def RHash.hash_for_msg(msg, hash_id)\n\
  RHash.new(hash_id).update(msg).finish.to_s\n\
end\n\
\n\
def RHash.hash_for_file(filename, hash_id)\n\
  RHash.new(hash_id).update_file(filename).finish.to_s\n\
end\n\
\n\
def RHash.magnet_for_file(filename, *hash_ids)\n\
  RHash.new(*hash_ids).update_file(filename).finish.magnet(filename)\n\
end");
	
	/** CRC32 checksum. */
	rb_define_const(cRHash, "CRC32",     INT2FIX(RHASH_CRC32));
	/** MD4 hash. */
	rb_define_const(cRHash, "MD4",       INT2FIX(RHASH_MD4));
	/** MD5 hash. */
	rb_define_const(cRHash, "MD5",       INT2FIX(RHASH_MD5));
	/** SHA-1 hash. */
	rb_define_const(cRHash, "SHA1",      INT2FIX(RHASH_SHA1));
	/** Tiger hash. */
	rb_define_const(cRHash, "TIGER",     INT2FIX(RHASH_TIGER));
	/** Tiger tree hash */
	rb_define_const(cRHash, "TTH",       INT2FIX(RHASH_TTH));
	/** BitTorrent info hash. */
	rb_define_const(cRHash, "BTIH",      INT2FIX(RHASH_BTIH));
	/** EDonkey 2000 hash. */
	rb_define_const(cRHash, "ED2K",      INT2FIX(RHASH_ED2K));
	/** eMule AICH. */
	rb_define_const(cRHash, "AICH",      INT2FIX(RHASH_AICH));
	/** Whirlpool hash. */
	rb_define_const(cRHash, "WHIRLPOOL", INT2FIX(RHASH_WHIRLPOOL));
	/** RIPEMD-160 hash. */
	rb_define_const(cRHash, "RIPEMD160", INT2FIX(RHASH_RIPEMD160));
	/** GOST R 34.11-94. */
	rb_define_const(cRHash, "GOST",      INT2FIX(RHASH_GOST));
	/** GOST R 34.11-94. */
	rb_define_const(cRHash, "GOST_CRYPTOPRO", INT2FIX(RHASH_GOST_CRYPTOPRO));
	/** HAS-160 hash. */
	rb_define_const(cRHash, "HAS160",    INT2FIX(RHASH_HAS160));
	/** Snefru-128 hash. */
	rb_define_const(cRHash, "SNEFRU128", INT2FIX(RHASH_SNEFRU128));
	/** Snefru-256 hash. */
	rb_define_const(cRHash, "SNEFRU256", INT2FIX(RHASH_SNEFRU256));
	/** SHA-224 hash. */
	rb_define_const(cRHash, "SHA224",    INT2FIX(RHASH_SHA224));
	/** SHA-256 hash. */
	rb_define_const(cRHash, "SHA256",    INT2FIX(RHASH_SHA256));
	/** SHA-384 hash. */
	rb_define_const(cRHash, "SHA384",    INT2FIX(RHASH_SHA384));
	/** SHA-512 hash. */
	rb_define_const(cRHash, "SHA512",    INT2FIX(RHASH_SHA512));
	/** EDON-R 256. */
	rb_define_const(cRHash, "EDONR256",  INT2FIX(RHASH_EDONR256));
	/** EDON-R 512. */
	rb_define_const(cRHash, "EDONR512",  INT2FIX(RHASH_EDONR512));
	/** SHA3-224 hash. */
	rb_define_const(cRHash, "SHA3_224",    INT2FIX(RHASH_SHA3_224));
	/** SHA3-256 hash. */
	rb_define_const(cRHash, "SHA3_256",    INT2FIX(RHASH_SHA3_256));
	/** SHA3-384 hash. */
	rb_define_const(cRHash, "SHA3_384",    INT2FIX(RHASH_SHA3_384));
	/** SHA3-512 hash. */
	rb_define_const(cRHash, "SHA3_512",    INT2FIX(RHASH_SHA3_512));
	/** Create RHash with this parameter to compute hashes for all available algorithms. */
	rb_define_const(cRHash, "ALL",       INT2FIX(RHASH_ALL_HASHES));
}