电子词典服务器

已于 2022-12-04 11:59:25 修改
阅读量138 收藏
点赞数
分类专栏： 代码作业 文章标签： 数据库
于 2022-12-04 11:49:20 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_65394904/article/details/128170781
版权

func.c

#include "./func.h"

//printf("%s  %d\n",__FILE__,__LINE__);//查找错误

int deal_cli_msg(void* meg, sqlite3* db,int cfd)
{   
    if(0 == strcmp(((struct cli*)meg)->c.str,"reg"))
    {
        //查找用户是否已经被注册
        or_reg(meg, db, cfd);
    }
    else if(0 == strcmp(((struct cli*)meg)->c.str,"loin"))
    {
        //查找用户是否已经登录
        or_loin(meg, db, cfd);
    }
    else if(0 == strcmp(((struct cli*)meg)->c.str,"quit"))
    {
        printf("将数据库中用户状态改为下线\n");
        do_update(((struct cli*)meg)->db, "0", "user", ((struct cli*)meg)->c.a.user);
    }
    else if(0 == strcmp(((struct cli*)meg)->c.str,"danci"))
    {
        //单词查询
        danc(meg, db,cfd);
    }
    else if(0 == strcmp(((struct cli*)meg)->c.str,"gotoprint1"))
    {
        printf("选择了返回一级菜单的功能\n");
        do_update(((struct cli*)meg)->db, "0", "user", ((struct cli*)meg)->c.a.user);
    }
    else if(0 == strcmp(((struct cli*)meg)->c.str,"recordlook"))
    {
        printf("选择了查询用户历史记录的功能\n");
        recordlook(meg, db, cfd, "record");
    }

}

//注册和登录
int reguser(void* meg, sqlite3* db, int cfd, char* str)
{
    ssize_t res_rec;
    int num = 0;
    //接收用户名
    res_rec = msg_rec(cfd,meg);
	if(-1 == res_rec)
	{
	    return -1;
	}
    strcpy(((struct cli*)meg)->c.a.user,((struct cli*)meg)->massage);
    //接收密码
    res_rec = msg_rec(cfd,meg);
	if(-1 == res_rec)
	{
		return -1;
	}
    strcpy(((struct cli*)meg)->c.a.passd,((struct cli*)meg)->massage);

    num = sql_reg(meg, db, str);
    return num;
}

//获取时间函数
int time_fun(void* meg)
{
        time_t tim;
        time(&tim);
        struct tm* p = localtime(&tim);
        sprintf(((struct cli*)meg)->d.time,"%4d/%02d/%02d\t%02d:%02d",p->tm_year+1900,
                    p->tm_mon+1, p->tm_mday, p->tm_hour, p->tm_min);
    return 0;
}

//客户端退出后释放资源相关操作
int rel_sour(void* meg)
{
    do_update(((struct cli*)meg)->db, "0", "user", ((struct cli*)meg)->c.a.user);
    free((*(struct cli*)meg).massage);
    //free((*(struct cli*)meg).c.a.user);
	free((*(struct cli*)meg).c.a.passd);
	free((*(struct cli*)meg).c.a.online);
	free((*(struct cli*)meg).c.str);
}

//查找用户是否已经被注册
int or_reg(void* meg, sqlite3* db,int cfd)
{
    int num = 0;
    char buf[40] = "";
    printf("数据库中查找用户是否已经被注册\n");
    num = reguser(meg, db, cfd, "user");
    if( num == 0)
    {
        strcpy(buf, "user is exit!");
        msg_send(cfd, (void*)buf);
    }
    else if(num < 0)
    {
        if(0 == do_insert(db, "user", meg))
            strcpy(buf, "user reg success!");
        msg_send(cfd,(void*)buf);
    }
}

