linux网络编程小项目-在线词典

1. 项目概述

在线词典项目是在linux系统下结合c语言、网络编程和sqlite3数据库等技术来实现的一个在线的英译英单词解释，当客户端成功连接到服务器后，客户端登录账号后输入想查询的单词，服务器端会在词库(网上找的)中寻找这个单词的解释并发送给客户端，从而实现在线查询。服务端同时也会向数据库存储该用户的一个查询记录，方便管理的同时，也方便客户端查询。

2. 实现的功能

• 用户注册和登录验证，服务器端将用户信息和历史记录保存在数据库中。

• 客户端输入用户名和密码，服务器端在数据库中查找、匹配，返回查询结果

• 根据客户端输入的单词在字典文件中搜索，将查询结果返回

• 历史记录查询

3. 代码实现

3.1 服务器

主函数和一些基本信息：这部分定义了一个双方通信的信息结构体，其中type是R时，表示客户端发来了注册请求；是L时，客户端发来了登录请求；是Q时，客户端发来了查询请求；是H时，客户端发来了观看历史请求。主函数实现的就是打开后台数据库，创建进程，与客户端成功连接后，子进程完成与对端的通信任务，父进程则继续监听与客户端的连接。这样就实现了服务器的一个并发功能，即同时可以连接处理多个客户端。

#define N 32
#define R 1    //user - register
#define L 2    //user - login
#define Q 3    //user - query
#define H 4    //user - history
#define DATABASE "my.db"

//定义通信双方的信息结构体
typedef struct {
    int type;
    char name[N];
    char data[256];
}MSG;

int main(int argc, const char *argv[]){
    int sockfd;                      //监听描述符
    struct sockaddr_in serveraddr;   //存放服务器的信息结构体
    MSG msg;
    int acceptfd;         //通信描述符
    pid_t pid;
    sqlite3 *db;          //数据库的一个地址指针
    if(argc != 3){
        printf("Usage:%s serverip port.\n",argv[0]);  //执行时没有输入ip和端口会退出
        return -1;
    }
    //打开数据库
    if(sqlite3_open(DATABASE, &db) != SQLITE_OK){    //通过数据库指针打开数据库my.db
        printf("%s\n", sqlite3_errmsg(db));          //失败打印具体错误信息
        return -1;
    }else{
        printf("open DATABASE success\n");           //成功就打印该行代码
    }
    sockfd = socket(AF_INET,SOCK_STREAM,0);          //得到监听描述符
    if(sockfd < 0){
        perror("fail to socket...\n");
        return -1;
    }
    bzero(&serveraddr,sizeof(serveraddr));           //对服务器结构体置0，下面初始化信息
    serveraddr.sin_family = AF_INET;
    serveraddr.sin_port = htons(atoi(argv[2]));      //因为argv[]传进来的是字符串，所以先要将端口转换为整数，再转换为网络字节序， atoi是转换为整数用的
    serveraddr.sin_addr.s_addr = inet_addr(argv[1]); //将点分十进制(是一种表示IP地址的字符串形式)转化为网络字节序
    int opt = 1;
    setsockopt(sockfd,SOL_SOCKET,SO_REUSEADDR,&opt,sizeof(opt));   //端口复用
    if(bind(sockfd, (struct sockaddr *)&serveraddr, sizeof(serveraddr))<0){  //服务端进行绑定
        perror("fail to bind...\n");   //如果绑定失败，打印错误信息并退出
        return -1;
    }
    if(listen(sockfd, 5)<0){
        printf("fail to listen...\n");
        return -1;
    }
    //处理僵尸进程
    signal(SIGCHLD, SIG_IGN);
    //监听描述符创建成功和服务端绑定成功后，进入循环，让服务器一直监听连接
    while(1){
        if((acceptfd = accept(sockfd, NULL, NULL)) < 0){  //进行监听连接，得到通信描述符
            perror("fail to accept");
            return -1;
        }
        //与客户端成功连接后，就创建进程
        if((pid = fork())<0){
            perror("fail to fork");   //生成进程失败
            return -1;
        }
        else if(pid == 0){         //儿子进程：处理与客户端的通信
            //处理客户端具体的信息
            close(sockfd);         //关闭监听进程
            do_client(acceptfd, db);  //进入与客户端的通信函数。参数是通信描述符、数据库指针
        }
        else{                    //父亲进程，用来监听客户端的请求的
            close(acceptfd);     //关闭通信描述符，继续循环，监听，等待其它客户端连接
        }    
    }
    return 0;
}

