英译词典

在线英译词典，功能实现描述
1、用户注册和登录验证
2、单词在线翻译
3、历史记录查询
sqlite编程实现
/* client */
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<unistd.h>
#include<sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <arpa/inet.h>

#define M 128
#define N 256

#define OK 0
#define ERROR -1
#define SUCCESS 1


typedef struct {
    int type;
    char name[M];
    char data[N];
}MSG;

/* 注册 */
int do_register(int sockfd) 
{
	int ret;
	MSG msg;
	memset(&msg, 0, sizeof(MSG));
	msg.type = 1;
    printf("please input username :\n");
	scanf("%s", msg.name);
	printf("name: %s\n", msg.name);
    printf("please input passwd :\n");
	scanf("%s", msg.data);
	printf("name: %s\n", msg.data);

	ret = write(sockfd, &msg, sizeof(MSG));
	if (-1 == ret) 
    {
		perror("write");
		return ERROR;
	}
    memset(&msg, 0, sizeof(MSG));
	ret = read(sockfd, &msg, sizeof(MSG));
	if (-1 == ret) 
    {
		perror("read");
		return ERROR;
	}
	if (!(strcmp(msg.data, "ok")))
    {
        printf("success register !\n");
    }
    else
    {
        printf("register failed, user name already exists !\n");
    }
	return OK;
}

/* 登陆 */
int do_login(int sockfd)
{
	int ret; 
	MSG msg; 
	msg.type = 2;
    printf("please input username and passwd :\n");
	scanf("%s%s", msg.name, msg.data);
    
    ret = write(sockfd, &msg, sizeof(MSG));
    if (-1 == ret)
    {
        perror("write");
        return ERROR;
    }
    memset(&msg, 0, sizeof(MSG));
    ret = read(sockfd, &msg, sizeof(MSG));
	if (-1 == ret) 
    {
		perror("read");
		return ERROR;
	}
	if (!(strcmp(msg.data,"ok")))
    {
        printf("success login !\n");
        return SUCCESS;
    }
    else
    {
        printf("username or passwd error !\n");
    }
    return OK;
}

/* 退出 */
int do_quit(int sockfd)
{
    close(sockfd);
    printf("success quit !\n");
    exit(0);
}

/* 查询 */
int do_query(int sockfd, MSG *msg)
{
    int ret;
    msg->type = 3;
    printf("please input the word you want to query:\n");
    scanf("%s", msg->data);
    ret = write(sockfd, msg, sizeof(MSG));
    if (-1 == ret)
    {
        perror("write");
        return ERROR;
    }
    memset(msg, 0, sizeof(msg));
    ret = read(sockfd, msg, sizeof(MSG));
    if (-1 ==ret)
    {
        perror("read");
        return ERROR;
    }
    printf("%s\n",msg->data); /* 解释输出 */
    return OK;
}

/* 历史记录 */
int do_history(int sockfd, MSG *msg)
{
    int ret;
    msg->type = 4;
    ret = write(sockfd, msg, sizeof(MSG)); 
    if (-1 == ret)
    {
        perror("write");
        return ERROR;
    }
    memset(msg, 0, sizeof(MSG));
    while (1)
    {
        ret = read(sockfd, msg, sizeof(MSG));
        if (-1 == ret)
        {
            perror("read");
            return ERROR;
        }
        if ('\0' == msg->data[0])
        {
            break;
        }
        printf("%s\n",msg->data);
    }
    return OK;
}

