电子词典项目

Lucifer_9q

于 2023-07-30 23:16:42 发布

阅读量61

点赞数

文章标签：算法 linux 网络

本文链接：https://blog.csdn.net/Lucifer_9q/article/details/132013329

版权

客户端

//客户端
//socket
//connect
//send
//recv
//close 

#include <stdio.h>
#include <sys/types.h>  
#include <sys/socket.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <string.h>
#include <ctype.h>
#include <errno.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <signal.h>
#include <strings.h>



int cli_init(char *,int );//初始化客户端
int do_register(int connfd); //注册
int do_login(int connfd); //登陆
int search_word(int connfd); //查单词
int do_history(int connfd); //历史记录
int do_quit(); // 退出
void do_upLevel(); //返回上一界面（登陆界面）
void desk_one(); //界面1
void desk_two(); //界面2

#define IP "0"
#define PORT 6666

//定义发送的信息结构体 
typedef struct{
	int type;
	char name[50];
	char data[256];
}MSG;



int main(){
	int connfd = cli_init(IP,PORT);
	desk_one();
	
	char choice;
	char c;
	
	while(1){
		printf("请选择：\n");
		setbuf(stdin,NULL);
		
		choice = getchar();
		c=getchar();
		
		switch(choice){
			case 'R' : do_register(connfd);break;  //注册 
			case 'L' : do_login(connfd);break;   //登录 
			case 'S' : search_word(connfd);break;  //查单词 
			case 'H' : do_history(connfd);break;  //查历史记录 
			case 'Q' : ref = do_quit();    //退出 
						if(ref==0){
							return 0;
						}
						break;
			case 'q' : do_uplevel();break;	  //返回上级	
		}
	}
	close(connfd);
	
	return 0;
}


/************界面**************/
void desk_one(){
	
	printf("\t\t________________________________________\n");
    printf("\t\t|               电子词典               |\n");
    printf("\t\t|                                      |\n");
	printf("\t\t|                                      |\n");
    printf("\t\t|欢迎来到电子词典！                    |\n");
    printf("\t\t|                                      |\n");
    printf("\t\t|                                      |\n");
    printf("\t\t|                注册 R                |\n");
    printf("\t\t|                登录 L                |\n");
    printf("\t\t|                退出 Q                |\n");
    printf("\t\t|                                      |\n");
    printf("\t\t|______________________________________|\n");
    
}

void desk_two(){
	
	printf("\t\t________________________________________\n");
    printf("\t\t|               电子词典               |\n");
    printf("\t\t|                                      |\n");
	printf("\t\t|                                      |\n");
    printf("\t\t|欢迎来到电子词典！                    |\n");
    printf("\t\t|                                      |\n");
    printf("\t\t|                                      |\n");
    printf("\t\t|               查询单词 S             |\n");
    printf("\t\t|               历史记录 H             |\n");
    printf("\t\t|               返回上级 q             |\n");
    printf("\t\t|                                      |\n");
    printf("\t\t|______________________________________|\n");
	
} 

/*********** 退出 **************/
/*
判断输入的字符，执行或不执行退出 
*/
int do_quit()
{
    while(1)
    {
        printf("\t\t|             是否退出【Y\N】                |\n");
        setbuf(stdin,NULL); //关闭缓存区
        char v;
        char c;
        v = getchar();
        c = getchar(); //接受回车
        if(v == 'Y' || v == 'y')
        {
            return 0;
        }
        else if(v == 'N' || v == 'n')
        {
            return 1;
        }
    }
}

/*********** 返回上一级 **************/
/*
判断输入的字符，执行或不执行退出 
*/
void do_upLevel()
{
    char var;
    char c;
    while(1)
    {
        printf("\t\t|             是否回到登录界面【Y\N】            |\n");
        setbuf(stdin,NULL); //关闭缓存区
        var = getchar();
        c = getchar(); //接受回车
        if(var == 'Y' || var == 'y')
        {
            system("clear");
            desk_one();
            return;
        }
        else if(var == 'N' || 'n')
        {
            return;
        }
    }
}

