linux实现聊天室（TCP、线程、多路IO、数据库）

#include"commond.h"

int login_Menu(void);//登陆的菜单
void del_Accout(void);//删除用户
void login_Accout(void);//登陆
void register_Accout(void);//注册

int after_Login_Menu(void);//登陆后的菜单
void* group_Write(void *arg);//群聊的写
void* Read(void *arg);//群聊的读
void groupChat(void);//群聊
void privateChat(void);//私聊
void* pri_Write(void *arg);//私聊的读
void quit_Login(void);//退出登陆把其状态设为下线

void chat_Log(void);//查看聊天记录

int after_Group_Chat_Menu(void);//管理员的页面菜单
void admin_Account(void);//管理员页面的函数
int isAdmin(void);//判断是否是管理员
void setAdmin(void);//设置管理员
void mushin_user(void);//禁言
void kick_user(void);//踢出

struct clifdId uid[50];//存放登陆用户的结构体
struct User user;//用户的结构体
int socfd;
int count_account=1;//记录登陆用户的个数
MYSQL *con;

int main()
{
    //创建套接子
    socfd = socket(AF_INET,SOCK_STREAM,0);
    if(socfd == -1)
    {
        perror("socfd");
        return -1;
    }

    // 初始化句柄,并连接数据库
    con = mysql_init(NULL);
    if(mysql_real_connect(con,"localhost","root","1","ChatRooms",0,NULL,0) == NULL)
    {
        printf("数据库连接失败\n");
        return -1;
    }

    //TCP连接
    struct sockaddr_in self;
    self.sin_family = AF_INET;
    self.sin_addr.s_addr = inet_addr(IP);
    self.sin_port = htons(PORT);
    connect(socfd,(struct sockaddr*)(&self),sizeof(self));

    while(1)
    {
        switch(login_Menu())
        {
            case REGISTER: register_Accout();break;
            case LOGIN:login_Accout();break;
            case DEL:del_Accout();break;
            case EXIT:return 0;break;
            default:printf("输入错误\n");
        }
    }
    return 0;
}


void register_Accout(void)
{
    printf("********注册功能********\n");

    printf("请输入用户名\n");
    scanf("%s",user.name);
    getchar();
    printf("请输入密码\n");
    scanf("%s",user.passwd);
    getchar();
    user.change = REGISTER;
    user.status=0;
    send(socfd,&user,sizeof(user),0);

    recv(socfd,&user,sizeof(user),0);
    printf("注册的账号：%d\t注册的用户名：%s\t注册的密码：%s,user.info:%s\n",user.id,user.name,user.passwd,user.info);
    printf("%s\n",user.info);
}

void del_Accout(void)
{
    printf("********注销功能********\n");
    printf("请输入要删除的账号：\n");
    scanf("%d",&user.id);
    getchar();
    printf("请输入要删除账号的密码:\n");
    scanf("%s",user.passwd);
    getchar();
    user.change = DEL;

    send(socfd,&user,sizeof(user),0);

    recv(socfd,&user,1000,0);
    sleep(1);
    printf("%s\n",user.info);
}

void login_Accout(void)
{
    printf("********登陆功能********\n");
loop:
    printf("请输入账号:\n");
    scanf("%d",&user.id);
    getchar();
    printf("请输入密码:\n");
    scanf("%s",user.passwd);
    getchar();
    user.change = LOGIN;

    send(socfd,&user,sizeof(user),0);
    int re =recv(socfd,&user,1000,0);
    //打印信息
    printf("%s\n",user.info);
    if(strcmp(user.info,"登陆成功")!=0)
    {
        goto loop;
    }
    count_account++;       

    //sleep(2);
    //登陆之后群聊私聊等

   while(1)
   {
        switch(after_Login_Menu())
        {
            case GROUPCHAT-3: 
                user.change = GROUPCHAT;
                memset(user.f_write,0,100);
                strcpy(user.f_write,"join");//如果等于join那么就不需要打印
                send(socfd,&user,sizeof(user),0);
                groupChat();
                break;
            case PRIVATECHAT-3:privateChat();break;
            case CHAT_LOG-3:chat_Log();break;
            case ADMIN-4:admin_Account();break;
            case EXIT:quit_Login();return;break;   
            default:printf("输入错误\n");
        }
   }
}


