devbox
我家小花儿
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

网络电子词典

作者：我家小花儿 | 2024-05-31 22:04:13

赞

踩

网络电子词典

一、项目要求：

1. 登录注册功能，不能重复登录，重复注册

2. 单词查询功能

3. 历史记录功能，存储单词，意思，以及查询时间

4. 基于TCP，支持多客户端连接

5. 采用数据库保存用户信息与历史记录

格式要求： 1. main函数只跑逻辑，不允许跑功能代码 2. 功能代码封装成函数 

二、流程示意图

服务器：

客户端：

 

 三、实现代码

server.c代码部分：

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <unistd.h>
  4. #include <string.h>
  5. #include <sqlite3.h>
  6. #include <signal.h>
  7. #include <time.h>
  8. #include <sys/socket.h>
  9. #include <netinet/in.h>
  10. #include <arpa/inet.h>
  11.  
  12. #define DATABASE "my.db"
  13. #define N  16
  14.  
  15. enum CMD{
  16.     R=1,
  17.     L,
  18.     Q,
  19.     H
  20. };
  21.  
  22. typedef struct sockaddr SA;
  23.  
  24. typedef struct
  25. {
  26.     int type;
  27.     char name[N];
  28.     char data[256];   // password or word
  29. } MSG;
  30.  
  31. static sqlite3 *db;   //数据库句柄指针
  32.  
  33. void do_register(int connfd, MSG *pbuf)    //用户注册模块
  34. {
  35.     char sqlstr[128];
  36.     char *errmsg;
  37.  
  38.     sprintf(sqlstr, "insert into usr values ('%s', '%s')", pbuf->name, pbuf->data);
  39.     printf("%s\n", sqlstr);
  40.     if (sqlite3_exec(db, sqlstr, NULL, NULL, &errmsg) != SQLITE_OK)   //执行SQL语句并处理结果
  41.     {
  42.         sqlite3_free(errmsg);
  43.         sprintf(pbuf->data, "user %s already exist!!!", pbuf->name);
  44.     }
  45.     else
  46.     {
  47.         strncpy(pbuf->data, "OK", 256);
  48.     }
  49.     send(connfd, pbuf, sizeof(MSG), 0);
  50. }
  51.  
  52.  
  53. void do_login(int connfd, MSG *pbuf)  //用户登录模块
  54. {
  55.     char sqlstr[128];    //拼接后的查询语句
  56.     char *errmsg, **result; //存放错误信息和查询到的结果
  57.     int nrow, ncolumn;   //查询到的行数和列数
  58.  
  59.     sprintf(sqlstr, "select * from usr where name = '%s' and pass = '%s'", pbuf->name, pbuf->data);
  60.     if (sqlite3_get_table(db, sqlstr, &result, &nrow, &ncolumn, &errmsg) != SQLITE_OK)  
  61.     {
  62.         printf("error : %s\n", errmsg);
  63.         sqlite3_free(errmsg);
  64.     }
  65.  
  66.     if (nrow == 0)   //查询到的条数为0条
  67.     {
  68.         strncpy(pbuf->data, "name or password is wrong!!!", 256);
  69.     }
  70.     else  //查询到的所需信息
  71.     {
  72.         strncpy(pbuf->data, "OK", 256);
  73.     }
  74.     send(connfd, pbuf, sizeof(MSG), 0);
  75.     sqlite3_free_table(result);
  76.  
  77.     return;
  78. }
  79.  
  80. #if 0
  81. int do_searchword(int connfd, MSG *pbuf)   //查询单词模块调用的查询单词函数方式一
  82. {
  83.     FILE *fp;
  84.     char line[300];
  85.     char *p;
  86.     int len, result;
  87.  
  88.     len = strlen(pbuf->data); //要查询的单词长度
  89.     if ((fp = fopen("dict.txt", "r")) == NULL)  //打开保存单词文件
  90.     {
  91.         strcpy(pbuf->data, "dict on server can't be opened :(");
  92.         send(connfd, pbuf, sizeof(MSG), 0);
  93.         return 0;
  94.     }
  95.     printf("query word is %s\n", pbuf->data); //打印一下客户端要查询的单词
  96.     while (fgets(line, 300, fp) != NULL)  //读文件，每次读300个字符存放到字符数组line中，来查询单词
  97.     {
  98.         result = strncmp(pbuf->data, line, len); //比较一下要查询的单词和line中读取到的文件中每行的单词信息进行比较，比较的长度大小为要查询的单词大小
  99.         if (result > 0) continue; //大于0，说明要查询的单词大小大于读取的单词大小，则继续下一行，比如abandon ,查询abc,则跳入下一行
  100.         if (result < 0 || line[len] != ' ') break;//小于0，则说明要查找的单词小于读取的单词大小，但之前的都已比较完毕，则查询失败。不是空格也不行，比如查询ab,而读取的是abandon.
  101.  
  102.         p = line + len; //指针指到单词末尾
  103.         while (*p == ' ') p++;  //指针移动到注释之前
  104.         strcpy(pbuf->data, p); //拷贝单词注释
  105.         fclose(fp);     //
  106.         return 1;
  107.     }
  108.     fclose(fp);
  109.  
  110.     return 0;
  111. }
  112. #else
  113. int do_searchword(int connfd, MSG *pbuf)   //查询单词模块调用的查询单词函数方式二
  114. {
  115.     char buf[128] = {0};
  116.  
  117.     printf("query word is %s\n", pbuf->data);
  118.     sprintf(buf, "select * from dic where word='%s'", pbuf->data);
  119.  
  120.     char *errmsg;
  121. 	char **resultp;
  122. 	int n_row, n_cloum;
  123.  
  124. 	if (sqlite3_get_table(db, buf, &resultp, &n_row, &n_cloum, &errmsg) != SQLITE_OK) 
  125.     {
  126.         printf("err:%s\n", errmsg);
  127.         return -1;
  128.     }
  129.  
  130.     if(n_row != 1)
  131.     {
  132.         return 0;
  133.     }
  134.  
  135.     char **p;
  136.     p = resultp + n_cloum;
  137.  
  138.     // printf("data=%s\n", p[1]);
  139.  
  140.     strcpy(pbuf->data, p[1]);
  141.  
  142.     return 1;
  143. }
  144. #endif
  145.  
  146. void get_date(char date[])  //获取系统时间
  147. {
  148.     time_t t;
  149.     struct tm *tp;
  150.  
  151.     time(&t);  //获取到一个时间秒数
  152.  
  153.     tp = localtime(&t);//进行时间格式转换
  154.     /*
  155. 	//字符串拼接
  156.     sprintf(date, "%d-%02d-%02d %02d:%02d:%02d", tp->tm_year+1900,
  157.             tp->tm_mon+1, tp->tm_mday, tp->tm_hour, tp->tm_min, tp->tm_sec);
  158.     */
  159.     strftime(date, 64, "%Y-%m-%d %H:%M:%S", tp);
  160.  
  161.     return;
  162. }
  163.  
  164. void do_query(int connfd, MSG *pbuf)   //查询单词模块
  165. {
  166.     char sqlstr[128], *errmsg;
  167.     int len, result, found = 0;
  168.     char date[64], word[64];
  169.  
  170.     strcpy(word, pbuf->data);  //拿出pbuf结构体中要查询的单词
  171.     found = do_searchword(connfd, pbuf);  //调用do_searchword函数模块去查询
  172.     if(found)  //返回值非0，表示找到了该单词，则将用户查询信息（包括用户名，时间和单词）插入到历史记录表中
  173.     {
  174.         get_date(date);//调用时间函数获取时间
  175.         sprintf(sqlstr, "insert into record values ('%s', '%s', '%s')", pbuf->name, date, word);
  176.         if (sqlite3_exec(db, sqlstr, NULL, NULL, &errmsg) != SQLITE_OK)
  177.         {
  178.             printf("error : %s\n", errmsg);
  179.             sqlite3_free(errmsg);
  180.         }
  181.     }
  182.     else   //返回值为0，表示没有找到，发送没到到提示信息
  183.     {
  184.         strcpy(pbuf->data, "not found\n");
  185.     }
  186.     send(connfd, pbuf, sizeof(MSG), 0);   //把查找到的信息发送给客户端
  187.     return;
  188. }
  189.  
  190. //得到查询结果，并将历史记录发送给客户端
  191. int history_callback(void *arg, int f_num, char **f_value, char **f_name)
  192. {
  193.     int connfd;
  194.     MSG buf;
  195.  
  196.     connfd = *(int *)arg;
  197.     sprintf(buf.data, "%s : %s", f_value[1], f_value[2]);
  198.     send(connfd, &buf, sizeof(buf), 0);
  199.  
  200.     return 0;
  201. }
  202.  
  203. void do_history(int connfd, MSG *pbuf)   //查询历史记录模块
  204. {
  205.     char sqlstr[128], *errmsg;
  206.  
  207.     sprintf(sqlstr, "select * from record where name = '%s'", pbuf->name);
  208.     if (sqlite3_exec(db, sqlstr, history_callback, (void *)&connfd, &errmsg) != SQLITE_OK) //查询数据库
  209.     {
  210.         printf("error : %s\n", errmsg);
  211.         sqlite3_free(errmsg);
  212.     }
  213.     pbuf->data[0] = '\0';         //所有的记录发送完毕之后，给客户端发送一个结束信息
  214.     send(connfd, pbuf, sizeof(MSG), 0);
  215.  
  216.     return;
  217. }
  218.  
  219.  
  220.  
  221. void do_client(int connfd)     //处理客户端请求主模块，调用函数完成所需功能
  222. {
  223.     MSG buf;
  224.     while(recv(connfd, &buf, sizeof(buf), 0) > 0){
  225.         switch (buf.type) {
  226.         case R:
  227.             printf("will reg\n");
  228.             do_register(connfd, &buf);
  229.             break;
  230.         case L:
  231.             printf("will login\n");
  232.             do_login(connfd, &buf);
  233.             break;
  234.         case Q:
  235.             printf("will query\n");
  236.             do_query(connfd, &buf);
  237.             break;
  238.         case H:
  239.             printf("will history\n");
  240.             do_history(connfd, &buf);
  241.             break;
  242.         default:
  243.             break;
  244.         }
  245.     }
  246.  
  247.     exit(0);
  248. }
  249.  
  250.  
  251. int main(int argc, char *argv[])    //主函数
  252. {
  253.     int listenfd, connfd;
  254.     struct sockaddr_in myaddr;
  255.     pid_t pid;
  256.     MSG buf;
  257.     
  258.  
  259.     if (argc < 3)
  260.     {
  261.         printf("Usage : %s <ip> <port>\n", argv[0]);
  262.         exit(-1);
  263.     }
  264.  
  265.     //打开数据库
  266.     if(sqlite3_open(DATABASE, &db) < 0){
  267.         printf("fail to sqlite3_open : %s\n", sqlite3_errmsg(db));
  268.         return -1;
  269.     }
  270.  
  271.     //创建服务器socket
  272.     listenfd = socket(PF_INET, SOCK_STREAM, 0);
  273.     if(listenfd < 0){
  274.         perror("fail to socket");
  275.         exit(-1);
  276.     }
  277.     bzero(&myaddr, sizeof(myaddr));
  278.     myaddr.sin_family = PF_INET;
  279.     myaddr.sin_port = htons(atoi(argv[2]));
  280.     myaddr.sin_addr.s_addr = inet_addr(argv[1]);
  281.     if (bind(listenfd, (SA *)&myaddr, sizeof(myaddr)) < 0)
  282.     {
  283.         perror("fail to bind");
  284.         exit(-1);
  285.     }
  286.  
  287.     // 将套接字设为监听模式
  288.     if (listen(listenfd, 5) < 0)
  289.     {
  290.         perror("fail to listen");
  291.         exit(-1);
  292.     }
  293.  
  294.     //并发服务器模型
  295.     while(1){
  296. 		
  297.         if((connfd = accept(listenfd, NULL, NULL)) < 0){
  298.             perror("fail to accept");
  299.             exit(-1);
  300.         }
  301. 		
  302.         pid = fork();
  303.         if(pid == -1){
  304.             perror("fail to fork\n");
  305.             exit(-1);
  306.         }
  307.         else if(pid == 0){ //子进程处理客户端具体的消息
  308.             printf("a user comming\n");
  309.             do_client(connfd);
  310.         }else{  //父进程用于接收客户端的请求
  311.             close(connfd);
  312.         }
  313.     }
  314. }

