基于TCP的在线词典

最新推荐文章于 2024-07-06 20:01:16 发布
最新推荐文章于 2024-07-06 20:01:16 发布
阅读量1.2k 收藏 19
点赞数 2
分类专栏： 代码 文章标签： TCP 电子词典 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41868476/article/details/83546995
版权

此程序主要是利用tcp传输和sqlite3进行操作的。
程序执行过程部分截图
在这里插入图片描述
#在终端输入sqlite3，查看是否安装sqlite3，没有的话先安装sqlite3
sudo apt-get install sqlite3
sudo apt-get install libsqlite3-dev

打开数据库 sqlite3 my.db
然后在里面创建数据库
create table <table_name> (f1 type1, f2 type2,…);

需要在编译选项上加入-lsqlite3

server.c

#include <stdlib.h>
#include <string.h>
#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <signal.h>
#include <sqlite3.h>
#include <time.h>


#define  N  256 

typedef struct _msg
{
    char types;
    char name[N] ;
    char text[N] ;
}msg_t;

int login_callback(void*data,int num,char**value,char**name)
{
 //   int i;
    *(int * )data = 1 ;
#if 0
    if(*flag)
    {
        *flag = 0 ; 
        for(i=0;i<num;i++)
        {
            printf("%-10s",name[i]);
        }
        printf("\n");
    }
    for(i=0;i<num;i++)
    {
        printf("%-10s",value[i]);
    }
    printf("\n");

#endif

    return 0;
    
}
int process_register(int newsockfd,msg_t *msgp,sqlite3 *db)
{

    int ret;
    char *errmsg ;
    char sqlstr[N] = {0};
    sprintf(sqlstr,"insert into user values('%s','%s');",msgp->name,msgp->text);
    printf("sqlstr=%s\n",sqlstr) ;
    ret = sqlite3_exec(db,sqlstr,NULL,NULL,&errmsg);
    if(ret != SQLITE_OK)
    {
        printf("sqlite3_exec:%s\n",errmsg);
        strcpy(msgp->text,"用户名已经存在，请重新输入");
    }
    else 
    {
        strcpy(msgp->text,"注册成功");
    }

    ret = write(newsockfd,msgp,sizeof(msg_t));
    if(ret < 0)
    {
        perror("write"); 
        exit(-1);
    }
    return 0;
}
int process_login(int newsockfd,msg_t *msgp,sqlite3 *db)
{

    int ret;
    char *errmsg ;
    char sqlstr[N] = {0};
    int  login_flag = 0 ; 
    sprintf(sqlstr,"select * from user where name='%s' and passwd='%s';",msgp->name,msgp->text);
    printf("sqlstr=%s\n",sqlstr) ;
    ret = sqlite3_exec(db,sqlstr,login_callback,&login_flag,&errmsg);
    if(ret != SQLITE_OK)
    {
        printf("sqlite3_exec:%s\n",errmsg);
    }
    if(login_flag == 1)
    {
        strcpy(msgp->text,"登录成功");
    }
    else 
    {
        strcpy(msgp->text,"用户或密码错误，请重新输入");
    }
    ret = write(newsockfd,msgp,sizeof(msg_t));
    if(ret < 0)
    {
        perror("write"); 
        exit(-1);
    }
    return 0;
}
char * search_word(char *word)
{
    FILE * filp;
    static char line[N] ={0};
    char newword[100] ;
    strcpy(newword,word);
    strcat(newword," ");
    filp = fopen("./dict.txt","r");
    if(filp == NULL)
    {
        perror("fopen") ; 
        exit(-1);
    }
    while( fgets(line,N,filp) != NULL ) 
    {
        if( strncmp(newword,line,strlen(newword)) == 0 )  
        {
           printf("%s",line) ;
           return line ;
        }
        
    }
    return NULL;
}

char * get_localtime() 
{
    static char buf[100] ={0} ;
    time_t tm;
    time(&tm);
    strcpy(buf,ctime(&tm));
    buf[strlen(buf) -1] = 0 ;
    return buf;
}

