LinuxC编程实战 xunchat聊天室（伪）项目文档

西邮Linux兴趣小组 大一暑期项目

开发设计文档

项目作者	孙首勋
项目名称	xunchat聊天室

1.项目引言

1.1项目综述
该项目基本模拟QQ的功能，可以实现群聊，私聊，收发文件，查看聊天消息等基本功能，进行操作优化，对于添加好友，添加群聊有应有的项目交互，支持多个用户接入实时聊天。
1.2术语表

序号	术语或缩略语	说明性定义
1	C/S	Client/Server模型
2	epoll	epoll 是 Linux 内核为处理大批句柄而作改进的 poll ，是 Linux 特有的 I/O 函数。
3	数据库	此项目使用的数据库为MySQL
4	TCP/IP协议	网络传输协议，此项目使用的就是这中传输协议
5	API	函数借口

应用程序编程接口

1.3参考资料

作者	资料名称
zzy大佬	LinuxC编程实战
楚东方学长	Csdn博文 借鉴了部分操作的宏命名（英语实在太差）https://blog.csdn.net/chudongfang2015/article/details/52250340
杨懿凡	数据库操作两篇帖子
不认识的博主pylemon	数据库增删改查 https://blog.csdn.net/qq_27648991/article/details/80412395
等等	博客园，csdn各类博客，太多了找不到原链接了

1.4 项目开发环境、流程图绘制工具
开发环境：Deepin桌面版15.10.1，gcc编译器，vscode，vim，MySQL。

程序运行环境：
1.局域网

2.数据结构说明

使用list.h和分页器来增加界面的友好性和美化性，熟练使用c语言操作数据库的函数，网络编程的操作函数，服务器使用epoll的LT+单线程+阻塞实现多用户并发操作，客户端使用一个单线程收包，主线程进行聊天收发文件操作。
数据库主要建立了7张表。
分别是（具体作用在模块设计解释）

3.模块设计

3.1程序函数调用图及模块化分

客户端主要分为三层，层层递进实现功能，操作流程很友好。
第一层没一步操作对应一个recv收包，主要功能是登录注册找回密码，只有登录成功后才能进入第二层界面。
第二层是核心布局，你可以选择自己需要的功能，群聊私聊等等，进入此层后，所有的recv操作单开一个线程进行收包，之后由用户选择，进入实现功能操作的第三层。
第三层就是实现用户操作的一层，比如私聊，添加好友，删除好友，建群，踢人等操作。

服务器主要分为两层
第一层初始化服务器所需的东西，外加不停接受客户端发来的包。
第二层通过一个函数来处理所收到的包。

3.2功能设计说明

void UI_loginin(int conn_fd);
第一层登录界面ui。

int login(int conn_fd);
第二层界面UI

void watchfrilist(int conn_fd);
查看好友列表，进而选择不同的函数进入不同功能

void watchgrouplist(int conn_fd);
查看群组列表，通过用户选择进入功能实现的界面。

void watchlistbox(int conn_fd);
查看消息界面，会实时更新在上线时的消息记录和通知消息。

int UI_filesend(int conn_fd);
客户端发送文件函数

客户端初始化成功

*void myallthread(PACK pack);
处理包的主函数，根据包所携带的type位进行判断，在细分调用那个处理函数

3.3函数说明

客户端函数头文件

void judgeaddfri(int mes, int conn_fd);
void judgeaddgro(int mes, int conn_fd);
void watchfrilist(int conn_fd);   //查看好友列表
void watchgrouplist(int conn_fd); //查看群组列表
int login(int conn_fd);
int UI_zhuce(int conn_fd);
void UI_loginin(int conn_fd);
void UI_user(int conn_fd);
int UI_friendadd(int conn_fd);
int UI_frienddel(int delfd, int conn_fd);
int UI_friendchat(int chatfd, int conn_fd);
int UI_groupchat(int grochatfd, int conn_fd);
int UI_groupadd(int conn_fd, int groupid);
int UI_groupmbkick(int groupid, int conn_fd);
int UI_groupout(int groupid, int conn_fd);
int UI_groupdel(int groupid, int conn_fd);
int UI_groupcreate(int conn_fd);
int UI_frimessbox(int chatfd, int conn_fd);
int UI_gromessbox(int grochatfd, int conn_fd);
int UI_filesend(int conn_fd);
void printtype(int type);

void input_userinfo(int conn_fd, const PACK *senddata);

