1 公共模块

~/TNV/src/01_common/01_types.h

xxxxxxxxxx
69
1
// 公共模块
2
// 定义所有模块都会用到的宏和数据类型
3
//
4
#pragma once
5

6
#include <netinet/in.h>
7
//
8
// 函数返回值
9
//
10
#define OK            0 // 成功
11
#define ERROR        -1 // 本地错误
12
#define SOCKET_ERROR -2 // 套接字通信错误
13
#define STATUS_ERROR -3 // 服务器状态异常
14
//
15
// 缓存
16
//
17
#define TRACKER_REDIS_PREFIX "tracker" // 跟踪服务器Redis前缀
18
#define STORAGE_REDIS_PREFIX "storage" // 存储服务器Redis前缀
19
//
20
// 存储服务器状态
21
//
22
typedef enum storage_status {
23
    STORAGE_STATUS_OFFLINE, // 存储服务器离线
24
    STORAGE_STATUS_ONLINE,  // 存储服务器在线
25
    STORAGE_STATUS_ACTIVE   // 存储服务器活动
26
}   storage_status_t;       // 存储服务器状态
27
//
28
// 存储服务器加入和信息
29
//
30
#define STORAGE_VERSION_MAX     6 // 版本最大字符数
31
#define STORAGE_GROUPNAME_MAX  16 // 组名最大字符数
32
#define STORAGE_HOSTNAME_MAX  128 // 主机名最大字符数
33
#define STORAGE_ADDR_MAX       16 // 地址最大字符数
34

35
typedef struct storage_join {
36
    char      sj_version[STORAGE_VERSION_MAX+1];     // 版本
37
    char      sj_groupname[STORAGE_GROUPNAME_MAX+1]; // 组名
38
    char      sj_hostname[STORAGE_HOSTNAME_MAX+1];   // 主机名
39
    in_port_t sj_port;                               // 端口号
40
    time_t    sj_stime;                              // 启动时间
41
    time_t    sj_jtime;                              // 加入时间
42
}   storage_join_t; // 存储服务器加入
43

44
typedef struct storage_info {
45
    char             si_version[STORAGE_VERSION_MAX+1];   // 版本
46
    char             si_hostname[STORAGE_HOSTNAME_MAX+1]; // 主机名
47
    char             si_addr[STORAGE_ADDR_MAX+1];         // IP地址
48
    in_port_t        si_port;                             // 端口号
49
    time_t           si_stime;                            // 启动时间
50
    time_t           si_jtime;                            // 加入时间
51
    time_t           si_btime;                            // 心跳时间
52
    storage_status_t si_status;                           // 状态
53
}   storage_info_t; // 存储服务器信息
54
//
55
// ID键值对
56
//
57
#define ID_KEY_MAX 64 // 键最大字符数
58

59
typedef struct id_pair {
60
    char id_key[ID_KEY_MAX+1]; // 键
61
    long id_value;             // 值
62
    int  id_offset;            // 偏移
63
}   id_pair_t;                 // ID键值对
64
//
65
// 存储服务器读写磁盘文件缓冲区
66
//
67
#define STORAGE_RCVWR_SIZE (512 * 1024) // 接收写入缓冲区字节数
68
#define STORAGE_RDSND_SIZE (512 * 1024) // 读取发送缓冲区字节数

~/TNV/src/01_common/02_proto.h

xxxxxxxxxx
61
1
// 公共模块
2
// 定义与报文规约有关的宏和数据类型
3
//
4
#pragma once
5

6
#include "01_types.h"
7
//
8
// |包体长度|命令|状态|  包体  |
9
// |    8   |  1 |  1 |包体长度|
10
//
11
#define BODYLEN_SIZE 8 // 包体长度字节数
12
#define COMMAND_SIZE 1 // 命令字节数
13
#define STATUS_SIZE  1 // 状态字节数
14
#define HEADLEN (BODYLEN_SIZE + COMMAND_SIZE + STATUS_SIZE) // 包头长度
15
//
16
// |包体长度|命令|状态|错误号|错误描述|
17
// |    8   |  1 |  1 |   2  | <=1024 |
18
//
19
#define ERROR_NUMB_SIZE    2 // 错误号字节数
20
#define ERROR_DESC_SIZE 1024 // 错误描述最大字节数(含结尾空字符)
21
//
22
// |包体长度|命令|状态|应用ID|用户ID|文件ID|
23
// |    8   |  1 |  1 |  16  |  256 |  128 |
24
//
25
#define APPID_SIZE   16 // 应用ID最大字节数(含结尾空字符)
26
#define USERID_SIZE 256 // 用户ID最大字节数(含结尾空字符)
27
#define FILEID_SIZE 128 // 文件ID最大字节数(含结尾空字符)
28
//
29
// 存储服务器加入包和心跳包
30
//
31
typedef struct storage_join_body {
32
    char sjb_version[STORAGE_VERSION_MAX+1];     // 版本
33
    char sjb_groupname[STORAGE_GROUPNAME_MAX+1]; // 组名
34
    char sjb_hostname[STORAGE_HOSTNAME_MAX+1];   // 主机名
35
    char sjb_port[sizeof(in_port_t)];            // 端口号
36
    char sjb_stime[sizeof(time_t)];              // 启动时间
37
    char sjb_jtime[sizeof(time_t)];              // 加入时间
38
}   storage_join_body_t; // 存储服务器加入包体
39

