本程序依赖 c99, 只支持终端“标准输入”，转换成的链接以”标准输出“而输出，错误以”标出错误输出“而输出。

md4 编码代码来自网络。

编译命令：gcc -std=c99 -o ed2k md4.c  ed2k.c  utils.c

用户命令：ed2k

产生的链是最简短的形式：ed2k://|file||||/

c++版本:

编译命令：g++ -o ed2k ed2k.cpp utils.cpp MD4Hash.cpp ED2KHash.cpp

用户命令：ed2k    (虽然--help可以看到其它选项，但都没实现)

defs.h

#ifndef MYCODE_DEFS_H

#define MYCODE_DEFS_H

#include /* uint32_t ... */

#include /* size_t, ssize_t */

#include

#endif

#if __cplusplus

# define BEGIN_NAMESPACE_MYCODE namespace mc {

# define END_NAMESPACE_MYCODE }

# if __cplusplus < 201103L

# define nullptr ((void*)0)

# endif

#endif /* __cplusplus */

#endif /* MYCODE_DEFS_H */

utils.h

#ifndef MYCODE_UTILS_H

#define MYCODE_UTILS_H

#include

#if __cplusplus

# include

# include

# include

#endif /* __cplusplus */

#include "defs.h"

#if __cplusplus

extern "C" {

#endif

#undef byteswap32

#define byteswap32(x) \

( (((x) & 0xff000000) >> 24) | (((x) & 0x00ff0000) >> 8) | \

(((x) & 0x0000ff00) << 8) | (((x) & 0x000000ff) << 24) )

#undef htobe32

#undef htole32

#if __BYTE_ORDER == __LITTLE_ENDIAN

# define htobe32(x) byteswap32(x)

# define htole32(x) (x)

#else

# define htobe32(x) (x)

# define htole32(x) byteswap32(x)

#endif

enum { string_npos = (size_t)-1 };

/* 查找字符串 str 中第一个与 c 匹配的字符，返回该字符在字符串中的下标， 失败返回 string_npos */

size_t string_find(const char *str, size_t size, char c);

/* 逆向查找*/

size_t string_rfind(const char *str, size_t size, char c);

void setBigEndian_uint32(uint32_t *data, size_t n);

char* toHexString_uint32(char *buf, size_t bufSize,

const uint32_t *data, size_t n);

char* createShortFileName(char *buf, size_t bufSize,

const char *fullName, size_t size);

/* 成功时返回指针 fullName 某部分的地址， 失败时返回 NULL */

const char* getShortFileName(const char* fullName, size_t size);

/* 当返回0大小时， 需要检查state， state == 0 表示失败 */

size_t getFileSize(FILE *in, int *state);

#if __cplusplus

} /* extern "C" */

#endif

/******************************************************************************

* c++

*****************************************************************************/

#if __cplusplus

BEGIN_NAMESPACE_MYCODE

# if __cplusplus >= 201103L

# define mc_move(x) std::move(x)

# else

# define mc_move(x) (x);

# endif

///

template

void setBigEndian(T*, size_t);

template<>

inline void setBigEndian(uint32_t *p, size_t n)

{ setBigEndian_uint32(p, n); }

///

template

std::string toHexString(T*, size_t);

template<>

inline std::string toHexString(uint32_t *p, size_t n)

{

std::string strHex;

char buf[9];

for (size_t i = 0; i < n; ++i) {

sprintf(buf, "%08X", p[i]);

strHex += buf;

}

return mc_move(strHex);

}

///

std::string getShortFileName(const std::string& fullName);

void getShortFileName(std::string *shortName, const std::string& fullName);

size_t getFileSize(std::ifstream& f);

END_NAMESPACE_MYCODE

#endif /* __cplusplus */

#endif /* MYCODE_UTILS_H */

utils.c

#include "utils.cpp"

utils.cpp

#include

#include "utils.h"

#if __cplusplus

