当前位置: 开发笔记 > 编程语言 > 正文

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

作者：fangziqiang | 来源：互联网 | 2022-08-10 02:54

这篇文章主要介绍了Linux编程实现制作文件的ed2k链的相关资料,需要的朋友可以参考下

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

md4 编码代码来自网络。

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

c++版本:

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

defs.h

#ifndef MYCODE_DEFS_H
#define MYCODE_DEFS_H
 
#include  /* uint32_t ... */ 
#include  /* size_t, ssize_t */
#include 
#endif
 
#if __cplusplus
# define BEGIN_NAMESPACE_MYCODE namespace mc {
# define END_NAMESPACE_MYCODE }
# if __cplusplus <201103L
# define nullptr ((void*)0)
# endif
#endif /* __cplusplus */
 
#endif /* MYCODE_DEFS_H */

utils.h

#ifndef MYCODE_UTILS_H
#define MYCODE_UTILS_H
 
#include 
#if __cplusplus
# include 
# include 
# include 
#endif /* __cplusplus */
#include "defs.h"
 
#if __cplusplus
extern "C" {
#endif
 
#undef byteswap32
#define byteswap32(x) \
  ( (((x) & 0xff000000) >> 24) | (((x) & 0x00ff0000) >> 8) | \
   (((x) & 0x0000ff00) <<8) | (((x) & 0x000000ff) <<24) )
 
#undef htobe32
#undef htole32
#if __BYTE_ORDER == __LITTLE_ENDIAN
# define htobe32(x) byteswap32(x)
# define htole32(x) (x)
#else
# define htobe32(x) (x)
# define htole32(x) byteswap32(x)
#endif
 
enum { string_npos = (size_t)-1 };
/* 查找字符串 str 中第一个与 c 匹配的字符，返回该字符在字符串中的下标， 失败返回 string_npos */
size_t string_find(const char *str, size_t size, char c);
/* 逆向查找*/
size_t string_rfind(const char *str, size_t size, char c);
 
void setBigEndian_uint32(uint32_t *data, size_t n);
 
char* toHexString_uint32(char *buf, size_t bufSize,
             const uint32_t *data, size_t n);
 
char* createShortFileName(char *buf, size_t bufSize,
             const char *fullName, size_t size);
/* 成功时返回指针 fullName 某部分的地址， 失败时返回 NULL */
const char* getShortFileName(const char* fullName, size_t size);
 
/* 当返回0大小时， 需要检查state， state == 0 表示失败 */
size_t getFileSize(FILE *in, int *state);
 
#if __cplusplus
} /* extern "C" */
#endif
 
/******************************************************************************
 *             c++
 *****************************************************************************/
#if __cplusplus
BEGIN_NAMESPACE_MYCODE
 
# if __cplusplus >= 201103L
# define mc_move(x) std::move(x)
# else
# define mc_move(x) (x);
# endif
 
///////////////////////////////////////////////////////////////////////////////
 
template
void setBigEndian(T*, size_t);
 
template<>
inline void setBigEndian(uint32_t *p, size_t n)
{ setBigEndian_uint32(p, n); }
 
///////////////////////////////////////////////////////////////////////////////
 
template
std::string toHexString(T*, size_t);
 