void *clientrecive(void *conn_fd);
void changepassword(int conn_fd);
void findpassword(int conn_fd);

void watchlistbox(int conn_fd);

服务端处理收包头文件

void myallthread(PACK *pack);
int threadlogin(PACK *pack);
void userregister(PACK *pack);
void mysqlinit(MYSQL *mysql);
void srv_deletefriend(PACK *pack);
void srv_addfriend(PACK *pack);
void srv_groupquit(PACK *pack);
void srv_groupdel(PACK *pack);
void srv_groupjoin(PACK *pack);
void srv_findpassword(PACK *pack);
void srv_frienchat(PACK *pack);
void srv_groupchat(PACK *pack);
void srv_creategroup(PACK *pack);
void srv_groupkick(PACK *pack);
void srv_groupsee(PACK *pack);
void srv_friendsee(PACK *pack);
void srv_changenum(PACK *pack);
int close_mysql(MYSQL mysql);
void judgeaddfri(PACK *pack);
void judgeaddgro(PACK *pack);
void srv_frimessbox(PACK *pack);
void srv_gromessbox(PACK *pack);
int Filetran(PACK *pack);

3.4其他说明

7张表的作用，只用7张完全就够用了，不用更多。
群用户和朋友两张表是作为好友表使用的，由于MySQL是关系型数据库，当时想了很久，我想不到更好的建表方式，只能采取是一对一建表，所以每次获取好友列表和群列表时会遍历整个数据库的群用户和朋友整张表，效率很低，但也没办法，现阶段只学了这么多。
私聊消息和群消息是作为消息记录用的，在此不做过多赘述。
用户数据和群数据是用来存储用户信息和群信息的，在此不做过多赘述。
个人消息存储添加好友添加群组一类的通知消息，用户已读之后会实时删除，每次没人上线时会发送该用户的通知消息。

4.文件说明

文件名	功能描述
my_client.c	客户端所有操作
my_recv.c和my_recv.h	本来计划作为处理解析接收文件的，后来感觉没必要，但是也懒得改了
my_server.c和my_server.h	服务器初始化和服务器收包
my_serthread.c和my_serthread.h	服务器端对收到的包的处理
all.h和list.h	所有使用的宏定义

5.异常、错误处理

对于所有用户操作，我以标明输入极限和正常输入是什么，只要用户按照操作进行正常输入，就不会出现任何bug，而如果用户不按照正常输入，那么，我也进行了相应的操作方案，私聊时如果输入的用户不是该用户的好友，将不会进入聊天界面，删除好友同样，解散群聊，和踢人时，如果输入的是权限不够的群聊，将也无法进行正确操作。如果在输入数字的界面输入了好多非法字符，本来由于scanf("%d",&n);将无法读入字符串，但是我在进行每步操作时，使用了清屏函数，错误输出将无法出现在用户界面。

6.已知存在的问题及改善方案

1.虽然找到了md5加密的代码，也了解了md5的原理和功能，但是由于我太懒了加之之前写ttms时已经使用过md5加密，就没想着在写一遍。（源码发在下面）
2.本机传输文件速度非常快，但是当程序放到局域网上是，由于带宽的影响和我只用了单线程传输，导致传输速度过慢，但是可以保证传输的正确性。
3.资源浪费，数据库虽然加了外键，但是由于对于数据库操作不够熟悉，没有使用级联删除，还是多次调用数据库实现群解散，删除好友的功能，还有每次添加完成好友需要重新刷新好友列表，得重新把所有好友信息刷新一遍。
4.聊天界面太过丑陋。
5.密码不回显未解决，在linux下没有getch函数，之前写ttms时使用手写的getch。

改善方案：等我学一阵算法并完成linuxc整本书所有未解决的问题，我将会尝试加入断点续传和多线程收发文件功能，其他功能主要是花费时间就能做好的，感觉并不能很好的是我学到新东西。

md5.c

#include 
#include "md5.h"
 
