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链的代码了,希望大家能够喜欢。

(0)

相关推荐

  • Linux网络编程之socket文件传输示例

    本文所述示例程序是基于Linux平台的socket网络编程,实现文件传输功能.该示例是基于TCP流协议实现的socket网络文件传输程序.采用C语言编写.最终能够实现传输任何格式文件的文件传输程序. 具体实现代码如下: Server端代码如下: /************************************************************************* > File Name: Server.c > Author: SongLee ***********

  • linux c多线程编程实例代码

    直接看代码吧,代码里有注释 复制代码 代码如下: #include <stdio.h>#include <stdlib.h>#include <string.h>#include <pthread.h>#include <time.h>#define MAX 3 int number =0;pthread_t id[2];pthread_mutex_t mut; //初始化静态互斥锁 void thread1(void){    int i;  

  • VBS 提取狗狗影视中的ED2K连接的实现代码

    打开狗狗影视,搜索自己需要的资源,资源类型选:电驴,如下图: 我找到一个 19.75GB 的: 点开它,出现如下图的界面,可以看到正常下载地址已被屏蔽.我们复制地址栏中的网址,备用. 打开从本站下载的 VBS 脚本,复制该网址到输入框,然后确定,稍过一会,会出现提示完成的消息框,这个时间的长短由你的网速决定! 最后,我们得到最终的 ED2K 连接地址,全部保存在当前目录下的 ed2k.txt 文件中: 还等什么?打开你的下载工具,开始下载吧!^_^ GetEd2kLink.VBS 代码如下,你也

  • Linux网络编程之UDP Socket程序示例

    在网络传输协议中,TCP协议提供的是一种可靠的,复杂的,面向连接的数据流(SOCK_STREAM)传输服务,它通过三段式握手过程建立连接.TCP有一种"重传确认"机制,即接收端收到数据后要发出一个肯定确认的信号,发送端如果收到接收端肯定确认的信号,就会继续发送其他的数据,如果没有,它就会重新发送. 相对而言,UDP协议则是一种无连接的,不可靠的数据报(SOCK_DGRAM)传输服务.使用UDP套接口不用建立连接,服务端在调用socket()生成一个套接字并调用bind()绑定端口后就可

  • Linux shell脚本编程if语句的使用方法(条件判断)

    if 语句格式if  条件then Commandelse Commandfi        别忘了这个结尾If语句忘了结尾fitest.sh: line 14: syntax error: unexpected end of fi     if 的三种条件表达式 ifcommandthen if 函数then 命令执行成功,等于返回0 (比如grep ,找到匹配)执行失败,返回非0 (grep,没找到匹配)if [ expression_r_r_r  ]then    表达式结果为真,则返回0

  • Linux下进行MYSQL编程时插入中文乱码的解决方案

    插入中文是乱码,尝试了许多方法,比如我先把vim里设置为:set fileencoding=utf-8不起作用,后来想想也对,和vim没什么关系 然后就尝试c#代码,用Encoding.UTF8.GetString()方法,后来也不对. 我就郁闷了,忽然想起来莫不是mysql的设置问题??? 于是,sudo nano /etc/mysql/my.cnf 插入下面红色代码,default-character-set = utf8,成功,不乱码了~~~根本不用什么Encoding..... # Th

  • linux多线程编程详解教程(线程通过信号量实现通信代码)

    线程分类 线程按照其调度者可以分为用户级线程和核心级线程两种. (1)用户级线程 用户级线程主要解决的是上下文切换的问题,它的调度算法和调度过程全部由用户自行选择决定,在运行时不需要特定的内核支持.在这里,操作系统往往会提供一个用户空间的线程库,该线程库提供了线程的创建.调度.撤销等功能,而内核仍然仅对进程进行管理.如果一个进程中的某一个线程调用了一个阻塞的系统调用,那么该进程包括该进程中的其他所有线程也同时被阻塞.这种用户级线程的主要缺点是在一个进程中的多个线程的调度中无法发挥多处理器的优势.

  • Linux命令行和shell脚本编程宝典 Richard Blum

    第一个脚本文件 复制代码 代码如下: #!/bin/bashecho "This is my first bash code!"exit 0 重定向符号和数学计算 复制代码 代码如下: #!/bin/bashecho -n "The time and date are: "datevalue1=100  #等号前后不允许出现空格value2=$value1echo -n "value1="echo $value1echo -n "val

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

    本程序依赖 c99, 只支持终端"标准输入",转换成的链接以"标准输出"而输出,错误以"标出错误输出"而输出. md4 编码代码来自网络. 编译命令:gcc -std=c99 -o ed2k md4.c  ed2k.c  utils.c 用户命令:ed2k <File...> 产生的链是最简短的形式:ed2k://|file|<FileName>|<FileSize>|<FileHash>|/ c+

  • linux下socket编程常用头文件(推荐)

    sys/types.h:数据类型定义 sys/socket.h:提供socket函数及数据结构 netinet/in.h:定义数据结构sockaddr_in arpa/inet.h:提供IP地址转换函数 netdb.h:提供设置及获取域名的函数 sys/ioctl.h:提供对I/O控制的函数 sys/poll.h:提供socket等待测试机制的函数 其他在网络程序中常见的头文件 unistd.h:提供通用的文件.目录.程序及进程操作的函数 errno.h:提供错误号errno的定义,用于错误处理

  • 解决linux下openoffice word文件转PDF中文乱码的问题

    网上很多介绍是由于jdk中的没有字体导致乱码,而我遇到的是转换过程并未报错,但转换后的PDF中是乱码,尝试在jre/lib/fonts/中增加字体,还是不能解决问题,因此可以判断非jre字体问题,是linux系统字体问题. 用vim /etc/fonts/fonts.conf,可以看到系统字体文件在/usr/share/fonts,将windows系统字体文件连接到此目录下 ln -s /usr/local/fonts fonts 然后更新缓存:fc-cache 重启openoffice: /o

  • Linux下.tar.xz文件的解压教程详解

    前言 对于xz这个压缩相信很多人陌生,但xz是绝大数linux默认就带的一个压缩工具,xz格式比7z还要小. 最近在下载某个源码包的时候遇到的这种压缩格式,乘此机会分享一下xz的压缩与解压方法. 安装 如果系统没有xz命令,需要进行安装,安装方法非常简单, 在centos下,直接运行: yum install xz 也可以使用源码包安装: 先下载该工具源码包http://tukaani.org/xz/ 下载后解压进入该目录运行configure生成makefile文件用-prefix指定安装目录

  • Linux下的压缩文件剖析

    对于刚刚接触Linux的人来说,一定会给Linux下一大堆各式各样的文件名给搞晕.别个不说,单单就压缩文件为例,我们知道在Windows下最常见的压缩文件就只有两种,一是,zip,另一个是.rap.可是Linux就不同了,它有.gz..tar.gz.tgz.bz2..Z..tar等众多的压缩文件名,此外windows下的.zip和.rar也可以在Linux下使用,不过在Linux使用.zip和.rar的人就太少了.本文就来对这些常见的压缩文件进行一番小结,希望你下次遇到这些文件时不至于被搞晕:)

  • Linux中的搜索文件命令

    文件搜索命令locate:搜索快,新建文件无法搜索: 命令格式: locate 文件名  //在后台数据库中按文件名搜索,搜索速度快: /var/lib/mlocate : locate命令所搜索的后台数据库 命令:updatedb // 更新数据库,默认是一天自动更新: /etc/uodatedb.conf 配置文件中: 1.      PRUNE_BIND_MOUNTS = "yes" 开启搜索限制 2.      PRINEFS = 搜索时,不搜索的文件系统: 3.      P

  • Linux du命令查看文件夹大小并按降序排列

    1. df -lh 2. du -s /usr/* | sort -rn 这是按字节排序 3. du -sh /usr/* | sort -rn 这是按兆(M)来排序 4.选出排在前面的10个 du -s /usr/* | sort -rn | head 5.选出排在后面的10个 du -s /usr/* | sort -rn | tail du -h –-max-depth=0 user du -sh –-max-depth=2 | more 总结du常用命令 du -h --max-dept

  • linux 驱动之Kconfig文件和Makefile文件实例

    linux 驱动之Kconfig文件和Makefile文件实例 在Linux编写驱动的过程中,有两个文件是我们必须要了解和知晓的.这其中,一个是Kconfig文件,另外一个是Makefile文件.如果大家比较熟悉的话,那么肯定对内核编译需要的.config文件不陌生,在.config文件中,我们发现有的模块被编译进了内核,有的只是生成了一个module.这中间,我们如何让内核发现我们编写的模块呢,这就需要在Kconfig中进行说明.至于如何生成模块,那么就需要利用Makefile告诉编译器,怎么

  • Linux 修改 etc/hosts文件详细介绍

     Linux 修改 etc/hosts文件 hosts文件 hosts -- the static table lookup for host name(主机名查询静态表). hosts文件是Linux系统上一个负责ip地址与域名快速解析的文件,以ascii格式保存在/etc/目录下.hosts文件包含了ip地址与主机名之间的映射,还包括主机的别名.在没有域名解析服务器的情况下,系统上的所有网络程序都通过查询该文件来解析对应于某个主机名的ip地址,否则就需要使用dns服务程序来解决.通过可以将常

  • asp.net编程实现删除文件夹及文件夹下文件的方法

    本文实例讲述了asp.net编程实现删除文件夹及文件夹下文件的方法.分享给大家供大家参考,具体如下: //获取文件夹 string path = Server.MapPath("Image"); //获取文件夹中所有图片 if (Directory.GetFileSystemEntries(path).Length > 0) { //遍历文件夹中所有文件 foreach (string file in Directory.GetFiles(path)) { //文件己存在 if

随机推荐