extern "C" {

#endif

void setBigEndian_uint32(uint32_t *data, size_t n)

{

for (size_t i = 0; i < n; ++i)

data[i] = htobe32(data[i]);

}

char* toHexString_uint32(char *buf, size_t bufSize, const uint32_t *data, size_t n)

{

char *p = buf;

size_t i = 0;

size_t one_uint32_size = sizeof(uint32_t);

if ( one_uint32_size * n < bufSize )

{

while (i < n) {

sprintf(p, "%08X", data[i++]);

p += 8;

}

}

*p = '\0';

return buf;

}

size_t string_find(const char *str, size_t size, char c)

{

size_t pos = 0;

while (pos < size) {

if (str[pos] == c)

return pos;

++pos;

}

return string_npos;

}

size_t string_rfind(const char *str, size_t size, char c)

{

while (size) {

if (str[--size] == c)

return size;

}

return string_npos;

}

char* createShortFileName(char *buf, size_t bufSize,

const char *fullName, size_t size)

{

const char * p = getShortFileName(fullName, size);

buf[0] = '\0';

if (p)

{

size_t len = strlen(p);

if (bufSize > len)

memcpy(buf, p, len + 1);

}

return buf;

}

const char* getShortFileName(const char *fileName, size_t size)

{

#if _WIN32

char c = '\\';

#else

char c = '/';

#endif

size_t pos = string_rfind(fileName, size, c);

if (pos == string_npos)

return NULL;

else

return fileName + (pos + 1);

}

size_t getFileSize(FILE *in, int *state)

{

*state = 0;

if (!in)

return 0;

size_t curpos = ftell(in);

if (fseek(in, 0, SEEK_END) == -1)

return 0;

size_t fileSize = ftell(in);

if (fseek(in, curpos, SEEK_SET) == -1)

return 0;

*state = 1;

return fileSize;

}

#if __cplusplus

} /* extern "C" */

#endif

/******************************************************************************

* c++

*****************************************************************************/

#if __cplusplus

BEGIN_NAMESPACE_MYCODE

void getShortFileName(std::string *shortName, const std::string& fullName)

{

# if _WIN32

char c = '\\';

# else

char c = '/';

# endif

size_t pos = fullName.rfind(c);

if (pos == std::string::npos)

shortName->assign(fullName);

else

shortName->assign(fullName.begin() + pos + 1, fullName.end());

}

std::string getShortFileName(const std::string& fullName)

{

std::string shortName;

getShortFileName(&shortName, fullName);

return mc_move(shortName);

}

size_t getFileSize(std::ifstream& f)

{

f.seekg(0, f.end);

size_t fileSize = f.tellg();

f.seekg(0);

return fileSize;

}

END_NAMESPACE_MYCODE

#endif /* __cplusplus */

md4.h

#ifndef MYCODE_MD4_H

#define MYCODE_MD4_H

#include "defs.h"

#if __cplusplus

extern "C" {

#endif

enum { MD4_COUNT_SIZE = 8, MD4_STATE_SIZE = 16, MD4_BUFFER_SIZE = 64 };

typedef struct {

uint32_t count[2];

uint32_t state[4];

uint8_t buffer[MD4_BUFFER_SIZE];

} md4_t;

#define md4_data(md4_ptr) ((char*)((md4_ptr)->state))

#define md4_cdata(md4_ptr) ((const char*)((md4_ptr)->state))

#define md4_dataSize() (MD4_STATE_SIZE)

void md4_reset(md4_t *md4);

void md4_update(md4_t *md4, const char *src, size_t srcSize);

void md4_finish(md4_t *md4);

void md4_setBigEndian(md4_t *md4);

char* md4_toHashString(char dest[33], const md4_t *md4);

#if __cplusplus

}

#endif

#endif /* MYCODE_MD4_H */

md4.c

/* #include */

#include

#include

#include "utils.h"

#include "md4.h"

#if __cplusplus