unsigned char PADDING[]={0x80,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
                         0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
                         0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
                         0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
                         
void MD5Init(MD5_CTX *context)
{
     context->count[0] = 0;
     context->count[1] = 0;
     context->state[0] = 0x67452301;
     context->state[1] = 0xEFCDAB89;
     context->state[2] = 0x98BADCFE;
     context->state[3] = 0x10325476;
}
void MD5Update(MD5_CTX *context,unsigned char *input,unsigned int inputlen)
{
    unsigned int i = 0,index = 0,partlen = 0;
    index = (context->count[0] >> 3) & 0x3F;
    partlen = 64 - index;
    context->count[0] += inputlen << 3;
    if(context->count[0] < (inputlen << 3))
       context->count[1]++;
    context->count[1] += inputlen >> 29;
    
    if(inputlen >= partlen)
    {
       memcpy(&context->buffer[index],input,partlen);
       MD5Transform(context->state,context->buffer);
       for(i = partlen;i+64 <= inputlen;i+=64)
           MD5Transform(context->state,&input[i]);
       index = 0;        
    }  
    else
    {
        i = 0;
    }
    memcpy(&context->buffer[index],&input[i],inputlen-i);
}
void MD5Final(MD5_CTX *context,unsigned char digest[16])
{
    unsigned int index = 0,padlen = 0;
    unsigned char bits[8];
    index = (context->count[0] >> 3) & 0x3F;
    padlen = (index < 56)?(56-index):(120-index);
    MD5Encode(bits,context->count,8);
    MD5Update(context,PADDING,padlen);
    MD5Update(context,bits,8);
    MD5Encode(digest,context->state,16);
}
void MD5Encode(unsigned char *output,unsigned int *input,unsigned int len)
{
    unsigned int i = 0,j = 0;
    while(j < len)
    {
         output[j] = input[i] & 0xFF;  
         output[j+1] = (input[i] >> 8) & 0xFF;
         output[j+2] = (input[i] >> 16) & 0xFF;
         output[j+3] = (input[i] >> 24) & 0xFF;
         i++;
         j+=4;
    }
}
void MD5Decode(unsigned int *output,unsigned char *input,unsigned int len)
{
     unsigned int i = 0,j = 0;
     while(j < len)
     {
           output[i] = (input[j]) |
                       (input[j+1] << 8) |
                       (input[j+2] << 16) |
                       (input[j+3] << 24);
           i++;
           j+=4; 
     }
}
void MD5Transform(unsigned int state[4],unsigned char block[64])
{
     unsigned int a = state[0];
     unsigned int b = state[1];
     unsigned int c = state[2];
     unsigned int d = state[3];
     unsigned int x[64];
     MD5Decode(x,block,64);
     FF(a, b, c, d, x[ 0], 7, 0xd76aa478); /* 1 */
 FF(d, a, b, c, x[ 1], 12, 0xe8c7b756); /* 2 */
 FF(c, d, a, b, x[ 2], 17, 0x242070db); /* 3 */
 FF(b, c, d, a, x[ 3], 22, 0xc1bdceee); /* 4 */
 FF(a, b, c, d, x[ 4], 7, 0xf57c0faf); /* 5 */
 FF(d, a, b, c, x[ 5], 12, 0x4787c62a); /* 6 */
 FF(c, d, a, b, x[ 6], 17, 0xa8304613); /* 7 */
 FF(b, c, d, a, x[ 7], 22, 0xfd469501); /* 8 */
 FF(a, b, c, d, x[ 8], 7, 0x698098d8); /* 9 */
 FF(d, a, b, c, x[ 9], 12, 0x8b44f7af); /* 10 */
 FF(c, d, a, b, x[10], 17, 0xffff5bb1); /* 11 */
 FF(b, c, d, a, x[11], 22, 0x895cd7be); /* 12 */
 FF(a, b, c, d, x[12], 7, 0x6b901122); /* 13 */
 FF(d, a, b, c, x[13], 12, 0xfd987193); /* 14 */
 FF(c, d, a, b, x[14], 17, 0xa679438e); /* 15 */
 FF(b, c, d, a, x[15], 22, 0x49b40821); /* 16 */
 
 /* Round 2 */
 GG(a, b, c, d, x[ 1], 5, 0xf61e2562); /* 17 */
 GG(d, a, b, c, x[ 6], 9, 0xc040b340); /* 18 */
 GG(c, d, a, b, x[11], 14, 0x265e5a51); /* 19 */
 GG(b, c, d, a, x[ 0], 20, 0xe9b6c7aa); /* 20 */
 GG(a, b, c, d, x[ 5], 5, 0xd62f105d); /* 21 */
 GG(d, a, b, c, x[10], 9,  0x2441453); /* 22 */
 GG(c, d, a, b, x[15], 14, 0xd8a1e681); /* 23 */
 GG(b, c, d, a, x[ 4], 20, 0xe7d3fbc8); /* 24 */
 GG(a, b, c, d, x[ 9], 5, 0x21e1cde6); /* 25 */
 GG(d, a, b, c, x[14], 9, 0xc33707d6); /* 26 */
 GG(c, d, a, b, x[ 3], 14, 0xf4d50d87); /* 27 */
 GG(b, c, d, a, x[ 8], 20, 0x455a14ed); /* 28 */
 GG(a, b, c, d, x[13], 5, 0xa9e3e905); /* 29 */
 GG(d, a, b, c, x[ 2], 9, 0xfcefa3f8); /* 30 */
 GG(c, d, a, b, x[ 7], 14, 0x676f02d9); /* 31 */
 GG(b, c, d, a, x[12], 20, 0x8d2a4c8a); /* 32 */
 
 /* Round 3 */
 HH(a, b, c, d, x[ 5], 4, 0xfffa3942); /* 33 */
 HH(d, a, b, c, x[ 8], 11, 0x8771f681); /* 34 */
 HH(c, d, a, b, x[11], 16, 0x6d9d6122); /* 35 */
 HH(b, c, d, a, x[14], 23, 0xfde5380c); /* 36 */
 HH(a, b, c, d, x[ 1], 4, 0xa4beea44); /* 37 */
 HH(d, a, b, c, x[ 4], 11, 0x4bdecfa9); /* 38 */
 HH(c, d, a, b, x[ 7], 16, 0xf6bb4b60); /* 39 */
 HH(b, c, d, a, x[10], 23, 0xbebfbc70); /* 40 */
 HH(a, b, c, d, x[13], 4, 0x289b7ec6); /* 41 */
 HH(d, a, b, c, x[ 0], 11, 0xeaa127fa); /* 42 */
 HH(c, d, a, b, x[ 3], 16, 0xd4ef3085); /* 43 */
 HH(b, c, d, a, x[ 6], 23,  0x4881d05); /* 44 */
 HH(a, b, c, d, x[ 9], 4, 0xd9d4d039); /* 45 */
 HH(d, a, b, c, x[12], 11, 0xe6db99e5); /* 46 */
 HH(c, d, a, b, x[15], 16, 0x1fa27cf8); /* 47 */
 HH(b, c, d, a, x[ 2], 23, 0xc4ac5665); /* 48 */
 
 /* Round 4 */
 II(a, b, c, d, x[ 0], 6, 0xf4292244); /* 49 */
 II(d, a, b, c, x[ 7], 10, 0x432aff97); /* 50 */
 II(c, d, a, b, x[14], 15, 0xab9423a7); /* 51 */
 II(b, c, d, a, x[ 5], 21, 0xfc93a039); /* 52 */
 II(a, b, c, d, x[12], 6, 0x655b59c3); /* 53 */
 II(d, a, b, c, x[ 3], 10, 0x8f0ccc92); /* 54 */
 II(c, d, a, b, x[10], 15, 0xffeff47d); /* 55 */
 II(b, c, d, a, x[ 1], 21, 0x85845dd1); /* 56 */
 II(a, b, c, d, x[ 8], 6, 0x6fa87e4f); /* 57 */
 II(d, a, b, c, x[15], 10, 0xfe2ce6e0); /* 58 */
 II(c, d, a, b, x[ 6], 15, 0xa3014314); /* 59 */
 II(b, c, d, a, x[13], 21, 0x4e0811a1); /* 60 */
 II(a, b, c, d, x[ 4], 6, 0xf7537e82); /* 61 */
 II(d, a, b, c, x[11], 10, 0xbd3af235); /* 62 */
 II(c, d, a, b, x[ 2], 15, 0x2ad7d2bb); /* 63 */
 II(b, c, d, a, x[ 9], 21, 0xeb86d391); /* 64 */
     state[0] += a;
     state[1] += b;
     state[2] += c;
     state[3] += d;
}

md5.h

#ifndef MD5_H
#define MD5_H
 
typedef struct
{
    unsigned int count[2];
    unsigned int state[4];
    unsigned char buffer[64];   
}MD5_CTX;
 
                         
#define F(x,y,z) ((x & y) | (~x & z))
#define G(x,y,z) ((x & z) | (y & ~z))
#define H(x,y,z) (x^y^z)
#define I(x,y,z) (y ^ (x | ~z))
#define ROTATE_LEFT(x,n) ((x << n) | (x >> (32-n)))
#define FF(a,b,c,d,x,s,ac) \
          { \
          a += F(b,c,d) + x + ac; \
          a = ROTATE_LEFT(a,s); \
          a += b; \
          }
#define GG(a,b,c,d,x,s,ac) \
          { \
          a += G(b,c,d) + x + ac; \
          a = ROTATE_LEFT(a,s); \
          a += b; \
          }
#define HH(a,b,c,d,x,s,ac) \
          { \
          a += H(b,c,d) + x + ac; \
          a = ROTATE_LEFT(a,s); \
          a += b; \
          }
#define II(a,b,c,d,x,s,ac) \
          { \
          a += I(b,c,d) + x + ac; \
          a = ROTATE_LEFT(a,s); \
          a += b; \
          }                                            
void MD5Init(MD5_CTX *context);
void MD5Update(MD5_CTX *context,unsigned char *input,unsigned int inputlen);
void MD5Final(MD5_CTX *context,unsigned char digest[16]);
void MD5Transform(unsigned int state[4],unsigned char block[64]);
void MD5Encode(unsigned char *output,unsigned int *input,unsigned int len);
void MD5Decode(unsigned int *output,unsigned char *input,unsigned int len);
 
#endif

md5原文链接

list.h

/*
* Copyright(C), 2007-2008, XUPT Univ.	 
* File name: list.h			 
* Description : 链表操作宏定义、分页操作 
* Author:   XUPT  		 
* Version:  v.1 	 
* Date: 	2015年4月22日		 
*/

#ifndef LIST_H_
#define LIST_H_

#include 
#include 

/*初始化链表list。链表为带头结点的双向循环链表*/
#define List_Init(list, list_node_t) {					\
		list=(list_node_t*)malloc(sizeof(list_node_t)); \
		(list)->next=(list)->prev=list;					\
	}