40
typedef struct storage_beat_body {
41
    char sbb_groupname[STORAGE_GROUPNAME_MAX+1]; // 组名
42
    char sbb_hostname[STORAGE_HOSTNAME_MAX+1];   // 主机名
43
}   storage_beat_body_t; // 存储服务器心跳包体
44
//
45
// 命令
46
//
47
#define CMD_TRACKER_JOIN   10 // 存储服务器向跟踪服务器发送加入包
48
#define CMD_TRACKER_BEAT   11 // 存储服务器向跟踪服务器发送心跳包
49
#define CMD_TRACKER_SADDRS 12 // 客户机从跟踪服务器获取存储服务器地址列表
50
#define CMD_TRACKER_GROUPS 13 // 客户机从跟踪服务器获取组列表
51

52
#define CMD_ID_GET 40 // 存储服务器从ID服务器获取ID
53

54
#define CMD_STORAGE_UPLOAD   70 // 客户机向存储服务器上传文件
55
#define CMD_STORAGE_FILESIZE 71 // 客户机向存储服务器询问文件大小
56
#define CMD_STORAGE_DOWNLOAD 72 // 客户机从存储服务器下载文件
57
#define CMD_STORAGE_DELETE   73 // 客户机删除存储服务器上的文件
58

59
#define CMD_TRACKER_REPLY 100 // 跟踪服务器应答
60
#define CMD_ID_REPLY      101 // ID服务器应答
61
#define CMD_STORAGE_REPLY 102 // 存储服务器应答

~/TNV/src/01_common/03_util.h

xxxxxxxxxx
28
1
// 公共模块
2
// 声明几个实用函数
3
//
4
#pragma once
5

6
#include <string>
7
#include <vector>
8

9
// long long类型整数主机序转网络序
10
void llton(long long ll, char* n);
11
// long long类型整数网络序转主机序
12
long long ntoll(char const* n);
13

14
// long类型整数主机序转网络序
15
void lton(long l, char* n);
16
// long类型整数网络序转主机序
17
long ntol(char const* n);
18

19
// short类型整数主机序转网络序
20
void ston(short s, char* n);
21
// short类型整数网络序转主机序
22
short ntos(char const* n);
23

24
// 字符串是否合法，即是否只包含26个英文字母大小写和0到9十个阿拉伯数字
25
int valid(char const* str);
26

27
// 以分号为分隔符将一个字符串拆分为多个子字符串
28
int split(char const* str, std::vector<std::string>& substrs);

~/TNV/src/01_common/04_util.cpp

1
// 公共模块
2
// 定义几个实用函数
3
//
4
#include <string.h>
5
#include "01_types.h"
6
#include "03_util.h"
7

8
// long long类型整数主机序转网络序
9
void llton(long long ll, char* n) {
10
    for (size_t i = 0; i < sizeof(ll); ++i)
11
        n[i] = ll >> (sizeof(ll) - i - 1) * 8;
12
}
13

14
// long long类型整数网络序转主机序
15
long long ntoll(char const* n) {
16
    long long ll = 0;
17
    for (size_t i = 0; i < sizeof(ll); ++i)
18
        ll |= (long long)(unsigned char)n[i] << (sizeof(ll) - i - 1) * 8;
19
    return ll;
20
}
21

22
// long类型整数主机序转网络序
23
void lton(long l, char* n) {
24
    for (size_t i = 0; i < sizeof(l); ++i)
25
        n[i] = l >> (sizeof(l) - i - 1) * 8;
26
}
27

28
// long类型整数网络序转主机序
29
long ntol(char const* n) {
30
    long l = 0;
31
    for (size_t i = 0; i < sizeof(l); ++i)
32
        l |= (long)(unsigned char)n[i] << (sizeof(l) - i - 1) * 8;
33
    return l;
34
}
35

36
// short类型整数主机序转网络序
37
void ston(short s, char* n) {
38
    for (size_t i = 0; i < sizeof(s); ++i)
39
        n[i] = s >> (sizeof(s) - i - 1) * 8;
40
}
41

42
// short类型整数网络序转主机序
43
short ntos(char const* n) {
44
    short s = 0;
45
    for (size_t i = 0; i < sizeof(s); ++i)
46
        s |= (short)(unsigned char)n[i] << (sizeof(s) - i - 1) * 8;
47
    return s;
48
}
49

50
// 字符串是否合法，即是否只包含26个英文字母大小写和0到9十个阿拉伯数字
51
int valid(char const* str) {
52
    if (!str)
53
        return ERROR;
54

55
    size_t len = strlen(str);
56
    if (!len)
57
        return ERROR;
58

59
    for (size_t i = 0; i < len; ++i)
60
        if (!(('a' <= str[i] && str[i] <= 'z') ||
61
              ('A' <= str[i] && str[i] <= 'Z') ||
62
              ('0' <= str[i] && str[i] <= '9')))
63
            return ERROR;
64

65
    return OK;
66
}
67

68
// 以分号为分隔符将一个字符串拆分为多个子字符串
69
int split(char const* str, std::vector<std::string>& substrs) {
70
    if (!str)
71
        return ERROR;
72

73
    size_t len = strlen(str);
74
    if (!len)
75
        return ERROR;
76

77
    char* buf = new char[len+1];
78
    strcpy(buf, str);
79

80
    char const* sep = ";";
81
    for (char* substr = strtok(buf, sep); substr;
82
        substr = strtok(NULL, sep))
83
        substrs.push_back(substr);
84

85
    delete[] buf;
86

87
    return OK;
88
}