template<>
inline std::string toHexString(uint32_t *p, size_t n)
{
  std::string strHex;
  char buf[9];
  for (size_t i = 0; i

utils.c

#include "utils.cpp"

utils.cpp

#include 
#include "utils.h"
 
#if __cplusplus
extern "C" {
#endif
 
void setBigEndian_uint32(uint32_t *data, size_t n)
{
  for (size_t i = 0; i  len)
      memcpy(buf, p, len + 1);
  }
  return buf;
}
 
const char* getShortFileName(const char *fileName, size_t size)
{
#if _WIN32
  char c = '\\';
#else
  char c = '/';
#endif
  size_t pos = string_rfind(fileName, size, c);
  if (pos == string_npos)
    return NULL;
  else
    return fileName + (pos + 1);
}
 
size_t getFileSize(FILE *in, int *state)
{
  *state = 0;
  if (!in)
    return 0;
   
  size_t curpos = ftell(in);
  if (fseek(in, 0, SEEK_END) == -1)
    return 0;
  size_t fileSize = ftell(in);
  if (fseek(in, curpos, SEEK_SET) == -1)
    return 0;
 
  *state = 1;
  return fileSize;
}
 
#if __cplusplus
} /* extern "C" */
#endif
 
/******************************************************************************
 *             c++
 *****************************************************************************/
#if __cplusplus
BEGIN_NAMESPACE_MYCODE
 
void getShortFileName(std::string *shortName, const std::string& fullName)
{
# if _WIN32
  char c = '\\';
# else
  char c = '/';
# endif
  size_t pos = fullName.rfind(c);
  if (pos == std::string::npos)
    shortName->assign(fullName);
  else
    shortName->assign(fullName.begin() + pos + 1, fullName.end());
}
 
std::string getShortFileName(const std::string& fullName)
{
  std::string shortName;
  getShortFileName(&shortName, fullName);
  return mc_move(shortName);
}
 
size_t getFileSize(std::ifstream& f)
{
  f.seekg(0, f.end);
  size_t fileSize = f.tellg();
  f.seekg(0);
  return fileSize;
}
 
END_NAMESPACE_MYCODE
#endif /* __cplusplus */

md4.h

#ifndef MYCODE_MD4_H
#define MYCODE_MD4_H
 
#include "defs.h"
 
#if __cplusplus
extern "C" {
#endif
   
enum { MD4_COUNT_SIZE = 8, MD4_STATE_SIZE = 16, MD4_BUFFER_SIZE = 64 };
   
typedef struct {
  uint32_t count[2];
  uint32_t state[4];
  uint8_t buffer[MD4_BUFFER_SIZE];
} md4_t;
 
#define md4_data(md4_ptr) ((char*)((md4_ptr)->state))
#define md4_cdata(md4_ptr) ((const char*)((md4_ptr)->state))
#define md4_dataSize() (MD4_STATE_SIZE)
 
void md4_reset(md4_t *md4);
void md4_update(md4_t *md4, const char *src, size_t srcSize);
void md4_finish(md4_t *md4);
void md4_setBigEndian(md4_t *md4);
char* md4_toHashString(char dest[33], const md4_t *md4);
 
#if __cplusplus
}
#endif
 
#endif /* MYCODE_MD4_H */

md4.c

/* #include  */
#include 
#include 
#include "utils.h"
#include "md4.h"
 
#if __cplusplus
extern "C" {
#endif
   
#if __BYTE_ORDER == __LITTLE_ENDIAN
# define md4_htole32_4(buf) /* empty */
# define md4_htole32_14(buf) /* empty */
# define md4_htole32_16(buf) /* empty */
#else
# define md4_htole32_4(buf) \
 (buf)[ 0] = htole32((buf)[ 0]); \
 (buf)[ 1] = htole32((buf)[ 1]); \
 (buf)[ 2] = htole32((buf)[ 2]); \
 (buf)[ 3] = htole32((buf)[ 3])
  
# define md4_htole32_14(buf) \
 (buf)[ 0] = htole32((buf)[ 0]); \
 (buf)[ 1] = htole32((buf)[ 1]); \
 (buf)[ 2] = htole32((buf)[ 2]); \
 (buf)[ 3] = htole32((buf)[ 3]); \
 (buf)[ 4] = htole32((buf)[ 4]); \
 (buf)[ 5] = htole32((buf)[ 5]); \
 (buf)[ 6] = htole32((buf)[ 6]); \
 (buf)[ 7] = htole32((buf)[ 7]); \
 (buf)[ 8] = htole32((buf)[ 8]); \
 (buf)[ 9] = htole32((buf)[ 9]); \
 (buf)[10] = htole32((buf)[10]); \
 (buf)[11] = htole32((buf)[11]); \
 (buf)[12] = htole32((buf)[12]); \
 (buf)[13] = htole32((buf)[13])
  
# define md4_htole32_16(buf) \
 (buf)[ 0] = htole32((buf)[ 0]); \
 (buf)[ 1] = htole32((buf)[ 1]); \
 (buf)[ 2] = htole32((buf)[ 2]); \
 (buf)[ 3] = htole32((buf)[ 3]); \
 (buf)[ 4] = htole32((buf)[ 4]); \
 (buf)[ 5] = htole32((buf)[ 5]); \
 (buf)[ 6] = htole32((buf)[ 6]); \
 (buf)[ 7] = htole32((buf)[ 7]); \
 (buf)[ 8] = htole32((buf)[ 8]); \
 (buf)[ 9] = htole32((buf)[ 9]); \
 (buf)[10] = htole32((buf)[10]); \
 (buf)[11] = htole32((buf)[11]); \
 (buf)[12] = htole32((buf)[12]); \
 (buf)[13] = htole32((buf)[13]); \
 (buf)[14] = htole32((buf)[14]); \
 (buf)[15] = htole32((buf)[15])
 
#endif
 
/* #define F1(x, y, z) (x & y | ~x & z) */
#define F1(x, y, z) (z ^ (x & (y ^ z)))
#define F2(x, y, z) ((x & y) | (x & z) | (y & z))
#define F3(x, y, z) (x ^ y ^ z)
 
/* This is the central step in the MD4 algorithm. */
#define MD4STEP(f, w, x, y, z, data, s) \
 ( w += f(x, y, z) + data, w = w<>(32-s) )
 
static void md4_transform(uint32_t *state, const uint8_t *buffer)
{
 uint32_t a, b, c, d;
 const uint32_t *src = (const uint32_t *)buffer;
 
 a = state[0];
 b = state[1];
 c = state[2];
 d = state[3];
  
 MD4STEP(F1, a, b, c, d, src[ 0], 3);
 MD4STEP(F1, d, a, b, c, src[ 1], 7);
 MD4STEP(F1, c, d, a, b, src[ 2], 11);
 MD4STEP(F1, b, c, d, a, src[ 3], 19);
 MD4STEP(F1, a, b, c, d, src[ 4], 3);
 MD4STEP(F1, d, a, b, c, src[ 5], 7);
 MD4STEP(F1, c, d, a, b, src[ 6], 11);
 MD4STEP(F1, b, c, d, a, src[ 7], 19);
 MD4STEP(F1, a, b, c, d, src[ 8], 3);
 MD4STEP(F1, d, a, b, c, src[ 9], 7);
 MD4STEP(F1, c, d, a, b, src[10], 11);
 MD4STEP(F1, b, c, d, a, src[11], 19);
 MD4STEP(F1, a, b, c, d, src[12], 3);
 MD4STEP(F1, d, a, b, c, src[13], 7);
 MD4STEP(F1, c, d, a, b, src[14], 11);
 MD4STEP(F1, b, c, d, a, src[15], 19);
 
 MD4STEP(F2, a, b, c, d, src[ 0] + 0x5a827999, 3);
 MD4STEP(F2, d, a, b, c, src[ 4] + 0x5a827999, 5);
 MD4STEP(F2, c, d, a, b, src[ 8] + 0x5a827999, 9);
 MD4STEP(F2, b, c, d, a, src[12] + 0x5a827999, 13);
 MD4STEP(F2, a, b, c, d, src[ 1] + 0x5a827999, 3);
 MD4STEP(F2, d, a, b, c, src[ 5] + 0x5a827999, 5);
 MD4STEP(F2, c, d, a, b, src[ 9] + 0x5a827999, 9);
 MD4STEP(F2, b, c, d, a, src[13] + 0x5a827999, 13);
 MD4STEP(F2, a, b, c, d, src[ 2] + 0x5a827999, 3);
 MD4STEP(F2, d, a, b, c, src[ 6] + 0x5a827999, 5);
 MD4STEP(F2, c, d, a, b, src[10] + 0x5a827999, 9);
 MD4STEP(F2, b, c, d, a, src[14] + 0x5a827999, 13);
 MD4STEP(F2, a, b, c, d, src[ 3] + 0x5a827999, 3);
 MD4STEP(F2, d, a, b, c, src[ 7] + 0x5a827999, 5);
 MD4STEP(F2, c, d, a, b, src[11] + 0x5a827999, 9);
 MD4STEP(F2, b, c, d, a, src[15] + 0x5a827999, 13);
 
 MD4STEP(F3, a, b, c, d, src[ 0] + 0x6ed9eba1, 3);
 MD4STEP(F3, d, a, b, c, src[ 8] + 0x6ed9eba1, 9);
 MD4STEP(F3, c, d, a, b, src[ 4] + 0x6ed9eba1, 11);
 MD4STEP(F3, b, c, d, a, src[12] + 0x6ed9eba1, 15);
 MD4STEP(F3, a, b, c, d, src[ 2] + 0x6ed9eba1, 3);
 MD4STEP(F3, d, a, b, c, src[10] + 0x6ed9eba1, 9);
 MD4STEP(F3, c, d, a, b, src[ 6] + 0x6ed9eba1, 11);
 MD4STEP(F3, b, c, d, a, src[14] + 0x6ed9eba1, 15);
 MD4STEP(F3, a, b, c, d, src[ 1] + 0x6ed9eba1, 3);
 MD4STEP(F3, d, a, b, c, src[ 9] + 0x6ed9eba1, 9);
 MD4STEP(F3, c, d, a, b, src[ 5] + 0x6ed9eba1, 11);
 MD4STEP(F3, b, c, d, a, src[13] + 0x6ed9eba1, 15);
 MD4STEP(F3, a, b, c, d, src[ 3] + 0x6ed9eba1, 3);
 MD4STEP(F3, d, a, b, c, src[11] + 0x6ed9eba1, 9);
 MD4STEP(F3, c, d, a, b, src[ 7] + 0x6ed9eba1, 11);
 MD4STEP(F3, b, c, d, a, src[15] + 0x6ed9eba1, 15);
 
 state[0] += a;
 state[1] += b;
 state[2] += c;
 state[3] += d;
} 
 
 
void md4_reset(md4_t *md4)
{
 md4->count[0] = 0;
 md4->count[1] = 0;
 md4->state[0] = 0x67452301; 
 md4->state[1] = 0xEFCDAB89; 
 md4->state[2] = 0x98BADCFE; 
 md4->state[3] = 0x10325476;
}
 
void md4_update(md4_t *md4, const char *src, size_t srcSize)
{
 uint32_t count = (uint32_t)((md4->count[0] >> 3) & 0x3f);
 
 if ((md4->count[0] += (srcSize <<3)) <(srcSize <<3))
  ++(md4->count[1]);
 md4->count[1] += (srcSize >> 29);
 
 if (count > 0)
 { 
  size_t partSize = MD4_BUFFER_SIZE - count;
  if (srcSize buffer + count, src, srcSize);
   return;
  }
  memcpy(md4->buffer + count, src, partSize);
   
  md4_htole32_16((uint32_t*)md4->buffer);
  md4_transform(md4->state, md4->buffer);
  src += partSize;
  srcSize -= partSize;
 }
 
 while (srcSize >= MD4_BUFFER_SIZE)
 {
  memcpy(md4->buffer, src, MD4_BUFFER_SIZE);
  md4_transform(md4->state, md4->buffer);
  md4_htole32_16((uint32_t *)md4->buffer);
  src += MD4_BUFFER_SIZE;
  srcSize -= MD4_BUFFER_SIZE;
 }
 memcpy(md4->buffer, src, srcSize);
}
 
void md4_finish(md4_t *md4)
{
 uint32_t count = (uint32_t)((md4->count[0] >> 3) & 0x3f);
  
 uint8_t *p = md4->buffer + count;
 *p++ = 0x80;
 
 count = MD4_BUFFER_SIZE - 1 - count;
 
 if (count <8)
 {
  memset(p, 0, count);
  md4_htole32_16((uint32_t *)md4->buffer);
  md4_transform(md4->state, md4->buffer);
  memset(md4->buffer, 0, 56);
 }
 else
 {
  memset(p, 0, count - 8);
 }
 md4_htole32_14((uint32_t *)md4->buffer);
 
 /* Append bit count and transform */
 ((uint32_t *)md4->buffer)[14] = md4->count[0];
 ((uint32_t *)md4->buffer)[15] = md4->count[1];
 
 md4_transform(md4->state, md4->buffer);
 md4_htole32_4(md4->state);
  
 memset(md4->buffer, 0, MD4_BUFFER_SIZE);
}
 
void md4_setBigEndian(md4_t *md4)
{
  uint32_t *p = md4->state;
  p[0] = htobe32(p[0]);
  p[1] = htobe32(p[1]);
  p[2] = htobe32(p[2]);
  p[3] = htobe32(p[3]);
}
 
char* md4_toHashString(char dest[33], const md4_t *md4)
{
  return toHexString_uint32(dest, 33, md4->state, 4);
}
 
#if __cplusplus
}
#endif