通信函数：当服务器与客户端成功连接后，等待接收客户端发来的信息，通过发来信息的不同请求，服务器执行不同的处理函数，处理完后，继续循环监听接收客户端发的信息，当客户端断开连接后，服务器就会退出监听接收循环，从而退出与该客户端的通信函数。

int do_client(int acceptfd, sqlite3 *db){   //与客户端通信的函数，参数是通信描述符和数据库指针
    MSG msg;                //定义了装信息的结构体
    while(recv(acceptfd, &msg, sizeof(msg), 0) > 0){   //接收客户端发来的信息
        printf("type:%d\n", msg.type);      //先打印客户端需要的请求序号
        //通过不同的请求序号，服务器执行不同的处理函数
        switch(msg.type){
            //参数是通信描述符、信息结构体MSG地址，数据库指针
            case R:
                do_register(acceptfd, &msg, db); //如果是1，就进入注册函数。
                break;
            case L:
                do_login(acceptfd, &msg, db);   //如果是2，就进入登录函数。
                break;
            case Q:
                do_query(acceptfd, &msg, db);   //如果是3，就进入查询函数
                break;
            case H:
                do_history(acceptfd, &msg, db); //如果是4，就进入历史查询函数
                break;
            default:
                printf("Invalid data msg...\n"); //如果是其它内容，就输入该行
        }
    }
    //退出循环，表示该客户端执行的内容完了
    printf("client exit...\n");
    close(acceptfd);      //关闭通信描述符                                               
    exit(0);       //退出进程
    return 0;      //这行执行不了
}

注册函数实现登录函数实现

这部分实现的就是处理客户端的注册请求任务，将客户端发送来的用户名和密码存储在后台的数据库中，服务器如果存储失败，则返回给客户端注册失败的信息；存储成功，则返回给客户端ok，表示注册成功。最后执行完该函数后，会继续监听该客户端的下一个请求任务。

void do_register(int acceptfd, MSG *msg, sqlite3 *db){     //响应客户端注册的函数
    char *errmsg;                 //存放描述错误信息
    char sql[128];                //存放sql语句
    //拼接一条向数据库的usr用户表中插入数据(用户名，密码)的语句
    sprintf(sql, "insert into usr values('%s', %s);",msg->name, msg->data); //拼接sql语句，然后存放在sql中
    printf("%s\n", sql);       //打印拼接的sql语句
    if(sqlite3_exec(db, sql, NULL, NULL, &errmsg) != SQLITE_OK){ //执行sql语句，如果报错，errmsg就存放错误原因
        printf("%s\n", errmsg);            //打印错误原因
        strcpy(msg->data, "usr name already exist...");  //报错了，就将该行内容存放在data中，等下发送给客户端
    }else{
        printf("client register ok!\n");  //如果执行sql成功，就打印该行内容
        strcpy(msg->data, "OK!");         //将ok存放在data中，等下发送给客户端
    }
    if(send(acceptfd, msg, sizeof(MSG), 0) < 0){    //将注册是否成功的信息发送给客户端
        perror("fail to send");    //如果发送失败就打印错误信息并直接退出
        return;
    }
    return;   //处理完该函数后，直接退出，继续在外面中循环，等待客户端的下一个请求序号
}

这部分实现的就是处理客户端的登录请求任务，将客户端发送来的用户名和密码在后台数据库中的用户名usr表中查询，如果查询到了，则返回给客户端ok，表示登录成功；没有查询到，则发送usr/passwd wrong...给客户端，表示登录失败。最后执行完该函数后，会继续监听该客户端的下一个请求任务