//查找用户是否已经登录
int or_loin(void* meg, sqlite3* db,int cfd)
{
    int num = 0;
    char buf[40] = "";
    printf("数据库中查找用户状态是否已被登录\n");
    num = reguser(meg, db, cfd, "loin");
    if( -2 == num)
    {
        strcpy(buf, "user is loin!");
        msg_send(cfd, (void*)buf);
    }
    else if(-3 == num)
    {
        strcpy(buf, "user or passd error!");
        msg_send(cfd, (void*)buf);
    }
    else if(0 == num)
    {
        printf("%d\n",((struct cli*)meg)->flag);
        do_update(db, "1", "user", ((struct cli*)meg)->c.a.user);
        
        strcpy(buf, "user loin success!");
        msg_send(cfd,(void*)buf);
        printf("%s登录成功\n", ((struct cli*)meg)->c.a.user);
    }
}

//单词查询
int danc(void* meg, sqlite3* db,int cfd)
{
    printf("选择了查询单词功能\n");
    msg_rec(cfd, meg);
    ((struct cli*)meg)->d.b.eng = (char*)malloc(60);
    ((struct cli*)meg)->d.b.chinese = (char*)malloc(60);
    ((struct cli*)meg)->d.time = (char*)malloc(60);
    strcpy(((struct cli*)meg)->d.b.eng,((struct cli*)meg)->massage);
    dancilook(meg, db, cfd, "danci");
    printf("单词查询完毕\n");
    free(((struct cli*)meg)->d.b.eng);
    free(((struct cli*)meg)->d.b.chinese);
    free(((struct cli*)meg)->d.time);
}

ser_main.c

#include <stdio.h>
#include "./sql.h"
#include "./tcp_ser.h"

//printf("%s  %d\n",__FILE__,__LINE__);//查找错误

int main(int argc, const char *argv[])
{
	//1.数据库初始化
	sqlite3* db = (sqlite3*)sql_init();
	printf("数据库初始化完毕\n");
	//2.服务器初始化
	int sfd = ser_init(); 
	printf("服务器初始化完毕\n");
	//2.等待客户端连接
	deal_connect(sfd, db);

	return 0;
}

sql.c

#include "./sql.h"

//printf("%s  %d\n",__FILE__,__LINE__);//查找错误

//初始化
void* do_open()
{
	sqlite3* db = NULL;
	char str[20] = "";
	//创建并打开数据库
	strcpy(str,"./my.db");//需要打开的数据库;
	if(sqlite3_open(str, &db) != SQLITE_OK)
	{
		fprintf(stderr, "sqlite3_open:%s\t%d", sqlite3_errmsg(db), __LINE__);
		return NULL;
	}
	printf("database open success!\n");
	
	return (void*)db;
}

//创建表
int do_create(sqlite3* db,char* str)
{

	char* sql = (char*)malloc(80);
	*sql = 0;
	char* errmsg = NULL;

	if(0 == strcmp(str,"user"))
	{
		sprintf(sql,"create table if not exists %s (user char primary key, passd char, stat char);", str);//创建用户表
	}
	else if(0 == strcmp(str,"danci"))
	{
		sprintf(sql,"create table if not exists %s (eng char, chinese char);",str);//创建单词表
	}
	else if(0 == strcmp(str,"record"))
	{
		sprintf(sql,"create table if not exists %s (user char, eng char, chinese char, time char);",str);//创建历史记录表
	}
	//printf("%s",sql);

	if(sqlite3_exec(db, sql, NULL, NULL, &errmsg))
	{
		fprintf(stderr, "sqlite3_exec:%s\t%d\n", errmsg, __LINE__);
		puts(sql);
		return -1;
	}
	printf("create %s table success!\n", str);
	free(sql);

	return 0;
}