extern "C" {

#endif

#if __BYTE_ORDER == __LITTLE_ENDIAN

# define md4_htole32_4(buf) /* empty */

# define md4_htole32_14(buf) /* empty */

# define md4_htole32_16(buf) /* empty */

#else

# define md4_htole32_4(buf) \

(buf)[ 0] = htole32((buf)[ 0]); \

(buf)[ 1] = htole32((buf)[ 1]); \

(buf)[ 2] = htole32((buf)[ 2]); \

(buf)[ 3] = htole32((buf)[ 3])

# define md4_htole32_14(buf) \

(buf)[ 0] = htole32((buf)[ 0]); \

(buf)[ 1] = htole32((buf)[ 1]); \

(buf)[ 2] = htole32((buf)[ 2]); \

(buf)[ 3] = htole32((buf)[ 3]); \

(buf)[ 4] = htole32((buf)[ 4]); \

(buf)[ 5] = htole32((buf)[ 5]); \

(buf)[ 6] = htole32((buf)[ 6]); \

(buf)[ 7] = htole32((buf)[ 7]); \

(buf)[ 8] = htole32((buf)[ 8]); \

(buf)[ 9] = htole32((buf)[ 9]); \

(buf)[10] = htole32((buf)[10]); \

(buf)[11] = htole32((buf)[11]); \

(buf)[12] = htole32((buf)[12]); \

(buf)[13] = htole32((buf)[13])

# define md4_htole32_16(buf) \

(buf)[ 0] = htole32((buf)[ 0]); \

(buf)[ 1] = htole32((buf)[ 1]); \

(buf)[ 2] = htole32((buf)[ 2]); \

(buf)[ 3] = htole32((buf)[ 3]); \

(buf)[ 4] = htole32((buf)[ 4]); \

(buf)[ 5] = htole32((buf)[ 5]); \

(buf)[ 6] = htole32((buf)[ 6]); \

(buf)[ 7] = htole32((buf)[ 7]); \

(buf)[ 8] = htole32((buf)[ 8]); \

(buf)[ 9] = htole32((buf)[ 9]); \

(buf)[10] = htole32((buf)[10]); \

(buf)[11] = htole32((buf)[11]); \

(buf)[12] = htole32((buf)[12]); \

(buf)[13] = htole32((buf)[13]); \

(buf)[14] = htole32((buf)[14]); \

(buf)[15] = htole32((buf)[15])

#endif

/* #define F1(x, y, z) (x & y | ~x & z) */

#define F1(x, y, z) (z ^ (x & (y ^ z)))

#define F2(x, y, z) ((x & y) | (x & z) | (y & z))

#define F3(x, y, z) (x ^ y ^ z)

/* This is the central step in the MD4 algorithm. */

#define MD4STEP(f, w, x, y, z, data, s) \

( w += f(x, y, z) + data, w = w<>(32-s) )

static void md4_transform(uint32_t *state, const uint8_t *buffer)

{

uint32_t a, b, c, d;

const uint32_t *src = (const uint32_t *)buffer;

a = state[0];

b = state[1];

c = state[2];

d = state[3];

MD4STEP(F1, a, b, c, d, src[ 0], 3);

MD4STEP(F1, d, a, b, c, src[ 1], 7);

MD4STEP(F1, c, d, a, b, src[ 2], 11);

MD4STEP(F1, b, c, d, a, src[ 3], 19);

MD4STEP(F1, a, b, c, d, src[ 4], 3);

MD4STEP(F1, d, a, b, c, src[ 5], 7);

MD4STEP(F1, c, d, a, b, src[ 6], 11);

MD4STEP(F1, b, c, d, a, src[ 7], 19);

MD4STEP(F1, a, b, c, d, src[ 8], 3);

MD4STEP(F1, d, a, b, c, src[ 9], 7);

MD4STEP(F1, c, d, a, b, src[10], 11);

MD4STEP(F1, b, c, d, a, src[11], 19);

MD4STEP(F1, a, b, c, d, src[12], 3);

MD4STEP(F1, d, a, b, c, src[13], 7);

MD4STEP(F1, c, d, a, b, src[14], 11);

MD4STEP(F1, b, c, d, a, src[15], 19);

MD4STEP(F2, a, b, c, d, src[ 0] + 0x5a827999, 3);

MD4STEP(F2, d, a, b, c, src[ 4] + 0x5a827999, 5);

MD4STEP(F2, c, d, a, b, src[ 8] + 0x5a827999, 9);

MD4STEP(F2, b, c, d, a, src[12] + 0x5a827999, 13);

MD4STEP(F2, a, b, c, d, src[ 1] + 0x5a827999, 3);

MD4STEP(F2, d, a, b, c, src[ 5] + 0x5a827999, 5);

MD4STEP(F2, c, d, a, b, src[ 9] + 0x5a827999, 9);

MD4STEP(F2, b, c, d, a, src[13] + 0x5a827999, 13);

MD4STEP(F2, a, b, c, d, src[ 2] + 0x5a827999, 3);

MD4STEP(F2, d, a, b, c, src[ 6] + 0x5a827999, 5);

MD4STEP(F2, c, d, a, b, src[10] + 0x5a827999, 9);

MD4STEP(F2, b, c, d, a, src[14] + 0x5a827999, 13);

MD4STEP(F2, a, b, c, d, src[ 3] + 0x5a827999, 3);

MD4STEP(F2, d, a, b, c, src[ 7] + 0x5a827999, 5);

MD4STEP(F2, c, d, a, b, src[11] + 0x5a827999, 9);

MD4STEP(F2, b, c, d, a, src[15] + 0x5a827999, 13);

MD4STEP(F3, a, b, c, d, src[ 0] + 0x6ed9eba1, 3);

MD4STEP(F3, d, a, b, c, src[ 8] + 0x6ed9eba1, 9);

MD4STEP(F3, c, d, a, b, src[ 4] + 0x6ed9eba1, 11);

MD4STEP(F3, b, c, d, a, src[12] + 0x6ed9eba1, 15);

MD4STEP(F3, a, b, c, d, src[ 2] + 0x6ed9eba1, 3);

MD4STEP(F3, d, a, b, c, src[10] + 0x6ed9eba1, 9);

MD4STEP(F3, c, d, a, b, src[ 6] + 0x6ed9eba1, 11);

MD4STEP(F3, b, c, d, a, src[14] + 0x6ed9eba1, 15);

MD4STEP(F3, a, b, c, d, src[ 1] + 0x6ed9eba1, 3);

MD4STEP(F3, d, a, b, c, src[ 9] + 0x6ed9eba1, 9);

MD4STEP(F3, c, d, a, b, src[ 5] + 0x6ed9eba1, 11);

MD4STEP(F3, b, c, d, a, src[13] + 0x6ed9eba1, 15);

MD4STEP(F3, a, b, c, d, src[ 3] + 0x6ed9eba1, 3);

MD4STEP(F3, d, a, b, c, src[11] + 0x6ed9eba1, 9);

MD4STEP(F3, c, d, a, b, src[ 7] + 0x6ed9eba1, 11);

MD4STEP(F3, b, c, d, a, src[15] + 0x6ed9eba1, 15);

state[0] += a;

state[1] += b;

state[2] += c;

state[3] += d;

}

void md4_reset(md4_t *md4)

{

md4->count[0] = 0;

md4->count[1] = 0;

md4->state[0] = 0x67452301;

md4->state[1] = 0xEFCDAB89;

md4->state[2] = 0x98BADCFE;

md4->state[3] = 0x10325476;

}

void md4_update(md4_t *md4, const char *src, size_t srcSize)

{

uint32_t count = (uint32_t)((md4->count[0] >> 3) & 0x3f);

if ((md4->count[0] += (srcSize << 3)) < (srcSize << 3))

++(md4->count[1]);

md4->count[1] += (srcSize >> 29);

if (count > 0)

{

size_t partSize = MD4_BUFFER_SIZE - count;

if (srcSize < partSize)

{

memcpy(md4->buffer + count, src, srcSize);

return;

}

memcpy(md4->buffer + count, src, partSize);

md4_htole32_16((uint32_t*)md4->buffer);

md4_transform(md4->state, md4->buffer);

src += partSize;

srcSize -= partSize;

}

while (srcSize >= MD4_BUFFER_SIZE)

{

memcpy(md4->buffer, src, MD4_BUFFER_SIZE);

md4_transform(md4->state, md4->buffer);

md4_htole32_16((uint32_t *)md4->buffer);

src += MD4_BUFFER_SIZE;

srcSize -= MD4_BUFFER_SIZE;

}

memcpy(md4->buffer, src, srcSize);

}

void md4_finish(md4_t *md4)

{

uint32_t count = (uint32_t)((md4->count[0] >> 3) & 0x3f);

uint8_t *p = md4->buffer + count;

*p++ = 0x80;

count = MD4_BUFFER_SIZE - 1 - count;

if (count < 8)

{

memset(p, 0, count);

md4_htole32_16((uint32_t *)md4->buffer);

md4_transform(md4->state, md4->buffer);

memset(md4->buffer, 0, 56);

}

else

{

memset(p, 0, count - 8);

}

md4_htole32_14((uint32_t *)md4->buffer);

/* Append bit count and transform */

((uint32_t *)md4->buffer)[14] = md4->count[0];

((uint32_t *)md4->buffer)[15] = md4->count[1];

md4_transform(md4->state, md4->buffer);

md4_htole32_4(md4->state);

memset(md4->buffer, 0, MD4_BUFFER_SIZE);

}

void md4_setBigEndian(md4_t *md4)

{

uint32_t *p = md4->state;

p[0] = htobe32(p[0]);

p[1] = htobe32(p[1]);

p[2] = htobe32(p[2]);

p[3] = htobe32(p[3]);

}

char* md4_toHashString(char dest[33], const md4_t *md4)

{

return toHexString_uint32(dest, 33, md4->state, 4);

}

#if __cplusplus

}