void admin_Account(void)//管理员页面
{
    printf("---------管理员页面-------\n");
    while(1)
    {
        switch(after_Group_Chat_Menu())
        {
            case SETADMIN-8: setAdmin();break;
            case MUSHIN-8:mushin_user();break;
            case KICK-8:kick_user();break;
            case EXIT:return;break;   
            default:printf("输入错误\n");
        }
    }

}

void kick_user(void)//踢出
{
    printf("---------管理员设置踢人功能-------\n");

    int isadmin = isAdmin();//踢人前要确定是否是管理员
    if(isadmin == 1)
    {
        printf("请输入要踢人的账户\n");
        scanf("%d",&user.sjid);
        getchar();
        user.change=KICK;
        send(socfd,&user,sizeof(user),0);
        recv(socfd,&user,sizeof(user),0);
        printf("%s\n",user.info);
    }
    else if(isadmin == -1)
    {
        printf("你不是管理员，无权操作\n");
    }
}

void mushin_user(void)//禁言
{
    printf("---------管理员设置禁言功能-------\n");

    int isadmin = isAdmin();//禁言前要确定是否是管理员
    if(isadmin == 1)
    {
        printf("请输入要禁言的账户\n");
        scanf("%d",&user.sjid);
        getchar();
        user.change=MUSHIN;
        send(socfd,&user,sizeof(user),0);
        recv(socfd,&user,sizeof(user),0);
        printf("%s\n",user.info);
    }
    else if(isadmin == -1)
    {
        printf("你不是管理员，无权操作\n");
    }
}

void setAdmin(void)//设置管理员
{
    printf("---------设置管理员功能-------\n");
    int isadmin = isAdmin();
    if(isadmin == 1)
    {
        printf("请输入要设置的管理员的ID\n");
        scanf("%d",&user.sjid);
        getchar();
        user.change = SETADMIN;
        send(socfd,&user,sizeof(user),0);
        recv(socfd,&user,sizeof(user),0);
        printf("%s\n",user.info);
    }
    else if(isadmin == -1)
    {
        printf("你不是管理员，无权操作\n");
    }
    
}


int isAdmin(void)//判断是否是管理员
{
    user.change=ISADMIN;
    send(socfd,&user,sizeof(user),0);

    recv(socfd,&user,sizeof(user),0);
    printf("%s\n",user.info);
    if(strcmp(user.info,"该账户是管理员")==0)
        return 1;
    else
        return -1;
}


void chat_Log(void)//查看聊天记录功能
{
    printf("********查看聊天记录功能********\n");
    int filefd = open("./Account/ChatLog.txt",O_CREAT|O_RDONLY,0644);
    if(filefd == -1)
    {
        perror("filefd");
        return;
    } 

    while(read(filefd,&user,sizeof(user)))
    {
        printf("%s %d用户发送：%s\n",user.time_buf,user.id,user.f_write);
    }
    close(filefd);
}

void quit_Login(void)//退出登陆即把其在线的状态改为下线
{
    printf("正在下线...\n");
    user.status=0;
    user.change=QUIT_LOGIN;
    send(socfd,&user,sizeof(user),0);
}


void* group_Write(void *arg)
{
    while(1)
    {
        printf("请输入：\n");
        scanf("%s",user.f_write);
        getchar();
        //发送时带上选择
        user.change = GROUPCHAT;
        send(socfd,&user,sizeof(user),0);
        if(!strcmp(user.f_write,"xl"))
        {
            pthread_exit(NULL);
        }
    }
}