//增
int do_insert(sqlite3* db, char* str, void* p)
{
	//插入表
	char* sql = (char*)malloc(200);
	char* errmsg = NULL;
	if(0 == strcmp(str,"user"))
	{
		sprintf(sql,"insert into %s ('user', 'passd', 'stat') values (\"%s\", \"%s\", '0');", str, 
									((struct cli*)p)->c.a.user, ((struct cli*)p)->c.a.passd);
	}
	else if(0 == strcmp(str,"danci"))
	{
		sprintf(sql,"insert into %s ('eng', 'chinese') values (\"%s\", \"%s\");", str, 
									((struct danciinfo*)p)->eng, ((struct danciinfo*)p)->chinese);
	}
	else if(0 == strcmp(str,"record"))
	{
		sprintf(sql,"insert into %s ('user', 'eng', 'chinese', 'time') values (\"%s\", \"%s\", \"%s\", \"%s\");",
									 str, ((struct cli*)p)->c.a.user, ((struct cli*)p)->d.b.eng, 
									 ((struct cli*)p)->d.b.chinese, ((struct cli*)p)->d.time);
	}
	//printf("%s\n",sql);

	if(sqlite3_exec(db, sql, NULL, NULL, &errmsg))
	{
		fprintf(stderr, "sqlite3_exec:%s\t%d\n", errmsg, __LINE__);
		fprintf(stderr,"%s\n",sql);
		return -1;
	}
	free(sql);

 	return 0;
}

//删
int do_delete(sqlite3* db, char* str, void* p)
{
	char* sql = (char*)malloc(60);
	sprintf(sql,"delete from %s where eng='%s';", str, ((struct danciinfo*)p)->eng);
	//printf("%s\n",sql);
	char* errmsg = NULL;

	if(sqlite3_exec(db, sql, NULL, NULL, &errmsg))
	{
		fprintf(stderr, "sqlite3_exec:%s\t%d", errmsg, __LINE__);
		return -1;
	}
	//printf("create table success!\n");
	free(sql);

	return 0;
}

//查询函数调用
int handler(void *arg, int column, char** column_text, char** column_name) 	//void* arg = &flag
{
	//列数
	//printf("column=%d __%d__\n", column, __LINE__);

	//column_name
	char online[1] = "0";
	char buf[40] = "";
	char* re = (char*)malloc(128);
	bzero(re,128);
	strcpy(((struct cli*)arg)->c.a.online,online);
	int i = 0;
	if(0 == (((struct cli*)arg)->flag))
	{
		for(i=0; i<column; i++)
		{
			printf("%s\t", column_name[i]);
		}
		printf("\n");
		(((struct cli*)arg)->flag) = 1;
	}

	//column_text
	for(i=0; i<column; i++)
	{
		//printf("i = %d  :%s\t", i, column_text[i]);

		if(0 == strcmp(((struct cli*)arg)->c.a.online, column_text[i]))
		{
			((struct cli*)arg)->num = 0;
		}
		if(0 == strcmp(((struct cli*)arg)->buf,"danci"))
		{
			((struct cli*)arg)->num++;
			msg_send(((struct cli*)arg)->cfd,column_text[i]);
			strcpy(((struct cli*)arg)->d.b.chinese ,column_text[i]);
			//printf("%s  %d\n",__FILE__,__LINE__);
			time_fun(arg);
			do_insert(((struct cli*)arg)->db, "record", arg);
		}
		if(0 == strcmp(((struct cli*)arg)->buf,"record"))
		{
			((struct cli*)arg)->num++;
			sprintf(re,"%s %s ", re, column_text[i]);
		}

	}
	if(0 == strcmp(((struct cli*)arg)->buf,"record"))
	{
		sprintf(re,"%s\n",re);
		msg_send(((struct cli*)arg)->cfd,re);
		printf("%s",re);
	}
	free(re);
	
	return 0;
}