#endif

ed2k.c

#include

#include

#include

#include "defs.h"

#include "utils.h"

#include "md4.h"

enum { CHUNK_SIZE = 9728000, BUFFER_MAX_SIZE = 256 };

bool printEd2kLink(const char *fileName)

{

FILE *in = fopen(fileName, "rb");

if (!in)

{

fprintf(stderr, "error: Open file failed.\n");

return false;

}

size_t fileSize;

{

int state;

if ((fileSize = getFileSize(in, &state)) == 0)

{

if (state == 0)

fprintf(stderr, "error: get fileSize of \'%s\' failed\n", fileName);

else

fprintf(stderr, "error: \'%s\' is empty.\n", fileName);

fclose(in);

return false;

}

}

const char *shortFileName = getShortFileName(fileName, strlen(fileName));

if (shortFileName == NULL)

{

fprintf(stderr, "error: createNewFilename().\n");

fclose(in);

return false;

}

static md4_t md4HashSet, md4FileHash;

md4_reset(&md4FileHash);

static char chunk[CHUNK_SIZE];

size_t readCount;

bool bContinue = true;

int chunkCount = 0;

while (bContinue)

{

readCount = fread(chunk, sizeof(chunk[0]), CHUNK_SIZE, in);

if (readCount < CHUNK_SIZE)

{

if (feof(in)) {

if (0 == readCount)

break;

bContinue = false;

/* memset(chunk + readCount, 0, CHUNK_SIZE - readCount); */

} else {

fprintf(stderr, "error: Read file failed.\n");

fclose(in);

return false;

}

}

md4_reset(&md4HashSet);

md4_update(&md4HashSet, chunk, readCount);

md4_finish(&md4HashSet);

md4_update(&md4FileHash, md4_data(&md4HashSet), md4_dataSize());

chunkCount++;

}

static char strHash[33];

if (chunkCount > 1) {

md4_finish(&md4FileHash);

md4_setBigEndian(&md4FileHash);

md4_toHashString(strHash, &md4FileHash);

} else {

md4_setBigEndian(&md4HashSet);

md4_toHashString(strHash, &md4HashSet);

}

fprintf(stdout, "ed2k://|file|%s|%ld|%s|/\n", shortFileName, fileSize, strHash);

md4_reset(&md4FileHash);

fclose(in);

return true;

}