int do_login(int acceptfd, MSG *msg, sqlite3 *db){   //登录函数
    char sql[128] = {};    //存放sql语句
    char *errmsg;
    int  nrow;
    int ncloumn;
    char **resultp;
    //通过客户端发来的用户名和密码，拼接在数据库中的usr用户表中查询的语句
    sprintf(sql, "select * from usr where name = '%s' and pass = '%s';",msg->name,msg->data);
    printf("%s\n", sql);    //打印拼接的语句
    //进行查询
    if(sqlite3_get_table(db,sql,&resultp,&nrow,&ncloumn,&errmsg)!=SQLITE_OK){  //参数：数据库指针;sql语句;查询的结果;查询的到行数;查询到的列数;存放失败原因
        printf("%s\n", errmsg);     //语句执行不成功，打印具体错误
        return -1;
    }else{
        printf("get_table ok!\n");     //只是上面那句话执行成功，但并不代表数据库中有要查询的用户
    }
    if(nrow == 1){     //如果查询到的行数等于1，表示查询成功，数据库中拥有此用户
        strcpy(msg->data,"OK");     //将ok存到data，发送给客户端
        send(acceptfd, msg, sizeof(MSG), 0);     //发送给客户端查询的结果
        return 1;
    }
    if(nrow == 0){            //这种情况是密码或用户名错误
        strcpy(msg->data,"usr/passwd wrong...");
        send(acceptfd, msg, sizeof(MSG), 0);   //发送查询失败的信息给客户端
    }
    return 0;       //数据库中无该用户会返回0
}

搜索单词函数实现：这部分实现的就是处理客户端的查询单词的请求任务，通过客户端发送来的单词，服务器在词库中进行逐一查询，查询成功就返回单词的注释给客户端，查询失败，就返回给客户端信息Not dound!。同时，服务器也会在数据库中记录该用户的查询记录(用户名，查询时间，查询单词)。最后执行完该函数后，会继续监听该客户端的下一个请求任务。

int do_query(int acceptfd, MSG *msg, sqlite3 *db){  //1.查询客户端传过来的单词--->同时保留用户的查找记录，为另一个功能做铺垫
    char word[64];                     //装查询的单词
    int found = 0;
    char date[128];                    //装查询时间的
    char sql[128];                     //用于存放拼接的sql语句
    char *errmsg;
    //拿出msg结构体中，要查询的单词
    strcpy(word, msg->data);           //复制要查询的单词到word
    found = do_searchword(acceptfd, msg, word);    //如果找到了单词，就返回1，没有就返回0
    
    //表示找到了单词，那么此时应该将用名、时间、单词插入到历史记录表中去
    if(found == 1){
        get_date(date);     //获取系统时间
        //拼接插入数据库记录record表中数据(用户名，时间，单词)的语句
        sprintf(sql,"insert into record values('%s','%s','%s')",msg->name,date,word);   //拼接sql语句
        printf("%s\n",sql);         //打印拼接的sql语句
        if(sqlite3_exec(db,sql,NULL,NULL,&errmsg) != SQLITE_OK){    //将拼接的sql语句插入数据库，主要是为了历史查询
            printf("%s\n",errmsg);       //打印错误
            return -1;
        }
    }else{          //表示没有找到客户端要查询的单词
        strcpy(msg->data, "Not dound!");           //如果没有找到该单词，就返回没有找到的信息给客户端
    }
    //将查询的结果，发送给客户端
    send(acceptfd, msg, sizeof(MSG),0);           //找到与否，上面都将信息写到了msg->data
    return 1;
}