//查
int do_select(sqlite3* db, char* p, char* str, void* meg)
{
	char sql[128] = "";
	char* errmsg = NULL;
	((struct cli*)meg)->flag = 0;
	((struct cli*)meg)->num = 1;
	if(0 == strcmp(str,"user"))
		sprintf(sql,"select \"%s\" from \"%s\" where user=\"%s\";", "user", str, p);
	else if (0 == strcmp(str,"loin"))
	{
		sprintf(sql,"select \"%s\" from \"%s\" where user=\"%s\" and passd = \"%s\";", "stat", "user", p, ((struct cli*)meg)->c.a.passd);
	}
	else if(0 == strcmp(str,"danci"))
	{
		sprintf(sql,"select \"%s\" from \"%s\" where eng=\"%s\";", "chinese", "danci", ((struct cli*)meg)->d.b.eng);
		strcpy(((struct cli*)meg)->buf, "danci");
		puts(sql);
	}
	else if(0 == strcmp(str,"record"))
	{
		sprintf(sql,"select * from \"%s\" where user=\"%s\";", "record", ((struct cli*)meg)->c.a.user);
		strcpy(((struct cli*)meg)->buf, "record");
		puts(sql);
	}
	//puts(sql);
	
	if(sqlite3_exec(db, sql, handler, meg, &errmsg) != SQLITE_OK)
	{
		fprintf(stderr, "line:%d sqlite3_exec:%s\n", __LINE__, errmsg);
		return -1;
	}
	printf("查询完毕\n");
	return 0;
}

//改
int do_update(sqlite3* db, char* p, char* str, char* username)
{
	char sql[128] = "";
	char* errmsg = NULL;

	sprintf(sql,"update \"%s\" set stat=\"%s\" where user=\"%s\";", str, p, username);
	if(sqlite3_exec(db, sql, NULL, NULL, &errmsg))
	{
		fprintf(stderr, "sqlite3_exec:%s\t%d", errmsg, __LINE__);
		return -1;
	}
	puts(sql);

}

//关闭
int do_close(sqlite3* db)
{
	//关闭数据库
	if(sqlite3_close(db) != SQLITE_OK)
	{
		fprintf(stderr, "sqlite3_close:%s\t%d", sqlite3_errmsg(db), __LINE__);
		return -1;
	}

}

//将单词插入到数据库中
int danci_insert(sqlite3* db)
{
	FILE* fp = fopen("./1.txt","r");
	if(NULL == fp)
	{
		perror("fopen");
		return -1;
	}
	char str[100];
	char* p;
	struct danciinfo danci;
	danci.chinese = (char*)malloc(50);
	danci.eng = (char*)malloc(50);
	while(1)
	{
		bzero(str,sizeof(str));
		bzero(danci.chinese,50);
		bzero(danci.eng,50);
		p=str;
		if(NULL == fgets(str,sizeof(str),fp))
		{
			break;
		}
		str[strlen(str)-1] = 0;

		while(((*p) != ' ') || (*(p+1) != ' '))
			p++;
		*p = 0;
		p = p+3;
		strcpy(danci.eng,str);
		strcpy(danci.chinese,p);
		do_insert(db, "danci", (void*)&danci);
		//puts(str);
		//puts(p);
	}
	printf("单词导入成功!!!!\n");
	free(danci.chinese);
	free(danci.eng);
}
//初始化数据库
void* sql_init()
{

	sqlite3* db = (sqlite3*)do_open();   //打开一个数据库
	//do_create(db,"user");      //创建一个用户信息表
	//do_create(db,"danci");     //创建一个单词表
	//do_create(db,"record");    //创建一个历史记录表
	//将单词插入到数据库中
	//danci_insert(db);

	return (void*)db;
}

//数据库中查找用户是否已经被注册  是否已经登录
int sql_reg(void* meg, sqlite3* db, char* str)
{
	char p[40] = "";
	if((0 == strcmp(str, "user"))||(0 == strcmp(str,"loin")))
		strcpy(p,((struct cli*)meg)->c.a.user);
	int num = do_select(db, p, str, meg);
	printf("数据库查找操作\n");
	if(0 == ((struct cli*)meg)->flag)
	{
		if(((struct cli*)meg)->num)
			return -3;
		else	
			return -3;
	}
	else if(((struct cli*)meg)->flag > 0)
	{
		if(((struct cli*)meg)->num)
		{
			if(0 == strcmp(str, "user"))
				return 0;
			else
				return -2;
		}
		else
			return 0;	
	}
}