/*********** 初始化客户端 ************/
int cli_init(char *ip,int port){
	int connfd = socket(AF_INET,SOCK_STREAM,0);
	if(connfd<0){
		return -1;
	}
	
	//服务器地址信息
	struct sockaddr_in sin;
	sin.sin_family=AF_INET;
	sin.sin_port=htons(PORT);
	sin.sin_addr.s_addr=inet_addr(IP);
	
	if(connect(connfd,(struct sockaddr *)&sin,sizeof(sin))<0){
		perror("connect");
		return -1;
	}
	printf("connect success");

} 


/*********** 注册 **************/
/*
接收终端输入的数据 
发送到服务端
接收服务端的回应
判断回应是什么，返回注册结果 
*/


int do_register(int connfd){
	
	MSG buf;  //正文信息 
	MSG buf1; 
	
	char id_buf[50]="";  //账号密码
	char password_buf[50]="";
	 
	printf("请输入账号"); 
	scanf("%s",id_buf);
	//fgets(id_buf,sizeof(buf),stdin);
	id_buf[strlen(id_buf)-1]=0;
		 
	printf("请输入密码"); 
	scanf("%s",password_buf);
	//fgets(id_buf,sizeof(buf),stdin);
	id_buf[strlen(id_buf)-1]=0;
	
/* 把后面的格式串放到前面的字符串里，再把这个字符串发到服务端
格式串可能是%d,%lf */
	sprintf(buf1.name,"%s",id_buf);
	sprintf(buf1.data,"%s",password_buf);	
	
	if(send(connfd,&buf1,sizeof(buf1),0)){   //用buf1发送 
		perror("send");
		return -1;
	}
	if(recv(connfd,&buf,sizeof(buf),0)){	//用buf接收 
		perror("recv");
		return -1;
	}
	
/* 接收服务端发过来的回应 
*/
	if(buf.type=='T'){
		printf("%s\n",buf.data);
	}
	if(buf.type=='F'){
		printf("%s\n",buf.data);
	}
	
	return 0;
}


/*********** 登录 **************/
/*
接收终端输入的数据 
发送到服务端
接收服务端的回应
判断回应是什么，返回注册结果 
*/

int do_login(int connfd){
	
	MSG buf;   //接收的串
	MSG buf1;  //发送的串
	char id_buf[50]=" ";
	char password_buf[50]=" ";

	printf("请输入登陆的账号:");
	scanf("%s",id_buf);
	printf("\请输入登陆的密码:");
	scanf("%s",password_buf);


	buf1.type = 'L';    //发送buf1的type给服务端
	sprintf(buf1.name,"%s",id_buf);
	sprintf(buf1.data,"%s",password_buf);

	if(send(connfd,&buf1,sizeof(buf1),0)<0){
		perror("send");
		return -1;
	}
	if(recv(connfd,&buf,sizeof(buf),0)<0){
		perror("recv");
		return -1;
	}

	//判断的服务端回应
	if(buf.type=='T'){
		printf("%s",buf.data);
		system("clear");
		desk_two();
	}
	if(buf.type=='F'){
		printf("%s\n",buf.data);
	}

	return 0;
}


/**********查询单词**********/
int search_word(int connfd)
{
    MSG buf;
    MSG buf1;
    char search_buf[50] = {0};
 
    while(1)
    {
        bzero(&buf,sizeof(buf));
        bzero(&buf1,sizeof(buf1));
        bzero(search_buf,50);
 
        printf("请输入查询的单词：");
        scanf("%s",search_buf);
        system("clear"); //清屏
        buf.type = 'S';
        strcpy(buf.name,search_buf);
        //退出查询
        if(strncmp(search_buf,"Q",1) == 0)
        {
            break;
        }
        if(send(connfd,&buf,sizeof(buf),0) < 0) //发送查询单词信息到服务器
        {
            perror("send");
            return -1;
        }
 
        if(recv(connfd,&buf1,sizeof(buf1),0) < 0) //从服务器接受是否查询成功的信息
        {
            perror("recv");
            return -1;
        }
        if(buf1.type == 'F')
        {
            printf("抱歉！查询不到此单词，请重新输入想要查找的单词\n");
            continue;
        }
        else if(buf1.type == 'T')
        {
            printf("查询结果：%s\n",buf1.data);    
        }
        else
        {
            printf("服务器异常\n");
            break;
        }
 
    }
    desk_two();//界面2
 
    return 0;
}