int do_searchword(int acceptfd, MSG *msg, char word[]){  //2.查询客户端传过来的单词--->从另一个函数过来的
    FILE *fp;
    char temp[512] = {};
    int result;
    char *p;
    //打开文件，读取文件，进行对比
    if((fp = fopen("dict.txt", "r"))==NULL){     //以只读方式打开文件dict.txt,如果等于NULL就是打开文件失败
        perror("fail to fopen...\n");
        strcpy(msg->data, "failed to open dict.txt");  //失败就返回打开词库失败的信息给客户端
        send(acceptfd, msg, sizeof(MSG),0);        //打开文件失败，将该信息发送给客户端
        return -1;                            //打开文件失败，直接退出，进入接收命令状态
    }
    //找出客户端要查询的单词(词库是按升序排列的)
    int len = strlen(word);                   //查询单词的长度
    printf("%s, len = %d\n", word, len);      //打印到终端要查询的单词和长度
    //读文件，来查询单词
    while(fgets(temp, 512, fp) != NULL){          //每次最多从文件读取512个字符,读满或遇到换行符就结束(说明这一次性是只读了一行数据)
        result = strncmp(temp,word,len);          //对单词进行比较
        if(result < 0){       //这种情况是在词库中，查询的当前行单词比客户端要查询的单词小，说明，还需要往后查
            continue;         //退出这种循环，继续下一次循环查询
        }
        if(result>0 || ((result == 0) && (temp[len]!=' '))){   //这种情况是在词库中找不到客户端要查询的单词
            break;                      //跳出循环，说明没有找到该单词
        }
        //表示找到了，查询的单词
        p = temp + len;         //让p到达了单词末尾
        while(*p == ' '){       //去掉空格
            p++;
        }
        //跳跃过所以的空格，找到了注释
        strcpy(msg->data, p);         //拷贝注释到data
        fclose(fp);                   //注释拷贝完毕之后，关闭文件
        return 1;                     //找到了该单词的注释，就返回1
    }
    fclose(fp);                     //表示没有找到
    return 0;                       //没有找到，就返回0
}

int get_date(char *date){           //3.获取当前时间
    time_t t;
    struct tm *tp;
    time(&t);
    //进行时间格式转换(得到的是从1970年到现在的秒数)
    tp = localtime(&t);
    sprintf(date,"%d-%d-%d %d:%d:%d",tp->tm_year+1900, tp->tm_mon+1, tp->tm_mday, tp->tm_hour, tp->tm_min, tp->tm_sec);
    return 0;
}

查询历史记录：这部分实现的就是处理客户端的查询历史记录的请求任务，通过客户端的用户名，服务器在数据库的record表中进行查询该用户产生的历史记录，并逐一发来客户端。最后执行完该函数后，会继续监听该客户端的下一个请求任务。

int do_history(int acceptfd, MSG *msg, sqlite3 *db){    //a只能查询a的历史记录，b只能查询b的历史记录
    char sql[128] = {};          //存放sql语句
    char *errmsg;
    //通过用户名，拼接在数据库record表中查询该用户产生的的记录的语句
    sprintf(sql,"select * from record where name = '%s'",msg->name);     //这里是查询某个用户执行查询的历史记录
    //执行该语句，查询数据库
    if(sqlite3_exec(db,sql,history_callback,(void *)&acceptfd, &errmsg) != SQLITE_OK){
        printf("%s\n",errmsg);                       //查询数据库失败，打印具体错误原因
    }else{
        printf("Query record done...\n");
    }
    //所有的记录查询发送完毕之后(查到几条数据，回调函数就执行了几次)，给客户端发出一个结束的信息，客户端那边接受到了'\0'就知道所有的记录的发送完毕
    msg->data[0] = '\0';
    send(acceptfd, msg, sizeof(MSG),0);          //像客户端发送发送完毕的信息
    return 0;
}

//得到查询结果(查到n条记录，就执行n次回调函数)，并且需要将历史记录发送给客户端
int history_callback(void* arg, int f_num, char** f_value, char** f_name){ //从sqlite3_callback传过来的参数;查询结果的列数；存放列数的结果；列的名字
    //record：name,data,word --->name就是客户端登录的时候，保存的客户名
    int acceptfd = *((int *)arg);    //将传过来的参数强制转换，并取值
    MSG msg;
    sprintf(msg.data, "%s , %s",f_value[1], f_value[2]);
    send(acceptfd, &msg, sizeof(MSG),0);        //每一次执行回调函数都是只将一条记录发送给客户端
    return 0;
}

3.2 客户端

主函数和一些基本信息：这部分定义了一个双方通信的信息结构体，其中type是R时，表示用户要求完成注册任务；是L时，表示用户要求完成登录任务；是Q时，表示用户要求完成查询任务；是H时，表示用户要求完成历史查询任务。客户端完成了任务函数后，又会继续等待用户从终端输入请求序号。