ed2k.c

#include #include #include #include "defs.h" #include "utils.h" #include "md4.h" enum { CHUNK_SIZE = 9728000, BUFFER_MAX_SIZE = 256 }; bool printEd2kLink(const char *fileName) { FILE *in = fopen(fileName, "rb"); if (!in) { fprintf(stderr, "error: Open file failed.\n"); return false; } size_t fileSize; { int state; if ((fileSize = getFileSize(in, &state)) == 0) { if (state == 0) fprintf(stderr, "error: get fileSize of \'%s\' failed\n", fileName); else fprintf(stderr, "error: \'%s\' is empty.\n", fileName); fclose(in); return false; } } const char *shortFileName = getShortFileName(fileName, strlen(fileName)); if (shortFileName == NULL) { fprintf(stderr, "error: createNewFilename().\n"); fclose(in); return false; } static md4_t md4HashSet, md4FileHash; md4_reset(&md4FileHash); static char chunk[CHUNK_SIZE]; size_t readCount; bool bCOntinue= true; int chunkCount = 0; while (bContinue) { readCount = fread(chunk, sizeof(chunk[0]), CHUNK_SIZE, in); if (readCount 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

MD4Hash.h

#ifndef MYCODE_MD4HASH_H #define MYCODE_MD4HASH_H #include #include #include "md4.h" #include "defs.h" BEGIN_NAMESPACE_MYCODE class MD4Hash { friend class MD4HashAlgo; struct Data{ uint32_t d[4]; }; public: MD4Hash(); MD4Hash(const MD4Hash& o); #if __cplusplus >= 201103L MD4Hash(MD4Hash&& o); MD4Hash& operator=(MD4Hash&& o); #endif ~MD4Hash(); MD4Hash& operator=(const MD4Hash& o); void setBigEndian(); std::string toString(); void swap(MD4Hash& o) { std::swap(m_data, o.m_data); } private: Data m_data; MD4Hash(uint32_t *data); }; class MD4HashAlgo { md4_t m_md4; public: MD4HashAlgo(); MD4HashAlgo(const MD4HashAlgo& o); #if __cplusplus >= 201103L MD4HashAlgo(MD4HashAlgo&& o); MD4HashAlgo& operator=(MD4HashAlgo&& o); #endif ~MD4HashAlgo(); MD4HashAlgo& operator=(const MD4HashAlgo& o); void reset() { md4_reset(&m_md4); } void update(const char *data, size_t size) { md4_update(&m_md4, data, size); } void update(const MD4Hash& hash) { md4_update(&m_md4, (const char*)(hash.m_data.d), 16); } void finish() { md4_finish(&m_md4); } MD4Hash getHash() { return MD4Hash(m_md4.state); } size_t hashSize() { return md4_dataSize(); } void swap(MD4HashAlgo& o) { std::swap(m_md4, o.m_md4); } }; END_NAMESPACE_MYCODE #endif /* MYCODE_MD4HASH_H */