//单词查询
int dancilook(void* meg, sqlite3* db, int cfd, char* p)
{
	do_select(db, "chinese", "danci", meg);
	//printf("%s  %d\n",__FILE__,__LINE__);
	if(((struct cli*)meg)->num > 1)
		msg_send(cfd,"123456");
	else if(1 == ((struct cli*)meg)->num)
		msg_send(cfd,"123456789");
}

//历史记录
int recordlook(void* meg, sqlite3* db, int cfd, char* p)
{
	do_select(db, "*", "record", meg);
	
	if(((struct cli*)meg)->num > 1)
		msg_send(cfd,"123456");
	else if(1 == ((struct cli*)meg)->num)
		msg_send(cfd,"123456789");
}

tcp_ser.c

#include "./tcp_ser.h"

//printf("%s  %d\n",__FILE__,__LINE__);//查找错误

//线程执行体
void* callback(void* p)
{
	//线程分离
	pthread_detach(pthread_self());
	struct cli meg1 = *(struct cli*)p;
	void* meg = (void*)&meg1;

	//资源申请
	sou_ask(meg);

	int cfd = ((struct cli*)meg)->cfd;
	//信息处理
	xin(meg, cfd);

	//do_update(((struct cli*)meg)->db, "0", "user", ((struct cli*)meg)->c.a.user);
	printf("cfd = %d  退出了\n", cfd);
	close(cfd);
	printf("vfd = %d关闭成功\n",cfd);
	rel_sour(meg);
	printf("资源释放成功\n");
	pthread_exit(NULL);

}

int ser_init()
{
	int sfd;
	struct sockaddr_in server_addr;

	//1.创建流式套接字
	sfd = socket(AF_INET, SOCK_STREAM, 0);
	if (sfd < 0)
	{
		ERROR("socket");
		return -1;
	}
	memset(&server_addr, 0, sizeof(struct sockaddr_in));
	
	//填充地址信息结构体
	server_addr.sin_family = AF_INET;
	server_addr.sin_port = htons(PORT);   //端口的网络字节序
	server_addr.sin_addr.s_addr = inet_addr(IP);  //IP的网络字节序
	
	//允许端口快速被重用
	int reuse = 1;
	if(setsockopt(sfd, SOL_SOCKET, SO_REUSEADDR, &reuse ,sizeof(reuse)) < 0)
	{
		ERROR("setsockopt");
		return -1;
	}

	//2.将地址信息绑定到套接字上
	if (bind(sfd, (struct sockaddr *) &server_addr,
				sizeof(struct sockaddr_in)) < 0)
	{
		ERROR("bind");
		return -1;
	}

	//3.将sfd设置为被动监听状态
	if (listen(sfd, 128) < 0)
	{
		ERROR("listen");
		return -1;
	}
	printf("服务器正在监听....\n");

	return sfd;
}


int deal_connect(int sfd, sqlite3* db)
{
	struct sockaddr_in server_addr,client_addr;
	socklen_t client_addr_size;
	int cfd;
	struct cli info;
	pthread_t tid;
	//创建线程用收发信息
	client_addr_size = sizeof(struct sockaddr_in);
	while(1)
	{
		//4.从队列头获取一个客户的信息
		cfd = accept(sfd, (struct sockaddr *) &client_addr,
				&client_addr_size);
		if (cfd < 0)
		{
			ERROR("accept");
			return -1;
		}
		printf("[%s:%d] cfd = %d 连接成功\n", \
				inet_ntoa(client_addr.sin_addr), \
				ntohs(client_addr.sin_port), cfd);

		//创建线程用于接待客户端
		info.cfd = cfd;
		info.client_addr = client_addr;
		info.db = db;
		
		if(pthread_create(&tid, NULL, callback,(void*)&info) < 0)
		{
			ERROR("pthread_create");
			return -1;
		}

	}	
}

int msg_send(int cfd,void* meg)
{
	char buf[MAX] = "";
	ssize_t res = 0;
	bzero(buf, sizeof(buf));
	strcpy(buf, (char*)meg);
	//6.发送来自客户端信息
	if((res = send(cfd, buf, sizeof(buf), 0)) < 0)
	{
		ERROR("send");
	}

	return res;
}

