登录
当前位置： 首页 > 编程笔记 >

Linux编程实现制作文件的ed2k链

叶举
2023-03-14
本文向大家介绍Linux编程实现制作文件的ed2k链，包括了Linux编程实现制作文件的ed2k链的使用技巧和注意事项，需要的朋友参考一下

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

md4 编码代码来自网络。

编译命令：gcc -std=c99 -o ed2k md4.c  ed2k.c  utils.c
用户命令：ed2k <File...>
产生的链是最简短的形式：ed2k://|file|<FileName>|<FileSize>|<FileHash>|/

c++版本:

编译命令：g++ -o ed2k ed2k.cpp utils.cpp MD4Hash.cpp ED2KHash.cpp
用户命令：ed2k <File...>   （虽然--help可以看到其它选项，但都没实现）

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);
 
/* 当返回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链的代码了，希望大家能够喜欢。

 类似资料：
  • Linux编程之PING实现

    本文向大家介绍Linux编程之PING实现，包括了Linux编程之PING实现的使用技巧和注意事项，需要的朋友参考一下 PING（Packet InterNet Groper）中文名为因特网包探索器，是用来查看网络上另一个主机系统的网络连接是否正常的一个工具。ping命令的工作原理是：向网络上的另一个主机系统发送ICMP报文，如果指定系统得到了报文，它将把回复报文传回给发送者，这有点象潜水艇声纳系

  • linux下制作ISO文件

    本文向大家介绍linux下制作ISO文件，包括了linux下制作ISO文件的使用技巧和注意事项，需要的朋友参考一下 linux下制作ISO文件有几种方法，分别如下： 1，从光盘中制作ISO文件 cp /dev/cdrom 路径/ISO 文件名 例子：cp /dev/cdrom /opt/mycd.iso，也可以用 dd if=/dev/cdrom of=/opt/mycd.iso 2，使用目录文件

  • Linux文件系统的实现

    Linux文件管理从用户的层面介绍了Linux管理文件的方式。Linux有一个树状结构来组织文件。树的顶端为根目录(/)，节点为目录，而末端的叶子为包含数据的文件。当我们给出一个文件的完整路径时，我们从根目录出发，经过沿途各个目录，最终到达文件。 我们可以对文件进行许多操作，比如打开和读写。在Linux文件管理相关命令中，我们看到许多对文件进行操作的命令。它们大都基于对文件的打开和读写操作。比如c

  • Linux Socket 编程简介和实现

    本文向大家介绍Linux Socket 编程简介和实现，包括了Linux Socket 编程简介和实现的使用技巧和注意事项，需要的朋友参考一下 在 TCP/IP 协议中，"IP地址 + TCP或UDP端口号" 可以唯一标识网络通讯中的一个进程，"IP地址+端口号" 就称为 socket。本文以一个简单的 TCP 协议为例，介绍如何创建基于 TCP 协议的网络程序。 TCP 协议通讯流程 下图描述了

  • linux 网络编程 socket选项的实现

    本文向大家介绍linux 网络编程 socket选项的实现，包括了linux 网络编程 socket选项的实现的使用技巧和注意事项，需要的朋友参考一下 socket选项函数 功能：用来读取和设置socket文件描述符属性的方法 socket选项表如下： getsockopt和setsockopt 这两个函数成功时返回0，失败时返回-1并设置errno。 对于服务器而言，有部分socket选项只能在

  • Linux网络编程之基于UDP实现可靠的文件传输示例

    本文向大家介绍Linux网络编程之基于UDP实现可靠的文件传输示例，包括了Linux网络编程之基于UDP实现可靠的文件传输示例的使用技巧和注意事项，需要的朋友参考一下 了解网络传输协议的人都知道，采用TCP实现文件传输很简单。相对于TCP，由于UDP是面向无连接、不可靠的传输协议，所以我们需要考虑丢包和后发先至（包的顺序）的问题，所以我们想要实现UDP传输文件，则需要解决这两个问题。方法就是给数据

相关阅读

Linux网络编程之基于UDP实现可靠的文件传输示例python实现操作文件（文件夹）Python实现Linux下守护进程的编写方法如何使用十六进制编辑器在Linux中制作可执行的ELF文件？编辑CSV文件（设计实现）

相关文章

文件上的操作Linux日志文件的格式分析Linux文件系统的层次结构Linux NTFS文件系统安装Linux /etc/rc.d/rc.local配置文件

相关问答

如何关闭现有的kafka制作程序mapreduce文件传输实现实现NG2文件上传将工作表添加到现有 Excel 文件中 [复制]静态编程语言的Java注释实现

相关工具

ed2k-ipfilterxiOS 多线程编程实例Intel显卡的Linux驱动程序《Go Web编程》"明"编程语言

相关文档

Linux 操作系统下 C 语言编程入门Linux C 编程一站式学习Linux 设备文件简介汇编中文教程Kivy 中文编程指南
快捷导航： 新手教程 算法原理 架构设计 Java进阶 数据库进阶 大厂专栏 面试经验 编程笔记 编程问答 所有专题 文档资料 工具软件 电子书籍 小牛导航
在线工具： 房贷计算器 个税计算器 Linux命令查询 Json格式化 正则表达式 颜色转换 AES加解密 SHA1加密 MD5加密 毒鸡汤 字数统计 随机密码生成 进制转换 Base64编解码 励志句子
Copyright © 2019-2024 小牛知识库@xnip.cn. All Rights Reserved.