/**********历史记录查询**********/
int do_history(int connfd)
{
 
    char history_buf[10240] = {0}; //存放历史记录信息
    MSG buf;
 
    buf.type = 'H';
    if(send(connfd,&buf,sizeof(buf),0) < 0)
    {
        perror("send");
        return -1;
    }
    memset(&buf,sizeof(buf),0);
 
    if(recv(connfd,history_buf,sizeof(history_buf),0) < 0)
    {
        perror("recv");
        return -1;
    }
    if(strncmp(history_buf,"F",1) == 0)
    {
        printf("未查询到历史记录\n");
    }
    else
    {
        printf("历史记录查询成功!\n");
        printf("%s",history_buf);
        desk_two();
    }
 
    return 0;   
}

服务端

//服务端 

#include <stdio.h>
#include <sys/types.h>      
#include <sys/socket.h>
#include <arpa/inet.h>
#include <signal.h>
#include <unistd.h>
#include <sys/wait.h>
#include <errno.h>
#include <sys/socket.h>
#include <sqlite3.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <strings.h>
#include <string.h>
#include <sqlite3.h>
#include <stdlib.h>
 
 
#define IP "0"
#define PORT 6666
#define BACKLOG 1024

typedef struct //接受发送结构体
{
    int type;
    char name[50];
    char data[256];
}MSG;
 
int init_server(char *ip,int port,int backlog); //初始化服务器
void signal_hander(int sig); //回收退出的进程
void sqlite3_exist(); //判断数据库是否存在，不存在则创建(单词数据库，用户数据库,历史记录数据库)
int word_sqlite3_create(); //创建单词数据库
int user_sqlite3_create(); //创建用户数据库
int history_sqlite3_create(); //创建历史记录库
int word_insert(sqlite3 *db,char *buf); //插入单词到单词表中
int do_client(int connfd,struct in_addr ip,uint16_t port); //处理客户端
int do_register(int connfd,char *name,char *data,sqlite3* db_user); //注册
int do_login(int connfd,char *name,char *data,sqlite3 *db_user,char *nameBuf); //登陆
int search_word(int connfd,char *nameBuf,char *name,sqlite3 *db_word,sqlite3 *db_history); //查单词
int do_history(int connfd,char *nameBuf,sqlite3 *db_history); //查历史记录


int main(int argc, char *argv[])
{ 
    signal(SIGCHLD,signal_hander); //注册SIGCHLD信号
 
    //创建数据库
    sqlite3_exist();
 
    //自定义初始化函数，初始化 ip port
    int listenfd = init_server(IP,PORT,BACKLOG);
    if(-1 == listenfd)
    {
        printf("init_server failed!\n");
        exit(-1);
    }
 
    while(1)
    {
        printf("请等待连接！\n");
        //accept
        struct sockaddr_in client_addr = {0};   //客户端的地址信息 
        socklen_t len = sizeof(client_addr);
        int connfd = accept(listenfd,(struct sockaddr *)&client_addr,&len);
        if(-1 == connfd)
        {
            if(errno == EINTR) //如果阻塞 跳过本次循环 执行下一次监听
            {
                continue;
            }
            else
            {
                perror("accept");
                exit(-1);
            }
        }
        printf("客户端:(ip:%s port:%d)已连接\n",
                    inet_ntoa(client_addr.sin_addr),ntohs(client_addr.sin_port));//打印连接客户端信息
 
        pid_t pid;  //进程号
        pid = fork();
        if(-1 == pid)
        {
            perror("fork");
            exit(-1);
        }
        else if(pid == 0)   /*子进程处理与客户端发送接受信息  关闭监听套接字*/
        {
            close(listenfd);
            //与客户端通信处理
            do_client(connfd,client_addr.sin_addr,client_addr.sin_port);
        }
        else    /*父进程处理客户端连接  关闭通信套接字*/
        {
            close(connfd);
            continue;
        }
    }
    close(listenfd); //所有子进程结束 关闭监听套接字 结束服务器
 
    return 0;
}