int msg_rec(int cfd,void* meg)
{
	struct sockaddr_in client_addr = ((struct cli*)meg)->client_addr;
	ssize_t res = 0;
	char buf[MAX] = "";
	//5.接收来自客户端信息
	res = recv(cfd,buf, sizeof(buf), 0);
	if(res < 0)
	{
		ERROR("recv");
		return -1;
	}
	if(0 == res)
	{
		do_update(((struct cli*)meg)->db, "0", "user", ((struct cli*)meg)->c.a.user);
		printf("客户端已关闭\n");
		
		return -1;
	}
	strcpy(((struct cli*)meg)->massage,buf);
	printf("[%s:%d]res = %ld  :%s\n",
			inet_ntoa(client_addr.sin_addr), 
			ntohs(client_addr.sin_port), res, (((struct cli*)meg)->massage));

	return res;
}

//信息处理
int xin(void* meg, int cfd)
{
	ssize_t res_rec,res_send;
	while(1)
	{
		//接收来自客户端的信息
		res_rec = msg_rec(cfd,meg);
		if(-1 == res_rec)
		{
			break;
		}
		strcpy(((struct cli*)meg)->c.str,((struct cli*)meg)->massage);
		//处理来自客户端的信息
		deal_cli_msg(meg, ((struct cli*)meg)->db,cfd);
		
	}
}

//资源申请
int sou_ask(void* meg)
{
	(*(struct cli*)meg).massage = (char*)malloc(40);
	(*(struct cli*)meg).c.a.user = (char*)malloc(40);
	(*(struct cli*)meg).c.a.passd = (char*)malloc(40);
	(*(struct cli*)meg).c.a.online = (char*)malloc(40);
	(*(struct cli*)meg).c.str = (char*)malloc(40);
}

Makefile

all:ser
ser: func.o ser_main.o sql.o tcp_ser.o
	gcc $^ -o ser -lsqlite3 -lpthread
%.o:%.c
	gcc -c $< -o $@
clean:
	rm *.o

func.h

#ifndef __FUN_H__
#define __FUN_H__

#include <stdio.h>
#include "./sql.h"
#include "./tcp_ser.h"
#include <time.h>

//处理消息
int deal_cli_msg(void* meg, sqlite3* db, int cfd);
//用户注册
int reguser(void* meg, sqlite3* db,int cfd, char* str);
//获取时间函数
int time_fun(void* meg);
//客户端退出后释放资源相关操作
int rel_sour(void* meg);
//查找用户是否已经被注册
int or_reg(void* meg, sqlite3* db,int cfd);
//查找用户是否已经登录
int or_loin(void* meg, sqlite3* db,int cfd);
//单词查询
int danc(void* meg, sqlite3* db,int cfd);


#endif

sql.h

#ifndef __SQL_H__
#define __SQL_H__

#include <stdio.h>
#include <sqlite3.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include "./tcp_ser.h"

struct userinfo
{
	char* user;
	char* passd;
	char* online;
};

struct danciinfo
{
	char* eng;
	char* chinese;
};

struct recordinfo
{
	char* user;
	struct danciinfo b;
	char* time;
};

struct msga
{
	struct  userinfo a;
	char* str;
};

struct cli
{
	int cfd;
	struct sockaddr_in client_addr;
	char *massage;
	sqlite3* db;
	struct msga c;
	int flag;
	struct recordinfo d;
	int num;
	char buf[4];
};