client.c代码部分：

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <unistd.h>
  4. #include <string.h>
  5. #include <sqlite3.h>
  6. #include <sys/socket.h>
  7. #include <netinet/in.h>
  8. #include <arpa/inet.h>
  9.  
  10. #define N  16
  11. typedef struct sockaddr SA;
  12.  
  13. enum CMD{
  14.     R=1,
  15.     L,
  16.     Q,
  17.     H
  18. };
  19.  
  20.  
  21. typedef struct
  22. {
  23.     int type;
  24.     char name[N];
  25.     char data[256];   // password or word
  26. } MSG;
  27.  
  28. void do_register(int sockfd, MSG *pbuf)   //一级菜单用户注册模块
  29. {
  30.     pbuf->type = R;
  31.     printf("input name : ");
  32.     scanf("%s", pbuf->name);
  33.     printf("input password : ");
  34.     scanf("%s", pbuf->data);
  35.     send(sockfd, pbuf, sizeof(MSG), 0);
  36.     recv(sockfd, pbuf, sizeof(MSG), 0);
  37.     printf("register : %s\n\n", pbuf->data);
  38. }
  39.  
  40. int do_login(int sockfd, MSG *pbuf)     //一级菜单用户登录模块
  41. {
  42.     pbuf->type = L;
  43.     printf("input name : ");
  44.     scanf("%s", pbuf->name);
  45.     printf("input password : ");
  46.     scanf("%s", pbuf->data);
  47.     send(sockfd, pbuf, sizeof(MSG), 0);
  48.     recv(sockfd, pbuf, sizeof(MSG), 0);
  49.     if(strncmp(pbuf->data, "OK", 3) == 0){    //3个字节：O K /0
  50.         printf("login sucess\n\n");
  51.         return 1;
  52.     }else{
  53.         printf("login : %s\n\n", pbuf->data);
  54.         return 0;
  55.     }
  56. }
  57.  
  58. void do_history(int sockfd, MSG *pbuf)   //二级菜单查询单词历史记录模块
  59. {
  60.     pbuf->type = H;
  61.     send(sockfd, pbuf, sizeof(MSG), 0);
  62.     while ( 1 )
  63.     {
  64.         recv(sockfd, pbuf, sizeof(MSG), 0);
  65.         if (pbuf->data[0] == '\0') break;
  66.         printf("%s\n", pbuf->data);
  67.     }
  68.  
  69.     return;
  70. }
  71.  
  72. void do_query(int sockfd, MSG *pbuf)  //二级菜单查询单词模块
  73. {
  74.     pbuf->type = Q;
  75.     while ( 1 )
  76.     {
  77.         printf("input word(# to quit) : ");
  78.         scanf("%s", pbuf->data);
  79.         if (strcmp(pbuf->data, "#") == 0) break; //输入#返回上一级菜单
  80.         send(sockfd, pbuf, sizeof(MSG), 0); //将要查询的单词发送给服务器
  81.         recv(sockfd, pbuf, sizeof(MSG), 0); //等待接收服务器传递回来的单词信息
  82.         printf("%s\n", pbuf->data);
  83.         printf("\n");
  84.     }
  85.  
  86.     return;
  87. }
  88.  
  89. void enter_query(int sockfd, MSG *buf)    //二级菜单主页面
  90. {
  91.     int input;
  92.     char cleanbuf[64];
  93.  
  94.     while (1) {
  95.         printf("***********************************************\n");
  96.         printf("* 1: query_word   2: history_record   3: quit *\n");
  97.         printf("***********************************************\n");
  98.         printf("please choose : ");
  99.         //获取用户输入
  100.         if(scanf("%d", &input) == 0){
  101.             fgets(cleanbuf, 64, stdin);  //类型错误需要重新清除输入缓冲区
  102.             continue;
  103.         }
  104.  
  105.         switch (input) {
  106.         case 1:
  107.             printf("\n");
  108.             do_query(sockfd, buf);
  109.             printf("\n");
  110.             break;
  111.         case 2:
  112.             printf("\n");
  113.             do_history(sockfd, buf);
  114.             printf("\n");
  115.             break;
  116.         case 3:
  117.             return;
  118.         default:
  119.             break;
  120.         }
  121.     }
  122. }
  123.  
  124. int main(int argc, char *argv[])      //主函数
  125. {
  126. 	int sockfd, login = 0;
  127. 	struct sockaddr_in servaddr;
  128. 	MSG buf;
  129. 	char clean[64];
  130.  
  131. 	if (argc < 3)
  132. 	{
  133. 		printf("Usage : %s <serv_ip> <serv_port>\n", argv[0]);
  134. 		exit(-1);
  135. 	}
  136.  
  137.     //创建客户端socket
  138. 	if ((sockfd = socket(PF_INET, SOCK_STREAM, 0)) < 0)
  139. 	{
  140. 		perror("fail to socket");
  141. 		exit(-1);
  142. 	}
  143.  
  144. 	bzero(&servaddr, sizeof(servaddr));
  145. 	servaddr.sin_family = PF_INET;
  146. 	servaddr.sin_port = htons(atoi(argv[2]));
  147. 	servaddr.sin_addr.s_addr = inet_addr(argv[1]);
  148.  
  149.     //连接服务器
  150. 	if (connect(sockfd, (SA *)&servaddr, sizeof(servaddr)) < 0)
  151. 	{
  152. 		perror("fail to connect");
  153. 		exit(-1);
  154. 	}
  155.  
  156.     int input;
  157.     char cleanbuf[64];
  158.     while(1){
  159.         printf("************************************\n");
  160.         printf("* 1: register   2: login   3: quit *\n");
  161.         printf("************************************\n");
  162.         printf("please choose : ");
  163.         //获取用户输入
  164.         if(scanf("%d", &input) == 0){
  165.             fgets(cleanbuf, 64, stdin);  //类型错误需要重新清除输入缓冲区
  166.             continue;
  167.         }
  168.  
  169.         switch (input) {
  170.         case 1:
  171.             do_register(sockfd, &buf);
  172.             break;
  173.         case 2:
  174.             if(do_login(sockfd, &buf) == 1){  //成功
  175.                 enter_query(sockfd, &buf);
  176.             }
  177.             break;
  178.         case 3:
  179.             close(sockfd);
  180.             exit(0);
  181.             break;
  182.         default:
  183.             break;
  184.         }
  185.     }
  186. }

Makefile代码部分：

  1. all:server client
  2.  
  3. server:server.c
  4. 	gcc $< -o $@ -l sqlite3
  5.  
  6. client:client.c
  7. 	gcc $< -o $@
  8. 	
  9. clean:
  10. 	rm server client

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/我家小花儿/article/detail/654592
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号