/**********初始化服务器***********/
int init_server(char *ip,int port,int backlog)
{
    //socket
    int listenfd = socket(PF_INET,SOCK_STREAM,0);
    if(-1 == listenfd)
    {
        perror("socket");
        exit(-1);
    }
    
     //允许重用本地地址和端口
    int opt = 1;
    setsockopt(listenfd,SOL_SOCKET,SO_REUSEADDR,&opt,sizeof(opt));
 
    //服务端地址信息  port ip
    struct sockaddr_in serveraddr ;
    serveraddr.sin_family = AF_INET,
    serveraddr.sin_port = htons(port),
    serveraddr.sin_addr.s_addr = inet_addr(ip)
    
 
    //bind
    int ret = bind(listenfd,(struct sockaddr *)&serveraddr,sizeof(serveraddr));
    if(-1 == ret)
    {
        perror("bind");
        exit(-1);
    }
    printf("bind success");
 
    //listen
    ret = listen(listenfd,backlog);
    if(-1 == ret)
    {
        perror("listen");
        exit(-1);
    }
	printf("listen success");
 
    return listenfd;
}

//信号处理函数 
void signal_hander(int sig)
{
	while(waitpid(-1,NULL,WNOHANG) > 0);
}


/***********判断3个数据库是否存在***********/
void sqlite3_exist()
{
	//判断单词数据库是否存在 不存在则创建
    if(access("./word.db",F_OK) == 0)
    {
        printf("单词数据库已存在!\n");
    }
    else //单词数据库不存在先判断单词表文本是否存在
    {
        printf("单词数据库不存在!\\n");
        sleep(1);
        if(access("./dict.txt",F_OK) == -1)
        {
            printf("单词表不存在!\n");//单词表不存在则退出
            return;
        }
        else //单词表存在则插入单词数据库
        {
            printf("单词数据库创建中......!\n");
            //创建单词表
            int ret = word_sqlite3_create();   //调用后面的创建函数 
            if(-1 == ret)
            {
                printf("world_sqlite3_create failed\n");
                return;
            }
            printf("单词数据库创建成功!\n");
        }
        
    }
    sleep(1);
	
	//判断用户数据库是否存在 不存在调用创建函数 
    if(access("./user.db",F_OK) == 0)
    {
        printf("用户数据库已存在!\n");
    }
    else
    {
        printf("\用户数据库不存在\n");
        sleep(1);
        printf("用户数据库创建中......!\n");
        //创建用户表
        int ret = user_sqlite3_create();  //自定义创建函数 
        if(-1 == ret)
        {
            printf("user_sqlite3__create failed\n");
            return;
        }
        sleep(1);
        printf("用户数据库创建成功!\n");
    }
    
    //判断历史记录数据库是否存在 不存在则创建
    if(access("./history.db",F_OK) == 0)
    {
        printf("历史记录库已存在!\n");
        return;
    }
    else
    {
        printf("历史记录库不存在!\n");
        sleep(1);
        printf("历史记录库创建中......!\n");
        //创建历史记录表
        int ret = history_sqlite3_create();
        if(-1 == ret)
        {
            printf("history_sqlite3_create failed\n");
            return;
        }
        sleep(1);
        printf("历史记录库创建成功!\n");
    }
    sleep(1);
    
    return ; 
}


/**********创建单词数据库**********/
int word_sqlite3_create()
{
    FILE *fp = fopen("./dict.txt","r"); //以只读方式打开单词表
    if(NULL == fp)
    {
        perror("open");
        exit(-1);
    }
    sqlite3 *db_word;  //操作单词数据库的句柄
    int ret = sqlite3_open("./word.db",&db_word);
    if(ret != SQLITE_OK)
    {
        perror("sqlite3_open");
        exit(-1);
    }
    //创建单词表
    char *errmsg;   //接收返回的错误信息
    char sql[256] = "create table if not exists word(word char, mean char);";
    ret = sqlite3_exec(db_word,sql,NULL,NULL,&errmsg);
    if(ret != SQLITE_OK)
    {
        perror("sqlite3_exec");
        exit(-1);
    }
    char buf[BUFSIZ] = {0};
    //读取单词数据到表中
    while(1)
    {
        bzero(buf,0); //清空数组
        if(NULL == fgets(buf,BUFSIZ,fp)) //读取一行数据
        {
            break;
        }
        buf[strlen(buf)-1] = 0; //去除 \n
        int ret = word_insert(db_word,buf);
        if(-1 ==ret)
        {
            //printf("%s\n",buf);
            printf("word_insert failed\n");
        }
    }
    sqlite3_close(db_word);
    fclose(fp);
    return 0;
}