int process_query(int newsockfd,msg_t *msgp,sqlite3 *db)
{

    int ret;
    char *retp;
    char *errmsg ;
    char sqlstr[N] = {0};
    int  login_flag = 0 ; 
    char word[100] = {0} ;
    strcpy(word,msgp->text);
    retp = search_word(word);
    if(retp == NULL)
    {
        strcpy(msgp->text,"要查找的单词不存在");
        ret = write(newsockfd,msgp,sizeof(msg_t));
        if(ret < 0)
        {
            perror("write"); 
            exit(-1);
        }
    }
    else 
    {
        strcpy(msgp->text,retp);
        sprintf(sqlstr,"insert into record values('%s','%s','%s');",msgp->name,word,get_localtime());
        printf("sqlstr=%s\n",sqlstr) ;
        ret = sqlite3_exec(db,sqlstr,NULL,NULL,&errmsg);
        if(ret != SQLITE_OK)
        {
            printf("sqlite3_exec:%s\n",errmsg);
        }
        ret = write(newsockfd,msgp,sizeof(msg_t));
        if(ret < 0)
        {
            perror("write"); 
            exit(-1);
        }
    }


    return 0;
}
int history_callback(void*data,int num,char**value,char**name)
{
    int i,ret;
    msg_t msg;
    char buf[256] ={0};
    
    int newsockfd = *(int * )data  ;
    memset(&msg,0,sizeof(msg_t));
    msg.types = 'H' ;
    for(i=0;i<num;i++)
    {
        sprintf(buf,"%-10s",value[i]);
        strcat(msg.text,buf);
    }
    ret = write(newsockfd,&msg,sizeof(msg_t));
    if(ret < 0)
    {
        perror("write"); 
        exit(-1);
    }
    return 0;
    
}
int process_history(int newsockfd,msg_t *msgp,sqlite3 *db)
{

    int ret;
    char *retp;
    char *errmsg ;
    char sqlstr[N] = {0};
    int  login_flag = 0 ; 
    sprintf(sqlstr,"select * from record where name='%s';",msgp->name);
    printf("sqlstr=%s\n",sqlstr) ;
    ret = sqlite3_exec(db,sqlstr,history_callback,&newsockfd,&errmsg);
    if(ret != SQLITE_OK)
    {
        printf("sqlite3_exec:%s\n",errmsg);
    }
    strcpy(msgp->text,"传输完成");
    ret = write(newsockfd,msgp,sizeof(msg_t));
    if(ret < 0)
    {
        perror("write"); 
        exit(-1);
    }


    return 0;
}
// ./a.out 192.168.1.57 8000
// argv[0] argv[1]       aegv[2]
int main(int argc, const char *argv[])
{
    sqlite3 *db  ;        /* OUT: SQLite db handle */
    int data = 1 ;
    int sockfd,ret,newsockfd;
    struct sockaddr_in myaddr,client;
    signal(SIGCHLD,SIG_IGN);
    msg_t msg;
    if(argc != 3)
    {
        printf("运行程序时带入ip 和 port\n");
        exit(-1);
    }
    socklen_t addrlen = sizeof(client);
    sockfd = socket(AF_INET,SOCK_STREAM,0);
    if(sockfd < 0)
    {
        perror("socket");
        exit(-1);
    }
    printf("sockfd=%d\n",sockfd);
    memset(&myaddr,0,sizeof(myaddr));
    myaddr.sin_family = AF_INET ;
    myaddr.sin_port   = htons(atoi(argv[2]));
    myaddr.sin_addr.s_addr   = inet_addr(argv[1]); 
    ret = bind(sockfd,(struct sockaddr *)&myaddr,sizeof(myaddr)) ; // 给socket 一个固定的ip 和端口 
    if(ret < 0)
    {
        perror("bind");
        exit(-1);
    }
    ret = listen(sockfd,10);
    if(ret < 0)
    {
        perror("listen");
        exit(-1);
    }
    if(sqlite3_open("my.db",&db) != SQLITE_OK)
    {
        printf("%s\n",sqlite3_errmsg(db));
        exit(-1);
    }

    while(1)
    {
        newsockfd = accept(sockfd,(struct sockaddr *)&client,&addrlen) ; 
        if(newsockfd < 0)
        {
            printf("accept");
            exit(-1);
        }
        printf("newsockfd = %d\n",newsockfd);
        printf("%s and %d\n",inet_ntoa(client.sin_addr),ntohs(client.sin_port));
        if( fork() == 0)
        {
            while(1)
            {
                ret = read(newsockfd,&msg,sizeof(msg_t));
                if(ret  < 0)
                {
                    printf("read");
                    exit(-1);
                }
                else if(ret == 0)
                {
                   break ; 
                }
                printf("msg.type=%c\n",msg.types);
                switch(msg.types)
                {
                    case 'R':
                        process_register(newsockfd,&msg,db);
                        break ; 
                    case 'L':
                        process_login(newsockfd,&msg,db);
                        break ; 
                    case 'Q':
                        process_query(newsockfd,&msg,db);
                        break ; 
                    case 'H':
                        process_history(newsockfd,&msg,db);
                        break ; 
                    default:
                        break ;
                }

            }
            close(newsockfd);
            exit(0);
        }

        close(newsockfd);
    }


    
    return 0;
}