int main()
{
	int ret;
    int sockfd;
    char buf[N];
	MSG msg;
	struct sockaddr_in srvaddr;
	sockfd = socket(AF_INET, SOCK_STREAM, 0);
	if (-1 == sockfd) 
    {
		perror("client->socket");
		return ERROR;
	}
	printf("create sockfd = %d success !\n", sockfd);
	memset(&srvaddr, 0, sizeof(struct sockaddr));
	srvaddr.sin_family = AF_INET;
	srvaddr.sin_port = htons(9998);
    srvaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
	ret = connect(sockfd, (const struct sockaddr *)&srvaddr, sizeof(struct sockaddr));
	if(-1 == ret) 
    {
		perror("client->connect");
		return ERROR;
	}
	printf("connect success !\n");

	int n;
    while(1) 
    {
        printf("*****************************************************************************\n");
        printf("*  please choose     1. register       2. login      3. quit                *\n");
        printf("*****************************************************************************\n");
        printf("please choose：\n");
        if (((scanf("%d",&n)) == 1) && ((0 < n) && (n < 4)))
        {
            switch (n)
            {
                case 1:
                    do_register(sockfd);
                    break;
                case 2:
                    if (SUCCESS == (ret = do_login(sockfd)))
                    {
                        goto next;
                    }
                    else                
                    {
                        continue;
                    }
                case 3:
                    do_quit(sockfd);
                    break;
            }   
        }
        else
        {
            printf("input error!\n");
            return ERROR;
        }

    }
next:
    while (1)
    { 
        printf("*****************************************************************************\n");
        printf("* please choose:   1. query     2. history record      3. quit              *\n");
        printf("*****************************************************************************\n");
        printf("please choose:\n");
        if ((1 == (scanf("%d",&n))) && ((1 <= n) && (n <= 3)))
        {
            switch (n)
            {
                case 1:
                    do_query(sockfd, &msg);
                    break;
                case 2:
                    do_history(sockfd, &msg);
                    break;
                case 3:
                    do_quit(sockfd);
                    break;
            } 
        } 
        else
        {
            printf("input error!\n");
            return ERROR;
        }
    }
	return OK;
}

/* server */
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<unistd.h>
#include<sys/types.h>
#include<arpa/inet.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<netinet/ip.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<dirent.h>
#include<sqlite3.h>
#include<sys/epoll.h>
#include<time.h>

#define MAX 300
#define N 256
#define M 128
#define LINE 64

#define OK 0
#define ERROR -1
#define SUCCESS 1
#define FAIL 0


typedef struct {
    int type;
    char name[M];
    char data[N];
}MSG;

MSG msg;

sqlite3 *db;

char *errmsg;
char sql[M];
char username[LINE];

/* 注册 */
int do_register(int connfd, MSG *msg, sqlite3 *db)
{
	int ret;
    sprintf(sql, "insert into  userinfo values('%s', '%s')", msg->name,msg->data);

    ret = sqlite3_exec(db, sql, NULL, NULL, &errmsg);
    if (ret != SQLITE_OK) 
    {
        strcpy(msg->data, errmsg); /* 失败返回错误信息 */
    }
    else
    {
	    strcpy(msg->data, "ok"); /* 成功返回OK */
    }

    ret = write(connfd, msg, sizeof(MSG));
    if (-1 == ret)
    {
        perror("write");
        return ERROR;
    }
    return OK;
}
/* 登陆 */
int do_login(int connfd, MSG *msg, sqlite3 *db)
{
    int ret;
    char **result;
    int row;
    int column;

    /* 比较用户名和密码 */
    sprintf(sql, "select * from userinfo where name = '%s' and passwd = '%s'" ,msg->name, msg->data);

    ret = sqlite3_get_table(db, sql, &result, &row, &column, &errmsg);
    if (SQLITE_OK != ret) 
    {
       strcpy(msg->data,errmsg);
    }
    if (0 == row) /* 失败的时候 */
    {
        strcpy(msg->data, "fail");
    }
    else /* 成功的时候 */
    {
        strcpy(msg->data,"ok"); 
        memset(username, 0, sizeof(username));
        strcpy(username, msg->name);
    }
	ret = write(connfd, msg, sizeof(MSG));
	if (-1 == ret) 
    {
		perror("write");
		return ERROR;
	}

    return OK;
}

/* 历史时间 */
char* do_historytime(char *buf)
{  
    time_t timep;
    struct tm *p;
    time(&timep);
    p = localtime(&timep);
    sprintf(buf,"%d-%d-%d  %d:%d:%d",(1900+p->tm_year),(1+p->tm_mon),p->tm_mday,p->tm_hour,p->tm_min,p->tm_sec);
    
    return buf;
}

