C语言网络聊天室程序

共分为四部分，服务器两个，客户端两个

1.my_sever.c

//******************************************************//
//鐢熸垚鏃ユ湡 2017骞?2鏈?4鏃?  浣滆€?闄堝浆   //
//璇ユ枃浠朵负鑱婂ぉ瀹ゆ湇鍔″櫒涓荤▼搴忥紝涓昏杩涜濂楁帴瀛楃殑寤虹珛锛岀粦瀹氾紝浠ュ強瀵瑰鎴风鐨勭洃鍚粠鑰屽疄鐜板悇绉嶅姛鑳?/

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<pthread.h>
#include<unistd.h>
#include<sys/time.h>
#include<sys/select.h>
#include"my_chat.h"
#include<sqlite3.h>

#define PORT 8888

int main()
{
    int sockfd, ret, i = 0, j, length, k, location, num = 0, n;
    struct sockaddr_in server_addr;
    struct sockaddr_in client_addr;
    struct info Recvbuf;
    fd_set ReadFd, TmpFd;
    int MaxFd;
    int fd[100];
    sqlite3* pdb;
    Linklist list;
    ret = ListInit(&list);
    if (ERROR == ret)
    {
        printf("Init failed!\n");
    }
    sockfd = socket(PF_INET, SOCK_STREAM, 0); //寤虹珛Socket
    if (-1 == sockfd)
    {
        perror("socket");
        exit(1);
    }
    memset(&server_addr, 0, sizeof(struct sockaddr_in));
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = PORT;
    server_addr.sin_addr.s_addr = inet_addr("192.168.159.128");
    int opt = 1;
    setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));

    ret = bind(sockfd, (struct sockaddr*)&server_addr, sizeof(struct sockaddr_in));//缁戝畾
    if (-1 == ret)
    {
        perror("bind");
        exit(1);
    }

    ret = listen(sockfd, 10);     //鐩戝惉
    if (-1 == ret)
    {
        perror("listen");
        exit(1);
    }

    ret = sqlite3_open("alluser.db", &pdb);     //鎵撳紑瀛樻斁鎵€浠ヨ亰澶╄褰曠殑鏁版嵁搴?    if (SQLITE_OK != ret)
    {
        perror("sqlite3_open");
        exit(1);
    }    

    FD_ZERO(&ReadFd);
    FD_ZERO(&TmpFd);
    FD_SET(sockfd, &ReadFd);
    MaxFd = sockfd;

    while(1)
    {
        TmpFd = ReadFd;
        ret = select(MaxFd + 1, &TmpFd, NULL, NULL, NULL);
        if (-1 == ret)
        {
            perror("select");
            exit(1);
        }

        if (FD_ISSET(sockfd, &TmpFd))
        {
            length = sizeof(client_addr);
            fd[i] = accept(sockfd, (struct sockaddr*)&client_addr, &length);
            if (-1 == fd[i])
            {
                perror("accept");
                exit(1);
            }
            printf("Accept:%d Port:%d\n", fd[i], client_addr.sin_port);
            FD_SET(fd[i], &ReadFd);
            for (k = 0; k <= i; k++)
            {
                if (fd[k] > MaxFd)
                {
                    MaxFd = fd[k];
                }
            }
    
            i++;
        }

        else
        {
            for (j = 0; j < i; j++)
            {
                if (FD_ISSET(fd[j], &TmpFd))
                {
                    memset(&Recvbuf, 0, sizeof(Recvbuf));
                    ret = recv(fd[j], &Recvbuf, sizeof(Recvbuf), 0);//鎺ユ敹瀹㈡埛绔彂閫佺殑淇℃伅
                    if (-1 == ret)
                    {
                        perror("recv");
                        exit(1);
                    }

                    if (Recvbuf.idlist == 1)
                    {
                        /*鍑芥暟鍚嶏細search  鍔熻兘锛氬垽鏂甯愬彿鏄惁宸茬粡鐧诲綍 鍙傛暟锛氬湪绾縤d鐨勪俊鎭摼琛紝
                        瀹㈡埛绔殑fd锛屽瓨鏀炬帴鏀朵俊鎭殑缁撴瀯浣?/
                        ret = search(list, Recvbuf.id, fd[j]);
                        if (ret == ERROR)
                        {
                            printf("search failed!\n"); 
                        }

                    }

                
                    else if (Recvbuf.namelist == 1)  //灏嗙綉鍚嶏紝fd鍜宨d甯愬彿瀛樺叆閾捐〃
                    {
                        ret = ListInsert(list, 1, fd[j], Recvbuf);
                        if (ret == ERROR)
                        {
                            printf("Insert failed!\n");
                        }
                        ret = send(fd[j], &Recvbuf, sizeof(Recvbuf), 0);
                        if (-1 == ret)
                        {
                            perror("sendname");
                            exit(1);
                        }
                        break;
                    }

                    else if (Recvbuf.look_online == 1)
                    {
                        /*鍑芥暟鍚嶏細lookonline 鍔熻兘锛氭煡鐪嬪湪绾垮ソ鍙嬩俊鎭紝骞朵紶閫佸洖瀹㈡埛绔?                        鍙傛暟锛氫俊鎭摼琛紝瀹㈡埛绔痜d锛岀粨鏋勪綋*/
                        ret = lookonline(list, fd[j], Recvbuf);
                        if (ret == ERROR)
                        {
                            printf("look failed!\n");
                        }
                        break;
                    }
                    

                    else if (Recvbuf.chat_personal == 1)
                    {
                        /*鍑芥暟鍚嶏細chatpersonal 鍔熻兘瀹炵幇绉佽亰鍔熻兘锛屽嵆淇℃伅鐨勮浆鍙?                        鍙傛暟锛氬鎴风fd锛岀粨鏋勪綋锛岃亰澶╄褰曟暟鎹簱pdb锛屼俊鎭摼琛?/
                        ret = chatpersonal(fd[j], Recvbuf, list, pdb);
                        if (ret == ERROR)
                        {
                            printf("chat personal failed!\n");
                        }
                        break;
                    }

                    else if (Recvbuf.chat_all == 1)
                    {
                        /*鍑芥暟鍚嶏細chatall 鍔熻兘锛氬疄鐜扮兢鍙戝姛鑳斤紝鍗冲皢淇℃伅杞彂缁欐墍浠ュ湪绾跨敤鎴?                        鍙傛暟锛氬鎴风fd锛岀粨鏋勪綋锛岃亰澶╄褰曟暟鎹簱pdb锛屼俊鎭摼琛?/
                        ret = chatall(fd[j], Recvbuf, list, pdb);
                        if (ret == ERROR)
                        {
                            printf("chat all people failed!\n");
                        }
                        break;
                    }

                    else if (Recvbuf.shutup == 1)
                    {
                        /*鍑芥暟鍚嶏細shutup 鍔熻兘锛氱瑷€ 鍙傛暟锛氬鎴风fd锛屼俊鎭摼琛紝缁撴瀯浣?/
                        ret = shutup(fd[j], Recvbuf, list);
                        if (ret == ERROR)
                        {
                            printf("Shutup failed!\n");
                        }
                        break;
                    }

                    else if (Recvbuf.speakout == 1)
                    {
                        /*鍑芥暟鍚嶏細shutup 鍔熻兘锛氱瑷€ 鍙傛暟锛氬鎴风fd锛屼俊鎭摼琛紝缁撴瀯浣?/
                        ret = speakout(fd[j], Recvbuf, list);
                        if (ret == ERROR)
                        {
                            printf("Speakout failed!\n");
                        }
                        break;
                    }

                    else if (Recvbuf.kickout == 1)
                    {
                        /*鍑芥暟鍚嶏細kickout 鍔熻兘锛氬皢鏌愮敤鎴疯涪鍑鸿亰澶╁锛岀粨鏉熷叾杩涚▼*/
                        ret = kickout(fd[j], Recvbuf, list);
                        if (ret == ERROR)
                        {
                            printf("Kickout failed!\n");
                            break;
                        }
                        else
                        {
                            close(ret);
                            FD_CLR(ret, &ReadFd);
                            location = Location(list, ret); //瀹氫綅璇ョ敤鎴凤紝纭畾鍏舵墍鍦ㄤ俊鎭摼琛ㄧ殑浣嶇疆
                            ret = ListDelete(list, location);//鍒犻櫎璇ョ敤鎴锋墍鍦ㄩ摼琛ㄤ俊鎭?                            if (ERROR == ret)
                            {
                                printf("Delete failed!\n");
                                break;
                            }
                            MaxFd = 5;     //閲嶆柊纭畾姝ゆ椂鐨凪axFd鐨勫€硷紝纭繚鏄渶澶х殑fd鐨勫€?                            for (k = 0; k < i; k++)
                            {
                                /*if (fd[k] == ret)
                                {
                                    continue;
                                }*/
                                if (fd[k] > MaxFd)
                                {
                                    MaxFd = fd[k];
                                }
                            }
                        }
                        break;
                    }
                        
                    else if (Recvbuf.esc == 1)
                    {
                        //澶勭悊閫€鍑洪€夐」浠ュ強ctrl c淇″彿锛?鍙戜俊鍙风粰瀹㈡埛绔紝浣垮叾鍏抽棴fd
                        memset(&Recvbuf, 0, sizeof(Recvbuf));
                        Recvbuf.esc = 1;
                        ret = send(fd[j], &Recvbuf, sizeof(Recvbuf), 0);
                        if (-1 == ret)
                        {
                            perror("send1");
                            exit(1);
                        }

                        close(fd[j]);
                        FD_CLR(fd[j], &ReadFd);
                        location = Location(list, fd[j]);   //瀹氫綅鍏跺湪閾捐〃浣嶇疆
                        ret = ListDelete(list, location);   //鍒犻櫎涓汉淇℃伅
                        if (ERROR == ret)
                        {
                            printf("Delete failed!\n");
                            break;
                        }
                        MaxFd = 5;                           //閲嶆柊纭畾MaxFd
                        for (k = 0; k < i; k++)
                        {
                            /*if (k == j)
                            {
                                continue;
                            }*/
                            if (fd[k] > MaxFd)
                            {
                                MaxFd = fd[k];
                            }
                        }

                        break;
                    }

                    else if (Recvbuf.quit == 1)
                    {                                        //澶勭悊鍦ㄧ櫥褰曠晫闈㈢殑閫€鍑洪€夐」
                        close(fd[j]);                        //鍏抽棴鐩稿簲fd
                        FD_CLR(fd[j], &ReadFd);
                        break;
                    }
                    break;
                }
            }
        }
    }

    return 0;
}

 