#define N 32
#define R 1    //user - register
#define L 2    //user - login
#define Q 3    //user - query
#define H 4    //user - history

//定义通信双方的信息结构体
typedef struct {
    int type;
    char name[N];
    char data[256];
}MSG;

int main(int argc, const char *argv[]){
    int sockfd;
    struct sockaddr_in serveraddr;    //存放服务器信息的结构体
    MSG msg;
    if(argc != 3){                    //说明执行命令的时候，密钥输入ip和端口，直接退出
        printf("Usage:%s serverip port.\n",argv[0]);
        return -1;
    }
    sockfd = socket(AF_INET,SOCK_STREAM,0);   //获取通信描述符
    if(sockfd < 0){
        perror("fail to socket...\n");
        return -1;
    }
    bzero(&serveraddr,sizeof(serveraddr));               //对结构体里的内容进行清空
    serveraddr.sin_family = AF_INET;
    serveraddr.sin_port = htons(atoi(argv[2]));
    serveraddr.sin_addr.s_addr = inet_addr(argv[1]);
    if(connect(sockfd, (struct sockaddr *)&serveraddr, sizeof(serveraddr))<0){      //连接服务端
        perror("fail to connect...\n");
        return -1;
    }
    //成功连接服务端后，就进入下面界面
    int n;
    while(1){
        printf("*****************************************************************************\n");
        printf("* 1.register                   2.login                   3.quit             *\n");
        printf("*****************************************************************************\n");
        printf("Please choose:");
        scanf("%d", &n);              //接收终端传来的命令序号
        getchar();                    //去掉垃圾字符(回车字符)
        switch(n){
            case 1:
                do_register(sockfd, &msg);    //输入的是1，进入注册函数。参数是通信描述符、MSG结构体的一个地址
                break;
            case 2:
                if(do_login(sockfd, &msg) == 1){   //输入的是2，则进入登录函数(输入的账号和密码存在则返回1)，否则返回0，继续循环该界面
                    goto next;             //返回1，则登录成功，跳转到二级菜单
                }
                break;
            case 3:
                close(sockfd);             //输入的是3，关闭通信描述符，直接退出，断开与服务端的连接
                exit(0);                   //退出进程
                break;
            default:
                printf("Invalid data cmd...\n");    //输入的是其他东西，打印该行内容，然后继续循环该界面
        }
    }
next:
    //登录成功，进入下面二级界面
    while(1){
        printf("-------------------------------------------------------------------------------\n");
        printf("- 1.query_word                  2.history_record                  3.quit      -\n");
        printf("-------------------------------------------------------------------------------\n");
        printf("Please choose:");
        scanf("%d", &n);
        getchar();                     //去掉垃圾字符(回车字符)
        switch(n){
            case 1:
                do_query(sockfd, &msg);           //输入的是1，进入单词查询界面。参数是通信描述符、MSG结构体的地址
                break;
            case 2:
                do_history(sockfd, &msg);         //输入的是2，进入查询历史函数
                break;
            case 3:
                close(sockfd);                    //输入的是3，关闭通信描述符，直接退出
                exit(0);
                break;
            default:
                printf("Invalid data cmd...\n");
        }
    }
}

以下是对应的功能函数实现：根据用户输入的请求序号，执行对应的处理任务。

注册函数实现登录函数实现查询单词实现查询历史记录实现

这部分负责处理用户的注册请求，用户从终端输入用户名和密码，客户端将该信息发送给服务器，服务器完成成功与否都会发送信息会客户端，客户端打印服务器发送来的信息告知用户。

int do_register(int sockfd, MSG *msg){       //注册函数，参数：通信描述符 和 发送消息结构体
    msg->type = R;                           //对type赋值1     
    printf("Input name:");                   //提示输入姓名
    scanf("%s", msg->name);                  //接收用户输入的姓名，存到name
    getchar();                               //去掉残留的垃圾字符
    
    printf("Input passwd:");                      //提示输入密码
    scanf("%s",msg->data);                        //接收密码，存到data
    if(send(sockfd, msg, sizeof(MSG),0) < 0){     //发送给服务端R(服务端接收R就通过R进入对应的函数执行)、姓名、密码信息
        printf("fail to send...\n");
        return -1;
    }
    if(recv(sockfd, msg, sizeof(MSG), 0) < 0){    //接收服务端那边是否完成注册任务的信息
        printf("fail to recv...\n");
        return -1;
    }
    printf("%s\n",msg->data);                    //打印传过来的内容，ok表示注册成功
    return 0;                                    //返回0，直接退出，继续循环该界面，接收命令序号
}