ED2KHash.h

#ifndef MYCODE_ED2KHASH_H #define MYCODE_ED2KHASH_H #include #include #include "defs.h" BEGIN_NAMESPACE_MYCODE class ED2KHash { public: enum mode { FileHash = 0x01, PartHash = 0x10, RootHash = 0x20, Default = FileHash }; ED2KHash(int mode = ED2KHash::Default); ED2KHash(const ED2KHash& o); ~ED2KHash(); ED2KHash& operator=(const ED2KHash& o); #if __cplusplus >= 201103L ED2KHash(ED2KHash&& o); ED2KHash& operator=(ED2KHash&& o); #endif void exec(const char* fileName); void swap(ED2KHash& o); std::string getFileHash(); friend std::ostream& operator<<(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 #include #include #include "utils.h" #include "MD4Hash.h" #include "ED2KHash.h" BEGIN_NAMESPACE_MYCODE /////////////////////////////////////////////////////////////////////////////// // ED2KHash // /////////////////////////////////////////////////////////////////////////////// ED2KHash::ED2KHash(int mode) : m_mode(mode), m_fileSize(0) { /* empty */ } void ED2KHash::copy(const ED2KHash& o) { m_mode = o.m_mode; m_fileSize = o.m_fileSize; m_fileName = o.m_fileName; m_fileHash = o.m_fileHash; } ED2KHash::ED2KHash(const ED2KHash& o) { copy(o); } ED2KHash& ED2KHash::operator=(const ED2KHash& o) { copy(o); return *this; } #if __cplusplus >= 201103L void ED2KHash::move(ED2KHash& o) { m_mode = o.m_mode; m_fileSize = o.m_fileSize; m_fileName = std::move(o.m_fileName); m_fileHash = std::move(o.m_fileHash); } ED2KHash::ED2KHash(ED2KHash&& o) { this->move(o); } ED2KHash& ED2KHash::operator=(ED2KHash&& o) { this->move(o); return *this; } #endif ED2KHash::~ED2KHash() { /* empty */ } void ED2KHash::swap(ED2KHash& o) { std::swap(*this, o); } std::string ED2KHash::getFileHash() { return m_fileHash; } enum { CHUNK_SIZE = 9728000 }; enum { BLOCK_180K = 184320, BLOCK_140K = 143360 }; void ED2KHash::exec(const char* fileName) { std::string msg("error: "); std::ifstream in(fileName, std::ios_base::binary | std::ios_base::in); if (!in.is_open()) throw msg = msg + "Open \'" + fileName + "\' failed."; if ((m_fileSize = mc::getFileSize(in)) == 0) throw msg = msg + fileName + " is empty."; mc::getShortFileName(&m_fileName, fileName); static mc::MD4Hash md4Hash; static mc::MD4HashAlgo partHashMD4Algo, fileHashMD4Algo; fileHashMD4Algo.reset(); static char chunk[CHUNK_SIZE]; size_t readCount; size_t chunkCount = 0; bool bCOntinue= true; while (bContinue) { in.read(chunk, CHUNK_SIZE); if ((readCount = in.gcount()) 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|" < 0) do { cout <getHash().toString(); if (--n == 0) break; ++it; cout <<':'; } while (1); out <<'|'; }*/ //if (v.m_mode | ED2KHash::RootHash) // out <<'|'; return out <<'/'; } END_NAMESPACE_MYCODE