/**********创建用户数据库**********/
int user_sqlite3_create()
{
    sqlite3 *db_user;  //操作单词数据库的句柄
    int ret = sqlite3_open("./user.db",&db_user);
    if(ret != SQLITE_OK)
    {
        perror("sqlite3_open");
        exit(-1);
    }
 
    //创建用户表
    char *errmsg;   //接收返回的错误信息
    char sql[256] = "create table if not exists user(id char, password char);";
    ret = sqlite3_exec(db_user,sql,NULL,NULL,&errmsg);
    if(ret != SQLITE_OK)
    {
        perror("sqlite3_exec");
        exit(-1);
    }
 
    sqlite3_close(db_user);
    return 0;
}


/**********创建历史记录库**********/
int history_sqlite3_create()
{
    sqlite3 *db_user;  //操作单词数据库的句柄
    int ret = sqlite3_open("./history.db",&db_user);
    if(ret != SQLITE_OK)
    {
        perror("sqlite3_open");
        exit(-1);
    }
 
    //创建历史记录表
    char *errmsg;   //接收返回的错误信息
    char sql[256] = "create table if not exists history(data char);";
    ret = sqlite3_exec(db_user,sql,NULL,NULL,&errmsg);
    if(ret != SQLITE_OK)
    {
        perror("sqlite3_exec");
        exit(-1);
    }
 
    sqlite3_close(db_user);
    return 0;
}


/*单词表插入数据库*/
int word_insert(sqlite3 *db,char *buf)
{
    char word_buf[50] = {0};
    char mean_buf[256] = {0};
    char sql[512] = {0};
    char *errmsg;
 
    for(int i=0;buf[i+1]!=0;i++)
    {
        if(buf[i]!=' ' && buf[i+1]==' ' && buf[i+2]==' ')
        {
            strncpy(word_buf,buf,i+1); //获取单词
        }
        else if(buf[i]==' ' && buf[i+1]==' ' && buf[i+2]!=' ')
        {
            strcpy(mean_buf,buf); //获取意思
            break;
        }
    }
    //插入到表中
    sprintf(sql,"insert into word values('%s','%s');",word_buf,mean_buf);
    int ret = sqlite3_exec(db,sql,NULL,NULL,&errmsg);
    if(ret != SQLITE_OK)
    {
        perror("sqlite3_exec");
        exit(-1);
    }
    
    bzero(word_buf,0);
    bzero(mean_buf,0);
    bzero(sql,0);
 
    return 0;
    
}


/**********回应客户端的请求**********/
int do_client(int connfd,struct in_addr ip,uint16_t port)
{
	//打开单词数据库
    sqlite3 *db_word;
    int ret = sqlite3_open("./word.db",&db_word);
    if(ret != SQLITE_OK )
    {
        perror("sqlite3_open");
        exit(-1);
    }
 
    //打开用户数据库 
    sqlite3 *db_user;
    ret = sqlite3_open("./user.db",&db_user);
    if(ret != SQLITE_OK )
    {
        perror("sqlite3_open");
        exit(-1);
    }
 
    //打开历史记录库
    sqlite3 *db_history;
    ret = sqlite3_open("./history.db",&db_history);
    if(ret != SQLITE_OK )
    {
        perror("sqlite3_open");
        exit(-1);
    }
    
    
    MSG buf;
    char nameBuf[50] = {0}; //存放登陆成功后的用户名
    while(1)
    {
        memset(&buf,0,sizeof(buf));
        ret = recv(connfd,&buf,sizeof(buf),0);   //接收发来的信息 
        if(ret < 0)
        {
            perror("recv");
            close(connfd);
            exit(-1);
        }
        else if(ret == 0)//用户退出
        {
            //关闭通信套接字
            printf("客户端[ip:%s port:%d]已退出 ",inet_ntoa(ip),ntohs(port));
 
            close(connfd);
            //关闭数据库
            sqlite3_close(db_word);
            sqlite3_close(db_user);
            sqlite3_close(db_history);
            
            exit(-1);
        }

	switch(buf.type)   //判断客户端发来的请求是哪种 
        {
            case 'R':
                do_register(connfd,buf.name,buf.data,db_user); //执行注册请求处理函数 
                break;
            case 'L':
                do_login(connfd,buf.name,buf.data,db_user,nameBuf); //登陆
                break;
            case 'S':
                search_word(connfd,nameBuf,buf.name,db_word,db_history); //查单词
                break;
            case 'H':
                do_history(connfd,nameBuf,db_history); //历史记录
                break;
            default:
                printf("客户端[%s]错误信息！\n",nameBuf);
        }
    }
    exit(0);
}