//释放链表list中所有数据结点。list 为链表头指针，list_node_t为链表结点类型
#define List_Free(list, list_node_t) {			\
		assert(NULL!=list);						\
		list_node_t *tmpPtr;					\
		(list)->prev->next=NULL; 				\
		while(NULL!=(tmpPtr=(list)->next)){ 	\
			(list)->next=tmpPtr->next;			\
			free(tmpPtr);						\
		}										\
		(list)->next=(list)->prev=list;			\
	}

//销毁链表list，释放所有数据结点及头结点。 list为链表头指针，tmpPtr为链表结点临时指针变量
#define List_Destroy(list, list_node_t) {		\
		assert(NULL!=list);						\
		List_Free(list, list_node_t)			\
		free(list);								\
		(list)=NULL;							\
	}

//链表头插法，list为头指针，new为新节点
#define List_AddHead(list, newNode) {			\
		(newNode)->next=(list)->next;		 	\
		(list)->next->prev=newNode;			 	\
		(newNode)->prev=(list);				 	\
		(list)->next=newNode;				 	\
	}

//链表尾插法，list为头指针，new为新节点
#define List_AddTail(list, newNode) {			\
		(newNode)->prev=(list)->prev; 		 	\
		(list)->prev->next=newNode;			 	\
		(newNode)->next=list;				 	\
		(list)->prev=newNode;				 	\
	}