//初始化数据库
void* sql_init(void);
//打开某一个数据库
void* do_open(void);
//创建表
int do_create(sqlite3* db, char* str);
//增
int do_insert(sqlite3* db, char* str, void* p);
//删
int do_delete(sqlite3* db, char* str,void* p);
//查
int do_select(sqlite3* db, char* p, char* str, void* meg);
//改
int do_update(sqlite3* db, char* p, char* str, char* username);
//关闭
int do_close(sqlite3* db);
//将单词插入到数据库中
int danci_insert(sqlite3* db);
//数据库中查找用户是否已经被注册
int sql_reg(void* meg, sqlite3* db, char* str);
//数据库中查找用户状态是否已被登录
int sql_loin(char* p, sqlite3* db);
//将数据库中用户状态改为下线
int sql_quit(char* p, sqlite3* db);
//单词查询
int dancilook(void* meg, sqlite3* db, int cfd, char* p);
//历史记录查询
int recordlook(void* meg, sqlite3* db, int cfd, char* p);

#endif

tcp_ser.h

#ifndef __TCP_SER_H__
#define __TCP_SER_H__
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <string.h>
#include <signal.h>
#include <sys/wait.h>
#include <stdlib.h>
#include <pthread.h>
#include "./func.h"
#include "./sql.h"

#define IP "192.168.8.101"    //服务器 IP
#define PORT 8888            //端口号
#define MAX 128

#define ERROR(msg) do{\
	fprintf(stderr, "%s:__%d__", __FILE__,  __LINE__);\
	perror(msg);\
}while(0)



//线程执行体
void* callback(void* meg);
//服务端初始化
int ser_init();
//等待客户端连接
int deal_connect(int sfd, sqlite3* db);
//发送信息
int msg_send(int cfd, void* meg);
//接收信息
int msg_rec(int cfd, void* meg);
//处理客户端发送的信息
int deal_msg(void* meg);
//信息处理
int xin(void* meg, int cfd);
//资源申请
int sou_ask(void* meg);