ed2k.cpp

#include #include #include #include #include #include "utils.h" #include "ED2KHash.h" #include "defs.h" void usage(bool b) { std::cout <<"command: ed2k [Option...] \n" <<" ed2k (1)\n" <<" ed2k -r (2)\n" <<" ed2k -p (3)\n" <<" ed2k -p -r (4)\n" <<" ed2k -pr (4)\n\n" <<"(1) ed2k://|file||||/\n" <<"(2) ed2k://|file|||||/\n" <<"(3) ed2k://|file|||||/\n" <<"(4) ed2k://|file||||||/" <
以上所述就是本文给大家分享的制作ed2k链的代码了，希望大家能够喜欢。

go

ios

写下你的评论吧 !

吐个槽吧,看都看了

会员登录 | 用户注册

推荐阅读

ios
Open judge C16H: Magical Balls 快速幂+逆元问题解析

本文主要解析了Open judge C16H问题中涉及到的Magical Balls的快速幂和逆元算法，并给出了问题的解析和解决方法。详细介绍了问题的背景和规则，并给出了相应的算法解析和实现步骤。通过本文的解析，读者可以更好地理解和解决Open judge C16H问题中的Magical Balls部分。 ... [详细]

蜡笔小新   2023-12-14 12:03:27

ios
单击后为什么远程通知操作无效？ - Why remote notification action is doing nothing after clicking?