2.sever.c

//******************************************************//
//鐢熸垚鏃ユ湡 2017骞?2鏈?4鏃?  浣滆€?闄堝浆   //
//璇ユ枃浠朵负鑱婂ぉ瀹ゆ湇鍔″櫒瀛愮▼搴忥紝涓昏杩涜瀹㈡埛绔悇椤瑰姛鑳界殑瀹炵幇//

#include<stdio.h>
#include"my_chat.h"
#include<stdlib.h>
#include<string.h>
#include<sqlite3.h>

int ListInit(Linklist* L)
{
    *L = (Linklist)malloc(sizeof(Node));
    if (*L == NULL)
    {
        return ERROR;
    }
    (*L)->next = NULL;
    return OK;
}

/*鍑芥暟鍚嶏細search  鍔熻兘锛氬垽鏂甯愬彿鏄惁宸茬粡鐧诲綍 鍙傛暟锛氬湪绾縤d鐨勪俊鎭摼琛紝
瀹㈡埛绔殑fd锛屽瓨鏀炬帴鏀朵俊鎭殑缁撴瀯浣?/
int search(Linklist L, char* id, int fd)
{
    if (NULL == L)
    {
        return ERROR;
    }
    struct info Sendbuf;
    Linklist p = L;
    int exist = 0, ret;
    while(p->next)
    {
        p = p->next;
        if (!strcmp(p->Id, id))
        {
            exist = 1;
            break;
        }
    }
    if (exist == 1)
    {
        memset(&Sendbuf, 0, sizeof(Sendbuf));
        Sendbuf.not_exist = 1;
        ret = send(fd, &Sendbuf, sizeof(Sendbuf), 0);
        if (-1 == ret)
        {
            perror("send");
            exit(1);
        }
        return OK;
    }

    else
    {
        memset(&Sendbuf, 0, sizeof(Sendbuf));
        Sendbuf.not_exist = 0;
        ret = send(fd, &Sendbuf, sizeof(Sendbuf), 0);
        if (-1 == ret)
        {
            perror("send");
            exit(1);
        }
        return OK;
    }
}

int ListInsert(Linklist L, int k, int fd, struct info Recvbuf)
{
    if (NULL == L)
    {
        return ERROR;
    }
    int j = 1;
    Linklist p = L;
    while (p && j < k)
    {
        p = p->next;
        j++;
    }
    if (!p || j > k)
    {
        return ERROR;
    }
    Linklist s = (Linklist)malloc(sizeof(Node));
    s->Fd = fd;
    strcpy(s->Id, Recvbuf.id);
    strcpy(s->Name, Recvbuf.name); 
    s->next = p->next;
    p->next = s;
    return OK;
}

/*鍑芥暟鍚嶏細lookonline 鍔熻兘锛氭煡鐪嬪湪绾垮ソ鍙嬩俊鎭紝骞朵紶閫佸洖瀹㈡埛绔?鍙傛暟锛氫俊鎭摼琛紝瀹㈡埛绔痜d锛岀粨鏋勪綋*/
int lookonline(Linklist L, int fd, struct info Recvbuf)
{
    if (NULL == L)
    {
        return ERROR;
    }
    Linklist p = L;
    struct info Sendbuf;
    int ret;
    memset(&Sendbuf, 0, sizeof(Sendbuf));
    while(p->next != NULL)
    {
        p = p->next;
        strcat(Sendbuf.buf, p->Name);
        strcat(Sendbuf.buf, " ");
    }
    Sendbuf.look_online = 1;

    ret = send(fd, &Sendbuf, sizeof(Sendbuf), 0);
    if (-1 == ret)
    {
        perror("send");
        exit(1);
    }
    return OK;
}