client.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#define  N   256 
typedef struct _msg
{
    char types;
    char name[N] ;
    char text[N] ;
}msg_t;


int process_register(int sockfd,msg_t *msgp)
{
    int ret;
    msgp->types = 'R';
    printf("input your name:");
    fgets(msgp->name,N,stdin);
    msgp->name[strlen(msgp->name) -1 ] = 0 ;
    printf("input your passwd:");
    fgets(msgp->text,N,stdin);
    msgp->text[strlen(msgp->text) -1 ] = 0 ;
    ret = write(sockfd,msgp,sizeof(msg_t));
    if(ret < 0)
    {
        perror("write"); 
        exit(-1);
    }
    memset(msgp,0,sizeof(msg_t)) ;
    ret = read(sockfd,msgp,sizeof(msg_t));
    if(ret < 0)
    {
        perror("write"); 
        exit(-1);
    }
    printf("%s\n",msgp->text);

    return 0;
}
int process_query(int sockfd,msg_t *msgp)
{
    int ret;
    msgp->types = 'Q';
    while(1)
    {
        printf("input your word:");
        fgets(msgp->text,N,stdin);
        msgp->text[strlen(msgp->text) -1 ] = 0 ;
        if(strncmp(msgp->text,"#",1) == 0 ) break ;
        ret = write(sockfd,msgp,sizeof(msg_t));
        if(ret < 0)
        {
            perror("write"); 
            exit(-1);
        }
        memset(msgp,0,sizeof(msg_t)) ;
        ret = read(sockfd,msgp,sizeof(msg_t));
        if(ret < 0)
        {
            perror("write"); 
            exit(-1);
        }
        printf("%s\n",msgp->text);

    }
    return 0;
}
int process_history(int sockfd,msg_t *msgp)
{
    int ret;
    msgp->types = 'H';
    ret = write(sockfd,msgp,sizeof(msg_t));
    if(ret < 0)
    {
        perror("write"); 
        exit(-1);
    }
    memset(msgp,0,sizeof(msg_t)) ;
    while(1) 
    {
        ret = read(sockfd,msgp,sizeof(msg_t));
        if(ret < 0)
        {
            perror("write"); 
            exit(-1);
        }
        if(strncmp(msgp->text,"传输完成",sizeof("传输完成")) == 0)  break ; 
        printf("%s\n",msgp->text);
        
    }
    return 0;
}
int process_login(int sockfd,msg_t *msgp)
{
    int ret,num;
    msgp->types = 'L';
    printf("input your name:");
    fgets(msgp->name,N,stdin);
    msgp->name[strlen(msgp->name) -1 ] = 0 ;
    printf("input your passwd:");
    fgets(msgp->text,N,stdin);
    msgp->text[strlen(msgp->text) -1 ] = 0 ;
    ret = write(sockfd,msgp,sizeof(msg_t));
    if(ret < 0)
    {
        perror("write"); 
        exit(-1);
    }
    memset(msgp,0,sizeof(msg_t)) ;
    ret = read(sockfd,msgp,sizeof(msg_t));
    if(ret < 0)
    {
        perror("write"); 
        exit(-1);
    }
    printf("%s\n",msgp->text);
    if(strncmp(msgp->text,"登录成功",sizeof("登陆成功")) == 0 )
    {
        while(1)
        {
            printf("*************************************************\n");
            printf("*1:search word   2: history   3: quit************\n");
            printf("*************************************************\n");
            printf("please input your choice >:");
            scanf("%d",&num);
            scanf("%*[^\n]");scanf("%*c"); //回收残留在标准输入的字符 
            switch(num)
            {
            case 1:
                process_query(sockfd,msgp); 
                break ; 
            case 2:
                process_history(sockfd,msgp); 
                break ; 
            case 3:
                close(sockfd); 
                exit(0);
            default:
                break ;
            }

        }
        

    }

    return 0;
}