IhaveconfiguredanactionforaremotenotificationwhenitarrivestomyiOsapp.Iwanttwodiff ... [详细]

蜡笔小新   2023-12-14 15:57:44

ios
差分约束系统求解House Man跳跃问题的思路与方法

本文讨论了使用差分约束系统求解House Man跳跃问题的思路与方法。给定一组不同高度，要求从最低点跳跃到最高点，每次跳跃的距离不超过D，并且不能改变给定的顺序。通过建立差分约束系统，将问题转化为图的建立和查询距离的问题。文章详细介绍了建立约束条件的方法，并使用SPFA算法判环并输出结果。同时还讨论了建边方向和跳跃顺序的关系。 ... [详细]

蜡笔小新   2023-12-14 11:49:51

ios
Monkey《大话移动——Android与iOS应用测试指南》的预购信息发布啦！

Monkey《大话移动——Android与iOS应用测试指南》的预购信息已经发布，可以在京东和当当网进行预购。感谢几位大牛给出的书评，并呼吁大家的支持。明天京东的链接也将发布。 ... [详细]

蜡笔小新   2023-12-14 18:57:09

ios
【机器学习】生成式对抗网络模型综述

生成式对抗网络模型综述摘要生成式对抗网络模型(GAN)是基于深度学习的一种强大的生成模型，可以应用于计算机视觉、自然语言处理、半监督学习等重要领域。生成式对抗网络 ... [详细]