/**********注册请求处理函数**********/
int do_register(int connfd,char *name,char *data,sqlite3* db_user)
{
    printf("用户发起注册请求\n");
    MSG buf1;
    memset(&buf1,0,sizeof(buf1));
 
    char sql[256] =  " ";
    char *errmsg;
    char **dbresult;
    int nrow = 0;
    int ncol = 0;
    //查询用户表中是否有注册用户名
    sprintf(sql,"select * from user where id='%s';",name);
    int ret = sqlite3_get_table(db_user,sql,&dbresult,&nrow,&ncol,&errmsg);
    if(ret != SQLITE_OK)
    {
        perror("sqlite3_get_table");
        exit(-1);
    }
    //用户已存在
    if(nrow != 0) //没有查询到接受用户的用户名
    {
        printf("用户名[%s]存在\n",name);
 
        buf1.type = 'F'; //注册失败返回 F
        strcpy(buf1.data,"用户名已存在!请重新注册[输入R后回车]");
        if(send(connfd,&buf1,sizeof(buf1),0) < 0) //返回注册失败信息给客户端
        {
            perror("send");
            exit(-1);
        }
    }
 
    //用户不存在，插入到用户数据表中
    if(nrow == 0)
    {
        memset(&sql,0,sizeof(sql));
        memset(&buf1,0,sizeof(buf1));
 
        sprintf(sql,"insert into user values('%s','%s');",name,data);
        ret = sqlite3_exec(db_user,sql,NULL,NULL,&errmsg);
        if(ret !=SQLITE_OK)
        {
            perror("sqlite3_exec");
            exit(-1);
        }
        strcpy(buf1.data,"注册成功!请登陆[输入L]");
        buf1.type = 'T'; //注册成功返回 T
        if(send(connfd,&buf1,sizeof(buf1),0) < 0) //返回注册成功信息给客户端
        {
            perror("send");
            exit(-1);
        }
        printf("用户[%s]注册成功\n",name);
    }
    //释放获取的空间
    sqlite3_free_table(dbresult);
    dbresult = NULL;
    return 0;
}
 
/**********登陆请求处理函数***********/
int do_login(int connfd,char *name,char *data,sqlite3 *db_user,char *nameBuf)
{
    printf("用户[%s]发起登陆请求\n",name);
    MSG buf1;
    memset(&buf1,0,sizeof(buf1));
 
    char sql[256] = " ";
    char *errmsg;
    char **dbresult;
    int nrow = 0;
    int ncol = 0;
    //查询用户表中是否有注册用户名
    sprintf(sql,"select * from user where id='%s' and password='%s';",name,data);
    int ret = sqlite3_get_table(db_user,sql,&dbresult,&nrow,&ncol,&errmsg);
    if(ret != SQLITE_OK)
    {
        perror("sqlite3_get_table");
        exit(-1);
    }
    //帐号密码与用户数据库匹配 登陆成功
    if(nrow != 0)
    {
        buf1.type = 'T'; //登陆成功返回T
        strcpy(buf1.data,"登陆成功");
        strcpy(nameBuf,name);// 接受登陆成功的用户名
        printf("用户[%s]登陆成功\n",name);
        if(send(connfd,&buf1,sizeof(buf1),0) < 0) // 返回登陆信息
        {
            perror("send");
            exit(-1);
        }
    }
 
    //帐号密码与用户数据库不匹配 登陆失败
    if(nrow == 0)
    {
        buf1.type = 'F'; //登陆失败返回F
        strcpy(buf1.data,"用户或密码错误!请重新登陆[输入L后回车]");
        if(send(connfd,&buf1,sizeof(buf1),0) < 0) //返回登陆信息
        {
            perror("send");
            exit(-1);
        }
        printf("用户[%s]登陆失败\n",name);
    }
    //获取释放的空间
    sqlite3_free_table(dbresult);
    dbresult = NULL;
 
    return 0;
}


