Linux編程實現(xiàn)制作文件的ed2k鏈
更新時間：2015年03月23日 10:05:46 投稿：hebedich
這篇文章主要介紹了Linux編程實現(xiàn)制作文件的ed2k鏈的相關(guān)資料,需要的朋友可以參考下
本程序依賴 c99, 只支持終端“標準輸入”，轉(zhuǎn)換成的鏈接以”標準輸出“而輸出，錯誤以”標出錯誤輸出“而輸出。
md4 編碼代碼來自網(wǎng)絡(luò)。
編譯命令：gcc -std=c99 -o ed2k md4.c ed2k.c utils.c
用戶命令：ed2k <File...>
產(chǎn)生的鏈是最簡短的形式：ed2k://|file|<FileName>|<FileSize>|<FileHash>|/
c++版本:
編譯命令：g++ -o ed2k ed2k.cpp utils.cpp MD4Hash.cpp ED2KHash.cpp
用戶命令：ed2k <File...> （雖然--help可以看到其它選項，但都沒實現(xiàn)）
defs.h
#ifndef MYCODE_DEFS_H
#define MYCODE_DEFS_H
#include <stdint.h> /* uint32_t ... */
#include <stddef.h> /* size_t, ssize_t */
#include <stdbool.h>
#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 <stdio.h>
#if __cplusplus
# include <utility>
# include <string>
# include <fstream>
#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);
/* 當(dāng)返回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<class T>
void setBigEndian(T*, size_t);
template<>
inline void setBigEndian<uint32_t>(uint32_t *p, size_t n)
{ setBigEndian_uint32(p, n); }
///////////////////////////////////////////////////////////////////////////////
template<class T>
std::string toHexString(T*, size_t);
template<>
inline std::string toHexString<uint32_t>(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 <string.h>
#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 <endian.h> */
#include <stdio.h>
#include <string.h>
#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<<s | 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 <stdlib.h>
#include <stdio.h>
#include <string.h>
#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 <string>
#include <utility>
#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 <string>
#include <iostream>
#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<<(std::ostream& out, const ED2KHash& v);
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 <cstring>
#include <fstream>
#include <utility>
#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<<(std::ostream& out, const ED2KHash& v)
{
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 <cstdlib>
#include <cstring>
#include <string>
#include <iostream>
#include <fstream>
#include "utils.h"
#include "ED2KHash.h"
#include "defs.h"
void usage(bool b)
{
std::cout
<< "command: ed2k [Option...] <File...>\n"
<< " ed2k <File...> (1)\n"
<< " ed2k -r <File...> (2)\n"
<< " ed2k -p <File...> (3)\n"
<< " ed2k -p -r <File...> (4)\n"
<< " ed2k -pr <File...> (4)\n\n"
<< "(1) ed2k://|file|<FileName>|<FileSize>|<FileHash>|/\n"
<< "(2) ed2k://|file|<FileName>|<FileSize>|<FileHash>|<h=RootHash>|/\n"
<< "(3) ed2k://|file|<FileName>|<FileSize>|<FileHash>|<p=PartHash>|/\n"
<< "(4) ed2k://|file|<FileName>|<FileSize>|<FileHash>|<p=PartHash>|<h=RootHash>|/"
<< 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鏈的代碼了，希望大家能夠喜歡。
相關(guān)文章
這篇文章主要介紹了Java?數(shù)據(jù)結(jié)構(gòu)之樹和二叉樹相關(guān)資料,文中通過示例代碼和一些相關(guān)題目來做介紹，非常詳細。對大家的學(xué)習(xí)或工作具有一定的參考借鑒價值，需要的朋友可以參考下2023-02-02
Qt通過三種形式提供了對線程的支持，本文主要介紹了Qt5多線程編程的實現(xiàn)，文中通過示例代碼介紹的非常詳細，具有一定的參考價值，感興趣的小伙伴們可以參考一下2021-12-12
C語言提供了豐富的字符串處理函數(shù),可以對字符串進行輸入、輸出、合并、修改、比較、轉(zhuǎn)換、復(fù)制、搜索等操作,下面這篇文章主要給大家介紹了關(guān)于C語言進階教程之字符函數(shù)&字符串函數(shù)的相關(guān)資料,需要的朋友可以參考下2022-03-03
Lambda?表達式（lambda?expression）是一個匿名函數(shù)，Lambda表達式基于數(shù)學(xué)中的λ演算得名。本文就來為大家詳細講講C++中Lambda表達式的使用，需要的可以參考一下2022-07-07
C++之std::vector刪除元素的幾種方式及區(qū)別說明
這篇文章主要介紹了C++之std::vector刪除元素的幾種方式及區(qū)別說明,具有很好的參考價值,希望對大家有所幫助,如有錯誤或未考慮完全的地方,望不吝賜教2023-08-08
這篇文章主要為大家詳細介紹了C語言常用的編輯器，中示例代碼介紹的非常詳細，具有一定的參考價值，感興趣的小伙伴們可以參考一下，希望能夠給你帶來幫助2022-02-02
這篇文章主要給大家介紹了關(guān)于利用C語言解決八皇后問題以及解析，文中通過示例代碼介紹的非常詳細，對大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價值，需要的朋友們下面隨著小編來一起學(xué)習(xí)學(xué)習(xí)吧2018-12-12
這篇文章主要給大家介紹了關(guān)于C++中auto類型說明符的相關(guān)資料,文中還附易錯實例,在C++11中引入了auto類型說明符,用它就能讓編譯器替我們?nèi)シ治霰磉_式所屬的類型,需要的朋友可以參考下2023-07-07
反射調(diào)用返回復(fù)雜對象的.NET方法怎么實現(xiàn)呢？今天小編通過本文給大家分享在C++中反射調(diào)用.NET的方法（二），需要的朋友參考下2017-02-02
詳解c語言中的 strcpy和strncpy字符串函數(shù)使用
strcpy 和strcnpy函數(shù)是字符串復(fù)制函數(shù)。接下來通過本文給大家介紹c語言中的strcpy和strncpy字符串函數(shù)使用，感興趣的朋友跟隨小編要求看看吧2018-10-10