/*鍑芥暟鍚嶏細chatpersonal 鍔熻兘瀹炵幇绉佽亰鍔熻兘锛屽嵆淇℃伅鐨勮浆鍙?鍙傛暟锛氬鎴风fd锛岀粨鏋勪綋锛岃亰澶╄褰曟暟鎹簱pdb锛屼俊鎭摼琛?/
int chatpersonal(int fd, struct info Recvbuf, Linklist L, sqlite3* pdb)
{
    char from_name[100] = {0};
    char to_name[100] = {0};
    char sql[100] = {0};
    char record[100] = {0};
    int to_fd;
    Linklist p = L;
    int ret, exist = 0;
    struct info Sendbuf;
    memset(sql, 0, sizeof(sql));
    sprintf(sql, "create table if not exists alluser (chatinfo text);");
    ret = sqlite3_exec(pdb, sql, NULL, NULL, NULL);
    if (SQLITE_OK != ret)
    {
        perror("sqlite3_exec1");
        exit(1);
    }

    while(p->next)
    {
        p = p->next;
        if (fd == p->Fd)
        {
            //printf("%s\n", p->Name);
            strcpy(from_name, p->Name);
            break;
        }
    }

    p = L;
    while(p->next)
    {
        p = p->next;
        if (!strcmp(Recvbuf.name, p->Name))
        {
            exist = 1;
            to_fd = p->Fd;
            memset(&Sendbuf, 0, sizeof(Sendbuf));
            strcpy(Sendbuf.name, from_name);
            strcpy(Sendbuf.buf, Recvbuf.buf);
            Sendbuf.chat_personal = 1;
            ret = send(to_fd, &Sendbuf, sizeof(Sendbuf), 0);
            if (-1 == ret)
            {
                perror("send");
                exit(1);
            }

            memset(record, 0, sizeof(record));
            strcpy(record, from_name);
            strcat(record, "鍚?);
            strcat(record, Recvbuf.name);
            strcat(record, "鍙戦€佷簡:");
            strcat(record, Sendbuf.buf);
            memset(sql, 0, sizeof(sql));
            sprintf(sql, "insert into alluser (chatinfo) values ('%s');", record);
            ret = sqlite3_exec(pdb, sql, NULL, NULL, NULL);
            if (SQLITE_OK != ret)
            {
                perror("sqlite3_exec2");
                exit(1);
            }
        }
    }

    
    if (exist == 0)
    {    
        memset(&Sendbuf, 0, sizeof(Sendbuf));
        Sendbuf.not_exist = 1;
        ret = send(fd, &Sendbuf, sizeof(Sendbuf), 0);
        if (-1 == ret)
        {
            perror("send");
            exit(1);
        }
        return ERROR;
    }

    return OK;
}

/*鍑芥暟鍚嶏細chatall 鍔熻兘锛氬疄鐜扮兢鍙戝姛鑳斤紝鍗冲皢淇℃伅杞彂缁欐墍浠ュ湪绾跨敤鎴?鍙傛暟锛氬鎴风fd锛岀粨鏋勪綋锛岃亰澶╄褰曟暟鎹簱pdb锛屼俊鎭摼琛?/
int chatall(int fd, struct info Recvbuf, Linklist L, sqlite3* pdb)
{
    if (NULL == L)
    {
        return ERROR;
    }

    char from_name[100] = {0};
    char sql[100] = {0};
    char record[100] = {0};
    Linklist p = L;
    int ret;
    struct info Sendbuf;
    while(p->next)
    {
        p = p->next;
        if (fd == p->Fd)
        {
            strcpy(from_name, p->Name);
            break;
        }
    }
    memset(sql, 0, sizeof(sql));
    sprintf(sql, "create table if not exists alluser (chatinfo text);");
    ret = sqlite3_exec(pdb, sql, NULL, NULL, NULL);
    if (SQLITE_OK != ret)
    {
        perror("sqlite3_exec1");
        exit(1);
    }

    p = L;
    memset(&Sendbuf, 0, sizeof(Sendbuf));
    Sendbuf.chat_all = 1;
    strcpy(Sendbuf.name, from_name);
    strcpy(Sendbuf.buf, Recvbuf.buf);
    while(p->next)
    {
        p = p->next;
        if (p->Fd == fd)
        {
            continue;
        }

        ret = send(p->Fd, &Sendbuf, sizeof(Sendbuf), 0);
        if (-1 == ret)
        {
            perror("send");
            exit(1);
        }        
    }
    memset(record, 0, sizeof(record));
    strcpy(record, from_name);
    strcat(record, "鍚?);
    strcat(record, "澶у");
    strcat(record, "鍙戦€佷簡:");
    strcat(record, Sendbuf.buf);
    memset(sql, 0, sizeof(sql));
    sprintf(sql, "insert into alluser (chatinfo) values ('%s');", record);
    ret = sqlite3_exec(pdb, sql, NULL, NULL, NULL);
    if (SQLITE_OK != ret)
    {
        perror("sqlite3_exec2");
        exit(1);
    }

    return OK;
}
//瑙ｉ櫎绂佽█
int speakout(int fd, struct info Recvbuf, Linklist L)
{
    if (NULL == L)
    {
        return ERROR;
    }

    char from_name[100] = {0};
    Linklist p = L;
    int ret, to_fd;
    int exist = 0;
    struct info Sendbuf;
    while(p->next)
    {
        p = p->next;
        if (fd == p->Fd)
        {
            strcpy(from_name, p->Name);
            break;
        }
    }

    p = L;
    while(p->next)
    {
        p = p->next;
        if (!strcmp(Recvbuf.name, p->Name))
        {
            to_fd = p->Fd;
            exist = 1;
            
            memset(&Sendbuf, 0, sizeof(Sendbuf));
            strcpy(Sendbuf.name, from_name);
            Sendbuf.speakout = 1;
            strcpy(Sendbuf.buf, "宸插皢瑙ｉ櫎浣犵瑷€锛?);

            ret = send(to_fd, &Sendbuf, sizeof(Sendbuf), 0);
            if (-1 == ret)
            {
                perror("send");
                exit(1);
            }        
        }
    }

    if (exist == 0)
    {
        memset(&Sendbuf, 0, sizeof(Sendbuf));
        Sendbuf.not_exist = 1;

        ret = send(fd, &Sendbuf, sizeof(Sendbuf), 0);
        if (-1 == ret)
        {
            perror("send");
            exit(1);
        }        

        return ERROR;
    }
    return OK;
}

/*鍑芥暟鍚嶏細shutup 鍔熻兘锛氱瑷€ 鍙傛暟锛氬鎴风fd锛屼俊鎭摼琛紝缁撴瀯浣?/
int shutup(int fd, struct info Recvbuf, Linklist L)
{
    if (NULL == L)
    {
        return ERROR;
    }

    char from_name[100] = {0};
    Linklist p = L;
    int ret, to_fd;
    int exist = 0;
    struct info Sendbuf;
    while(p->next)
    {
        p = p->next;
        if (fd == p->Fd)
        {
            strcpy(from_name, p->Name);
            break;
        }
    }

    p = L;
    while(p->next)
    {
        p = p->next;
        if (!strcmp(Recvbuf.name, p->Name))
        {
            to_fd = p->Fd;
            exist = 1;
            
            memset(&Sendbuf, 0, sizeof(Sendbuf));
            strcpy(Sendbuf.name, from_name);
            Sendbuf.speak = 1;
            strcpy(Sendbuf.buf, "宸插皢浣犵瑷€锛?);

            ret = send(to_fd, &Sendbuf, sizeof(Sendbuf), 0);
            if (-1 == ret)
            {
                perror("send");
                exit(1);
            }        
        }
    }

    if (exist == 0)
    {
        memset(&Sendbuf, 0, sizeof(Sendbuf));
        Sendbuf.not_exist = 1;

        ret = send(fd, &Sendbuf, sizeof(Sendbuf), 0);
        if (-1 == ret)
        {
            perror("send");
            exit(1);
        }        

        return ERROR;
    }
    return OK;
}

/*鍑芥暟鍚嶏細kickout 鍔熻兘锛氬皢鏌愮敤鎴疯涪鍑鸿亰澶╁锛岀粨鏉熷叾杩涚▼*/
int kickout(int fd, struct info Recvbuf, Linklist L)
{
    if (NULL == L)
    {
        return ERROR;
    }

    char from_name[100] = {0};
    Linklist p = L;
    int ret, to_fd;
    int exist = 0;
    struct info Sendbuf;
    while(p->next)
    {
        p = p->next;
        if (fd == p->Fd)
        {
            strcpy(from_name, p->Name);
            break;
        }
    }

    p = L;
    while(p->next)
    {
        p = p->next;
        if (!strcmp(Recvbuf.name, p->Name))
        {
            to_fd = p->Fd;
            exist = 1;
            memset(&Sendbuf, 0, sizeof(Sendbuf));
            strcpy(Sendbuf.name, from_name);
            Sendbuf.kickout = 1;
            strcpy(Sendbuf.buf, "宸插皢浣犺涪鍑鸿亰澶╁锛?);

            ret = send(to_fd, &Sendbuf, sizeof(Sendbuf), 0);
            if (-1 == ret)
            {
                perror("send");
                exit(1);
            }
        }
    }

    if (exist == 0)
    {
        memset(&Sendbuf, 0, sizeof(Sendbuf));
        Sendbuf.not_exist = 1;

        ret = send(fd, &Sendbuf, sizeof(Sendbuf), 0);
        if (-1 == ret)
        {
            perror("send");
            exit(1);
        }        

        return ERROR;
    }

    return to_fd;
}

int ListDelete(Linklist L, int k)
{
    Linklist p = L;
    int j = 1;
    Linklist l;
    if (NULL == L)
    {
        return ERROR;
    }

    while (p->next && j < k)
    {
        p = p->next;
        j++;
    }

    if (!(p->next) || j > k)
    {
        return ERROR;
    }

    l = p->next;
    p->next = p->next->next;
    free(l);
    return OK;
}

int Location(Linklist L, int fd)
{
    if (NULL == L)
    {
        return ERROR;
    }
    int count = 0;
    Linklist p = L;
    while(p->next)
    {
        count++;
        p = p->next;
        if (p->Fd == fd)
        {
            return count;
        }
    }
    return ERROR;
}

3.my_client.c

//******************************************************//
//鐢熸垚鏃ユ湡 2017骞?2鏈?4鏃?  浣滆€?闄堝浆   //
//璇ユ枃浠朵负鑱婂ぉ瀹ゅ鎴风涓荤▼搴忥紝涓昏杩涜濂楁帴瀛楃殑寤虹珛锛屼笌鏈嶅姟鍣ㄧ殑杩炴帴锛岀敤鎴风殑鐧诲綍娉ㄥ唽锛屼互鍙婅亰澶╁鐨勫悇绉嶅姛鑳界殑瀹炵幇//
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<pthread.h>
#include"my_chat.h"
#include<signal.h>
#include<sqlite3.h>

#define PORT 8888
int speak_flag = 0;

void* receive(void* arg)                     //绾跨▼鍑芥暟锛屼笉鏂帴鏀舵湇鍔″櫒鍙戦€佺殑淇℃伅
{
    int ret;
    sqlite3* pdb;
    char name1[100] = {0};
    char id1[100] = {0};
    char sql[100] = {0};
    char record[100] = {0};
    struct info Recvbuf;
    ret = sqlite3_open("user.db", &pdb);     //鎵撳紑瀛樻斁涓汉鐢ㄦ埛鑱婂ぉ璁板綍鐨勬暟鎹簱
    if (SQLITE_OK != ret)
    {
        perror("sqlite3_open");
        exit(1);
    }    

    while(1)
    {
        int ret;
        memset(&Recvbuf, 0, sizeof(Recvbuf));
        ret = recv(*(int*)arg, &Recvbuf, sizeof(Recvbuf), 0);  //涓嶆柇鎺ユ敹鏈嶅姟鍣ㄥ彂閫佺殑娑堟伅
        if (-1 == ret)
        {
            perror("recv");
            return;
        }
        if (Recvbuf.namelist == 1)                  //閫氳繃鏈嶅姟鍣ㄦ潵鑾峰彇鐧诲綍鍑芥暟鎵€鏀堕泦鐨勭敤鎴风綉鍚嶅拰
        {                                           //鐢ㄦ埛id鐨勪俊鎭?            strcpy(name1, Recvbuf.name);
            strcpy(id1, Recvbuf.id);
        }

        if (Recvbuf.look_online == 1)              //瀹炵幇鏌ョ湅鍦ㄧ嚎濂藉弸鍔熻兘锛屽苟灏嗗叾鎵撳嵃
        {
            printf("\n鍦ㄧ嚎濂藉弸:%s\n", Recvbuf.buf);
            sleep(3);
        }

        else if (Recvbuf.not_exist == 1)            //鑻ュ彂閫佷俊鎭椂鍑虹幇涓嶅瓨鍦ㄧ殑缃戝悕鍒欐墦鍗?        {
            printf("\n瀵逛笉璧凤紝璇ュソ鍙嬩笉瀛樺湪\n");
            sleep(2);
        }

        else if (Recvbuf.chat_personal == 1)        //瀹炵幇瀵圭鑱婁俊鎭殑鎺ユ敹锛屽苟鎵撳嵃鍙戦€佽€呭拰鍐呭
        {                                          
            memset(record, 0, sizeof(record));
            strcpy(record, Recvbuf.name);
            strcat(record, "鍚?);
            strcat(record, name1);
            strcat(record, "鍙戦€佷簡:");
            strcat(record, Recvbuf.buf);
            memset(sql, 0, sizeof(sql));
            sprintf(sql, "insert into '%s' (chatinfo) values ('%s');",id1, record);
            ret = sqlite3_exec(pdb, sql, NULL, NULL, NULL);   //灏嗘璁板綍瀛樺叆鏁版嵁搴?            if (SQLITE_OK != ret)
            {
                perror("sqlite3_exec2");
                exit(1);
            }

            printf("\n\t\t\t\t\t\t鏂版秷鎭細\n\t\t\t\t\t\t%s : %s\n", Recvbuf.name, Recvbuf.buf);
        }

        else if (Recvbuf.chat_all == 1)          //瀵圭兢鑱婁俊鎭殑鎺ユ敹
        { 
            printf("\n\t\t\t\t\t\t鏂版秷鎭?\n\t\t\t\t\t\t%s 鍚戝ぇ瀹跺彂閫佷簡娑堟伅:%s\n",
            Recvbuf.name, Recvbuf.buf);
            sleep(2);
        }

        else if (Recvbuf.speak == 1)             //鑻ヨ绂佽█锛屽垯鎵撳嵃绂佽█鑰呯綉鍚?        {
            speak_flag = 1;
            printf("\n\n%s%s\n", Recvbuf.name, Recvbuf.buf);
            sleep(2);
        }

        else if (Recvbuf.speakout == 1)             //鑻ヨ绂佽█锛屽垯鎵撳嵃绂佽█鑰呯綉鍚?        {
            speak_flag = 0;
            printf("\n\n%s%s\n", Recvbuf.name, Recvbuf.buf);
            sleep(2);
        }

        else if (Recvbuf.kickout == 1)           //鑻ヨ韪㈠嚭鑱婂ぉ瀹わ紝鎵撳嵃韪綘鐨勪汉缃戝悕
        {
            printf("\n\n%s%s\n", Recvbuf.name, Recvbuf.buf);
            break;
        }

        else if (Recvbuf.esc == 1)              //鎺ユ敹鏉ヨ嚜鐧诲綍鐣岄潰鐨勯€€鍑轰俊鎭?        {
            break;
        }
    }
    close(*(int*)arg);
    kill(getpid(), SIGSTOP);
}