/******查单词请求处理函数******/
int search_word(int connfd,char *nameBuf,char *name,sqlite3 *db_word,sqlite3 *db_history)
{   // 传参中 char *name 是存放客户端输入查询的的单词
    printf("客户端[%s]发起单词查询请求\n",nameBuf);
    MSG buf;
    memset(&buf,0,sizeof(buf));
 
    char sql[256] = {0};
    char **result;
    int ncol = 0;
    int nrow = 0;
    char *errmsg;
    sprintf(sql,"select * from word where word='%s';",name);
    int ret = sqlite3_get_table(db_word,sql,&result,&nrow,&ncol,&errmsg);//按条件查找单词
    if(ret != SQLITE_OK)
    {
        perror("sqlite3_get_table");
        exit(-1);
    }
 
    //查询失败
    if(nrow == 0)
    {
        buf.type = 'F'; //查询失败返回F
        strcpy(buf.data,"没有查询到此单词！请重新输入");
        if(send(connfd,&buf,sizeof(buf),0) < 0) //返回查寻单词失败的信息
        {
            perror("send");
            exit(-1);
        }
        printf("用户[%s]查找单词[%s]失败\n",nameBuf,name);
        printf("温馨提示：单词库没有此单词！建议新增此单词到数据库\n");
    }
 
    //查找成功
    if(nrow != 0)
    {
        for(int i=ncol;i<(nrow+1)*ncol;i+=2)
        {
            if(strcmp(name,result[i]) == 0)
            {
                strcpy(buf.data,result[i+1]); //将查找的单词意思放入buf.data中
                strcpy(buf.name,result[i]); //将查找的单词存方在buf.name中
 
                //将查询结果存入历史数据库中
                char sql1[256] = {0};
                sprintf(sql1,"insert into history values('%s');",result[i+1]);
                ret = sqlite3_exec(db_history,sql1,NULL,NULL,&errmsg);
                if(ret != SQLITE_OK)
                {
                    perror("sqlite3_exec");
                    exit(-1);
                }
 
                break;
            }
        }
        buf.type = 'T'; //查找成功返回T
        if(send(connfd,&buf,sizeof(buf),0) < 0) //返回查寻单词失败的信息
        {
            perror("send");
            exit(-1);
        }
        printf("用户[%s]查找单词[%s]成功\n",nameBuf,name);
    }
    //释放获取的空间
    sqlite3_free_table(result);
    result = NULL;
 
    return 0;
}


/**********查历史记录**********/
int do_history(int connfd,char *nameBuf,sqlite3 *db_history)
{
    printf("用户[%s]发起历史记录查询请求\n",nameBuf);
 
    char history_buf[10240] = {0}; //存放查询历史记录的数组（大约存放300条历史记录）
    MSG buf;
    char sql[256] = {0};
    char **result;
    char *errmsg;
    int nrow = 0;
    int ncol = 0;
    sprintf(sql,"select * from history;");
    int ret = sqlite3_get_table(db_history,sql,&result,&nrow,&ncol,&errmsg);
    if(ret != SQLITE_OK)
    {
        perror("sqlite3_get_table");
        exit(-1);
    }
 
    if(nrow != 0) //查询到有历史记录
    {
        printf("用户[%s]查询历史记录成功\n",nameBuf);
        for(int i=ncol;i<nrow+1;i++)
        {
            strcat(history_buf,result[i]);
            strcat(history_buf,"\n");
        }
        if(send(connfd,history_buf,sizeof(history_buf),0) < 0 ) //发送历史记录信息到客户端
        {
            perror("send");
            exit(-1);
        }
    }
    else if(nrow == 0) //没有查询到历史记录
    {
        printf("用户[%s]未查询到历史记录\n",nameBuf);
        strcpy(history_buf,"F");
        if(send(connfd,history_buf,sizeof(history_buf),0) < 0) //返回查寻历史记录失败的信息
        {
            perror("send");
            exit(-1);
        }
    }
    //释放获取的空间
    sqlite3_free_table(result);
    result = NULL;
 
    return 0;
}