void* Read(void *arg)
{
    time_t t;
    struct tm *local = NULL;
    while(1)
    {
        int re = recv(socfd,&user,sizeof(user),0);
      
        if(!strcmp(user.f_write,"xl"))
        {
            pthread_exit(NULL);
        }

        t=time(NULL);
        local = localtime(&t);

        if(strcmp(user.f_write,"join")!=0&&(user.admin!=-2)&&(user.admin!=-1))
        {
            printf("%d.%d.%d %d:%d:%d\t",
                    local->tm_year+1900,local->tm_mon+1,local->tm_mday,
                    local->tm_hour,local->tm_min,local->tm_sec);
            printf("用户：%d  发来的：%s\n",user.id,user.f_write);
        }
        /*if(user.admin==-2)
        {
            printf("该用户被禁言\n");
        }*/
    }
}
void groupChat(void)
{
    printf("********群聊功能********\n");

    pthread_t pt1,pt2;
    //创建2个线程区读写
    pthread_create(&pt1,NULL,group_Write,NULL);
    pthread_create(&pt2,NULL,Read,NULL);
    pthread_join(pt1,NULL);
    pthread_join(pt2,NULL);
}


void* pri_Write(void *arg)
{   
    int i=1,sjid=0;
    while(1)
    {       
       if(i==1)
        {
            printf("请输入要私聊的账号:\n");
            scanf("%d",&sjid);
            getchar();
        }
        printf("请输入私聊信息：\n");
        scanf("%s",user.f_write);
        getchar();
        user.sjid=sjid;
        user.change = PRIVATECHAT;
        send(socfd,&user,sizeof(user),0);
        if(!strcmp(user.f_write,"xl"))
        {
            pthread_exit(NULL);
        }
        i=2;
    }
}

void privateChat(void)
{
    printf("********私聊功能********\n");

    char buf_status[200];
    //查找在线的id
    memset(buf_status,0,100);
    sprintf(buf_status,"select id from chatroom where status =1");
    mysql_real_query(con,buf_status,strlen(buf_status));
    MYSQL_RES* res = mysql_store_result(con);
    int r = mysql_num_rows(res);
    if(r == 0)
    {
        printf("没有在线的账号\n");
        return;
    }

    char **a =NULL;
    while(--r>=0)
    {
        a= mysql_fetch_row(res);//找到了一行中一个数据
        printf("账号:%s\n",a[0]);
    }

    pthread_t pt3,pt4;
    //创建2个线程区读写
    pthread_create(&pt3,NULL,pri_Write,NULL);
    pthread_create(&pt4,NULL,Read,NULL);
    pthread_join(pt3,NULL);
    pthread_join(pt4,NULL);
}


int login_Menu(void)
{
    printf("\033[2J");
	printf("\033[0;0H");
    printf("--------1、注册--------\n");
    printf("--------2、登陆--------\n");
    printf("--------3、注销--------\n");
    printf("--------0、退出--------\n");
    int change =0;
    scanf("%d",&change);
    getchar();
    return change;
}

int after_Login_Menu(void)
{
    //printf("\033[2J");
	//printf("\033[0;0H");
    printf("--------1、  群聊------------\n");
    printf("--------2、  私聊------------\n");
    printf("--------3、查看聊天记录-------\n");
    printf("--------4、管理员页面---------\n");
    printf("--------0、  退出------------\n");
    int change =0;
    scanf("%d",&change);
    getchar();
    return change;
}

int after_Group_Chat_Menu(void)
{
    //printf("\033[2J");
	//printf("\033[0;0H");
    printf("--------1、设置管理员--------\n");
    printf("--------2、禁言--------\n");
    printf("--------3、踢人--------\n");
    printf("--------0、退出--------\n");
    int change =0;
    scanf("%d",&change);
    getchar();
    return change;
}

