diff -ruN cpdup-1.05.orig/bsd-MD5/md5c.c cpdup-1.05/bsd-MD5/md5c.c --- cpdup-1.05.orig/bsd-MD5/md5c.c 1969-12-31 18:00:00.000000000 -0600 +++ cpdup-1.05/bsd-MD5/md5c.c 2004-12-10 19:00:00.000000000 -0600 @@ -0,0 +1,338 @@ +/* + * MD5C.C - RSA Data Security, Inc., MD5 message-digest algorithm + * + * Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All + * rights reserved. + * + * License to copy and use this software is granted provided that it + * is identified as the "RSA Data Security, Inc. MD5 Message-Digest + * Algorithm" in all material mentioning or referencing this software + * or this function. + * + * License is also granted to make and use derivative works provided + * that such works are identified as "derived from the RSA Data + * Security, Inc. MD5 Message-Digest Algorithm" in all material + * mentioning or referencing the derived work. + * + * RSA Data Security, Inc. makes no representations concerning either + * the merchantability of this software or the suitability of this + * software for any particular purpose. It is provided "as is" + * without express or implied warranty of any kind. + * + * These notices must be retained in any copies of any part of this + * documentation and/or software. + * + * This code is the same as the code published by RSA Inc. It has been + * edited for clarity and style only. + */ + +#include +#ifndef __FBSDID +#define __FBSDID(s) +#endif +__FBSDID("$FreeBSD: src/lib/libmd/md5c.c,v 1.16 2003/06/05 13:17:32 markm Exp $"); + +#include + +#ifdef _KERNEL +#include +#else +#include +#endif + +#include +#include + +static void MD5Transform(u_int32_t [4], const unsigned char [64]); + +#ifdef _KERNEL +#define memset(x,y,z) bzero(x,z); +#define memcpy(x,y,z) bcopy(y, x, z) +#endif + +#if (BYTE_ORDER == LITTLE_ENDIAN) +#define Encode memcpy +#define Decode memcpy +#else + +/* + * Encodes input (u_int32_t) into output (unsigned char). Assumes len is + * a multiple of 4. + */ + +static void +Encode (unsigned char *output, u_int32_t *input, unsigned int len) +{ + unsigned int i; + u_int32_t *op = (u_int32_t *)output; + + for (i = 0; i < len / 4; i++) + op[i] = htole32(input[i]); +} + +/* + * Decodes input (unsigned char) into output (u_int32_t). Assumes len is + * a multiple of 4. + */ + +static void +Decode (u_int32_t *output, const unsigned char *input, unsigned int len) +{ + unsigned int i; + const u_int32_t *ip = (const u_int32_t *)input; + + for (i = 0; i < len / 4; i++) + output[i] = le32toh(ip[i]); +} +#endif + +static unsigned char PADDING[64] = { + 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 +}; + +/* F, G, H and I are basic MD5 functions. */ +#define F(x, y, z) (((x) & (y)) | ((~x) & (z))) +#define G(x, y, z) (((x) & (z)) | ((y) & (~z))) +#define H(x, y, z) ((x) ^ (y) ^ (z)) +#define I(x, y, z) ((y) ^ ((x) | (~z))) + +/* ROTATE_LEFT rotates x left n bits. */ +#define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32-(n)))) + +/* + * FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4. + * Rotation is separate from addition to prevent recomputation. + */ +#define FF(a, b, c, d, x, s, ac) { \ + (a) += F ((b), (c), (d)) + (x) + (u_int32_t)(ac); \ + (a) = ROTATE_LEFT ((a), (s)); \ + (a) += (b); \ + } +#define GG(a, b, c, d, x, s, ac) { \ + (a) += G ((b), (c), (d)) + (x) + (u_int32_t)(ac); \ + (a) = ROTATE_LEFT ((a), (s)); \ + (a) += (b); \ + } +#define HH(a, b, c, d, x, s, ac) { \ + (a) += H ((b), (c), (d)) + (x) + (u_int32_t)(ac); \ + (a) = ROTATE_LEFT ((a), (s)); \ + (a) += (b); \ + } +#define II(a, b, c, d, x, s, ac) { \ + (a) += I ((b), (c), (d)) + (x) + (u_int32_t)(ac); \ + (a) = ROTATE_LEFT ((a), (s)); \ + (a) += (b); \ + } + +/* MD5 initialization. Begins an MD5 operation, writing a new context. */ + +void +MD5Init (context) + MD5_CTX *context; +{ + + context->count[0] = context->count[1] = 0; + + /* Load magic initialization constants. */ + context->state[0] = 0x67452301; + context->state[1] = 0xefcdab89; + context->state[2] = 0x98badcfe; + context->state[3] = 0x10325476; +} + +/* + * MD5 block update operation. Continues an MD5 message-digest + * operation, processing another message block, and updating the + * context. + */ + +void +MD5Update (context, input, inputLen) + MD5_CTX *context; + const unsigned char *input; + unsigned int inputLen; +{ + unsigned int i, idx, partLen; + + /* Compute number of bytes mod 64 */ + idx = (unsigned int)((context->count[0] >> 3) & 0x3F); + + /* Update number of bits */ + if ((context->count[0] += ((u_int32_t)inputLen << 3)) + < ((u_int32_t)inputLen << 3)) + context->count[1]++; + context->count[1] += ((u_int32_t)inputLen >> 29); + + partLen = 64 - idx; + + /* Transform as many times as possible. */ + if (inputLen >= partLen) { + memcpy((void *)&context->buffer[idx], (const void *)input, + partLen); + MD5Transform (context->state, context->buffer); + + for (i = partLen; i + 63 < inputLen; i += 64) + MD5Transform (context->state, &input[i]); + + idx = 0; + } + else + i = 0; + + /* Buffer remaining input */ + memcpy ((void *)&context->buffer[idx], (const void *)&input[i], + inputLen-i); +} + +/* + * MD5 padding. Adds padding followed by original length. + */ + +void +MD5Pad (context) + MD5_CTX *context; +{ + unsigned char bits[8]; + unsigned int idx, padLen; + + /* Save number of bits */ + Encode (bits, context->count, 8); + + /* Pad out to 56 mod 64. */ + idx = (unsigned int)((context->count[0] >> 3) & 0x3f); + padLen = (idx < 56) ? (56 - idx) : (120 - idx); + MD5Update (context, PADDING, padLen); + + /* Append length (before padding) */ + MD5Update (context, bits, 8); +} + +/* + * MD5 finalization. Ends an MD5 message-digest operation, writing the + * the message digest and zeroizing the context. + */ + +void +MD5Final (digest, context) + unsigned char digest[16]; + MD5_CTX *context; +{ + /* Do padding. */ + MD5Pad (context); + + /* Store state in digest */ + Encode (digest, context->state, 16); + + /* Zeroize sensitive information. */ + memset ((void *)context, 0, sizeof (*context)); +} + +/* MD5 basic transformation. Transforms state based on block. */ + +static void +MD5Transform (state, block) + u_int32_t state[4]; + const unsigned char block[64]; +{ + u_int32_t a = state[0], b = state[1], c = state[2], d = state[3], x[16]; + + Decode (x, block, 64); + + /* Round 1 */ +#define S11 7 +#define S12 12 +#define S13 17 +#define S14 22 + FF (a, b, c, d, x[ 0], S11, 0xd76aa478); /* 1 */ + FF (d, a, b, c, x[ 1], S12, 0xe8c7b756); /* 2 */ + FF (c, d, a, b, x[ 2], S13, 0x242070db); /* 3 */ + FF (b, c, d, a, x[ 3], S14, 0xc1bdceee); /* 4 */ + FF (a, b, c, d, x[ 4], S11, 0xf57c0faf); /* 5 */ + FF (d, a, b, c, x[ 5], S12, 0x4787c62a); /* 6 */ + FF (c, d, a, b, x[ 6], S13, 0xa8304613); /* 7 */ + FF (b, c, d, a, x[ 7], S14, 0xfd469501); /* 8 */ + FF (a, b, c, d, x[ 8], S11, 0x698098d8); /* 9 */ + FF (d, a, b, c, x[ 9], S12, 0x8b44f7af); /* 10 */ + FF (c, d, a, b, x[10], S13, 0xffff5bb1); /* 11 */ + FF (b, c, d, a, x[11], S14, 0x895cd7be); /* 12 */ + FF (a, b, c, d, x[12], S11, 0x6b901122); /* 13 */ + FF (d, a, b, c, x[13], S12, 0xfd987193); /* 14 */ + FF (c, d, a, b, x[14], S13, 0xa679438e); /* 15 */ + FF (b, c, d, a, x[15], S14, 0x49b40821); /* 16 */ + + /* Round 2 */ +#define S21 5 +#define S22 9 +#define S23 14 +#define S24 20 + GG (a, b, c, d, x[ 1], S21, 0xf61e2562); /* 17 */ + GG (d, a, b, c, x[ 6], S22, 0xc040b340); /* 18 */ + GG (c, d, a, b, x[11], S23, 0x265e5a51); /* 19 */ + GG (b, c, d, a, x[ 0], S24, 0xe9b6c7aa); /* 20 */ + GG (a, b, c, d, x[ 5], S21, 0xd62f105d); /* 21 */ + GG (d, a, b, c, x[10], S22, 0x2441453); /* 22 */ + GG (c, d, a, b, x[15], S23, 0xd8a1e681); /* 23 */ + GG (b, c, d, a, x[ 4], S24, 0xe7d3fbc8); /* 24 */ + GG (a, b, c, d, x[ 9], S21, 0x21e1cde6); /* 25 */ + GG (d, a, b, c, x[14], S22, 0xc33707d6); /* 26 */ + GG (c, d, a, b, x[ 3], S23, 0xf4d50d87); /* 27 */ + GG (b, c, d, a, x[ 8], S24, 0x455a14ed); /* 28 */ + GG (a, b, c, d, x[13], S21, 0xa9e3e905); /* 29 */ + GG (d, a, b, c, x[ 2], S22, 0xfcefa3f8); /* 30 */ + GG (c, d, a, b, x[ 7], S23, 0x676f02d9); /* 31 */ + GG (b, c, d, a, x[12], S24, 0x8d2a4c8a); /* 32 */ + + /* Round 3 */ +#define S31 4 +#define S32 11 +#define S33 16 +#define S34 23 + HH (a, b, c, d, x[ 5], S31, 0xfffa3942); /* 33 */ + HH (d, a, b, c, x[ 8], S32, 0x8771f681); /* 34 */ + HH (c, d, a, b, x[11], S33, 0x6d9d6122); /* 35 */ + HH (b, c, d, a, x[14], S34, 0xfde5380c); /* 36 */ + HH (a, b, c, d, x[ 1], S31, 0xa4beea44); /* 37 */ + HH (d, a, b, c, x[ 4], S32, 0x4bdecfa9); /* 38 */ + HH (c, d, a, b, x[ 7], S33, 0xf6bb4b60); /* 39 */ + HH (b, c, d, a, x[10], S34, 0xbebfbc70); /* 40 */ + HH (a, b, c, d, x[13], S31, 0x289b7ec6); /* 41 */ + HH (d, a, b, c, x[ 0], S32, 0xeaa127fa); /* 42 */ + HH (c, d, a, b, x[ 3], S33, 0xd4ef3085); /* 43 */ + HH (b, c, d, a, x[ 6], S34, 0x4881d05); /* 44 */ + HH (a, b, c, d, x[ 9], S31, 0xd9d4d039); /* 45 */ + HH (d, a, b, c, x[12], S32, 0xe6db99e5); /* 46 */ + HH (c, d, a, b, x[15], S33, 0x1fa27cf8); /* 47 */ + HH (b, c, d, a, x[ 2], S34, 0xc4ac5665); /* 48 */ + + /* Round 4 */ +#define S41 6 +#define S42 10 +#define S43 15 +#define S44 21 + II (a, b, c, d, x[ 0], S41, 0xf4292244); /* 49 */ + II (d, a, b, c, x[ 7], S42, 0x432aff97); /* 50 */ + II (c, d, a, b, x[14], S43, 0xab9423a7); /* 51 */ + II (b, c, d, a, x[ 5], S44, 0xfc93a039); /* 52 */ + II (a, b, c, d, x[12], S41, 0x655b59c3); /* 53 */ + II (d, a, b, c, x[ 3], S42, 0x8f0ccc92); /* 54 */ + II (c, d, a, b, x[10], S43, 0xffeff47d); /* 55 */ + II (b, c, d, a, x[ 1], S44, 0x85845dd1); /* 56 */ + II (a, b, c, d, x[ 8], S41, 0x6fa87e4f); /* 57 */ + II (d, a, b, c, x[15], S42, 0xfe2ce6e0); /* 58 */ + II (c, d, a, b, x[ 6], S43, 0xa3014314); /* 59 */ + II (b, c, d, a, x[13], S44, 0x4e0811a1); /* 60 */ + II (a, b, c, d, x[ 4], S41, 0xf7537e82); /* 61 */ + II (d, a, b, c, x[11], S42, 0xbd3af235); /* 62 */ + II (c, d, a, b, x[ 2], S43, 0x2ad7d2bb); /* 63 */ + II (b, c, d, a, x[ 9], S44, 0xeb86d391); /* 64 */ + + state[0] += a; + state[1] += b; + state[2] += c; + state[3] += d; + + /* Zeroize sensitive information. */ + memset ((void *)x, 0, sizeof (x)); +} diff -ruN cpdup-1.05.orig/bsd-MD5/md5.h cpdup-1.05/bsd-MD5/md5.h --- cpdup-1.05.orig/bsd-MD5/md5.h 1969-12-31 18:00:00.000000000 -0600 +++ cpdup-1.05/bsd-MD5/md5.h 2004-12-10 19:00:00.000000000 -0600 @@ -0,0 +1,48 @@ +/* MD5.H - header file for MD5C.C + * $FreeBSD: src/sys/sys/md5.h,v 1.16 2002/06/24 14:18:39 mux Exp $ + */ + +/* Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All +rights reserved. + +License to copy and use this software is granted provided that it +is identified as the "RSA Data Security, Inc. MD5 Message-Digest +Algorithm" in all material mentioning or referencing this software +or this function. + +License is also granted to make and use derivative works provided +that such works are identified as "derived from the RSA Data +Security, Inc. MD5 Message-Digest Algorithm" in all material +mentioning or referencing the derived work. + +RSA Data Security, Inc. makes no representations concerning either +the merchantability of this software or the suitability of this +software for any particular purpose. It is provided "as is" +without express or implied warranty of any kind. + +These notices must be retained in any copies of any part of this +documentation and/or software. + */ + +#ifndef _SYS_MD5_H_ +#define _SYS_MD5_H_ +/* MD5 context. */ +typedef struct MD5Context { + u_int32_t state[4]; /* state (ABCD) */ + u_int32_t count[2]; /* number of bits, modulo 2^64 (lsb first) */ + unsigned char buffer[64]; /* input buffer */ +} MD5_CTX; + +#include + +__BEGIN_DECLS +void MD5Init (MD5_CTX *); +void MD5Update (MD5_CTX *, const unsigned char *, unsigned int); +void MD5Pad (MD5_CTX *); +void MD5Final (unsigned char [16], MD5_CTX *); +char * MD5End(MD5_CTX *, char *); +char * MD5File(const char *, char *); +char * MD5FileChunk(const char *, char *, off_t, off_t); +char * MD5Data(const unsigned char *, unsigned int, char *); +__END_DECLS +#endif /* _SYS_MD5_H_ */ diff -ruN cpdup-1.05.orig/bsd-MD5/mdXhl.c cpdup-1.05/bsd-MD5/mdXhl.c --- cpdup-1.05.orig/bsd-MD5/mdXhl.c 1969-12-31 18:00:00.000000000 -0600 +++ cpdup-1.05/bsd-MD5/mdXhl.c 2004-12-10 19:00:00.000000000 -0600 @@ -0,0 +1,101 @@ +/* mdXhl.c * ---------------------------------------------------------------------------- + * "THE BEER-WARE LICENSE" (Revision 42): + * wrote this file. As long as you retain this notice you + * can do whatever you want with this stuff. If we meet some day, and you think + * this stuff is worth it, you can buy me a beer in return. Poul-Henning Kamp + * ---------------------------------------------------------------------------- + */ + +#include +#ifndef __FBSDID +#define __FBSDID(s) +#endif +__FBSDID("$FreeBSD: src/lib/libmd/mdXhl.c,v 1.18 2002/09/08 15:10:04 phk Exp $"); + +#include +#include +#include +#include + +#include +#include +#include + +#include "mdX.h" + +char * +MDXEnd(MDX_CTX *ctx, char *buf) +{ + int i; + unsigned char digest[LENGTH]; + static const char hex[]="0123456789abcdef"; + + if (!buf) + buf = malloc(2*LENGTH + 1); + if (!buf) + return 0; + MDXFinal(digest, ctx); + for (i = 0; i < LENGTH; i++) { + buf[i+i] = hex[digest[i] >> 4]; + buf[i+i+1] = hex[digest[i] & 0x0f]; + } + buf[i+i] = '\0'; + return buf; +} + +char * +MDXFile(const char *filename, char *buf) +{ + return (MDXFileChunk(filename, buf, 0, 0)); +} + +char * +MDXFileChunk(const char *filename, char *buf, off_t ofs, off_t len) +{ + unsigned char buffer[BUFSIZ]; + MDX_CTX ctx; + struct stat stbuf; + int f, i, e; + off_t n; + + MDXInit(&ctx); + f = open(filename, O_RDONLY); + if (f < 0) + return 0; + if (fstat(f, &stbuf) < 0) + return 0; + if (ofs > stbuf.st_size) + ofs = stbuf.st_size; + if ((len == 0) || (len > stbuf.st_size - ofs)) + len = stbuf.st_size - ofs; + if (lseek(f, ofs, SEEK_SET) < 0) + return 0; + n = len; + i = 0; + while (n > 0) { + if (n > sizeof(buffer)) + i = read(f, buffer, sizeof(buffer)); + else + i = read(f, buffer, n); + if (i < 0) + break; + MDXUpdate(&ctx, buffer, i); + n -= i; + } + e = errno; + close(f); + errno = e; + if (i < 0) + return 0; + return (MDXEnd(&ctx, buf)); +} + +char * +MDXData (const unsigned char *data, unsigned int len, char *buf) +{ + MDX_CTX ctx; + + MDXInit(&ctx); + MDXUpdate(&ctx,data,len); + return (MDXEnd(&ctx, buf)); +} diff -ruN cpdup-1.05.orig/cpdup.c cpdup-1.05/cpdup.c --- cpdup-1.05.orig/cpdup.c 2003-11-29 16:29:52.000000000 -0600 +++ cpdup-1.05/cpdup.c 2004-12-10 19:00:00.000000000 -0600 @@ -310,6 +310,11 @@ { struct stat st1; struct stat st2; +#ifdef _FFLAGS_T_DECLARED + fflags_t st_flags; +#else + u_long st_flags; +#endif int r = 0; int mres = 0; int st2Valid = 0; @@ -322,7 +327,9 @@ if (lstat(spath, &st1) != 0) return(0); st2.st_mode = 0; /* in case lstat fails */ +#ifdef _FFLAGS_T_DECLARED st2.st_flags = 0; /* in case lstat fails */ +#endif if (dpath && lstat(dpath, &st2) == 0) st2Valid = 1; @@ -364,6 +371,7 @@ } } +#ifdef _FFLAGS_T_DECLARED if (xlink(hln->name, dpath, st1.st_flags) < 0) { logerr("%-32s hardlink: unable to link to %s: %s\n", (dpath ? dpath : spath), hln->name, strerror(errno) @@ -371,7 +379,9 @@ hltdelete(hln); hln = NULL; ++r; - } else { + } else +#endif + { if (hln->nlinked == st1.st_nlink) { hltdelete(hln); hln = NULL; @@ -405,8 +415,10 @@ if ( st2Valid && - st1.st_mode == st2.st_mode && - st1.st_flags == st2.st_flags + st1.st_mode == st2.st_mode +#ifdef _FFLAGS_T_DECLARED + && st1.st_flags == st2.st_flags +#endif ) { if (S_ISLNK(st1.st_mode) || S_ISDIR(st1.st_mode)) { ; @@ -611,9 +623,11 @@ if (st2Valid == 0 || st1.st_mode != st2.st_mode) { chmod(dpath, st1.st_mode); } +#ifdef _FFLAGS_T_DECLARED if (st2Valid == 0 || st1.st_flags != st2.st_flags) { chflags(dpath, st1.st_flags); } +#endif } } } else if (dpath == NULL) { @@ -651,7 +665,9 @@ * There could be a .tmp file from a previously interrupted * run, delete and retry. Fail if we still can't get at it. */ +#ifdef _FFLAGS_T_DECLARED chflags(path, 0); +#endif remove(path); fd2 = open(path, O_WRONLY|O_CREAT|O_EXCL|O_TRUNC, 0600); } @@ -684,7 +700,10 @@ utimes(path, tv); chown(path, st1.st_uid, st1.st_gid); chmod(path, st1.st_mode); - if (xrename(path, dpath, st2.st_flags) != 0) { +#ifdef _FFLAGS_T_DECLARED + st_flags = st2.st_flags; +#endif + if (xrename(path, dpath, st_flags) != 0) { logerr("%-32s rename-after-copy failed: %s\n", (dpath ? dpath : spath), strerror(errno) ); @@ -692,8 +711,12 @@ } else { if (VerboseOpt) logstd("%-32s copy-ok\n", (dpath ? dpath : spath)); +#ifdef _FFLAGS_T_DECLARED if (st1.st_flags) + { chflags(dpath, st1.st_flags); + } +#endif } CountReadBytes += size; CountWriteBytes += size; @@ -757,7 +780,10 @@ * there is no lchmod() or lchflags(), we * cannot chmod or chflags a softlink. */ - if (xrename(path, dpath, st2.st_flags) != 0) { +#ifdef _FFLAGS_T_DECLARED + st_flags = st2.st_flags; +#endif + if (xrename(path, dpath, st_flags) != 0) { logerr("%-32s rename softlink (%s->%s) failed: %s\n", (dpath ? dpath : spath), path, dpath, strerror(errno)); @@ -797,7 +823,10 @@ chmod(path, st1.st_mode); chown(path, st1.st_uid, st1.st_gid); remove(dpath); - if (xrename(path, dpath, st2.st_flags) != 0) { +#ifdef _FFLAGS_T_DECLARED + st_flags = st2.st_flags; +#endif + if (xrename(path, dpath, st_flags) != 0) { logerr("%-32s dev-rename-after-create failed: %s\n", (dpath ? dpath : spath), strerror(errno) @@ -1287,11 +1316,14 @@ { int r = 0; +#ifdef _FFLAGS_T_DECLARED if ((r = rename(src, dst)) < 0) { chflags(dst, 0); if ((r = rename(src, dst)) < 0) chflags(dst, flags); } +#endif + return(r); } @@ -1302,11 +1334,15 @@ int e; if ((r = link(src, dst)) < 0) { +#ifdef _FFLAGS_T_DECLARED chflags(src, 0); +#endif r = link(src, dst); e = errno; +#ifdef _FFLAGS_T_DECLARED chflags(src, flags); errno = e; +#endif } return(r); } diff -ruN cpdup-1.05.orig/GNUmakefile cpdup-1.05/GNUmakefile --- cpdup-1.05.orig/GNUmakefile 1969-12-31 18:00:00.000000000 -0600 +++ cpdup-1.05/GNUmakefile 2004-12-10 19:00:00.000000000 -0600 @@ -0,0 +1,23 @@ +# +# + +PREFIX ?= /usr/local +PROG= cpdup +SRCS= cpdup.c misc.c bsd-MD5/md5hl.c bsd-MD5/md5c.c +OBJS= $(SRCS:.c=.o) +LDADD+= -lmd +CFLAGS= -Wall -Wstrict-prototypes -I. -Ibsd-MD5 + +VERS = 1.05 + +all: ${PROG} + +${PROG}: ${OBJS} + ${CC} -o $@ ${OBJS} + +bsd-MD5/md5hl.c: bsd-MD5/mdXhl.c + (echo '#define LENGTH 16'; \ + sed -e 's/mdX/md5/g' -e 's/MDX/MD5/g' $<) > $@ + +clean: + rm -f ${PROG} ${OBJS} bsd-MD5/md5hl.c diff -ruN cpdup-1.05.orig/misc.c cpdup-1.05/misc.c --- cpdup-1.05.orig/misc.c 2003-11-29 16:23:32.000000000 -0600 +++ cpdup-1.05/misc.c 2004-12-10 19:00:00.000000000 -0600 @@ -2,6 +2,10 @@ * MISC.C */ +#define _GNU_SOURCE +#include +#undef _GNU_SOURCE + #include "cpdup.h" void