int main()
{
    int sockfd, ret;
    struct info Sendbuf;
    struct sockaddr_in server_addr;
    pthread_t tid;
    char buf[100] = {0};
    char name[100] = {0};
    sockfd = socket(PF_INET, SOCK_STREAM, 0);           //寤虹珛socket
    if (-1 == sockfd)
    {
        perror("socket");
        exit(1);
    }
    printf("Start Server!\n");
    memset(&server_addr, 0, sizeof(struct sockaddr_in));
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = PORT;
    server_addr.sin_addr.s_addr = inet_addr("192.168.159.128");
    ret = connect(sockfd, (struct sockaddr*)&server_addr, sizeof(server_addr));  //涓庢湇鍔″櫒杩炴帴
    if (-1 == ret)
    {
        perror("connect");
        exit(1);
    }

    logininterface(sockfd);     //鐧诲綍鐣岄潰鍑芥暟锛屽疄鐜版敞鍐岀櫥褰曠瓑鍔熻兘
    sleep(2);
    ret = pthread_create(&tid, 0, receive, (void*)&sockfd);  //鍒涘缓涓€涓嚎绋嬬敤鏉ヤ笉鏂帴鏀朵俊鎭?    if (ret != 0)
    {
        perror("create");
        exit(1);
    }

    funinterface(sockfd);  //璋冪敤鎵€鏈夊姛鑳界殑鍑芥暟
    return 0;
}

4.client.c

//******************************************************//
//鐢熸垚鏃ユ湡 2017骞?2鏈?4鏃?  浣滆€?闄堝浆   //
//璇ユ枃浠朵负鑱婂ぉ瀹ゅ鎴风瀛愮▼搴忥紝涓昏杩涜鐢ㄦ埛鐨勭櫥褰曟敞鍐岋紝浠ュ強鑱婂ぉ瀹ょ殑鍚勭鍔熻兘鐨勫疄鐜?/

#include<stdio.h>
#include<sqlite3.h>
#include<string.h>
#include<stdlib.h>
#include"my_chat.h"
#include<signal.h>

int id_exist = 0;       //鍒ゆ柇杈撳叆鐨刬d鏄惁瀛樺湪
int id_num = 0;         //纭畾璇d鍦ㄦ暟鎹簱琛ㄤ腑鐨勪綅缃?int id_num1 = 0;
int name_exist = 0;     //鍒ゆ柇璇ョ綉鍚嶆槸鍚﹂噸澶?int password_num = 0;   //鍒ゆ柇瀵嗙爜鎵€鍦ㄦ暟鎹簱琛ㄤ腑浣嶇疆锛屼互鎵惧埌鐩稿搴旂殑甯愬彿
int password_right = 0; //鍒ゆ柇瀵嗙爜鏄惁姝ｇ‘
int vip_flag = 0;       //鏄惁鏄痸ip鐨勬爣蹇?extern speak_flag;      //瀹氫箟鍦ㄥ鎴风涓诲嚱鏁版枃浠朵腑锛屼紶閫掓湇鍔″櫒鐨勭瑷€淇℃伅        
char name1[100] = {0};  //瀛樻斁缃戝悕
char id1[100] = {0};    //瀛樻斁id
int Sockfd;