这部分负责处理用户的登录请求，用户从终端输入用户名和密码，客户端将这些信息发送给服务器，服务器返回处理的结果。登录成功的话，用户进入二级目录，等待用户请求指令；登录失败的话，用户继续在一级目录，等待用户的请求指令。

int do_login(int sockfd, MSG *msg){                  //登录函数
    msg->type = L;                           //对type赋值为2
    printf("Input name:");                   //接收姓名
    scanf("%s", msg->name);
    getchar();
    
    printf("Input passwd:");                 //接收密码
    scanf("%s",msg->data);
    
    if(send(sockfd, msg, sizeof(MSG),0) < 0){   //发送给服务端L、姓名、密码
        printf("fail to send...\n");
        return -1;
    }
    if(recv(sockfd, msg, sizeof(MSG), 0) < 0){   //接收服务端传过来的信息
        printf("fail to recv...\n");
        return -1;
    }
    //接收到服务端发来的信息
    if(strncmp(msg->data, "OK",3) == 0){       //服务端发来OK表示数据库有该用户
        printf("Login ok!\n");       //则打印成功登录
        return 1;                    //返回1，进入二级目录
    }else{                            //数据库没有该用户，打印服务端发来的信息
        printf("%s\n",msg->data);
    }
    return 0;      //这种情况是登录失败，返回0，继续在一级目录循环等待用户的请求
}

这部分负责处理用户的查询单词请求，用户从终端输入要查询的单词，客户端将该单词发送给服务器，服务器在底层进行查询，将查询的结果返回给客户端，客户端向终端打印服务器发送来的查询结果。

int do_query(int sockfd, MSG *msg){              //查询单词
    msg->type = Q;                               //type赋值为3
    puts("--------------------");
    while(1){
        printf("Input word:");               //输入查询单词
        scanf("%s", msg->data);              //将单词赋值给data
        //用户输入#，返回上一级菜单
        if(strncmp(msg->data,"#",1)==0){     //如果输入的是#，退出循环(查询状态)，进入二级界面(说明退出查询)
            break;
        }
        //将要查询的单词发送给服务器
        if(send(sockfd, msg, sizeof(MSG),0) < 0){
            printf("fail to send...\n");
            return -1;
        }
        //等待接受服务器，传递回来的单词的注释信息
        if(recv(sockfd, msg, sizeof(MSG),0) < 0){
            printf("fail to recv...\n");
            return -1;
        }
        printf("%s\n", msg->data);        //输出服务端传来的信息
    }
    return 0;
}

这部分负责处理用户的查询历史记录请求，客户端只需要将请求序号赋值到type，发送给服务器即可，服务器接收到信息是type是H，就会通过该用户的用户名进行历史记录查询，将查询到的结果返回给客户端，客户端向终端打印查询的记录。

int do_history(int sockfd, MSG *msg){             //查看历史查询
    msg->type = H;
    send(sockfd, msg, sizeof(MSG), 0);        //发送给服务端信息--->主要是传送H
    
    //接受服务器，传递回来的历史记录信息
    while(1){
        recv(sockfd, msg, sizeof(MSG), 0);    //接收服务端传来的结果
        if(msg->data[0] == '\0'){             //当服务端将所有历史记录发送完毕后，会发送'\0'
            break;                        //查询完毕，退出循环，进入二级目录，等待下一个命令
        }
        //输出历史记录信息
        printf("%s\n",msg->data);
    }
    //此时不应该关闭sockfd,因为一个客户端在查询完历史记录后，不代表，它要退出，也可能还要执行其他业务
    return 0;
}

4. 执行效果

第一个用户

第二个用户

两个用户产生的数据库中的数据情况

词库的单词情况，大约20000个单词