int main(int argc, const char *argv[])

{

if (argc < 2)

{

fprintf(stderr, "error: argc < 2\n");

exit(EXIT_FAILURE);

}

int linkCount = 0;

for (int i = 1; i < argc; ++i)

{

if (!printEd2kLink(argv[i]))

{

fprintf(stderr, "Created %d links.\n",linkCount);

exit(EXIT_FAILURE);

}

linkCount++;

}

exit(EXIT_SUCCESS);

}

MD4Hash.h

#ifndef MYCODE_MD4HASH_H

#define MYCODE_MD4HASH_H

#include

#include

#include "md4.h"

#include "defs.h"

BEGIN_NAMESPACE_MYCODE

class MD4Hash

{

friend class MD4HashAlgo;

struct Data{ uint32_t d[4]; };

public:

MD4Hash();

MD4Hash(const MD4Hash& o);

#if __cplusplus >= 201103L

MD4Hash(MD4Hash&& o);

MD4Hash& operator=(MD4Hash&& o);

#endif

~MD4Hash();

MD4Hash& operator=(const MD4Hash& o);

void setBigEndian();

std::string toString();

void swap(MD4Hash& o) { std::swap(m_data, o.m_data); }

private:

Data m_data;

MD4Hash(uint32_t *data);

};

class MD4HashAlgo

