#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 */

#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 __cplusplusextern "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 __cplusplusBEGIN_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 */

#include "utils.cpp"

#include <string.h>#include "utils.h" #if __cplusplusextern "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 __cplusplusBEGIN_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 */

#ifndef MYCODE_MD4_H#define MYCODE_MD4_H #include "defs.h" #if __cplusplusextern "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 */

/* #include <endian.h> */#include <stdio.h>#include <string.h>#include "utils.h"#include "md4.h" #if __cplusplusextern "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

#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);}

#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 */

#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 */

#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 >= 201103Lvoid 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

#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);}