蜡笔小新   2023-12-14 17:51:18

ios
基于layUI的图片上传前预览功能的2种实现方式

本文介绍了基于layUI的图片上传前预览功能的两种实现方式：一种是使用blob+FileReader，另一种是使用layUI自带的参数。通过选择文件后点击文件名，在页面中间弹窗内预览图片。其中，layUI自带的参数实现了图片预览功能。该功能依赖于layUI的上传模块，并使用了blob和FileReader来读取本地文件并获取图像的base64编码。点击文件名时会执行See()函数。摘要长度为169字。 ... [详细]

蜡笔小新   2023-12-14 17:06:58

md5
开发笔记:加密&json&StringIO模块&BytesIO模块

篇首语：本文由编程笔记#小编为大家整理，主要介绍了加密&json&StringIO模块&BytesIO模块相关的知识，希望对你有一定的参考价值。一、加密加密 ... [详细]

蜡笔小新   2023-12-14 15:18:35

md5
HDU 2372 El Dorado（DP）的最长上升子序列长度求解方法

本文介绍了解决HDU 2372 El Dorado问题的一种动态规划方法，通过循环k的方式求解最长上升子序列的长度。具体实现过程包括初始化dp数组、读取数列、计算最长上升子序列长度等步骤。 ... [详细]

蜡笔小新   2023-12-14 15:08:18