{

md4_t m_md4;

public:

MD4HashAlgo();

MD4HashAlgo(const MD4HashAlgo& o);

#if __cplusplus >= 201103L

MD4HashAlgo(MD4HashAlgo&& o);

MD4HashAlgo& operator=(MD4HashAlgo&& o);

#endif

~MD4HashAlgo();

MD4HashAlgo& operator=(const MD4HashAlgo& o);

void reset() { md4_reset(&m_md4); }

void update(const char *data, size_t size) { md4_update(&m_md4, data, size); }

void update(const MD4Hash& hash) { md4_update(&m_md4, (const char*)(hash.m_data.d), 16); }

void finish() { md4_finish(&m_md4); }

MD4Hash getHash() { return MD4Hash(m_md4.state); }

size_t hashSize() { return md4_dataSize(); }

void swap(MD4HashAlgo& o) { std::swap(m_md4, o.m_md4); }

};

END_NAMESPACE_MYCODE

#endif /* MYCODE_MD4HASH_H */

ED2KHash.h

#ifndef MYCODE_ED2KHASH_H

#define MYCODE_ED2KHASH_H

#include

#include

#include "defs.h"

BEGIN_NAMESPACE_MYCODE

class ED2KHash

{

public:

enum mode {

FileHash = 0x01,

PartHash = 0x10,

RootHash = 0x20,

Default = FileHash

};

ED2KHash(int mode = ED2KHash::Default);

ED2KHash(const ED2KHash& o);

~ED2KHash();

ED2KHash& operator=(const ED2KHash& o);

#if __cplusplus >= 201103L

ED2KHash(ED2KHash&& o);

ED2KHash& operator=(ED2KHash&& o);

#endif

void exec(const char* fileName);

void swap(ED2KHash& o);

std::string getFileHash();

friend std::ostream& operator<

private:

int m_mode;

size_t m_fileSize;

std::string m_fileName;

std::string m_fileHash;

void copy(const ED2KHash& o);

#if __cplusplus >= 201103L

void move(ED2KHash& o);

#endif

};

END_NAMESPACE_MYCODE

#endif /* MYCODE_ED2KHASH_H */

ED2KHash.cpp

#include

#include

#include

#include "utils.h"

#include "MD4Hash.h"

#include "ED2KHash.h"

BEGIN_NAMESPACE_MYCODE

///

// ED2KHash //

///

ED2KHash::ED2KHash(int mode)

: m_mode(mode), m_fileSize(0)

{ /* empty */ }

void ED2KHash::copy(const ED2KHash& o)

{

m_mode = o.m_mode;

m_fileSize = o.m_fileSize;

m_fileName = o.m_fileName;

m_fileHash = o.m_fileHash;

}

ED2KHash::ED2KHash(const ED2KHash& o)

{

copy(o);

}

ED2KHash& ED2KHash::operator=(const ED2KHash& o)

{

copy(o);

return *this;

}

#if __cplusplus >= 201103L

void ED2KHash::move(ED2KHash& o)

{

m_mode = o.m_mode;

m_fileSize = o.m_fileSize;

m_fileName = std::move(o.m_fileName);

m_fileHash = std::move(o.m_fileHash);

}

ED2KHash::ED2KHash(ED2KHash&& o)

{

this->move(o);

}

ED2KHash& ED2KHash::operator=(ED2KHash&& o)

{

this->move(o);

return *this;

}

#endif

ED2KHash::~ED2KHash()

{ /* empty */ }

void ED2KHash::swap(ED2KHash& o)

{

std::swap(*this, o);

}

std::string ED2KHash::getFileHash()

{

return m_fileHash;

}

enum { CHUNK_SIZE = 9728000 };

enum { BLOCK_180K = 184320, BLOCK_140K = 143360 };

void ED2KHash::exec(const char* fileName)