void quit(int sig)      //澶勭悊閫€鍑轰俊鍙凤紝 纭繚鍏抽棴鐩稿簲fd
{
    printf("姝ｅ湪淇濆瓨淇℃伅......\n");
    int ret;
    struct info Sendbuf;
    memset(&Sendbuf, 0, sizeof(Sendbuf));
    Sendbuf.esc = 1;
    ret = send(Sockfd, &Sendbuf, sizeof(Sendbuf), 0); //鍙戦€佺粰鏈嶅姟鍣紝浣垮叾鍏抽棴fd
    if (-1 == ret)
    {
        perror("send");
        exit(1);
    }
    sleep(2);
    kill(getpid(), SIGSTOP);        //缁撴潫涓诲嚱鏁?}
/*鍑芥暟鍚嶏細name  鍙傛暟锛氳緭鍏ョ殑缃戝悕 鍔熻兘锛氬垽鏂缃戝悕鏄惁宸茬粡瀛樺湪*/
int name(void* para, int columncount, char** columnValue, char** columnName)
{
    if (strcmp((char*)para, columnValue[2]) == 0)
    {
        name_exist = 1;
    }
    return 0;
}

/*鍑芥暟鍚嶏細idnum 鍙傛暟锛氳緭鍏ョ殑id甯愬彿  鍔熻兘锛氬垽鏂甯愬彿鏄惁宸茬粡瀛樺湪锛岃嫢瀛樺湪纭畾璧锋墍鍦ㄦ暟鎹簱琛ㄤ腑浣嶇疆*/
int idnum(void* para, int columncount, char** columnValue, char** columnName)
{
    id_num++;
    if (strcmp((char*)para, columnValue[0]) == 0)
    {
        id_exist = 1;
        id_num1 = id_num;
    }
    return 0;
}

/*鍑芥暟鍚嶏細password 鍙傛暟锛氳緭鍏ョ殑瀵嗙爜 鍔熻兘锛氭壘鍒板笎鍙风浉瀵圭殑瀵嗙爜锛屽苟涓庤緭鍏ヨ繘琛屾瘮杈冿紝鍒ゆ柇杈撳叆瀵嗙爜瀵归敊*/
int passwordnum(void* para, int columncount, char** columnValue, char** columnName)
{
    password_num++;
    if (password_num == id_num1)
    {
        if(strcmp((char*)para, columnValue[1]) == 0)
        {
            password_right = 1;
            strcpy(name1, columnValue[2]);
        }
    }
    return 0;
}

/*鍑芥暟鍚嶏細print 鍙傛暟锛氭棤 鍔熻兘锛氭墦鍗板瓨鏀捐亰澶╄褰曠殑鏁版嵁搴撹〃涓墍鏈夊唴瀹?/
int print(void* para, int columncount, char** columnValue, char** columnName)
{
    printf("\n");
    printf("%s\n", *columnValue);
    return 0;
}

int logininterface(int sockfd)        //鐧诲綍鐣岄潰鍑芥暟锛屽弬鏁颁负寤虹珛濂界殑sockfd
{                                     //瀹炵幇鐧诲綍娉ㄥ唽锛屽苟鏃佹柇鐧诲綍鐨刬d鏄惁瀛樺湪锛岃緭鍏ョ殑瀵嗙爜鏄惁姝ｇ‘
    sqlite3* pdb;                     //浠ュ強娉ㄥ唽鏃秈d鏄惁瀛樺湪锛岀綉鍚嶆槸鍚﹂噸澶?    int ret, i, age, choose;
    char sql[100] = {0};
    char id[100] = {0};
    Sockfd = sockfd;
    char password[100] = {0};
    struct info Sendbuf;
    struct info Recvbuf;
    ret = sqlite3_open("info.db", &pdb);//鎵撳紑瀛樻斁甯愬彿瀵嗙爜缃戝悕淇℃伅鐨勬暟鎹簱
    if (SQLITE_OK != ret)
    {
        perror("sqlite3_open");
        exit(1);
    }    

    sprintf(sql, "create table if not exists id_info (id text, password text, name text);");
    ret = sqlite3_exec(pdb, sql, NULL, NULL, NULL);       //寤虹珛涓€寮犲瓨鏀緄d锛屽瘑鐮侊紝缃戝悕鐨勮〃
    if (SQLITE_OK != ret)
    {
        perror("sqlite3_exec1");
        exit(1);
    }
    signal(SIGINT, SIG_IGN);        //姝ゆ椂蹇界暐ctrl锛媍淇″彿

    while(1)
    {
        system("clear");
        printf("\n\n\n");
        printf("***********************************************************\n");
        printf("*    *         *  *                 *           *         *\n");
        printf("*   *       *        *       *                   *        *\n");
        printf("*      *          *      Welcome!      *     *    *       *\n");
        printf("*  *          *               *                 *       * *\n");
        printf("*       *        Happy   *    *   Chating!      *         *\n");
        printf("*    *                  *    *         *     *            *\n");
        printf("*          *        *           *     *    *   *   *      *\n");
        printf("***********************************************************\n");
        sleep(2);
        system("clear");
        printf("\n\n\n");
        printf("***********************************************************\n");
        printf("*             *       *                            *      *\n");
        printf("*     *                  1.鐧诲綍甯愬彿       *               *\n");
        printf("*       *    *   *     * 2.娉ㄥ唽甯愬彿          *   *        *\n");
        printf("*    *              *    3.閫€鍑?           *              *\n");
        printf("*        *  *   *     *            *        *       *     *\n");
        printf("*     *       (璐﹀彿瀵嗙爜杈撳叆涓緭鍏xit閮藉皢閫€鍑?            *\n");
        printf("*            *          *                          *      *\n");
        printf("***********************************************************\n");
        printf("\n");
    
        ret = scanf("%d", &choose);
        if (ret == 0)
        {
            int ch;
            printf("杈撳叆閿欒!\n");
            while ((ch = getchar()) != EOF && ch != '\n');
            sleep(1);
            continue;
        }
        else if (choose == 1)
        {
            id_exist = 0;
            id_num = 0;
            id_num1 = 0;
            password_num = 0;
            password_right = 0;
            system("clear");
            printf("\n\n\n\n");
            while(1)
            {
                printf("璇疯緭鍏ュ笎鍙?");
                memset(id, 0, sizeof(id));
                scanf("%s", id);
                if (!strcmp(id, "exit"))         //鑻ヨ緭鍏xit锛屽垯杩涜閫€鍑虹郴缁?                {
                    printf("娆㈣繋涓嬫鍐嶆潵!\n");
                    memset(&Sendbuf, 0, sizeof(Sendbuf));
                    Sendbuf.quit = 1;
                    ret = send(sockfd, &Sendbuf, sizeof(Sendbuf), 0);  //鍙戦€佺粰鏈嶅姟鍣ㄩ€€鍑轰俊鍙?                    if (-1 == ret)
                    {
                        perror("send");
                        exit(1);
                    }
                    printf("閫€鍑烘垚鍔燂紒\n");
                    close(sockfd);
                    sleep(1);
                    exit(1);
                }
                memset(&Sendbuf, 0, sizeof(Sendbuf));
                Sendbuf.idlist = 1;                 //鍒ゆ柇璇ュ笎鍙锋槸鍚﹀凡缁忕櫥褰?                strcpy(Sendbuf.id, id);
                ret = send(sockfd, &Sendbuf, sizeof(Sendbuf), 0);
                if (-1 == ret)
                {
                    perror("send");
                    exit(1);
                }
                ret = recv(sockfd, &Recvbuf, sizeof(Recvbuf), 0); //鎺ユ敹鏈嶅姟鍣ㄧ殑鍙嶉淇℃伅
                if (-1 == ret)                                
                {
                    perror("recv");
                    exit(1);
                }
                if (Recvbuf.not_exist == 1)
                {
                    printf("\n璇ュ笎鍙峰凡鐧诲綍锛乗n");
                    continue;
                }

                else if (Recvbuf.not_exist == 0)
                {
                    break;
                }

            }
            sprintf(sql, "select * from id_info;");             //浠庢暟鎹簱涓垽鏂甯愬彿鏄惁瀛樺湪
            ret = sqlite3_exec(pdb, sql, idnum, (void*)id, NULL);
            if (SQLITE_OK != ret)
            {
                perror("sqlite3_exec2");
                exit(1);
            }

            if (id_exist == 0)
            {
                printf("\n閿欒:璇ュ笎鍙蜂笉瀛樺湪!\n");
                sleep(2);
            }
            else
            {
                memset(password, 0, sizeof(password));
                printf("\n璇疯緭鍏ュ瘑鐮?");
                scanf("%s", password);
                if (!strcmp(password, "exit"))      //閫€鍑烘搷浣?                {
                    printf("娆㈣繋涓嬫鍐嶆潵!\n");
                    memset(&Sendbuf, 0, sizeof(Sendbuf));
                    Sendbuf.quit = 1;
                    ret = send(sockfd, &Sendbuf, sizeof(Sendbuf), 0);
                    if (-1 == ret)
                    {
                        perror("send");
                        exit(1);
                    }
                    printf("閫€鍑烘垚鍔燂紒\n");
                    close(sockfd);
                    sleep(1);
                    exit(1);
                }

                sprintf(sql, "select * from id_info;");      //璋冪敤甯愬彿鏁版嵁搴撲俊鎭紝鍒ゆ柇瀵嗙爜鏄惁姝ｇ‘
                ret = sqlite3_exec(pdb, sql, passwordnum, (void*)password, NULL);
                if (SQLITE_OK != ret)
                {
                    perror("sqlite3_exec2");
                    exit(1);
                }
                if (password_right == 0)
                {
                    printf("瀵嗙爜閿欒\n");
                    sleep(2);
                }
                else
                {
                    memset(&Sendbuf, 0, sizeof(Sendbuf));
                    Sendbuf.namelist = 1;            //瀵嗙爜姝ｇ‘鍚庯紝灏嗕俊鎭瓨鍏ュ湪绾跨敤鎴风殑閾捐〃
                    strcpy(Sendbuf.name, name1);
                    strcpy(Sendbuf.id, id);
                    ret = send(sockfd, &Sendbuf, sizeof(Sendbuf), 0); 
                    if (-1 == ret)
                    {
                        perror("send");
                        exit(1);
                    }

                    strcpy(id1, id);
                    printf("\n姝ｅ湪鐧诲綍......\n");
                    sleep(1);
                    printf("\n鐧诲綍鎴愬姛锛乗n");
                    break;
                }

            }
        }
        else if (choose == 2)
        {
            system("clear");
            printf("\n\n\n\n");
            printf("璇疯緭鍏ュ笎鍙?");
            scanf("%s", id);
            if (!strcmp(id, "exit"))
            {
                printf("娆㈣繋涓嬫鍐嶆潵!\n");
                memset(&Sendbuf, 0, sizeof(Sendbuf));
                Sendbuf.quit = 1;
                ret = send(sockfd, &Sendbuf, sizeof(Sendbuf), 0);
                if (-1 == ret)
                {
                    perror("send");
                    exit(1);
                }
                printf("閫€鍑烘垚鍔燂紒\n");
                close(sockfd);
                sleep(1);
                exit(1);
            }
        
            sprintf(sql, "select * from id_info;");
            ret = sqlite3_exec(pdb, sql, idnum, (void*)id, NULL);  //鍒ゆ柇璇ュ笎鍙锋槸鍚﹀瓨鍦?            if (SQLITE_OK != ret)
            {
                perror("sqlite3_exec2");
                exit(1);
            }
            if (id_exist == 1)
            {
                printf("\n閿欒:璇ュ笎鍙峰凡瀛樺湪!\n\n");
                id_exist = 0;
                sleep(2);
            }

            else
            {
                printf("\n璇疯緭鍏ュ瘑鐮?");
                scanf("%s", password);
                if (!strcmp(password, "exit"))
                {
                    printf("娆㈣繋涓嬫鍐嶆潵!\n");
                    memset(&Sendbuf, 0, sizeof(Sendbuf));
                    Sendbuf.quit = 1;
                    ret = send(sockfd, &Sendbuf, sizeof(Sendbuf), 0);
                    if (-1 == ret)
                    {
                        perror("send");
                        exit(1);
                    }
                    printf("閫€鍑烘垚鍔燂紒\n");
                    close(sockfd);
                    sleep(1);
                    exit(1);
                }

                printf("\n璇疯緭鍏ョ綉鍚?");
                scanf("%s", name1);
                if (!strcmp(name1, "exit"))
                {
                    printf("娆㈣繋涓嬫鍐嶆潵!\n");
                    memset(&Sendbuf, 0, sizeof(Sendbuf));
                    Sendbuf.quit = 1;
                    ret = send(sockfd, &Sendbuf, sizeof(Sendbuf), 0);
                    if (-1 == ret)
                    {
                        perror("send");
                        exit(1);
                    }
                    printf("閫€鍑烘垚鍔燂紒\n");
                    close(sockfd);
                    sleep(1);
                    exit(1);
                }

                sprintf(sql, "select * from id_info;");
                ret = sqlite3_exec(pdb, sql, name, (void*)name1, NULL); //鍒ゆ柇璇ョ綉鍚嶆槸鍚﹂噸澶?                if (SQLITE_OK != ret)
                {
                    perror("sqlite3_exec2");
                    exit(1);
                }
                if (name_exist == 1)
                {
                    printf("\n閿欒:璇ョ綉鍚嶅凡瀛樺湪!\n\n");
                    name_exist = 0;
                    sleep(1);
                }

                else      //閮芥纭悗锛屽皢鏂扮殑甯愬彿淇℃伅瀛樺叆鏁版嵁搴?                {
                    sprintf(sql, "insert into id_info (id,password,name) values ('%s', '%s', '%s');", id, password, name1);
                    ret = sqlite3_exec(pdb, sql, NULL, NULL, NULL);
                    if (SQLITE_OK != ret)
                    {
                        perror("sqlite3_exec2");
                        exit(1);
                    }
                    memset(&Sendbuf, 0, sizeof(Sendbuf));
                    Sendbuf.namelist = 1;         //绫讳技浜庣櫥褰曟垚鍔燂紝瀛樺叆鍦ㄧ嚎鐢ㄦ埛淇℃伅閾捐〃
                    strcpy(Sendbuf.name, name1);
                    strcpy(Sendbuf.id, id);
                    ret = send(sockfd, &Sendbuf, sizeof(Sendbuf), 0); 
                    if (-1 == ret)
                    {
                        perror("send");
                        exit(1);
                    }
                    strcpy(id1, id);
                    printf("\n");
                    printf("姝ｅ湪娉ㄥ唽......\n");
                    sleep(1);
                    printf("\n");
                    printf("**********\n");
                    printf("*娉ㄥ唽鎴愬姛*\n");
                    printf("**********\n");
                    break;
                }
            }
        }
        else if (choose == 3)
        {
            printf("娆㈣繋涓嬫鍐嶆潵!\n");
            memset(&Sendbuf, 0, sizeof(Sendbuf));
            Sendbuf.quit = 1;
            ret = send(sockfd, &Sendbuf, sizeof(Sendbuf), 0);
            if (-1 == ret)
            {
                perror("send");
                exit(1);
            }
            printf("閫€鍑烘垚鍔燂紒\n");
            close(sockfd);
            sleep(1);
            exit(1);
        }

        else
        {
            printf("杈撳叆閿欒!\n");
            sleep(1);
        }
    }
    return 0;
}

int funinterface(int sockfd)       //鍔熻兘瀹炵幇鍑芥暟锛屼紶鍏ヤ簬鏈嶅姟鍣ㄨ繛鎺ュソ鐨剆ockfd
{
    int choose, ret;
    sqlite3* pdb;
    char sql[100] = {0};
    char name[100] = {0};
    char look[100] = {0};
    char str[100] = {0};
    char use[100] = {0};
    char record[100] = {0};
    struct info Sendbuf;
    Sockfd = sockfd;
    signal(SIGINT, quit);         //姝ゆ椂鑻ヨ幏鍙朿trl锛媍淇″彿锛屽垯璋冪敤quit鍑芥暟锛岃繘琛屽fd鐨勫叧闂?    ret = sqlite3_open("user.db", &pdb);
    if (SQLITE_OK != ret)
    {
        perror("sqlite3_open");
        exit(1);
    }    
    memset(sql, 0, sizeof(sql));
    sprintf(sql, "create table if not exists '%s' (chatinfo text);", id1); //鍒涘缓涓撳睘鐨勮亰澶╄褰曡〃
    ret = sqlite3_exec(pdb, sql, NULL, NULL, NULL);
    if (SQLITE_OK != ret)
    {
        perror("sqlite3_exec1");
        exit(1);
    }

    while(1)
    {
        system("clear");
        printf("*************************************************************\n");
        printf("*     *  *        Welcome  to chatting room!      *         *\n");
        printf("*    *                1.鏌ョ湅鎵€鏈夊湪绾垮ソ鍙?         *    *   **\n");
        printf("* * *       *         2.绉佽亰濂藉弸                         *  *\n");
        printf("*     *          *    3.缇ゅ彂娑堟伅          *     *           *\n");
        printf("*                     4.韪㈠嚭缇よ亰     *   *       *     *    *\n");
        printf("*   *       *         5.绂佽█            *         *         *\n");
        printf("*    *       *  *     6.瑙ｉ櫎绂佽█           *           *    *\n");
        printf("*  *    *             7.鍙戦€佽〃鎯?     *      *      *       *\n");
        printf("*  *        *     *   8.鍙戦€佸父鐢ㄨ            *             *\n");
        printf("*    *                9.娉ㄥ唽浼氬憳           *       *        *\n");
        printf("* *       *           10.鏌ョ湅鑱婂ぉ璁板綍        *              *\n");
        printf("*   *           *     11.閫€鍑鸿亰澶╁   *            *        *\n");
        printf("*      *      *       12.浣跨敤鎵嬪唽        *          *       *\n");              
        printf("*************************************************************\n");
        printf("浣犵殑缃戝悕:%s  \n璇疯緭鍏ユ偍閫夋嫨鐨勫姛鑳?\n", name1);
        printf("\n");
        printf("***********************************************/  娑堟伅鏍? /\n");
        ret = scanf("%d", &choose);
        if (ret == 0)
        {
            int ch;
            printf("杈撳叆閿欒!\n");
            while ((ch = getchar()) != EOF && ch != '\n');
            sleep(1);
            continue;
        }
        switch(choose)
        {
            case(1):
            memset(&Sendbuf, 0, sizeof(Sendbuf));
            if (speak_flag == 1)
            {
                Sendbuf.speak = 1;
            }
            Sendbuf.look_online = 1;
            ret = send(sockfd, &Sendbuf, sizeof(Sendbuf), 0); //鍙戦€佺粰鏈嶅姟鍣紝杩涜鏌ョ湅鍦ㄧ嚎鐢ㄦ埛
            if (-1 == ret)
            {
                perror("send");
                exit(1);
            }
            sleep(2);
            break;

            case(2):
            if (speak_flag)             //鑻ユ帴鏀剁殑绂佽█鏍囧織浣嶅凡缃?锛屽垯宸茶绂佽█
            {
                printf("\n瀵逛笉璧凤紝鎮ㄥ凡琚瑷€!\n");
                sleep(2);
                break;
            }
            else
            {
                memset(&Sendbuf, 0, sizeof(Sendbuf));
                printf("璇疯緭鍏ュソ鍙嬬綉鍚?");
                scanf("%s", name);
                printf("\n璇疯緭鍏ュ唴瀹?鎸塃nter閿彂閫? 缁撴潫鑱婂ぉ璇疯緭鍏?exit):\n");
                printf("\n");
                printf("*           鍙€氳繃蹇嵎鏂瑰紡鍙戦€佽〃鎯呭摝         *\n");
                printf("**********************************************\n");
                printf("*     蹇嵎鏂瑰紡   :)     寮€蹇? ( *^0^* )      *\n");
                printf("*     蹇嵎鏂瑰紡   :(     鐢熸皵  ( > o < )      *\n");
                printf("*     蹇嵎鏂瑰紡   :<     浼ゅ績  (T _ T )       *\n");
                printf("*     蹇嵎鏂瑰紡   :>     鎯婅  (0 A 0|||)     *\n");
                printf("*     蹇嵎鏂瑰紡   :,     浜蹭翰  (o^3^o)        *\n");
                printf("**********************************************\n");
    
                while(1)
                {
                    memset(&Sendbuf, 0, sizeof(Sendbuf));
                    scanf("%s", Sendbuf.buf);
                    if (!strcmp(Sendbuf.buf, "exit"))
                    {
                        break;
                    }
                    else if (!strcmp(Sendbuf.buf, ":)"))
                    {    
                        memset(&Sendbuf, 0, sizeof(Sendbuf));
                        Sendbuf.chat_personal = 1;
                        strcpy(Sendbuf.name, name);
                        strcpy(Sendbuf.buf, "鍚戜綘寰瑧浜嗕竴涓?( *^0^* )");
                        memset(record, 0, sizeof(record));
                        strcpy(record, name1);
                        strcat(record, "鍚?);
                        strcat(record, name);
                        strcat(record, "鍙戦€佷簡:");
                        strcat(record, Sendbuf.buf);
                        memset(sql, 0, sizeof(sql));
                        sprintf(sql, "insert into '%s' (chatinfo) values ('%s');",id1, record);
                        ret = sqlite3_exec(pdb, sql, NULL, NULL, NULL);
                        if (SQLITE_OK != ret)
                        {
                            perror("sqlite3_exec2");
                            exit(1);
                        }

                        ret = send(sockfd, &Sendbuf, sizeof(Sendbuf), 0);
                        if (-1 == ret)
                        {
                            perror("send");
                            exit(1);
                        }
                    }

                    else if (!strcmp(Sendbuf.buf, ":("))
                    {    
                        memset(&Sendbuf, 0, sizeof(Sendbuf));
                        Sendbuf.chat_personal = 1;
                        strcpy(Sendbuf.name, name);
                        strcpy(Sendbuf.buf, "鎴戝緢鐢熸皵 ( > o < )");
                        memset(record, 0, sizeof(record));
                        strcpy(record, name1);
                        strcat(record, "鍚?);
                        strcat(record, name);
                        strcat(record, "鍙戦€佷簡:");
                        strcat(record, Sendbuf.buf);
                        memset(sql, 0, sizeof(sql));
                        sprintf(sql, "insert into '%s' (chatinfo) values ('%s');",id1, record);
                        ret = sqlite3_exec(pdb, sql, NULL, NULL, NULL);
                        if (SQLITE_OK != ret)
                        {
                            perror("sqlite3_exec2");
                            exit(1);
                        }

                        ret = send(sockfd, &Sendbuf, sizeof(Sendbuf), 0);
                        if (-1 == ret)
                        {
                            perror("send");
                            exit(1);
                        }
                    }
                    
                    else if (!strcmp(Sendbuf.buf, ":<"))
                    {    
                        memset(&Sendbuf, 0, sizeof(Sendbuf));
                        Sendbuf.chat_personal = 1;
                        strcpy(Sendbuf.name, name);
                        strcpy(Sendbuf.buf, "鎴戝緢浼ゅ績 ( > o < )");
                        memset(record, 0, sizeof(record));
                        strcpy(record, name1);
                        strcat(record, "鍚?);
                        strcat(record, name);
                        strcat(record, "鍙戦€佷簡:");
                        strcat(record, Sendbuf.buf);
                        memset(sql, 0, sizeof(sql));
                        sprintf(sql, "insert into '%s' (chatinfo) values ('%s');",id1, record);
                        ret = sqlite3_exec(pdb, sql, NULL, NULL, NULL);
                        if (SQLITE_OK != ret)
                        {
                            perror("sqlite3_exec2");
                            exit(1);
                        }

                        ret = send(sockfd, &Sendbuf, sizeof(Sendbuf), 0);
                        if (-1 == ret)
                        {
                            perror("send");
                            exit(1);
                        }
                    }

                    else if (!strcmp(Sendbuf.buf, ":>"))
                    {    
                        memset(&Sendbuf, 0, sizeof(Sendbuf));
                        Sendbuf.chat_personal = 1;
                        strcpy(Sendbuf.name, name);
                        strcpy(Sendbuf.buf, "浠€涔堥 (0 A 0|||)");
                        memset(record, 0, sizeof(record));
                        strcpy(record, name1);
                        strcat(record, "鍚?);
                        strcat(record, name);
                        strcat(record, "鍙戦€佷簡:");
                        strcat(record, Sendbuf.buf);
                        memset(sql, 0, sizeof(sql));
                        sprintf(sql, "insert into '%s' (chatinfo) values ('%s');",id1, record);
                        ret = sqlite3_exec(pdb, sql, NULL, NULL, NULL);
                        if (SQLITE_OK != ret)
                        {
                            perror("sqlite3_exec2");
                            exit(1);
                        }

                        ret = send(sockfd, &Sendbuf, sizeof(Sendbuf), 0);
                        if (-1 == ret)
                        {
                            perror("send");
                            exit(1);
                        }
                    }

                    else if (!strcmp(Sendbuf.buf, ":,"))
                    {    
                        memset(&Sendbuf, 0, sizeof(Sendbuf));
                        Sendbuf.chat_personal = 1;
                        strcpy(Sendbuf.name, name);
                        strcpy(Sendbuf.buf, "鍋峰伔浜蹭簡浣犱竴涓?(o^3^o)");
                        memset(record, 0, sizeof(record));
                        strcpy(record, name1);
                        strcat(record, "鍚?);
                        strcat(record, name);
                        strcat(record, "鍙戦€佷簡:");
                        strcat(record, Sendbuf.buf);
                        memset(sql, 0, sizeof(sql));
                        sprintf(sql, "insert into '%s' (chatinfo) values ('%s');",id1, record);
                        ret = sqlite3_exec(pdb, sql, NULL, NULL, NULL);
                        if (SQLITE_OK != ret)
                        {
                            perror("sqlite3_exec2");
                            exit(1);
                        }

                        ret = send(sockfd, &Sendbuf, sizeof(Sendbuf), 0);
                        if (-1 == ret)
                        {
                            perror("send");
                            exit(1);
                        }
                    }
                    else
                    {
                        memset(record, 0, sizeof(record)); //灏嗗彂閫佽€咃紝鍙戦€佸璞★紝鍙戦€佺殑鍐呭鐩告帴鍚?                        strcpy(record, name1);             //瀛樺叆鏁版嵁搴?                        strcat(record, "鍚?);
                        strcat(record, name);
                        strcat(record, "鍙戦€佷簡:");
                        strcat(record, Sendbuf.buf);
                        memset(sql, 0, sizeof(sql));
                        sprintf(sql, "insert into '%s' (chatinfo) values ('%s');",id1, record);
                        ret = sqlite3_exec(pdb, sql, NULL, NULL, NULL);
                        if (SQLITE_OK != ret)
                        {
                            perror("sqlite3_exec2");
                            exit(1);
                        }
                        strcpy(Sendbuf.name, name);
                        Sendbuf.chat_personal = 1;      //灏嗙鑱婃爣蹇椾綅缃竴
                        ret = send(sockfd, &Sendbuf, sizeof(Sendbuf), 0);
                        if (-1 == ret)
                        {
                            perror("send");
                            exit(1);
                        }
                    }
                }
            }
            break;
            case(3):
            if (speak_flag)
            {
                printf("\n瀵逛笉璧凤紝鎮ㄥ凡琚瑷€!\n");
                sleep(2);
                break;
            }
            else
            {
                printf("\n娉ㄦ剰锛?閫€鍑鸿杈撳叆:exit\n");
                memset(&Sendbuf, 0, sizeof(Sendbuf));
                printf("璇疯緭鍏ュ唴瀹?");
                scanf("%s", Sendbuf.buf);
                memset(record, 0, sizeof(record));
                strcpy(record, name1);
                strcat(record, "鍚戝ぇ瀹?);
                strcat(record, "鍙戦€佷簡:");
                strcat(record, Sendbuf.buf);
                memset(sql, 0, sizeof(sql));
                sprintf(sql, "insert into '%s' (chatinfo) values ('%s');",id1, record);
                ret = sqlite3_exec(pdb, sql, NULL, NULL, NULL);
                if (SQLITE_OK != ret)
                {
                    perror("sqlite3_exec2");
                    exit(1);
                }

                Sendbuf.chat_all = 1;
                ret = send(sockfd, &Sendbuf, sizeof(Sendbuf), 0);
                if (-1 == ret)
                {
                    perror("send");
                    exit(1);
                }

                if (!strcmp(Sendbuf.buf, "exit"))
                {
                    break;
                }
            }
            break;

            case(4):
            if (vip_flag == 0)
            {
                printf("\n瀵逛笉璧凤紝鎮ㄦ病鏈夋潈闄怽n");  //鑻ユ病鏈夋敞鍐屼細鍛橈紝鍒欐棤鏉冮檺
                sleep(2);
            }

            else
            {
                memset(&Sendbuf, 0, sizeof(Sendbuf));
                printf("\n璇疯緭鍏ヤ綘鎯宠涪鍑鸿亰澶╁瀵硅薄鐨勭綉鍚?");
                sleep(1);
                scanf("%s", Sendbuf.name);
                Sendbuf.kickout = 1;
                ret = send(sockfd, &Sendbuf, sizeof(Sendbuf), 0);
                if (-1 == ret)
                {
                    perror("send");
                    exit(1);
                }
                sleep(1);
            }
            break;
            case(5):
            if (vip_flag == 0)
            {
                printf("\n瀵逛笉璧凤紝鎮ㄦ病鏈夋潈闄怽n");
                sleep(2);
            }

            else
            {
                memset(&Sendbuf, 0, sizeof(Sendbuf));
                printf("\n璇疯緭鍏ヤ綘鎯崇瑷€瀵硅薄鐨勭綉鍚?");
                sleep(1);
                scanf("%s", Sendbuf.name);
                Sendbuf.shutup = 1;
                ret = send(sockfd, &Sendbuf, sizeof(Sendbuf), 0);
                if (-1 == ret)
                {
                    perror("send");
                    exit(1);
                }
                sleep(1);
            }
            break;

            case(6):
            if (vip_flag == 0)
            {
                printf("\n瀵逛笉璧凤紝鎮ㄦ病鏈夋潈闄怽n");
                sleep(2);
            }

            else
            {
                memset(&Sendbuf, 0, sizeof(Sendbuf));
                printf("\n璇疯緭鍏ヤ綘鎯宠В闄ょ瑷€瀵硅薄鐨勭綉鍚?");
                sleep(1);
                scanf("%s", Sendbuf.name);
                Sendbuf.speakout = 1;
                ret = send(sockfd, &Sendbuf, sizeof(Sendbuf), 0);
                if (-1 == ret)
                {
                    perror("send");
                    exit(1);
                }
                sleep(1);
            }
            break;

            case(7):
            system("clear");
            printf("\n璇疯緭鍏ユ偍瑕佸彂閫佺殑瀵硅薄:");
            scanf("%s", name);
            printf("\n");
            printf("**********************************************\n");
            printf("*     蹇嵎鏂瑰紡   :)     寮€蹇? ( *^0^* )      *\n");
            printf("*     蹇嵎鏂瑰紡   :(     鐢熸皵  ( > o < )      *\n");
            printf("*     蹇嵎鏂瑰紡   :<     浼ゅ績  (T _ T )       *\n");
            printf("*     蹇嵎鏂瑰紡   :>     鎯婅  (0 A 0|||)     *\n");
            printf("*     蹇嵎鏂瑰紡   :,     浜蹭翰  (o^3^o)        *\n");
            printf("**********************************************\n");
            printf("璇疯緭鍏ヨ〃鎯呭揩鎹锋柟寮?\n");
            memset(look, 0, sizeof(look));
            scanf("%s", look);
            if (!strcmp(look, ":)"))
            {
                memset(&Sendbuf, 0, sizeof(Sendbuf));
                Sendbuf.chat_personal = 1;
                strcpy(Sendbuf.name, name);
                strcpy(Sendbuf.buf, "鍚戜綘寰瑧浜嗕竴涓?( *^0^* )");
                memset(record, 0, sizeof(record));
                strcpy(record, name1);
                strcat(record, "鍚?);
                strcat(record, name);
                strcat(record, "鍙戦€佷簡:");
                strcat(record, Sendbuf.buf);
                memset(sql, 0, sizeof(sql));
                sprintf(sql, "insert into '%s' (chatinfo) values ('%s');",id1, record);
                ret = sqlite3_exec(pdb, sql, NULL, NULL, NULL);
                if (SQLITE_OK != ret)
                {
                    perror("sqlite3_exec2");
                    exit(1);
                }

                ret = send(sockfd, &Sendbuf, sizeof(Sendbuf), 0);
                if (-1 == ret)
                {
                    perror("send");
                    exit(1);
                }
                printf("宸插彂閫?..\n");
                sleep(2);
                break;
            }

            else if (!strcmp(look, ":("))
            {
                memset(&Sendbuf, 0, sizeof(Sendbuf));
                Sendbuf.chat_personal = 1;
                strcpy(Sendbuf.name, name);
                strcpy(Sendbuf.buf, "鎴戝緢鐢熸皵 ( > o < )");
                memset(record, 0, sizeof(record));
                strcpy(record, name1);
                strcat(record, "鍚?);
                strcat(record, name);
                strcat(record, "鍙戦€佷簡:");
                strcat(record, Sendbuf.buf);
                memset(sql, 0, sizeof(sql));
                sprintf(sql, "insert into '%s' (chatinfo) values ('%s');",id1, record);
                ret = sqlite3_exec(pdb, sql, NULL, NULL, NULL);
                if (SQLITE_OK != ret)
                {
                    perror("sqlite3_exec2");
                    exit(1);
                }
    
                ret = send(sockfd, &Sendbuf, sizeof(Sendbuf), 0);
                if (-1 == ret)
                {
                    perror("send");
                    exit(1);
                }
                printf("宸插彂閫?..\n");
                sleep(2);
                break;
            }

            else if (!strcmp(look, ":<"))
            {
                memset(&Sendbuf, 0, sizeof(Sendbuf));
                Sendbuf.chat_personal = 1;
                strcpy(Sendbuf.name, name);
                strcpy(Sendbuf.buf, "鎴戝緢浼ゅ績 ( > o < )");
                memset(record, 0, sizeof(record));
                strcpy(record, name1);
                strcat(record, "鍚?);
                strcat(record, name);
                strcat(record, "鍙戦€佷簡:");
                strcat(record, Sendbuf.buf);
                memset(sql, 0, sizeof(sql));
                sprintf(sql, "insert into '%s' (chatinfo) values ('%s');",id1, record);
                ret = sqlite3_exec(pdb, sql, NULL, NULL, NULL);
                if (SQLITE_OK != ret)
                {
                    perror("sqlite3_exec2");
                    exit(1);
                }

                ret = send(sockfd, &Sendbuf, sizeof(Sendbuf), 0);
                if (-1 == ret)
                {
                    perror("send");
                    exit(1);
                }
                printf("宸插彂閫?..\n");
                sleep(2);
                break;
            }

            else if (!strcmp(look, ":>"))
            {
                memset(&Sendbuf, 0, sizeof(Sendbuf));
                Sendbuf.chat_personal = 1;
                strcpy(Sendbuf.name, name);
                strcpy(Sendbuf.buf, "浠€涔堥 (0 A 0|||)");
                memset(record, 0, sizeof(record));
                strcpy(record, name1);
                strcat(record, "鍚?);
                strcat(record, name);
                strcat(record, "鍙戦€佷簡:");
                strcat(record, Sendbuf.buf);
                memset(sql, 0, sizeof(sql));
                sprintf(sql, "insert into '%s' (chatinfo) values ('%s');",id1, record);
                ret = sqlite3_exec(pdb, sql, NULL, NULL, NULL);
                if (SQLITE_OK != ret)
                {
                    perror("sqlite3_exec2");
                    exit(1);
                }
    
                ret = send(sockfd, &Sendbuf, sizeof(Sendbuf), 0);
                if (-1 == ret)
                {
                    perror("send");
                    exit(1);
                }
                printf("宸插彂閫?..\n");
                sleep(2);
                break;
            }

            else if (!strcmp(look, ":,"))
            {
                memset(&Sendbuf, 0, sizeof(Sendbuf));
                Sendbuf.chat_personal = 1;
                strcpy(Sendbuf.name, name);
                strcpy(Sendbuf.buf, "鍋峰伔浜蹭簡浣犱竴涓?(o^3^o)");
                memset(record, 0, sizeof(record));
                strcpy(record, name1);
                strcat(record, "鍚?);
                strcat(record, name);
                strcat(record, "鍙戦€佷簡:");
                strcat(record, Sendbuf.buf);
                memset(sql, 0, sizeof(sql));
                sprintf(sql, "insert into '%s' (chatinfo) values ('%s');",id1, record);
                ret = sqlite3_exec(pdb, sql, NULL, NULL, NULL);
                if (SQLITE_OK != ret)
                {
                    perror("sqlite3_exec2");
                    exit(1);
                }

                ret = send(sockfd, &Sendbuf, sizeof(Sendbuf), 0);
                if (-1 == ret)
                {
                    perror("send");
                    exit(1);
                }
                printf("宸插彂閫?..\n");
                sleep(2);
                break;
            }

            else
            {
                printf("杈撳叆閿欒锛乗n");
                sleep(1);
                break;
            }

            case(8):
            system("clear");
            printf("\n\n");
            printf("***********************************\n");
            printf("*   杈撳叆鏍煎紡 渚嬪: john /welcome  *\n");
            printf("*                                 *\n");
            printf("*         娆㈣繋  /welcome          *\n");
            printf("*         鐐硅禐  /praise           *\n");
            printf("*         鍐嶈  /goodbye          *\n");
            printf("***********************************\n");
            printf("\n璇疯緭鍏?");
            memset(name, 0 ,sizeof(name));
            memset(str, 0, sizeof(str));
            scanf("%s %s", name, str);
            if (!strcmp(str, "/welcome"))
            {
                memset(&Sendbuf, 0, sizeof(Sendbuf));
                Sendbuf.chat_personal = 1;
                strcpy(Sendbuf.name, name);
                strcpy(Sendbuf.buf, "娆㈣繋浣犳潵鍒拌亰澶╁");

                memset(record, 0, sizeof(record));
                strcpy(record, name1);
                strcat(record, "鍚?);
                strcat(record, name);
                strcat(record, "鍙戦€佷簡:");
                strcat(record, Sendbuf.buf);
                memset(sql, 0, sizeof(sql));
                sprintf(sql, "insert into '%s' (chatinfo) values ('%s');",id1, record);
                ret = sqlite3_exec(pdb, sql, NULL, NULL, NULL);
                if (SQLITE_OK != ret)
                {
                    perror("sqlite3_exec2");
                    exit(1);
                }

                ret = send(sockfd, &Sendbuf, sizeof(Sendbuf), 0);
                if (-1 == ret)
                {
                    perror("send");
                    exit(1);
                }
                printf("宸插彂閫?..\n");
                sleep(2);
                break;
            }

            else if (!strcmp(str, "/praise"))
            {
                memset(&Sendbuf, 0, sizeof(Sendbuf));
                Sendbuf.chat_personal = 1;
                strcpy(Sendbuf.name, name);
                strcpy(Sendbuf.buf, "缁欎綘鐐逛釜璧烇紝浣犵湡妫?);

                memset(record, 0, sizeof(record));
                strcpy(record, name1);
                strcat(record, "鍚?);
                strcat(record, name);
                strcat(record, "鍙戦€佷簡:");
                strcat(record, Sendbuf.buf);
                memset(sql, 0, sizeof(sql));
                sprintf(sql, "insert into '%s' (chatinfo) values ('%s');",id1, record);
                ret = sqlite3_exec(pdb, sql, NULL, NULL, NULL);
                if (SQLITE_OK != ret)
                {
                    perror("sqlite3_exec2");
                    exit(1);
                }
    
                ret = send(sockfd, &Sendbuf, sizeof(Sendbuf), 0);
                if (-1 == ret)
                {
                    perror("send");
                    exit(1);
                }
                printf("宸插彂閫?..\n");
                sleep(2);
                break;
            }

            else if (!strcmp(str, "/goodbye"))
            {
                memset(&Sendbuf, 0, sizeof(Sendbuf));
                Sendbuf.chat_personal = 1;
                strcpy(Sendbuf.name, name);
                strcpy(Sendbuf.buf, "鏈嬪弸鏈夌紭鍗冮噷鏉ョ浉浼?");
                memset(record, 0, sizeof(record));
                strcpy(record, name1);
                strcat(record, "鍚?);
                strcat(record, name);
                strcat(record, "鍙戦€佷簡:");
                strcat(record, Sendbuf.buf);
                memset(sql, 0, sizeof(sql));
                sprintf(sql, "insert into '%s' (chatinfo) values ('%s');",id1, record);
    
                ret = sqlite3_exec(pdb, sql, NULL, NULL, NULL);
                if (SQLITE_OK != ret)
                {
                    perror("sqlite3_exec2");
                    exit(1);
                }
                ret = send(sockfd, &Sendbuf, sizeof(Sendbuf), 0);
                if (-1 == ret)
                {
                    perror("send");
                    exit(1);
                }
                printf("宸插彂閫?..\n");
                sleep(2);
                break;
            }

            else
            {
                printf("杈撳叆閿欒锛乗n");
                sleep(1);
                break;
            }

            case(9):
            printf("鎭枩鎮ㄥ凡娉ㄥ唽涓虹櫧閲戜細鍛?\n");
            vip_flag = 1;               //灏嗕細鍛樻爣蹇椾綅缃竴
            sleep(2);
            break;

            case(10):
            memset(sql, 0, sizeof(sql));
            sprintf(sql, "select * from '%s';", id1);  //鎵撳嵃鐢ㄦ埛鏁版嵁搴撲腑鎵€鏈夎亰澶╄褰?            ret = sqlite3_exec(pdb, sql, print, NULL, NULL);
            if (SQLITE_OK != ret)
            {
                perror("sqlite3_exec2");
                exit(1);
            }
            printf("杈撳叆浠绘剰閿€€鍑篭n");
            scanf("%s", look);
            break;

            case(11):
            printf("娆㈣繋涓嬫鍐嶆潵!\n");      //閫€鍑洪€夐」
            memset(&Sendbuf, 0, sizeof(Sendbuf));
            Sendbuf.esc = 1;
            ret = send(sockfd, &Sendbuf, sizeof(Sendbuf), 0);
            if (-1 == ret)
            {
                perror("send");
                exit(1);
            }
            printf("閫€鍑烘垚鍔燂紒\n");
            sleep(2);
            break;
            
            case(12):
            printf("  杈撳叆浠绘剰閿€€鍑篭n");
            printf("\n1.杈撳叆鏁板瓧閫夋嫨鍔熻兘\n");
            printf("2.绉佽亰濂藉弸鏃跺彧鏈夎緭鍏xit鎵嶅彲浠ラ€€鍑篭n");
            printf("3.甯愬彿涓嶅彲閲嶅鐧诲綍锛岀綉鍚嶄笉鍙噸澶峔n");
            scanf("%s", use);
            break;
            default:
            printf("杈撳叆閿欒锛乗n");
            sleep(1);
            break;
        }
    }

    return 0;
}

运行时将两个server文件编译成一个可执行文件，两个client文件也编译成一个可持续文件，先运行服务器，再运行客户端