```c
#include"commond.h"

int isKick(void);//判断是否踢出
int isMushin(void);//判断是否禁言

void chat_Log(struct User user);//查看聊天记录功能
int open_Account(void);//创建账号

struct User user;//用户
struct clifdId uid[50];//存储用户账号与对应的客户端
struct SiL sil;//存放发送方和接收方的账号及客户端
struct clifdId qunl[50];
MYSQL *con;

int main()
{
    //创建套接子
    int socfd = socket(AF_INET,SOCK_STREAM,0);
    if(socfd == -1)
    {
        perror("socfd");
        return -1;
    }
    //防止网络重复
    int val=1;
    setsockopt(socfd,SOL_SOCKET,SO_REUSEADDR,&val,sizeof(val));

    // 初始化句柄,并连接数据库
    con = mysql_init(NULL);
    if(mysql_real_connect(con,"localhost","root","1","ChatRooms",0,NULL,0) == NULL)
    {
        printf("数据库连接失败\n");
        return -1;
    }

    //绑定
    struct sockaddr_in self;
    self.sin_family = AF_INET;
    self.sin_addr.s_addr = inet_addr(IP);
    self.sin_port = htons(PORT);
    int bd = bind(socfd,(struct sockaddr*)(&self),sizeof(self));
    if(bd == -1)
    {
        perror("bd");
        return -1;
    }

    //监听
    listen(socfd,50);
    int zf_flag=0;
    //多路IO

    int change = 0;
    int buf_clifd[50]={0};
    struct sockaddr_in cli_addr;
    int len = sizeof(cli_addr);
    int ret=0,clifd[50]={0},count=0,logincount=0,row=0,groupcount=0;
    int maxfd = socfd;
    fd_set readset,fdset;//创建一个监测集合
    FD_ZERO(&readset);
    FD_SET(socfd,&readset);
    fdset = readset;
    while(1)
    {
        readset = fdset;//每次去保存
        ret = select(maxfd+1,&readset,NULL,NULL,NULL);
        if(ret == -1)
        {
            perror("select");
            return -1;
        }
        if(FD_ISSET(socfd,&readset))
        {
            clifd[count] = accept(socfd,(struct sockaddr *)(&cli_addr),&len);//接收连接信息
            printf("%d上线\n",clifd[count]);
            FD_SET(clifd[count],&fdset);//重新向集合中添加描述符
            
            if(clifd[count]>maxfd)  
                maxfd=clifd[count];
            count++;
            if(ret == 1)//如果就是连接就不需要进行下面的读写操作
                continue;   
        }
        time_t t;
        struct tm *local = NULL;

        int re=0,ff=0;//ff标志
        char buf_info[100]={0},buf_status[100];
        for(int i=0;i<count;i++)
        {
            if(FD_ISSET(clifd[i],&readset))//如果集合中clifd[i]发生白变化，则是读写操作
            {
                int readrcv = recv(clifd[i],&user,sizeof(user),0);//从user中得到做的选择，如果选择非群聊和私聊则没有f.write,如果是群聊直接在此处区接受消息
                //客户端对应的账号
                if(clifd[i]==uid[i].clifd)
                     user.id=uid[i].id;

                if(readrcv==0)
                {
                    memset(&user,0,sizeof(user));
                }
                
                switch(user.change)
                {
                    case REGISTER://注册
                    { 
                        //创建账号
                        user.id = open_Account();

                        //把数据导入数据库
                        char buf[1000]={0},buf_info[100]={0};
                        sprintf(buf,"insert into chatroom values('%s',%d,'%s',%d,%d)",
                                user.name,user.id,user.passwd,user.status,0);
                        mysql_real_query(con,buf,strlen(buf));
                        printf("注册成功\n");
                        strcpy(user.info,"注册成功\n");
                        send(clifd[i],&user,sizeof(user),0); 
                        break;
                    } 
                    case LOGIN:
                    {
                        char buf_login[1000]={0};
                        sprintf(buf_login,"select passwd from chatroom where id =%d",user.id);
                        mysql_real_query(con,buf_login,strlen(buf_login));
                        //把查找的数据放入结构体中----对其操作的都要放在数组中
                        MYSQL_RES* res = mysql_store_result(con);
                        row = mysql_num_rows(res);
                        if(row == 0)
                        {
                            printf("没找到该账号\n");
                            strcpy(user.info,"没找到该账号");
                            send(clifd[i],&user,sizeof(user),0); 
                            break;
                        }
                        char **a =mysql_fetch_row(res);//找到了一行中一个数据
                        if(strcmp(user.passwd,a[0])==0)
                        {
                            printf("登陆成功\n");
                            strcpy(user.info,"登陆成功");
                            send(clifd[i],&user,sizeof(user),0); 
                            
                             //改为上线status=1
                            sprintf(buf_status,"update chatroom set status=1 where id = %d",user.id);
                            mysql_real_query(con,buf_status,strlen(buf_status));

                            //登陆成功把其账号和客户端对应方便，后面发送和接受消息
                            uid[logincount].clifd=clifd[i];
                            uid[logincount].id=user.id;

                            //登陆上既可以进行群聊，logincount记录群聊的人数
                            logincount++;
                            printf("logincount: %d\n",logincount);
                        }
                        else
                        {
                            printf("密码错误\n");
                            strcpy(user.info,"密码错误");
                            send(clifd[i],&user,sizeof(user),0); 
                        }
                        break;
                    }
                    case QUIT_LOGIN:
                    {
                        //改为下线status=0，并让logincount在线的人数进行减一
                        sprintf(buf_status,"update chatroom set status=0 where id = %d",user.id);
                        mysql_real_query(con,buf_status,strlen(buf_status));
                        if(logincount>0)
                            logincount--;
                        printf("退出登陆成功\n");
                        break;
                    }

                    case GROUPCHAT:
                    {
                         //查看是否被踢出
                        user.sjid=user.id;
                        int iskick = isKick();
                        printf("178userid %d\n",user.id);
                        if(iskick==-1)
                        {
                            printf("该用户被踢出\n");
                            strcpy(user.info,"该用户被踢出");
                            user.admin=-1;
                            send(clifd[i],&user,sizeof(user),0); 
                            continue;
                        }    
                        user.sjid=user.id;
                        //查看是否被禁言
                        int ismushin = isMushin();
                        printf("190userid %d\n",user.id);
                        
                        if(ismushin==-2)
                        {
                            printf("该用户禁言\n");
                            //continue;
                        }

                        ff=0;//标志为判断该群聊中是否有该用户
                        for(int y=0;y<groupcount;y++)//在群聊中查找用户是否已经加入群聊，如果加入那么就不需要重新加入
                        {
                            if(qunl[y].clifd==clifd[i])
                            {
                                ff=1;
                                break;
                            }
                        }
                        if(ff==0)//如果没加入那么就需要加入
                        {
                            qunl[groupcount].id=user.id;
                            qunl[groupcount].clifd=clifd[i];
                            groupcount++;
                        }
                        
                        t=time(NULL);
                        local = localtime(&t);
                        sprintf(user.time_buf,"%d.%d.%d %d:%d:%d\t",
                                local->tm_year+1900,local->tm_mon+1,local->tm_mday,
                                local->tm_hour,local->tm_min,local->tm_sec);

                        chat_Log(user);//群聊的聊天信息保存到文件中

                        if(clifd[i]==uid[i].clifd)
                            user.id=uid[i].id;

                        for(int j=0;j<=groupcount;j++)
                        {
                            if((strcmp(user.f_write,"xl")==0)&&(qunl[j].clifd==clifd[i]))  //如果是xl表示退出群聊
                            {
                                send(clifd[i],&user,sizeof(user),0);    
                                for(int y=0;y<groupcount;y++)//如果有人退出群聊那么就从群聊的人数中删除该用户的信息
                                {
                                    if(clifd[i]==qunl[y].clifd)
                                    {
                                        qunl[y].clifd=0;
                                        qunl[y].id=0;
                                    }
                                }
                                break;
                            }
                            else if((qunl[j].clifd!=clifd[i])&&clifd[i]>0&&(strcmp(user.f_write,"xl")!=0)&&(ismushin!=-2))//没有被禁言发送给群聊中的人
                            {      
                                send(qunl[j].clifd,&user,sizeof(user),0);
                                printf("218:%d发送给客户端：%d: 发送内容：%s\n",clifd[i],clifd[j],user.f_write);  
                            }
                            if(ismushin==-2)//如果是禁言，则返回一个admin，客户端不打印
                            {
                                user.admin=-2;
                                strcpy(user.info,"该用户禁言");
                                send(socfd,&user,sizeof(user),0);
                            }
                            
                        }
                         break;
                    }

                    case PRIVATECHAT:
                    {   
                        //存储起来私聊的发送方和接收方
                        int n=0,flag=0;
                        sil.sjid=user.sjid;//记录接收方的id
                        sil.sfid=user.id;//记录发送的id
                        sil.fclifd=clifd[i];//记录发送的客户端
                        flag=0;
                        for(int s=0;s<logincount;s++)
                        {
                            if(strcmp(user.f_write,"xl")==0)//输入xl表示下了  
                            {
                                send(clifd[i],&user,sizeof(user),0);//发送给自己
                                break;
                            }
                            else if(sil.sjid==uid[s].id)//根据接收方的id去找接收方的客户端
                            {
                                sil.jclifd=uid[s].clifd;
                                re = send(sil.jclifd,&user,sizeof(user),0);
                                printf("160:send %d  %d发送给客户端：%d: 发送内容：%s\n",re,clifd[i],sil.jclifd,user.f_write);  
                                flag=1;
                                break;
                            }
                        }
                        if(flag!=1)//该用户不在线
                        {
                            printf("该账号没在线\n");    
                        }

                        break;
                    }

                    case DEL:
                    {
                        char buf_search[1000]={0},buf_del[1000];
                        //查找是否有该人的操作
                        sprintf(buf_search,"select passwd from chatroom where id =%d",user.id);
                        mysql_real_query(con,buf_search,strlen(buf_search));
                        
                        //把查找的数据放入结构体中----对其操作的都要放在数组中
                        MYSQL_RES* res = mysql_store_result(con);
                        row = mysql_num_rows(res);
                        if(row == 0)
                        {
                            strcpy(user.info,"没找到该账户");
                            send(clifd[i],&user,sizeof(user),0); 
                            break;
                        }

                        char **a =mysql_fetch_row(res);//找到了一行中一个数据
                        if(strcmp(user.passwd,a[0])==0)
                        {
                            sprintf(buf_del,"delete from chatroom where id= %d",user.id);
                            mysql_real_query(con,buf_del,strlen(buf_del));
                            printf("删除成功\n");
                            strcpy(user.info,"删除成功");
                            send(clifd[i],&user,sizeof(user),0);
                        } 
                        break;
                    }
                    
                    case KICK://踢人
                    {
                        char buf_kick[1000]={0};
                        //查找该人是否为管理员
                        sprintf(buf_kick,"update chatroom set admin=-1 where id = %d",user.sjid);
                        mysql_real_query(con,buf_kick,strlen(buf_kick));
                        strcpy(user.info,"踢出成功");
                        send(clifd[i],&user,sizeof(user),0);
                        break; 
                    }

                    case MUSHIN://设置禁言
                    {
                        char buf_setmushin[1000]={0};
                        //查找该人是否为管理员
                        sprintf(buf_setmushin,"update chatroom set admin=-2 where id = %d",user.sjid);
                        mysql_real_query(con,buf_setmushin,strlen(buf_setmushin));
                        strcpy(user.info,"禁言成功");
                        send(clifd[i],&user,sizeof(user),0);
                        break; 
                    }
                    case SETADMIN://设置管理员
                    {
                        char buf_setadmin[1000]={0};
                        //查找该人是否为管理员
                        sprintf(buf_setadmin,"update chatroom set admin=1 where id = %d",user.sjid);
                        mysql_real_query(con,buf_setadmin,strlen(buf_setadmin));
                        strcpy(user.info,"设置成功");
                        send(clifd[i],&user,sizeof(user),0);
                        break; 
                    }
                    case ISADMIN://是否是管理员
                    {
                        char buf_admin_search[1000]={0};
                        //查找该人是否为管理员
                        sprintf(buf_admin_search,"select admin from chatroom where id =%d",user.id);
                        mysql_real_query(con,buf_admin_search,strlen(buf_admin_search));

                        //把查找的数据放入结构体中----对其操作的都要放在数组中
                        MYSQL_RES* res = mysql_store_result(con);
                        row = mysql_num_rows(res);
                        if(row == 0)
                        {
                            strcpy(user.info,"该账户不是管理员");
                            send(clifd[i],&user,sizeof(user),0); 
                            break;
                        }

                        char **a =mysql_fetch_row(res);//找到了一行中一个数据
                        if(strcmp("1",a[0])==0)
                        {
                            printf("该账户是管理员\n");
                            strcpy(user.info,"该账户是管理员");
                            send(clifd[i],&user,sizeof(user),0); 
                        }
                        else
                        {
                            printf("该账户不是管理员\n");
                            strcpy(user.info,"该账户不是管理员");
                            send(clifd[i],&user,sizeof(user),0);
                        }
                        break;
                    }
                    case EXIT:break;
                    default:printf("输入错误\n");
                }
            }
        }
    }
}

int isKick(void)//判断是否踢出
{
    int row=0;
    char buf_kick[1000]={0};
    //查找该人是否为管理员
    sprintf(buf_kick,"select admin from chatroom where id =%d",user.sjid);
    mysql_real_query(con,buf_kick,strlen(buf_kick));

    //把查找的数据放入结构体中----对其操作的都要放在数组中
    MYSQL_RES* res = mysql_store_result(con);
    row = mysql_num_rows(res);
    char **a =mysql_fetch_row(res);//找到了一行中一个数据

    if(strcmp("-1",a[0])==0)
        return -1;
    else 
        return 1;
}


int isMushin(void)//判断是否禁言
{
    int row=0;
    char buf_jinyan[1000]={0};
    //查找该人是否为管理员
    sprintf(buf_jinyan,"select admin from chatroom where id =%d",user.sjid);
    mysql_real_query(con,buf_jinyan,strlen(buf_jinyan));

    //把查找的数据放入结构体中----对其操作的都要放在数组中
    MYSQL_RES* res = mysql_store_result(con);
    row = mysql_num_rows(res);
    char **a =mysql_fetch_row(res);//找到了一行中一个数据

    if(strcmp("-2",a[0])==0)
        return -2;
    else 
        return 1;
}

void chat_Log(struct User user)//查看聊天记录功能
{
    int filefd = open("./Account/ChatLog.txt",O_CREAT|O_WRONLY|O_APPEND,0644);
    if(filefd == -1)
    {
        perror("filefd");
        return;
    }  

    write(filefd,&user,sizeof(user));
    close(filefd);
}


int open_Account(void)//为用户开账号
{
    int cur_id = 1000;
    int filefd = open("./Account/account.txt",O_CREAT|O_RDWR,0644);
    if(filefd == -1)
    {
        perror("filefd");
        return -1;
    }  
    read(filefd,&cur_id,sizeof(int));
    cur_id++;
    lseek(filefd,SEEK_SET,0);
    write(filefd,&cur_id,sizeof(int));
    close(filefd);
    return cur_id;
}

#ifndef _COMMOND_H_ 
#define _COMMOND_H_

#include <sys/types.h>        
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h> 
#include <arpa/inet.h>
#include <string.h>
#include <stdio.h>
#include <pthread.h>
#include <sys/time.h>
#include <unistd.h>
#include<mysql/mysql.h>
#include<string.h>
#include <fcntl.h>
#include<time.h>
#define IP "127.0.0.1"
#define PORT 23456

enum {EXIT,REGISTER,LOGIN,DEL,GROUPCHAT,PRIVATECHAT,CHAT_LOG,QUIT_LOGIN,ADMIN,SETADMIN,MUSHIN,KICK,ISADMIN,};//注册登陆注销//群聊私聊
/*
0-----正常用户
1-----管理员
-2----禁言
-1----踢出
*/


struct User
{
    int admin;//    0：正常用户   1：管理员   -2：禁言    -1：踢出
    int id;
    int sjid;//私聊接收方的id
    int sfid;//私聊发送方的id
    char name[20];
    char passwd[20];
    char info[100];//打印信息
    int change;//选择
    char f_write[500];//输入内容
    int status;//状态
    char time_buf[100];//存放时间：保存聊天信息和打印聊天信息
};

struct clifdId
{
    int id;
    int clifd;
};

struct SiL
{
    int sjid;//私聊接收方的id
    int sfid;//私聊发送方的id
    int fclifd;
    int jclifd;
};

#endif