python
Alink回归预测的不完善问题及期待

本文讨论了Alink回归预测的不完善问题，指出目前主要针对Python做案例，对其他语言支持不足。同时介绍了pom.xml文件的基本结构和使用方法，以及Maven的相关知识。最后，对Alink回归预测的未来发展提出了期待。 ... [详细]

蜡笔小新   2023-12-14 14:25:33

python
如何找到并终止在8080端口上运行的进程？

本文介绍了如何找到并终止在8080端口上运行的进程的方法，通过使用终端命令lsof -i :8080可以获取在该端口上运行的所有进程的输出，并使用kill命令终止指定进程的运行。 ... [详细]

蜡笔小新   2023-12-14 13:45:13

python
求解hdu 1003 java题目的动态规划优化方法

本文讨论了如何优化解决hdu 1003 java题目的动态规划方法，通过分析加法规则和最大和的性质，提出了一种优化的思路。具体方法是，当从1加到n为负时，即sum(1,n)sum(n,s)，可以继续加法计算。同时，还考虑了两种特殊情况：都是负数的情况和有0的情况。最后，通过使用Scanner类来获取输入数据。 ... [详细]

蜡笔小新   2023-12-14 13:11:00

python
九度OnlineJudge之1002：Grading问题的解决方法

本文介绍了九度OnlineJudge中的1002题目“Grading”的解决方法。该题目要求设计一个公平的评分过程，将每个考题分配给3个独立的专家，如果他们的评分不一致，则需要请一位裁判做出最终决定。文章详细描述了评分规则，并给出了解决该问题的程序。 ... [详细]

蜡笔小新   2023-12-14 13:00:09

python
C++省略号类型和参数个数不确定函数参数范例

本文介绍了C++中省略号类型和参数个数不确定函数参数的使用方法，并提供了一个范例。通过宏定义的方式，可以方便地处理不定参数的情况。文章中给出了具体的代码实现，并对代码进行了解释和说明。这对于需要处理不定参数的情况的程序员来说，是一个很有用的参考资料。 ... [详细]

蜡笔小新   2023-12-14 12:36:28

python
OC学习笔记之@property和@synthesize

本文介绍了OC学习笔记中的@property和@synthesize，包括属性的定义和合成的使用方法。通过示例代码详细讲解了@property和@synthesize的作用和用法。 ... [详细]

蜡笔小新   2023-12-14 12:05:06

python
Mac OS 升级到11.2.2 Eclipse打不开了，报错Failed to create the Java Virtual Machine

本文介绍了在Mac OS升级到11.2.2版本后，使用Eclipse打开时出现报错Failed to create the Java Virtual Machine的问题，并提供了解决方法。 ... [详细]

蜡笔小新   2023-12-14 12:01:13

fangziqiang

这个家伙很懒，什么也没留下！

Tags | 热门标签

client

substring

metadata

flutter

scala

lua

express

default

nodejs

regex

node.js

dagger

php5

iostream

c语言

web

python

less

yaml

cPlusPlus

search

dll

md5

text

solr

instance

netty

keyword

httpclient

window

RankList | 热门文章

1在tqdm中将“处理”更改为“已处理”

2html5 背景边框颜色渐变,css边框颜色渐变

3vivoz3中将屏幕旋转关掉具体方法介绍

4phpStudy环境下composer的装置

5网站访问速度过慢的原因

6前方车辆检测的常用方法

7前端单元测试入门3react测试

8pandas csv的数据处理（二）

9Android：EditText在hint字体大小和text字体大小不一致时的设置方法

10i3 9350KF和i5 9400F哪款值得买 i39350KF与i59400F区别对比评测

11Java 使用falstjson包技巧

12开发笔记:Python如何爬取淘宝MM呢?教你一招

13Twitter error: "UNAUTHORIZED_ACCESS""This request is not properly authenticated"

14网页不提示php文件的语法异常

15北大AI公开课第八课自然语言对话的现状与未来by今日头条李航