{

std::string msg("error: ");

std::ifstream in(fileName, std::ios_base::binary | std::ios_base::in);

if (!in.is_open())

throw msg = msg + "Open \'" + fileName + "\' failed.";

if ((m_fileSize = mc::getFileSize(in)) == 0)

throw msg = msg + fileName + " is empty.";

mc::getShortFileName(&m_fileName, fileName);

static mc::MD4Hash md4Hash;

static mc::MD4HashAlgo partHashMD4Algo, fileHashMD4Algo;

fileHashMD4Algo.reset();

static char chunk[CHUNK_SIZE];

size_t readCount;

size_t chunkCount = 0;

bool bContinue = true;

while (bContinue)

{

in.read(chunk, CHUNK_SIZE);

if ((readCount = in.gcount()) < CHUNK_SIZE)

{

if (in.eof()) {

if (0 == readCount)

break;

bContinue = false;

memset(chunk + readCount, 0, CHUNK_SIZE - readCount);

} else {

throw msg += "Read file failed.";

}

}

partHashMD4Algo.reset();

partHashMD4Algo.update(chunk, readCount);

partHashMD4Algo.finish();

md4Hash = mc_move(partHashMD4Algo.getHash());

fileHashMD4Algo.update(md4Hash);

/*if (m_mode & PartHash) {

if (bWriteToData)

;//

else {

md4Hash.setBigEndian();

m_listPartHash.push_back(md4Hash);

}

}*/

if (m_mode & RootHash) {

//

}

chunkCount++;

}

if (chunkCount > 1) {

fileHashMD4Algo.finish();

md4Hash = mc_move(fileHashMD4Algo.getHash());

md4Hash.setBigEndian();

m_fileHash = mc_move(md4Hash.toString());

} else {

md4Hash = mc_move(partHashMD4Algo.getHash());

md4Hash.setBigEndian();

m_fileHash = mc_move(md4Hash.toString());

}

}

std::ostream& operator<

{

out << "ed2k://|file|" << v.m_fileName << '|' << v.m_fileSize << '|'

<< v.m_fileHash << '|';

/*if (v.m_mode | ED2KHash::PartHash) {

size_t n = m_listPartHash.size();

m_listPartHash.iterator it = m_listPartHash.begin();

if (n > 0) do {

cout << it->getHash().toString();

if (--n == 0)

break;

++it;

cout << ':';

} while (1);

out << '|';

}*/

//if (v.m_mode | ED2KHash::RootHash)

// out << '|';

return out << '/';

}

END_NAMESPACE_MYCODE

ed2k.cpp

#include

#include

#include

#include

#include

#include "utils.h"

#include "ED2KHash.h"

#include "defs.h"

void usage(bool b)

{

std::cout

<< "command: ed2k [Option...] \n"

<< " ed2k (1)\n"

<< " ed2k -r (2)\n"

<< " ed2k -p (3)\n"

<< " ed2k -p -r (4)\n"

<< " ed2k -pr (4)\n\n"

<< "(1) ed2k://|file||||/\n"

<< "(2) ed2k://|file|||||/\n"

<< "(3) ed2k://|file||||

|/\n"

<< "(4) ed2k://|file||||

||/"

<< std::endl;

if (b)

exit(EXIT_SUCCESS);

}

bool parsed(int argc, const char *argv[], int *opt, int *pos)

{

if (argc < 2)

return false;

if (strcmp("--help", argv[1]) == 0)

usage(true);

if (strcmp("--version", argv[1]) == 0)

{

std::cout << "0.1v" << std::endl;

exit(EXIT_SUCCESS);

}

*opt = mc::ED2KHash::FileHash;

*pos = 1;

for (; *pos < argc; ++(*pos))

{

if ('-' != argv[*pos][0])

break;

int len = strlen(argv[*pos]);

for(int j = 1; j < len; ++j)

{

if ('p' == argv[*pos][j])

*opt |= mc::ED2KHash::PartHash;

else if ('r' == argv[*pos][j])

*opt |= mc::ED2KHash::RootHash;

else {

std::cerr << "error: \'" << argv[*pos] << "\' is not a option."

<< " Enter '--help' veiw usage." << std::endl;

return false;

}

}

}

if (*pos == argc)

{

std::cerr << "error: no parameter."

<< " Enter '--help' veiw usage." << std::endl;

return false;

}

return true;

}

int main(int argc, const char *argv[])

{

int opt, pos;

if (!parsed(argc, argv, &opt, &pos))

exit(EXIT_FAILURE);

int linkCount = 0;

mc::ED2KHash ed2k(opt);

for (; pos < argc; ++pos)

{

try {

ed2k.exec(argv[pos]);

std::cout << ed2k << std::endl;

} catch (std::string& e) {

std::cerr << e << "\ncreated " << linkCount << " links." << std::endl;

exit(EXIT_FAILURE);

}

linkCount++;

}

std::cerr << "\ncreated " << linkCount << " links." << std::endl;

exit(EXIT_SUCCESS);

}

以上所述就是本文给大家分享的制作ed2k链的代码了，希望大家能够喜欢。