// ./a.out 192.168.1.57 8000
int main(int argc, const char *argv[])
{
    char buf[N] = {0};
    int sockfd,ret,newsockfd;
    int num;
    struct sockaddr_in server,client;
    msg_t msg;
    if(argc != 3)
    {
        printf("运行程序时带入ip 和 port\n");
        exit(-1);
    }
    socklen_t addrlen = sizeof(client);
    sockfd = socket(AF_INET,SOCK_STREAM,0);
    if(sockfd < 0)
    {
        perror("socket");
        exit(-1);
    }
    printf("sockfd=%d\n",sockfd);
    memset(&msg,0,sizeof(msg));
    memset(&server,0,sizeof(server));
    server.sin_family = AF_INET ;
    server.sin_port   = htons( atoi(argv[2]) );
    server.sin_addr.s_addr   = inet_addr(argv[1]); 
    ret = connect(sockfd,(struct sockaddr *)&server,sizeof(server)) ;
    if(ret < 0)
    {
        perror("connect");
        exit(-1);
    }

    while(1)
    {
        printf("*************************************************\n");
        printf("*1:register   2: login    3: quit****************\n");
        printf("*************************************************\n");
        printf("please input your choice >:");
        scanf("%d",&num);
        scanf("%*[^\n]");scanf("%*c"); //回收残留在标准输入的字符 
        switch(num)
        {
            case 1:
                process_register(sockfd,&msg); 
                break ; 
            case 2:
                process_login(sockfd,&msg); 
                break ; 
            case 3:
                close(sockfd); 
                exit(0);
            default:
                break ;
        }
        
        
    }




    printf(">:");
    fgets(buf,N,stdin);
    ret  = write(sockfd,buf,N) ;
    if(ret < 0)
    {
        perror("write");
        exit(-1);
    }
    ret = read(sockfd,buf,N);
    if(ret  < 0)
    {
        printf("read");
        exit(-1);
    }
    printf("%s\n",buf);
    close(sockfd);


    
    return 0;
}

运行时gcc server.c -o server -lsqlite3
./server 本机ip 端口号
gcc client.c -o client -lsqlite3
./client 本机ip 端口号
此外还需要个词典的文件 。自行解决。