//将新节点newNode加入到node之前
#define List_InsertBefore(node, newNode) {		\
		(newNode)->prev=(node)->prev; 		 	\
		(newNode)->next=node;			 		\
		(newNode)->prev->next=newNode;			\
		(newNode)->next->prev=newNode;			\
	}

//将新节点newNode加入到node之后
#define List_InsertAfter(node, newNode) {		\
		(newNode)->next=node->next;			 	\
		(newNode)->prev=node; 				 	\
		(newNode)->next->prev=newNode;			\
		(newNode)->prev->next=newNode;			\
	}

//判断链表是否为空，list为头指针
#define List_IsEmpty(list)  ((list != NULL)	\
	&& ((list)->next == list)				\
	&& (list == (list)->prev))

//从删除链表结点node，
#define List_DelNode(node) {\
			assert(NULL!=node && node!=(node)->next && node!=(node)->prev);				\
			(node)->prev->next=(node)->next; 	\
			(node)->next->prev=(node)->prev;	\
	}

//从链表中删除并释放结点node
#define List_FreeNode(node) {	\
		List_DelNode(node);		\
		free(node);				\
	}


//使用指针curPos依次遍历链表list
#define List_ForEach(list, curPos) 		\
	 for (   curPos = (list)->next;  	\
		  	  	  curPos != list;       \
		  	  	  curPos=curPos->next	\
	    )