#endif
遇事不决先吃饭！
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Redis学习笔记(REmote DIctionary Server远程字典服务器)
sias1991的专栏
11-26 2385
在分布式数据库中CAP原理CAP+BASE：C:Consistency:强一致性，A:Availability：可用性，P:Partition tolerance：分区容错性。 CAP理论的核心是：**一个分布式系统不可能同时很好的满足一致性，可用性和分区容错性这三个需求， 最多只能同时较好的满足两个。** 因此，根据 CAP 原理将 NoSQL 数据库分成了满足 CA 原则、满足 CP 原
网络编程-在线词典（服务器端）
qq_52795957的博客
09-09 439
基于linux系统，实现在线词典的功能。
在线英英词典服务器代码(Linux平台)
08-29
该代码是在Linux下编写的在线英英词典服务器端。采用TCP/IP协议，结合了sqlite3编写词典数据库。代码非常简单，易于初学者练习Linux网络编程。
在线词典
Clear Code
05-27 845
文章目录应用综合项目在线词典 简介客户端 Client框架代码服务器端 Server框架代码 https://blog.csdn.net/m0_37542524/article/details/85001614 应用综合项目 在线词典 简介 1，在线词典功能，分为客户端和服务器端 2，客户端有三个模块：注册、登录、查询（查询单词、查询历史记录） 3，服务器端要实现多并发服务器，这里采用多进程并发服...
Flask-MDict搭建在线Mdict词典服务
wbsu2004的博客
07-27 1323
Flask-MDict 是在线 Mdict 词典服务器。
电子词典
Satellitex的博客
07-15 165
流程图：
python电子词典
RareJie的博客
09-19 984
服务端 #!/usr/bin/env python3 from __future__ import unicode_literals # coding=utf-8 from socket import * import os import pymysql import time import sys import signal DICT_TEXT = "./dict.txt" HOST = ...
mysql电子词典_电子词典
weixin_39980903的博客
02-19 126
一、功能说明用户可以登录和注册* 登录凭借用户名和密码登录* 注册要求用户必须填写用户名,密码,其他内容自定* 用户名要求不能重复* 要求用户信息能够长期保存可以通过基本的图形界面print以提示客户端输入。* 程序分为服务端和客户端两部分* 客户端通过print打印简单界面输入命令发起请求* 服务端主要负责逻辑数据处理* 启动服务端后应该能满足多个客户端同时操作客户端启动后即进入一级界面,包含如...
网络电子词典
qq_52049228的博客
08-24 2059
1. 登录注册功能，不能重复登录，重复注册2. 单词查询功能3. 历史记录功能，存储单词，意思，以及查询时间4. 基于TCP，支持多客户端连接5. 采用数据库保存用户信息与历史记录格式要求： 1. main函数只跑逻辑，不允许跑功能代码 2. 功能代码封装成函数。
python实现电子词典
12-20
Python 实现电子词典是...总的来说，这个 Python 实现的电子词典结合了网络编程、数据库操作、多进程处理以及基本的文本和时间处理，提供了一个完整的客户端-服务器架构，允许用户通过网络进行单词查询并记录查询历史。
嵌入式课程设计-基于Linux服务器与客户端的多功能电子词典设计
03-09
在本嵌入式课程设计项目中，我们关注的是构建一个基于Linux环境的服务器与客户端系统，该系统能够实现多功能电子词典服务。这个设计的核心在于客户端通过网络与服务器交互，以便用户可以方便地查询单词，扩展了传统...
android电子词典
04-25
综上所述，构建一个Android电子词典涉及服务器端开发、客户端UI设计、数据存储与网络通信等多个环节，需要综合运用多种Android开发技术和工具。通过对“Uy_dic_Server”和“BikKan_1”的分析，我们可以推测源码中...
Python_电子词典
12-22
《Python电子词典系统详解》 Python电子词典是一个基于Python编程语言开发的应用程序，它提供了用户注册、登录以及查询单词、查看查询历史记录、清除历史记录等功能。系统的数据库采用MySQL或其他关系型数据库，...
安卓电子词典
05-28
【安卓电子词典】是一款专为学生设计的移动学习应用，集成了丰富的词汇资源和实用功能，旨在提高用户的英语学习效率。这款应用的核心特点是具备删除、增加、查询以及语音识别等交互方式，同时支持本地查询和在线查询...
在线词典服务器流程图,流程图及数据字典.doc
weixin_39724009的博客
07-30 320
流程图及数据字典业务流程图数据流程图数据字典(1) 数据流描述数据流编号： D01数据流名称：图书采编信息简述：图书采编信息数据流来源：图书购买后，由图书馆采编人员编码整理后，输入计算机。数据流去向：采编管理模块。图书采编信息将采编数据存入数据库(图书表)数据项组成： BookID (图书编码)＋ BookType (图书类别)＋ BookName (书名)＋ Auth (作者)＋ Publish...
在线词典（服务器，客服端，Makefile）
weixin_48430195的博客
09-19 317
server： /*================================================================ * 文件名称：在线词典服务器v1.0.c 创 建 者：xiaowang 创建日期：2020年04月28日 描 述： ================================================================*/ #include <stdio.h> #include <stdlib.h>
set user & password for database 设置数据库 用户和密码
最新发布
DavidsonGong的博客
07-12 132
USE sbms;
7.10飞书一面面经
东篱君的博客
07-10 1157
B+树的⾮叶⼦节点不存放实际的记录数据，仅存放索引，所以数据量相同的情况下，相⽐存储即存索引⼜存记录的 B 树，B+树的⾮叶⼦节点可以存放更多的索引，因此 B+ 树可以⽐ B 树更「矮胖」，查询底层节点的磁盘 I/O次数会更少。主从复制：单节点Redis的并发能力是有上限的，要进一步提高Redis的并发能力，可以搭建主从集群，实现读写分离。B+ 树有⼤量的冗余节点（所有⾮叶⼦节点都是冗余索引），这些冗余索引让 B+ 树在插⼊、删除的效率都更⾼，⽐如删除根节点的时候，不会像 B 树那样会发⽣复杂的树的变化；
小程序设计-电子词典.pptx
11-13
"这是一个关于小程序设计的教程，特别针对电子词典应用的开发。内容涵盖了从项目创建、视图设计、小程序网络基础到逻辑实现的全过程。" 在设计一个小程序，尤其是像电子词典这样的应用时，首先要进行的是项目创建。...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值