diff --git a/net/btpd/Makefile b/net/btpd/Makefile new file mode 100644 index 000000000..177ccd967 --- /dev/null +++ b/net/btpd/Makefile @@ -0,0 +1,40 @@ +include $(TOPDIR)/rules.mk + +PKG_NAME:=btpd +PKG_VERSION:=0.13 +PKG_RELEASE:=1 + +PKG_SOURCE:=$(PKG_NAME)-$(PKG_VERSION).tar.gz +PKG_SOURCE_URL:=http://www.murmeldjur.se/btpd/ +PRG_MD5SUM:=0d9c4a672eea6f298fa6e44d94da1657 + +include $(INCLUDE_DIR)/package.mk + +define Package/btpd + SECTION:=net + CATEGORY:=Network + SUBMENU:=BitTorrent + TITLE:=btpd - BitTorrent Protocol Daemon + URL:=http://www.murmeldjur.se/btpd/ +endef + +define Package/btpd/description + BTPD is a bittorrent client consisting of a daemon and client commands, + which can be used to read and/or manipulate the daemon state. + The daemon is capable of running several torrents simultaneously and only uses one tcp port. + It's fairly low on resource usage and should be perfect for file distribution sites. + Efficient downloads and ease of use makes this client a good choice for the casual user as well. +endef + +CONFIGURE_ARGS += -C + +define Package/btpd/install + $(INSTALL_DIR) $(1)/usr/bin + $(INSTALL_BIN) $(PKG_BUILD_DIR)/btpd/btpd $(1)/usr/bin + $(INSTALL_BIN) $(PKG_BUILD_DIR)/cli/btcli $(1)/usr/bin + $(INSTALL_BIN) $(PKG_BUILD_DIR)/cli/btinfo $(1)/usr/bin + $(INSTALL_DIR) $(1)/etc/init.d + $(INSTALL_BIN) ./files/btpd.init $(1)/etc/init.d/btpd +endef + +$(eval $(call BuildPackage,btpd)) diff --git a/net/btpd/files/btpd.init b/net/btpd/files/btpd.init new file mode 100644 index 000000000..f897c6c9a --- /dev/null +++ b/net/btpd/files/btpd.init @@ -0,0 +1,16 @@ +#!/bin/sh /etc/rc.common + +RUN_D=/var/btpd + +start () { + btpd -d $RUN_D +} + +stop () { + echo -n "stop btpd " + while btcli -d $RUN_D kill ; do + echo -n . + sleep 3 + done 2>/dev/null + echo " done" +} diff --git a/net/btpd/patches/000-sha1.diff b/net/btpd/patches/000-sha1.diff new file mode 100644 index 000000000..71b161798 --- /dev/null +++ b/net/btpd/patches/000-sha1.diff @@ -0,0 +1,747 @@ +diff -purN btpd-0.13/btpd/content.c btpd-0.13-hack/btpd/content.c +--- btpd-0.13/btpd/content.c 2007-05-18 19:32:01.000000000 +0400 ++++ btpd-0.13-hack/btpd/content.c 2007-09-04 14:59:06.000000000 +0400 +@@ -7,7 +7,7 @@ + #include + #include + +-#include ++#include "sha1.h" + + #include "btpd.h" + #include "stream.h" +diff -purN btpd-0.13/btpd/download_subr.c btpd-0.13-hack/btpd/download_subr.c +--- btpd-0.13/btpd/download_subr.c 2007-05-18 19:32:01.000000000 +0400 ++++ btpd-0.13-hack/btpd/download_subr.c 2007-09-04 15:13:35.000000000 +0400 +@@ -24,8 +24,6 @@ + #include + #include + +-#include +- + #include "btpd.h" + #include "stream.h" + +diff -purN btpd-0.13/btpd/Makefile.am btpd-0.13-hack/btpd/Makefile.am +--- btpd-0.13/btpd/Makefile.am 2007-05-18 19:32:01.000000000 +0400 ++++ btpd-0.13-hack/btpd/Makefile.am 2007-09-04 15:15:17.000000000 +0400 +@@ -16,5 +16,5 @@ btpd_SOURCES=\ + util.c + + btpd_LDADD=../misc/libmisc.a ../libevent/libevent.a +-btpd_CPPFLAGS=-I$(top_srcdir)/misc -I$(top_srcdir)/libevent @openssl_CPPFLAGS@ +-btpd_LDFLAGS=@openssl_LDFLAGS@ -lcrypto -lm ++btpd_CPPFLAGS=-I$(top_srcdir)/misc -I$(top_srcdir)/libevent ++btpd_LDFLAGS=-lm +diff -purN btpd-0.13/btpd/torrent.c btpd-0.13-hack/btpd/torrent.c +--- btpd-0.13/btpd/torrent.c 2007-05-19 12:41:32.000000000 +0400 ++++ btpd-0.13-hack/btpd/torrent.c 2007-09-04 15:14:06.000000000 +0400 +@@ -10,8 +10,6 @@ + #include + #include + +-#include +- + #include "btpd.h" + #include "tracker_req.h" + #include "stream.h" +diff -purN btpd-0.13/cli/Makefile.am btpd-0.13-hack/cli/Makefile.am +--- btpd-0.13/cli/Makefile.am 2007-05-18 19:32:00.000000000 +0400 ++++ btpd-0.13-hack/cli/Makefile.am 2007-09-04 15:14:46.000000000 +0400 +@@ -1,11 +1,11 @@ + bin_PROGRAMS=btinfo btcli + + btinfo_SOURCES=btinfo.c +-btinfo_LDADD=../misc/libmisc.a -lcrypto -lm +-btinfo_CPPFLAGS=-I$(top_srcdir)/misc @openssl_CPPFLAGS@ +-btinfo_LDFLAGS=@openssl_LDFLAGS@ ++btinfo_LDADD=../misc/libmisc.a -lm ++btinfo_CPPFLAGS=-I$(top_srcdir)/misc ++btinfo_LDFLAGS= + + btcli_SOURCES=btcli.c btcli.h add.c del.c list.c kill.c start.c stop.c stat.c +-btcli_LDADD=../misc/libmisc.a -lcrypto -lm +-btcli_CPPFLAGS=-I$(top_srcdir)/misc @openssl_CPPFLAGS@ +-btcli_LDFLAGS=@openssl_LDFLAGS@ ++btcli_LDADD=../misc/libmisc.a -lm ++btcli_CPPFLAGS=-I$(top_srcdir)/misc ++btcli_LDFLAGS= +diff -purN btpd-0.13/configure.ac btpd-0.13-hack/configure.ac +--- btpd-0.13/configure.ac 2007-05-18 19:31:59.000000000 +0400 ++++ btpd-0.13-hack/configure.ac 2007-09-04 15:09:17.000000000 +0400 +@@ -10,14 +10,6 @@ AC_PROG_RANLIB + CFLAGS="$CFLAGS -std=c99" + CPPFLAGS="$CPPFLAGS -D_GNU_SOURCE=1 -D_FILE_OFFSET_BITS=64" + +-AC_ARG_WITH(openssl, +-[ --with-openssl=dir use openssl installed in dir], +-[ +- AC_SUBST(openssl_LDFLAGS,["-L${withval}/lib -Wl,-rpath=${withval}/lib"]) +- AC_SUBST(openssl_CPPFLAGS,"-I${withval}/include") +-], +-[]) +- + AC_ARG_WITH(warn, + [ --with-warn=level select warning preset (no,all,allerr)], + [ +@@ -38,11 +30,6 @@ AC_ARG_WITH(warn, + ], + []) + +-old_LDFLAGS="$LDFLAGS" +-LDFLAGS="$LDFLAGS $openssl_LDFLAGS" +-AC_CHECK_LIB(crypto, SHA1_Final, :, echo Must have openssl; exit 1) +-LDFLAGS=$old_LDFLAGS +- + AC_CONFIG_SUBDIRS([libevent]) + + AC_OUTPUT +diff -purN btpd-0.13/libevent/evdns.c btpd-0.13-hack/libevent/evdns.c +--- btpd-0.13/libevent/evdns.c 2007-05-18 19:32:01.000000000 +0400 ++++ btpd-0.13-hack/libevent/evdns.c 2007-09-04 15:12:38.000000000 +0400 +@@ -47,33 +47,21 @@ + + #ifndef DNS_USE_CPU_CLOCK_FOR_ID + #ifndef DNS_USE_GETTIMEOFDAY_FOR_ID +-#ifndef DNS_USE_OPENSSL_FOR_ID + #error Must configure at least one id generation method. + #error Please see the documentation. + #endif + #endif +-#endif + + // #define _POSIX_C_SOURCE 200507 + #define _GNU_SOURCE + + #ifdef DNS_USE_CPU_CLOCK_FOR_ID +-#ifdef DNS_USE_OPENSSL_FOR_ID +-#error Multiple id options selected +-#endif + #ifdef DNS_USE_GETTIMEOFDAY_FOR_ID + #error Multiple id options selected + #endif + #include + #endif + +-#ifdef DNS_USE_OPENSSL_FOR_ID +-#ifdef DNS_USE_GETTIMEOFDAY_FOR_ID +-#error Multiple id options selected +-#endif +-#include +-#endif +- + #define _FORTIFY_SOURCE 3 + + #include +@@ -1026,18 +1014,6 @@ transaction_id_pick(void) { + trans_id = tv.tv_usec & 0xffff; + #endif + +-#ifdef DNS_USE_OPENSSL_FOR_ID +- u16 trans_id; +- if (RAND_pseudo_bytes((u8 *) &trans_id, 2) == -1) { +- /* // in the case that the RAND call fails we back +- // down to using gettimeofday. +- struct timeval tv; +- gettimeofday(&tv, NULL); +- trans_id = tv.tv_usec & 0xffff; */ +- abort(); +- } +-#endif +- + if (trans_id == 0xffff) continue; + // now check to see if that id is already inflight + req = started_at = req_head; +diff -purN btpd-0.13/misc/Makefile.am btpd-0.13-hack/misc/Makefile.am +--- btpd-0.13/misc/Makefile.am 2007-05-18 19:32:01.000000000 +0400 ++++ btpd-0.13-hack/misc/Makefile.am 2007-09-04 14:57:39.000000000 +0400 +@@ -8,5 +8,6 @@ libmisc_a_SOURCES=\ + iobuf.c iobuf.h\ + queue.h\ + stream.c stream.h\ +- subr.c subr.h +-libmisc_a_CPPFLAGS=-I$(top_srcdir)/libevent @openssl_CPPFLAGS@ ++ subr.c subr.h\ ++ sha1.c sha1.h ++libmisc_a_CPPFLAGS=-I$(top_srcdir)/libevent +diff -purN btpd-0.13/misc/metainfo.c btpd-0.13-hack/misc/metainfo.c +--- btpd-0.13/misc/metainfo.c 2007-05-18 19:32:01.000000000 +0400 ++++ btpd-0.13-hack/misc/metainfo.c 2007-09-04 14:58:20.000000000 +0400 +@@ -5,8 +5,7 @@ + #include + #include + +-#include +- ++#include "sha1.h" + #include "benc.h" + #include "metainfo.h" + #include "subr.h" +@@ -158,7 +157,7 @@ mi_info_hash(const char *p, uint8_t *has + if (hash == NULL) + if ((hash = malloc(20)) == NULL) + return NULL; +- return SHA1(info, benc_length(info), hash); ++ return (uint8_t *)sha1_buffer(info, benc_length(info), hash); + } + + char * +diff -purN btpd-0.13/misc/sha1.c btpd-0.13-hack/misc/sha1.c +--- btpd-0.13/misc/sha1.c 1970-01-01 03:00:00.000000000 +0300 ++++ btpd-0.13-hack/misc/sha1.c 2007-09-04 14:45:36.000000000 +0400 +@@ -0,0 +1,423 @@ ++/* sha1.c - Functions to compute SHA1 message digest of files or ++ memory blocks according to the NIST specification FIPS-180-1. ++ ++ Copyright (C) 2000, 2001, 2003, 2004, 2005 Free Software Foundation, Inc. ++ ++ This program is free software; you can redistribute it and/or modify it ++ under the terms of the GNU General Public License as published by the ++ Free Software Foundation; either version 2, or (at your option) any ++ later version. ++ ++ 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. See the ++ GNU General Public License for more details. ++ ++ You should have received a copy of the GNU General Public License ++ along with this program; if not, write to the Free Software Foundation, ++ Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ ++ ++/* Written by Scott G. Miller ++ Credits: ++ Robert Klep -- Expansion function fix ++*/ ++ ++#ifdef HAVE_CONFIG_H ++# include ++#endif ++ ++#include "sha1.h" ++ ++#include ++#include ++ ++#if USE_UNLOCKED_IO ++# include "unlocked-io.h" ++#endif ++ ++/* SWAP does an endian swap on architectures that are little-endian, ++ as SHA1 needs some data in a big-endian form. */ ++ ++#ifdef WORDS_BIGENDIAN ++# define SWAP(n) (n) ++#else ++# define SWAP(n) \ ++ (((n) << 24) | (((n) & 0xff00) << 8) | (((n) >> 8) & 0xff00) | ((n) >> 24)) ++#endif ++ ++#define BLOCKSIZE 4096 ++#if BLOCKSIZE % 64 != 0 ++# error "invalid BLOCKSIZE" ++#endif ++ ++/* This array contains the bytes used to pad the buffer to the next ++ 64-byte boundary. (RFC 1321, 3.1: Step 1) */ ++static const unsigned char fillbuf[64] = { 0x80, 0 /* , 0, 0, ... */ }; ++ ++ ++/* ++ Takes a pointer to a 160 bit block of data (five 32 bit ints) and ++ intializes it to the start constants of the SHA1 algorithm. This ++ must be called before using hash in the call to sha1_hash. ++*/ ++void ++sha1_init_ctx (struct sha1_ctx *ctx) ++{ ++ ctx->A = 0x67452301; ++ ctx->B = 0xefcdab89; ++ ctx->C = 0x98badcfe; ++ ctx->D = 0x10325476; ++ ctx->E = 0xc3d2e1f0; ++ ++ ctx->total[0] = ctx->total[1] = 0; ++ ctx->buflen = 0; ++} ++ ++/* Put result from CTX in first 20 bytes following RESBUF. The result ++ must be in little endian byte order. ++ ++ IMPORTANT: On some systems it is required that RESBUF is correctly ++ aligned for a 32 bits value. */ ++void * ++sha1_read_ctx (const struct sha1_ctx *ctx, void *resbuf) ++{ ++ ((uint32_t *) resbuf)[0] = SWAP (ctx->A); ++ ((uint32_t *) resbuf)[1] = SWAP (ctx->B); ++ ((uint32_t *) resbuf)[2] = SWAP (ctx->C); ++ ((uint32_t *) resbuf)[3] = SWAP (ctx->D); ++ ((uint32_t *) resbuf)[4] = SWAP (ctx->E); ++ ++ return resbuf; ++} ++ ++/* Process the remaining bytes in the internal buffer and the usual ++ prolog according to the standard and write the result to RESBUF. ++ ++ IMPORTANT: On some systems it is required that RESBUF is correctly ++ aligned for a 32 bits value. */ ++void * ++sha1_finish_ctx (struct sha1_ctx *ctx, void *resbuf) ++{ ++ /* Take yet unprocessed bytes into account. */ ++ uint32_t bytes = ctx->buflen; ++ size_t pad; ++ ++ /* Now count remaining bytes. */ ++ ctx->total[0] += bytes; ++ if (ctx->total[0] < bytes) ++ ++ctx->total[1]; ++ ++ pad = bytes >= 56 ? 64 + 56 - bytes : 56 - bytes; ++ memcpy (&ctx->buffer[bytes], fillbuf, pad); ++ ++ /* Put the 64-bit file length in *bits* at the end of the buffer. */ ++ *(uint32_t *) &ctx->buffer[bytes + pad + 4] = SWAP (ctx->total[0] << 3); ++ *(uint32_t *) &ctx->buffer[bytes + pad] = SWAP ((ctx->total[1] << 3) | ++ (ctx->total[0] >> 29)); ++ ++ /* Process last bytes. */ ++ sha1_process_block (ctx->buffer, bytes + pad + 8, ctx); ++ ++ return sha1_read_ctx (ctx, resbuf); ++} ++ ++/* Compute SHA1 message digest for bytes read from STREAM. The ++ resulting message digest number will be written into the 16 bytes ++ beginning at RESBLOCK. */ ++int ++sha1_stream (FILE *stream, void *resblock) ++{ ++ struct sha1_ctx ctx; ++ char buffer[BLOCKSIZE + 72]; ++ size_t sum; ++ ++ /* Initialize the computation context. */ ++ sha1_init_ctx (&ctx); ++ ++ /* Iterate over full file contents. */ ++ while (1) ++ { ++ /* We read the file in blocks of BLOCKSIZE bytes. One call of the ++ computation function processes the whole buffer so that with the ++ next round of the loop another block can be read. */ ++ size_t n; ++ sum = 0; ++ ++ /* Read block. Take care for partial reads. */ ++ while (1) ++ { ++ n = fread (buffer + sum, 1, BLOCKSIZE - sum, stream); ++ ++ sum += n; ++ ++ if (sum == BLOCKSIZE) ++ break; ++ ++ if (n == 0) ++ { ++ /* Check for the error flag IFF N == 0, so that we don't ++ exit the loop after a partial read due to e.g., EAGAIN ++ or EWOULDBLOCK. */ ++ if (ferror (stream)) ++ return 1; ++ goto process_partial_block; ++ } ++ ++ /* We've read at least one byte, so ignore errors. But always ++ check for EOF, since feof may be true even though N > 0. ++ Otherwise, we could end up calling fread after EOF. */ ++ if (feof (stream)) ++ goto process_partial_block; ++ } ++ ++ /* Process buffer with BLOCKSIZE bytes. Note that ++ BLOCKSIZE % 64 == 0 ++ */ ++ sha1_process_block (buffer, BLOCKSIZE, &ctx); ++ } ++ ++ process_partial_block:; ++ ++ /* Process any remaining bytes. */ ++ if (sum > 0) ++ sha1_process_bytes (buffer, sum, &ctx); ++ ++ /* Construct result in desired memory. */ ++ sha1_finish_ctx (&ctx, resblock); ++ return 0; ++} ++ ++/* Compute MD5 message digest for LEN bytes beginning at BUFFER. The ++ result is always in little endian byte order, so that a byte-wise ++ output yields to the wanted ASCII representation of the message ++ digest. */ ++void * ++sha1_buffer (const char *buffer, size_t len, void *resblock) ++{ ++ struct sha1_ctx ctx; ++ ++ /* Initialize the computation context. */ ++ sha1_init_ctx (&ctx); ++ ++ /* Process whole buffer but last len % 64 bytes. */ ++ sha1_process_bytes (buffer, len, &ctx); ++ ++ /* Put result in desired memory area. */ ++ return sha1_finish_ctx (&ctx, resblock); ++} ++ ++void ++sha1_process_bytes (const void *buffer, size_t len, struct sha1_ctx *ctx) ++{ ++ /* When we already have some bits in our internal buffer concatenate ++ both inputs first. */ ++ if (ctx->buflen != 0) ++ { ++ size_t left_over = ctx->buflen; ++ size_t add = 128 - left_over > len ? len : 128 - left_over; ++ ++ memcpy (&ctx->buffer[left_over], buffer, add); ++ ctx->buflen += add; ++ ++ if (ctx->buflen > 64) ++ { ++ sha1_process_block (ctx->buffer, ctx->buflen & ~63, ctx); ++ ++ ctx->buflen &= 63; ++ /* The regions in the following copy operation cannot overlap. */ ++ memcpy (ctx->buffer, &ctx->buffer[(left_over + add) & ~63], ++ ctx->buflen); ++ } ++ ++ buffer = (const char *) buffer + add; ++ len -= add; ++ } ++ ++ /* Process available complete blocks. */ ++ if (len >= 64) ++ { ++#if !_STRING_ARCH_unaligned ++# define alignof(type) offsetof (struct { char c; type x; }, x) ++# define UNALIGNED_P(p) (((size_t) p) % alignof (uint32_t) != 0) ++ if (UNALIGNED_P (buffer)) ++ while (len > 64) ++ { ++ sha1_process_block (memcpy (ctx->buffer, buffer, 64), 64, ctx); ++ buffer = (const char *) buffer + 64; ++ len -= 64; ++ } ++ else ++#endif ++ { ++ sha1_process_block (buffer, len & ~63, ctx); ++ buffer = (const char *) buffer + (len & ~63); ++ len &= 63; ++ } ++ } ++ ++ /* Move remaining bytes in internal buffer. */ ++ if (len > 0) ++ { ++ size_t left_over = ctx->buflen; ++ ++ memcpy (&ctx->buffer[left_over], buffer, len); ++ left_over += len; ++ if (left_over >= 64) ++ { ++ sha1_process_block (ctx->buffer, 64, ctx); ++ left_over -= 64; ++ memcpy (ctx->buffer, &ctx->buffer[64], left_over); ++ } ++ ctx->buflen = left_over; ++ } ++} ++ ++/* --- Code below is the primary difference between md5.c and sha1.c --- */ ++ ++/* SHA1 round constants */ ++#define K1 0x5a827999L ++#define K2 0x6ed9eba1L ++#define K3 0x8f1bbcdcL ++#define K4 0xca62c1d6L ++ ++/* Round functions. Note that F2 is the same as F4. */ ++#define F1(B,C,D) ( D ^ ( B & ( C ^ D ) ) ) ++#define F2(B,C,D) (B ^ C ^ D) ++#define F3(B,C,D) ( ( B & C ) | ( D & ( B | C ) ) ) ++#define F4(B,C,D) (B ^ C ^ D) ++ ++/* Process LEN bytes of BUFFER, accumulating context into CTX. ++ It is assumed that LEN % 64 == 0. ++ Most of this code comes from GnuPG's cipher/sha1.c. */ ++ ++void ++sha1_process_block (const void *buffer, size_t len, struct sha1_ctx *ctx) ++{ ++ const uint32_t *words = buffer; ++ size_t nwords = len / sizeof (uint32_t); ++ const uint32_t *endp = words + nwords; ++ uint32_t x[16]; ++ uint32_t a = ctx->A; ++ uint32_t b = ctx->B; ++ uint32_t c = ctx->C; ++ uint32_t d = ctx->D; ++ uint32_t e = ctx->E; ++ ++ /* First increment the byte count. RFC 1321 specifies the possible ++ length of the file up to 2^64 bits. Here we only compute the ++ number of bytes. Do a double word increment. */ ++ ctx->total[0] += len; ++ if (ctx->total[0] < len) ++ ++ctx->total[1]; ++ ++#define rol(x, n) (((x) << (n)) | ((x) >> (32 - (n)))) ++ ++#define M(I) ( tm = x[I&0x0f] ^ x[(I-14)&0x0f] \ ++ ^ x[(I-8)&0x0f] ^ x[(I-3)&0x0f] \ ++ , (x[I&0x0f] = rol(tm, 1)) ) ++ ++#define R(A,B,C,D,E,F,K,M) do { E += rol( A, 5 ) \ ++ + F( B, C, D ) \ ++ + K \ ++ + M; \ ++ B = rol( B, 30 ); \ ++ } while(0) ++ ++ while (words < endp) ++ { ++ uint32_t tm; ++ int t; ++ for (t = 0; t < 16; t++) ++ { ++ x[t] = SWAP (*words); ++ words++; ++ } ++ ++ R( a, b, c, d, e, F1, K1, x[ 0] ); ++ R( e, a, b, c, d, F1, K1, x[ 1] ); ++ R( d, e, a, b, c, F1, K1, x[ 2] ); ++ R( c, d, e, a, b, F1, K1, x[ 3] ); ++ R( b, c, d, e, a, F1, K1, x[ 4] ); ++ R( a, b, c, d, e, F1, K1, x[ 5] ); ++ R( e, a, b, c, d, F1, K1, x[ 6] ); ++ R( d, e, a, b, c, F1, K1, x[ 7] ); ++ R( c, d, e, a, b, F1, K1, x[ 8] ); ++ R( b, c, d, e, a, F1, K1, x[ 9] ); ++ R( a, b, c, d, e, F1, K1, x[10] ); ++ R( e, a, b, c, d, F1, K1, x[11] ); ++ R( d, e, a, b, c, F1, K1, x[12] ); ++ R( c, d, e, a, b, F1, K1, x[13] ); ++ R( b, c, d, e, a, F1, K1, x[14] ); ++ R( a, b, c, d, e, F1, K1, x[15] ); ++ R( e, a, b, c, d, F1, K1, M(16) ); ++ R( d, e, a, b, c, F1, K1, M(17) ); ++ R( c, d, e, a, b, F1, K1, M(18) ); ++ R( b, c, d, e, a, F1, K1, M(19) ); ++ R( a, b, c, d, e, F2, K2, M(20) ); ++ R( e, a, b, c, d, F2, K2, M(21) ); ++ R( d, e, a, b, c, F2, K2, M(22) ); ++ R( c, d, e, a, b, F2, K2, M(23) ); ++ R( b, c, d, e, a, F2, K2, M(24) ); ++ R( a, b, c, d, e, F2, K2, M(25) ); ++ R( e, a, b, c, d, F2, K2, M(26) ); ++ R( d, e, a, b, c, F2, K2, M(27) ); ++ R( c, d, e, a, b, F2, K2, M(28) ); ++ R( b, c, d, e, a, F2, K2, M(29) ); ++ R( a, b, c, d, e, F2, K2, M(30) ); ++ R( e, a, b, c, d, F2, K2, M(31) ); ++ R( d, e, a, b, c, F2, K2, M(32) ); ++ R( c, d, e, a, b, F2, K2, M(33) ); ++ R( b, c, d, e, a, F2, K2, M(34) ); ++ R( a, b, c, d, e, F2, K2, M(35) ); ++ R( e, a, b, c, d, F2, K2, M(36) ); ++ R( d, e, a, b, c, F2, K2, M(37) ); ++ R( c, d, e, a, b, F2, K2, M(38) ); ++ R( b, c, d, e, a, F2, K2, M(39) ); ++ R( a, b, c, d, e, F3, K3, M(40) ); ++ R( e, a, b, c, d, F3, K3, M(41) ); ++ R( d, e, a, b, c, F3, K3, M(42) ); ++ R( c, d, e, a, b, F3, K3, M(43) ); ++ R( b, c, d, e, a, F3, K3, M(44) ); ++ R( a, b, c, d, e, F3, K3, M(45) ); ++ R( e, a, b, c, d, F3, K3, M(46) ); ++ R( d, e, a, b, c, F3, K3, M(47) ); ++ R( c, d, e, a, b, F3, K3, M(48) ); ++ R( b, c, d, e, a, F3, K3, M(49) ); ++ R( a, b, c, d, e, F3, K3, M(50) ); ++ R( e, a, b, c, d, F3, K3, M(51) ); ++ R( d, e, a, b, c, F3, K3, M(52) ); ++ R( c, d, e, a, b, F3, K3, M(53) ); ++ R( b, c, d, e, a, F3, K3, M(54) ); ++ R( a, b, c, d, e, F3, K3, M(55) ); ++ R( e, a, b, c, d, F3, K3, M(56) ); ++ R( d, e, a, b, c, F3, K3, M(57) ); ++ R( c, d, e, a, b, F3, K3, M(58) ); ++ R( b, c, d, e, a, F3, K3, M(59) ); ++ R( a, b, c, d, e, F4, K4, M(60) ); ++ R( e, a, b, c, d, F4, K4, M(61) ); ++ R( d, e, a, b, c, F4, K4, M(62) ); ++ R( c, d, e, a, b, F4, K4, M(63) ); ++ R( b, c, d, e, a, F4, K4, M(64) ); ++ R( a, b, c, d, e, F4, K4, M(65) ); ++ R( e, a, b, c, d, F4, K4, M(66) ); ++ R( d, e, a, b, c, F4, K4, M(67) ); ++ R( c, d, e, a, b, F4, K4, M(68) ); ++ R( b, c, d, e, a, F4, K4, M(69) ); ++ R( a, b, c, d, e, F4, K4, M(70) ); ++ R( e, a, b, c, d, F4, K4, M(71) ); ++ R( d, e, a, b, c, F4, K4, M(72) ); ++ R( c, d, e, a, b, F4, K4, M(73) ); ++ R( b, c, d, e, a, F4, K4, M(74) ); ++ R( a, b, c, d, e, F4, K4, M(75) ); ++ R( e, a, b, c, d, F4, K4, M(76) ); ++ R( d, e, a, b, c, F4, K4, M(77) ); ++ R( c, d, e, a, b, F4, K4, M(78) ); ++ R( b, c, d, e, a, F4, K4, M(79) ); ++ ++ a = ctx->A += a; ++ b = ctx->B += b; ++ c = ctx->C += c; ++ d = ctx->D += d; ++ e = ctx->E += e; ++ } ++} +diff -purN btpd-0.13/misc/sha1.h btpd-0.13-hack/misc/sha1.h +--- btpd-0.13/misc/sha1.h 1970-01-01 03:00:00.000000000 +0300 ++++ btpd-0.13-hack/misc/sha1.h 2007-09-04 14:49:48.000000000 +0400 +@@ -0,0 +1,90 @@ ++/* Declarations of functions and data types used for SHA1 sum ++ library functions. ++ Copyright (C) 2000, 2001, 2003, 2005 Free Software Foundation, Inc. ++ ++ This program is free software; you can redistribute it and/or modify it ++ under the terms of the GNU General Public License as published by the ++ Free Software Foundation; either version 2, or (at your option) any ++ later version. ++ ++ 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. See the ++ GNU General Public License for more details. ++ ++ You should have received a copy of the GNU General Public License ++ along with this program; if not, write to the Free Software Foundation, ++ Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ ++ ++#ifndef SHA1_H ++# define SHA1_H 1 ++ ++#include ++ ++#include ++ ++#define SHA_DIGEST_LENGTH 20 ++ ++/* Structure to save state of computation between the single steps. */ ++struct sha1_ctx ++{ ++ uint32_t A; ++ uint32_t B; ++ uint32_t C; ++ uint32_t D; ++ uint32_t E; ++ ++ uint32_t total[2]; ++ uint32_t buflen; ++ char buffer[128]; ++}; ++ ++ ++/* Initialize structure containing state of computation. */ ++extern void sha1_init_ctx (struct sha1_ctx *ctx); ++ ++/* Starting with the result of former calls of this function (or the ++ initialization function update the context for the next LEN bytes ++ starting at BUFFER. ++ It is necessary that LEN is a multiple of 64!!! */ ++extern void sha1_process_block (const void *buffer, size_t len, ++ struct sha1_ctx *ctx); ++ ++/* Starting with the result of former calls of this function (or the ++ initialization function update the context for the next LEN bytes ++ starting at BUFFER. ++ It is NOT required that LEN is a multiple of 64. */ ++extern void sha1_process_bytes (const void *buffer, size_t len, ++ struct sha1_ctx *ctx); ++ ++/* Process the remaining bytes in the buffer and put result from CTX ++ in first 20 bytes following RESBUF. The result is always in little ++ endian byte order, so that a byte-wise output yields to the wanted ++ ASCII representation of the message digest. ++ ++ IMPORTANT: On some systems it is required that RESBUF be correctly ++ aligned for a 32 bits value. */ ++extern void *sha1_finish_ctx (struct sha1_ctx *ctx, void *resbuf); ++ ++ ++/* Put result from CTX in first 20 bytes following RESBUF. The result is ++ always in little endian byte order, so that a byte-wise output yields ++ to the wanted ASCII representation of the message digest. ++ ++ IMPORTANT: On some systems it is required that RESBUF is correctly ++ aligned for a 32 bits value. */ ++extern void *sha1_read_ctx (const struct sha1_ctx *ctx, void *resbuf); ++ ++ ++/* Compute SHA1 message digest for bytes read from STREAM. The ++ resulting message digest number will be written into the 20 bytes ++ beginning at RESBLOCK. */ ++extern int sha1_stream (FILE *stream, void *resblock); ++ ++/* Compute SHA1 message digest for LEN bytes beginning at BUFFER. The ++ result is always in little endian byte order, so that a byte-wise ++ output yields to the wanted ASCII representation of the message ++ digest. */ ++extern void *sha1_buffer (const char *buffer, size_t len, void *resblock); ++ ++#endif +diff -purN btpd-0.13/misc/stream.c btpd-0.13-hack/misc/stream.c +--- btpd-0.13/misc/stream.c 2007-05-18 19:32:01.000000000 +0400 ++++ btpd-0.13-hack/misc/stream.c 2007-09-04 14:53:35.000000000 +0400 +@@ -5,7 +5,7 @@ + #include + #include + +-#include ++#include "sha1.h" + + #include "metainfo.h" + #include "subr.h" +@@ -161,21 +161,21 @@ bts_put(struct bt_stream *bts, off_t off + int + bts_sha(struct bt_stream *bts, off_t start, off_t length, uint8_t *hash) + { +- SHA_CTX ctx; ++ struct sha1_ctx ctx; + char buf[SHAFILEBUF]; + size_t wantread; + int err = 0; + +- SHA1_Init(&ctx); ++ sha1_init_ctx(&ctx); + while (length > 0) { + wantread = min(length, SHAFILEBUF); + if ((err = bts_get(bts, start, buf, wantread)) != 0) + break; + length -= wantread; + start += wantread; +- SHA1_Update(&ctx, buf, wantread); ++ sha1_process_bytes(buf, wantread, &ctx); + } +- SHA1_Final(hash, &ctx); ++ sha1_finish_ctx(&ctx, hash); + return err; + } + diff --git a/net/btpd/patches/100-clock.diff b/net/btpd/patches/100-clock.diff new file mode 100644 index 000000000..9873a7669 --- /dev/null +++ b/net/btpd/patches/100-clock.diff @@ -0,0 +1,4 @@ +--- btpd-0.13/config.cache 2007-10-13 17:10:21.000000000 +0400 ++++ btpd-0.13/config.cache 2008-01-12 01:58:20.000000000 +0300 +@@ -0,0 +1 @@ ++ac_cv_func_clock_gettime=no