/* 查询 */
int do_search(int connfd, MSG *msg)
{
    int ret; 
    FILE *fp1;
    int i;
    int len = 0;
    char buf[MAX];
    char *p;
    char *q;
    char p1[M];
    char *q1;

    if (NULL == (fp1 = fopen("dict.txt", "r")))
    {
        strcpy(msg->data, "dict on server can't be opened :");
        ret = write(connfd, msg, sizeof(MSG));
        if (-1 == ret)
        {
            perror("write");
            return ERROR;
        }
    }
    while (NULL != (fgets(buf, MAX, fp1)))    
    {
        q1 = buf;
        memset(p1, 0, sizeof(p1));
        i = 0;
        /* 找出要查询的单词 */
        while (*(q1) != ' ')
        {
            p1[i++] = *(q1++);
        }
        if (0 == strcmp(msg->data, p1))
        {
            p = buf + strlen(msg->data);
            /* 去掉这一行前面的单词和空格 */
            while(0 == strncmp(p, " ", 1)) 
            {
                p++;   
            }
            q = p;
            /* 去掉解释后面多余的空格 */
            while (*q != '\n')
            {
                q++;
                len++;  /* 解释部分的长度 */
            }
            memset(msg, 0, sizeof(MSG));
            strncpy(msg->data, p, len);  /* 解释的部分 */ 
            ret = write(connfd, msg, sizeof(MSG));
            if (-1 == ret)
            {
                perror("write");
                return ERROR;
            }
            fclose(fp1);
            return SUCCESS;/* 查找成功 */
        }
    }
    fclose(fp1);
    return FAIL;    /* 查找失败 */
}
/* 查询 */
int do_query(int connfd, MSG *msg, sqlite3 *db)
{
    int ret;
    int found = 0;
    char time[M];
    char word[M];
    strcpy(word, msg->data);
    memset(time, 0, M);

    found = do_search(connfd, msg);
    if (SUCCESS == found)
    {
        sprintf(sql, "insert into  history values('%s', '%s', '%s')", username,do_historytime(time), word);
        ret = sqlite3_exec(db, sql, NULL, NULL, &errmsg);
        if (SQLITE_OK != ret) 
        {
            strcpy(msg->data, errmsg); /* 失败返回错误信息 */
            ret = write(connfd, msg, sizeof(MSG));
            if (-1 == ret)
            {
                perror("write");
                return ERROR;
            }
        }
    }
    else
    {
        strcpy(msg->data, "no foud");
        ret = write(connfd, msg, sizeof(MSG));
        if (-1 == ret)
        {
            perror("write");
            return ERROR;
        }
    }
    return OK;

}
/* 回调函数 */
int callback(void *para, int f_num, char **f_value, char *f_name[])

{
    int connfd;
    int ret;
    MSG msg;
    connfd = *(int *)para;
    sprintf(msg.data, "%s : %s", f_value[1], f_value[2]);

    ret = write(connfd, &msg, sizeof(msg));
    if (-1 == ret)
    {
        perror("write");
        return ERROR;
    }
    return OK;
}
int do_history(int connfd, MSG *msg, sqlite3 *db)  //查找当前用户的历史记录
{
    int ret;
    char sqlstr[128], *errmsg;
    sprintf(sql, "select * from history where name = '%s'", username); 

    ret = sqlite3_exec(db, sql, callback, (void *)&connfd, &errmsg);
    if (SQLITE_OK != ret)
    {
        strcpy(msg->data, errmsg);
        ret = write(connfd, msg, sizeof(MSG));
        if (-1 == ret)        
        {
            perror("write");
            return ERROR;
        }
    }
    msg->data[0] = '\0';               //表示回调结束
    ret = write(connfd, msg, sizeof(MSG));
    if (-1 == ret)
    {
        perror("write");
        return ERROR;
    }
    return OK;
}
int client(int connfd)
{
    int ret;
    MSG msg;
    memset(&msg, 0, sizeof(MSG));
    ret = read(connfd, &msg, sizeof(MSG));
	if (-1 == ret) 
    {
        perror("server->read");
        return ERROR;
    } 
    else if (0 == ret) 
    {
        return ERROR;
    } 
	switch(msg.type) 
    {
	    case 1:
	        do_register(connfd, &msg, db);
	        break;
        case 2:
            do_login(connfd, &msg, db);
            break;
        case 3:
            do_query(connfd, &msg, db);
            break;
        case 4:
            do_history(connfd, &msg, db);
            break;
        default:
            break;	
	}

}
int server_init(char *ip, char *port)
{
    int ret;
    int listenfd;
    struct sockaddr_in srvaddr;

    listenfd = socket(AF_INET, SOCK_STREAM, 0);
    if (-1 == listenfd) 
    {
        perror("server->socket");
        return ERROR;
    }
    printf("create listenfd = %d success !!\n", listenfd);

    int opt = 1;
    setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));

    memset(&srvaddr, 0, sizeof(struct sockaddr));
    srvaddr.sin_family = AF_INET;
    srvaddr.sin_port = htons(atoi(port));
    srvaddr.sin_addr.s_addr = inet_addr(ip);

    ret = bind(listenfd, (const struct sockaddr *)&srvaddr, sizeof(struct sockaddr));
    if(-1 == ret) 
    {
        perror("server->bind");
        return ERROR;
    }
    printf("bind success !\n");

    ret = listen(listenfd, 10);
    if (-1 == ret) 
    {
        perror("server->listen");
        return ERROR;
    }
    printf("listen success !\n");
    return listenfd;
}