//分页数据结构体，简称分页器类型
typedef struct
{
	int totalRecords;	//总记录数
	int offset;			//当前页起始记录相对于第一条记录的偏移记录数
	int pageSize;		//页面大小
	void *curPos;		//当前页起始记录在链表中的结点地址
}Pagination_t;

//根据分页器paging的偏移量offset将分页器定位到链表list的对应位置
#define List_Paging(list, paging, list_node_t) {			\
		if(paging.offset+paging.pageSize>=paging.totalRecords){	\
			Paging_Locate_LastPage(list, paging, list_node_t);	}\
		else {													\
			int i;												\
			list_node_t * pos=(list)->next;						\
			for( i=0; inext;		 							\
			paging.curPos=(void*)pos;							\
		}														\
	}

//将分页器paging定位到链表list的第一页
#define Paging_Locate_FirstPage(list, paging) { \
		paging.offset=0;						\
		paging.curPos=(void *)((list)->next);	\
	}

//将分页器paging定位到链表list的最后一页
#define Paging_Locate_LastPage(list, paging, list_node_t) {	\
	int i=paging.totalRecords % paging.pageSize;	\
	if (0==i && paging.totalRecords>0)				\
		i=paging.pageSize;							\
	paging.offset=paging.totalRecords-i;			\
	list_node_t * pos=(list)->prev;					\
	for(;i>1;i--)									\
		pos=pos->prev;								\
	paging.curPos=(void*)pos;						\
													\
}

//对于链表list及分页器paging,使用指针curPos依次遍历paging指向页面中每个结点
//这里i为整型计数器变量
#define Paging_ViewPage_ForEach(list, paging, list_node_t, pos, i) 	\
	for (i=0, pos = (list_node_t *) (paging.curPos);	\
			pos != list && i < paging.pageSize; 		\
			i++, pos=pos->next)							\

//对于链表list,将分页器paging向前（后）移动offsetPage个页面.
//当offsetPage<0时，向前（链表头方向）移动|offsetPage|个页面
//当offsetPage>0时，向后（链末尾方向）移动offsetPage个页面
#define Paging_Locate_OffsetPage(list, paging, offsetPage, list_node_t) {\
	int offset=offsetPage*paging.pageSize;			\
	list_node_t *pos=(list_node_t *)paging.curPos;	\
	int i;											\
	if(offset>0){									\
		if( paging.offset + offset >= paging.totalRecords )	{\
			Paging_Locate_LastPage(list, paging, list_node_t);	\
		}else {												\
			for(i=0; inext;								\
			paging.offset += offset;						\
			paging.curPos= (void *)pos;						\
		}													\
	}else{													\
		if( paging.offset + offset <= 0 ){					\
			Paging_Locate_FirstPage(list, paging);			\
		}else {												\
			for(i=offset; i<0; i++ )						\
				pos	= pos->prev;							\
			paging.offset += offset;						\
			paging.curPos= pos;								\
		}													\
	}														\
}

//根据分页器paging计算当前的页号
#define Pageing_CurPage(paging) 	(0==(paging).totalRecords?0:1+(paging).offset/(paging).pageSize)

//根据分页器paging计算的总的页数
#define Pageing_TotalPages(paging)	(((paging).totalRecords%(paging).pageSize==0)?\
	(paging).totalRecords/(paging).pageSize:\
	(paging).totalRecords/(paging).pageSize+1)

//根据paging判断当前页面是否为第一页。结果为true表示是，否则false
#define Pageing_IsFirstPage(paging) (Pageing_CurPage(paging)<=1)

//根据paging判断当前页面是否为最后一页。结果为true表示是，否则false
#define Pageing_IsLastPage(paging) 	(Pageing_CurPage(paging)>=Pageing_TotalPages(paging))


#endif /* LIST_H_ */

项目github源码地址

总结：
1.这个项目写了有4000行不到，如果把所有能发现的问题解决了，可能差不多4000多行，实际很多问题我有能力解决，但是我并不想去解决，具体原因请参看暑期总结。

2.该项目里提到的我大一写的另一个项目ttms的总结，粗略统计那个项目大概8000行左右，但是由于框架给了，而且不需要进行网络编程，而且没有用到数据库，客户端和客户端之间进行交互，所以现在看看那个项目真的很水，
另外，很多我提到的我在该项目遗留的问题解决，很多都曾在这个项目中解决过，如果有人需要看的话可以看那个项目源码。

3.这是一篇写的不像项目文档的项目文档，但是大致意思就是这个意思，以后学弟做项目时别看我的这个项目总结去做参考，看看别的大佬学长的。