良辰没有景
关注
  • 2
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
网络编程---TCP电子词典
Anywanna的博客
09-04 1163
创作本文目的:记录自己的学习历程
基于TCP的“简单在线词典”小型项目
m0_72454289的博客
07-22 1527
C语言小型项目，TCP网络编程
基于TCP的在线词典系统(分阶段实现)（阻塞io和多路io复用（select）实现）
CSDN_DU666666的博客
07-06 701
一共四个功能：注册登录查询单词查询历史记录单词和解释保存在文件中，单词和解释只占一行,一行最多300个字节，单词和解释之间至少有一个空格。
基于TCP的在线词典(包含全部源码)
weixin_45695713的博客
09-22 963
基于TCP的在线词典(包含全部源码），还包括将文件中的内容插入到数据库中，以及数据库大量插入数据时的优化，将原本15秒插入两万条记录压缩到1秒插入，效率有了很大的提升。
C语言实现在线词典-TCP通信的方式实现
qq_60331192的博客
12-29 1363
功能介绍：基于Linux操作系统、网络编程和数据库实现在线词典，客户端可以进行注册、登录、查询、查看历史记录和退出功能，服务端基于TCP通信，多线程实现并发访问客户端，并利用sqlite3数据库实现对用户信息的管理。这里数据库已经设计好了，创建了两个表，一个是user表，用来存放用户名和密码；一个是record表，用来存放查询过的的单词、查询时间和查询用户。4.历史：可以查询当前用户历史查找过的单词。1.注册：若用户名已经注册过，可重新注册。3.查询：输入要查的单词，#键结束查询。5.退出：退出在线词典。
基于TCP的在线词典客户端与服务器端
08-08
《基于TCP的在线词典客户端与服务器端》 在信息技术领域，网络通信是不可或缺的一部分，尤其是在开发客户端-服务器应用时。本项目“基于TCP的在线词典客户端与服务器端”便是一个很好的实例，展示了如何利用QT框架...
基于Qt的Tcp电子词典
02-22
此项目用Qt 5.15.2开发，用与练习Tcp协议，解压出来用MinGW编译一下，先运行服务器，只允许客户端；输入你电脑的ip地址 与 端口号（8888或有效端口） Win+R 输入cmd ipconfig 获取ip地址
基于TCP的在线电子词典的完整工程文件
10-18
在这个基于TCP的在线电子词典项目中，我们深入探讨了如何利用网络通信协议TCP（Transmission Control Protocol）构建一个高效、可靠的在线词汇查询系统。这个完整的工程文件包括了服务端和客户端的源代码，数据库...
基于C语言tcp协议实现在线英语词典
11-11
本项目“基于C语言TCP协议实现在线英语词典”旨在利用C语言的强大功能，结合TCP/IP协议，构建一个可以在线查询英语词汇的系统。这个系统能够通过网络连接，为用户提供实时的单词翻译和定义。 TCP（Transmission ...
利用tcp协议实现在线电子词典
09-06
利用tcp协议实现在线电子词典
TCP实现电子词典
08-15
TCP实现电子词典,有查词、历史记录功能
在线词典（QT） 基于tcp通信的客户端和服务器端源码
08-08
基于QT，包含客户端登陆注册模块，词典查找，历史信息记录查阅模块，服务器端处理信息并返回数据给客户端
基于TCP的QT电子词典
最新发布
07-24
开发平台：Ubuntu18.04，QT creator 项目内容：1.用Ubuntu编写服务器，用QT creator编写客户端，实现数据传输。...基于TCP，实现多客户端链接。 6.用QT creator绘制ui界面。 7.编写大量信号与槽，实现具体功能。
网络编程项目——在线电子词典
weixin_54239317的博客
08-27 1271
登录注册功能，不能重复登录，重复注册单词查询功能历史记录功能，存储单词，意思，以及查询时间基于TCP，支持多客户端连接采用数据库保存用户信息与历史记录将dict.txt的数据导入到数据库中保存。按下ctrl+c退出客户端后，注销该客户端的登录信息格式要求：main函数只跑逻辑，不允许跑功能代码功能代码封装成函数。...
基于TCP/Ip协议的网络编程在线词典
hjvft的博客
10-10 910
超详细，带注释，利用Tcp协议搭建服务器，客户端通信连接，构建在线词典。
四 基于TCP的服务器端/客户端
weixin_48433164的博客
12-15 4037
** 第四章 基于TCP的服务器端/客户端（1） ** 主要内容： 这里我们讨论通过套接字收发数据 1.TCP与UDP的区别数据传输方式不同 2.协议栈的层次关系：链路层->IP层->tcp/udp层->应用层。重点！ 3.基于TCP的服务器端和客户端详解 服务器端定义的两个套接字的用途 serv_sock和clnt_sock（一个当做门卫，一个用于连接） 4.详解connect函数（可以分配地址） 5.回声服务器端和回声客户端的实现 之前介绍套接字创建时我们选择的是 面向连接的套接字，
基于tcp电子词典思路
06-17
基于TCP的电子词典应用通常采用客户端-服务器架构，通过网络通信实现词典数据的查找和交互。以下是实现这种思路的关键点： 1. **服务器端**: - 数据存储：将电子词典的数据（词汇、释义等）存储在服务器上，可以选择数据库如MySQL或NoSQL数据库如MongoDB。 - 服务接口：设计一个支持TCP连接的服务端程序，监听特定的端口，如8080或3000。 - 响应处理：当接收到客户端的查询请求后，解析查询词，从数据库中查找匹配的条目，并打包成响应发送给客户端。 2. **客户端**: - 用户界面：提供一个用户友好的界面，用户可以输入查询词。 - 网络连接：使用TCP套接字建立与服务器的连接。 - 发送请求：当用户输入查询后，构造包含查询词的请求消息，并通过TCP连接发送给服务器。 - 接收响应：客户端接收服务器返回的词典条目，并在界面上显示结果。 3. **协议设计**: - 使用TCP保证数据的可靠传输，避免丢失或乱序。 - 可能会使用一种自定义的二进制格式或者XML/JSON等结构化格式来封装查询和响应数据。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值