int server_wait_connect(int listenfd, struct sockaddr *addr, socklen_t *addrlen)
{
    int connfd;
    connfd = accept(listenfd, addr, addrlen);
    if (-1 == connfd) 
    {
        perror("server->accept");
        return ERROR;
    }
    printf("connect connfd = %d success \n", connfd);

    return connfd;
}

int main()
{
	int ret;
	int listenfd;
	int connfd;
	char buf[256];
	struct sockaddr_in cltaddr;
	socklen_t addrlen;

	listenfd = server_init("127.0.0.1", "9998");
	if (-1 == listenfd)
    {
		exit(EXIT_FAILURE);
    }
    ret = sqlite3_open("my.db", &db);
    if (SQLITE_OK != ret) 
    {
        fprintf(stderr, "open : %s\n", sqlite3_errmsg(db));
        return ERROR;
    }
#if 0
    sprintf(sql, "create table userinfo(name char primary key, passwd char)");/* 用户名和密码 */
    ret = sqlite3_exec(db, sql, NULL, NULL, &errmsg);
    if (SQLITE_OK != ret) 
    {
        fprintf(stderr, "create fail : %s\n", errmsg);
        return ERROR;
    }
#endif

#if 0
    sprintf(sql, "create table history(name char, time char, word char)");/* 用户名、时间、单词 */
    ret = sqlite3_exec(db, sql, NULL, NULL, &errmsg);
    if (SQLITE_OK != ret) 
    {
        fprintf(stderr, "create fail : %s\n", errmsg);
        return ERROR;
    }
#endif
    int epfd;
    int i;
    int fd;

    epfd = epoll_create(1024);
    if (-1 == epfd) 
    {
        perror("epoll_create");
        return ERROR;
    }
    printf("epfd = %d\n", epfd);

    struct epoll_event event;
    event.events = EPOLLIN;
    event.data.fd = listenfd;

    ret = epoll_ctl(epfd, EPOLL_CTL_ADD, listenfd, &event);
    if (-1 == ret) 
    {
        perror("epoll_ctl->EPOLL_CTL_ADD");
        return ERROR;
    }

    struct epoll_event events[1024];
    while(1) 
    {
        ret = epoll_wait(epfd, events, 1024, 5000);
        if (-1 == ret) 
        {
            perror("poll");
            return ERROR;
        } 
        else if (0 == ret) 
        {
            printf("timeout\n");
            continue;
        }
        for (i = 0; i < ret; i++) 
        {
            if (EPOLLIN == events[i].events) 
            {
                fd = events[i].data.fd;
                if (fd == listenfd) 
                {
                    memset(&cltaddr, 0, sizeof(cltaddr));
                    addrlen = sizeof(socklen_t);
                    connfd = accept(listenfd, (struct sockaddr *)&cltaddr, &addrlen);
                    if (-1 == connfd) 
                    {
                        perror("accept");
                        return ERROR;
                    }
                    printf("connfd = %d\n", connfd);
                    event.events = EPOLLIN;
                    event.data.fd = connfd;
                    ret = epoll_ctl(epfd, EPOLL_CTL_ADD, connfd, &event);
                    if (-1 == ret) 
                    {
                        perror("epoll_ctl->EPOLL_CTL_ADD");
                        return ERROR;
                    }
                } 
                else 
                {
                    ret = client(fd); 
                    if (-1 == ret) 
                    {
                        ret = epoll_ctl(epfd, EPOLL_CTL_DEL, fd, &event);
                        if (-1 == ret) 
                        {
                            perror("epoll_ctl->EPOLL_CTL_DEL");
                            return ERROR;
                        }
                        close(fd);
                    }
                }
            }
        }
    }
    close(epfd);
    close(listenfd);
    return OK;
}

如果有什么不足的地方，请大家多多指点。