UDP网络聊天室（服务器）

最新推荐文章于 2024-04-03 21:50:39 发布
最新推荐文章于 2024-04-03 21:50:39 发布
阅读量709 收藏
点赞数
分类专栏： 项目
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40945965/article/details/78917720
版权

/***************************************************************

File Name: server.h
Author: 浮生流年
Function List: main() 主函数
Created Time: 2017年12月12日 星期二 20时17分13秒
**************************************************************/

#ifndef _UDP_NET_SOCKET_
#define _UDP_NET_SOCKET_

#include <sys/types.h>
#include <sys/socket.h>
#include <stdlib.h>
#include <string.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <pthread.h>
#include <sqlite3.h>

#define PORT            8888


struct userinfo
{
    int flag;//
    char buf[100];//
    char account[20];
    char password[20];
    char nickname[100];
    char moto[256];
    int likes;
    char vip[20];
    char qq_email[64];
    char administrator[20];//管理员
    char msg[1024];//存储对话消息
    char to_nickname[20];
    int online_number;
    char online_nickname[100][20];//存储在线人员名单
    char file_name[64];//文件名称 
    char file_content[4096];//文件内容
    char shut_up[20];//禁言标志位
    char tmp_name[20];
};

typedef struct userinfo Userinfo;

struct node
{
    struct sockaddr_in client_addr;
    char nickname[20];
    struct node *next;
};

typedef struct node Node;

void forgot(sqlite3 *ppdb, Userinfo *recvbuf, Node **head, struct sockaddr_in *tmp_addr, int *sockfd);

#endif
#include <stdio.h>

#include "server.h"




void server_save_info(sqlite3 *ppdb, Userinfo *recvbuf, Userinfo *sendbuf)
{
    int ret;
    char auff[1024];

    sprintf(auff, "insert into save_info values('%s', '%s', '%s', '%s', '%d', '%s', '%s', '%s', '%s')", recvbuf->account, recvbuf->password,
            recvbuf->nickname, recvbuf->moto, recvbuf->likes, recvbuf->vip, recvbuf->qq_email, recvbuf->administrator, recvbuf->shut_up);
    ret = sqlite3_exec(ppdb, auff, NULL, NULL, NULL);
    if (ret != SQLITE_OK)
    {
        perror("sqlite3_exec");
        strcpy(sendbuf->buf, "帐号已存在！");
    }
    else
    {
        strcpy(sendbuf->buf, "注册成功！");
    }
}


void server_login(sqlite3 *ppdb, Userinfo *recvbuf, Userinfo *sendbuf, Node **head, struct sockaddr_in *tmp_addr)
{
    bzero(sendbuf, sizeof(*sendbuf));
    char **dbresult = NULL;
    char *errmsg = NULL;//用来存储错误信息字符串
    int nrow;//查询出多少记录（总行数）
    int ncolumn;//查询出来的记录有多少字段,(总列数)
    int ret, i;
    char cuff[1024];

    sprintf(cuff, "select account, password, nickname, moto, likes, vip , administrator from save_info where account = '%s' and password = '%s'", recvbuf->account, recvbuf->password);
    ret = sqlite3_get_table(ppdb, cuff, &dbresult, &nrow, &ncolumn, &errmsg);//执行成功返回SQLITE_OK，否则返回其他值
    if (ret != SQLITE_OK)
    {
        perror("sqlite3_get_table_server_login");
        return;
    }

    if (1 == nrow)
    {
        Node *tmp = (*head)->next;
        while (tmp != (*head))
        {
            if (!strcmp(tmp->nickname, dbresult[9]))
            {
                strcpy(sendbuf->buf, "该帐号已在其他地方登录！");
                return;
            }
            tmp = tmp->next;
        }

        strcpy(sendbuf->buf, "登录成功！");
        strcpy(sendbuf->nickname, dbresult[9]);
        strcpy(sendbuf->moto, dbresult[10]);
        sendbuf->likes = (*dbresult[11]) - 48;
        strcpy(sendbuf->vip, dbresult[12]);
        strcpy(sendbuf->administrator, dbresult[13]);

        Node *p = (Node *)malloc(sizeof(Node));//链表用来记录帐号是否已登录，登录的帐号接入链表
        if (NULL == p)
        {
            printf("Malloc Failure !\n");
            return;
        }
        p->client_addr.sin_family = tmp_addr->sin_family;
        p->client_addr.sin_port = tmp_addr->sin_port;
        p->client_addr.sin_addr.s_addr = tmp_addr->sin_addr.s_addr;

        strcpy(p->nickname, dbresult[9]);

        p->next = (*head)->next;
        (*head)->next = p;//循环链表；  记忆：head始终在最有边，新来的结点在最左边,head->next 始终指向p
    }
    else
    {
        strcpy(sendbuf->buf, "帐号或密码错误");
    }
}
void forgot_password(sqlite3 *ppdb, Userinfo *recvbuf, Node **head, struct sockaddr_in *tmp_addr, int *sockfd)
{
    Userinfo sendbuf = {0};
    bzero(&sendbuf, sizeof(sendbuf));
    char **dbresult = NULL;
    char *errmsg = NULL;//用来存储错误信息字符串
    int nrow;//查询出多少记录（总行数）
    int ncolumn;//查询出来的记录有多少字段,(总列数)
    int ret, i;
    char cuff[1024];

    sprintf(cuff, "select account, password from save_info where qq_email = '%s'", recvbuf->qq_email);
    ret = sqlite3_get_table(ppdb, cuff, &dbresult, &nrow, &ncolumn, &errmsg);//执行成功返回SQLITE_OK，否则返回其他值
    if (ret != SQLITE_OK)
    {
        perror("sqlite3_get_table_server_login");
        return;
    }

    if (1 == nrow)
    {
        strcpy(sendbuf.buf, "忘记密码");
        strcpy(sendbuf.account, dbresult[2]);
        strcpy(sendbuf.password, dbresult[3]);
        ret = sendto(*sockfd, &sendbuf, sizeof(sendbuf), 0, (struct sockaddr *)tmp_addr, sizeof(*tmp_addr));
        if (ret < 0)
        {
            perror("sendto_forgot_password");
            return;
        }
    }
    else
    {
        strcpy(sendbuf.buf, "该帐号未注册");
        ret = sendto(*sockfd, &sendbuf, sizeof(sendbuf), 0, (struct sockaddr *)tmp_addr, sizeof(*tmp_addr));
        if (ret < 0)
        {
            perror("sendto_forgot_password");
            return;
        }
    }
}
void transmit_to(sqlite3 *ppdb, Userinfo *sendbuf, Userinfo *recvbuf)//存储接收方用户信息to_nickname
{


    char **dbresult = NULL;
    char *errmsg = NULL;//用来存储错误信息字符串
    int nrow;//查询出多少记录（总行数）
    int ncolumn;//查询出来的记录有多少字段,(总列数)
    int ret, i;
    char cuff[1024];

    sprintf(cuff, "select shut_up, password, nickname, moto, likes, vip , administrator from save_info where nickname = '%s'", recvbuf->to_nickname);
    ret = sqlite3_get_table(ppdb, cuff, &dbresult, &nrow, &ncolumn, &errmsg);//执行成功返回SQLITE_OK，否则返回其他值
    if (ret != SQLITE_OK)
    {
        perror("sqlite3_get_table_server_login");
        return;
    }

    if (1 == nrow)
    {

        strcpy(sendbuf->shut_up, dbresult[7]);
        strcpy(sendbuf->nickname, dbresult[9]);//
        strcpy(sendbuf->moto, dbresult[10]);
        sendbuf->likes = (*dbresult[11]) - 48;
        strcpy(sendbuf->vip, dbresult[12]);
        strcpy(sendbuf->administrator, dbresult[13]);
    }
}
void transmit(sqlite3 *ppdb, Userinfo *sendbuf, Userinfo *recvbuf)//存储发送方用户信息
{


    char **dbresult = NULL;
    char *errmsg = NULL;//用来存储错误信息字符串
    int nrow;//查询出多少记录（总行数）
    int ncolumn;//查询出来的记录有多少字段,(总列数)
    int ret, i;
    char cuff[1024];

    sprintf(cuff, "select shut_up, password, nickname, moto, likes, vip , administrator from save_info where nickname = '%s'", recvbuf->nickname);
    ret = sqlite3_get_table(ppdb, cuff, &dbresult, &nrow, &ncolumn, &errmsg);//执行成功返回SQLITE_OK，否则返回其他值
    if (ret != SQLITE_OK)
    {
        perror("sqlite3_get_table_server_login");
        return;
    }

    if (1 == nrow)
    {

        strcpy(sendbuf->shut_up, dbresult[7]);
        strcpy(sendbuf->nickname, dbresult[9]);//
        strcpy(sendbuf->moto, dbresult[10]);
        sendbuf->likes = (*dbresult[11]) - 48;
        strcpy(sendbuf->vip, dbresult[12]);
        strcpy(sendbuf->administrator, dbresult[13]);
    }
}
void transmit_back(sqlite3 *ppdb, Userinfo *recvbuf, struct sockaddr_in *tmp_addr, int *sockfd)
    //存储发送方用户信息并直接返回发送方，用于处理客户端误操作或重复操作
{
    Userinfo sendbuf = {0};
    bzero(&sendbuf, sizeof(sendbuf));
    char **dbresult = NULL;
    char *errmsg = NULL;//用来存储错误信息字符串
    int nrow;//查询出多少记录（总行数）
    int ncolumn;//查询出来的记录有多少字段,(总列数)
    int ret, i;
    char cuff[1024];

    sprintf(cuff, "select shut_up, password, nickname, moto, likes, vip , administrator from save_info where nickname = '%s'", recvbuf->nickname);
    ret = sqlite3_get_table(ppdb, cuff, &dbresult, &nrow, &ncolumn, &errmsg);//执行成功返回SQLITE_OK，否则返回其他值
    if (ret != SQLITE_OK)
    {
        perror("sqlite3_get_table_server_login");
        return;
    }

    if (1 == nrow)
    {

        strcpy(sendbuf.shut_up, dbresult[7]);
        strcpy(sendbuf.nickname, dbresult[9]);//
        strcpy(sendbuf.moto, dbresult[10]);
        sendbuf.likes = (*dbresult[11]) - 48;
        strcpy(sendbuf.vip, dbresult[12]);
        strcpy(sendbuf.administrator, dbresult[13]);
    }
    ret = sendto(*sockfd, &sendbuf, sizeof(sendbuf), 0, (struct sockaddr *)tmp_addr, sizeof(*tmp_addr));
    if (ret < 0)
    {
        perror("sendto_transmit_back");
        return;
    }
}
void private_chat(sqlite3 *ppdb, Userinfo *recvbuf, Node **head, struct sockaddr_in *tmp_addr, int *sockfd)
{
    int ret;
    Userinfo sendbuf;
    bzero(&sendbuf, sizeof(sendbuf));
    Node *tmp = (*head)->next;
    Node *p = (*head)->next;
    while (p != *head)
    {
        p = p->next;
    }


    while (tmp != *head)
    {
        if (strcmp(tmp->nickname, recvbuf->to_nickname) == 0)//判断接收消息的用户是否已登录
        {
            strcpy(sendbuf.nickname, tmp->nickname);//把对方的名字发过去方便用于保存聊天记录
            strcpy(sendbuf.msg, recvbuf->msg);
            strcpy(sendbuf.tmp_name, recvbuf->nickname);
            strcpy(sendbuf.buf, "1私聊");//发送给指定用户

            transmit_to(ppdb, &sendbuf, recvbuf);//*********************************************************************
            ret = sendto(*sockfd, &sendbuf, sizeof(sendbuf), 0, (struct sockaddr *)&tmp->client_addr, sizeof(tmp->client_addr));
            if (ret < 0)
            { 
                perror("sendto_private_char_to_nickname");
                return;
            }
            bzero(&sendbuf, sizeof(sendbuf));
            strcpy(sendbuf.buf, "2正在转发私聊信息");
            transmit(ppdb, &sendbuf, recvbuf);//******************************************************************
            ret = sendto(*sockfd, &sendbuf, sizeof(sendbuf), 0, (struct sockaddr *)tmp_addr, sizeof(*tmp_addr));//发送给自己告知已发送消息
            bzero(&sendbuf, sizeof(sendbuf));
            if (ret < 0)
            {
                perror("sendto_private_char_nickname_success");
                return;
            }
            return;
        }
        tmp = tmp->next;
    }
    strcpy(sendbuf.buf, "3对方暂未登录");
    transmit(ppdb, &sendbuf, recvbuf);//*********************************************************************
    ret = sendto(*sockfd, &sendbuf, sizeof(sendbuf), 0, (struct sockaddr *)tmp_addr, sizeof(*tmp_addr));
    bzero(&sendbuf, sizeof(sendbuf));//ke yi bu yao
    if (ret < 0)
    {
        perror("sendto_private_char_nickname_not_login");
        return;
    }

}
void group_chat(sqlite3 *ppdb, Userinfo *recvbuf, Node **head, struct sockaddr_in *tmp_addr, int *sockfd)//群聊
{
    int ret, flag = 0;
    Userinfo sendbuf = {0};
    bzero(&sendbuf, sizeof(sendbuf));

    Node *tmp = (*head)->next;
    while (tmp != *head)
    {
        if (tmp->client_addr.sin_port != tmp_addr->sin_port)
        {
            flag = 1;
            strcpy(sendbuf.tmp_name, recvbuf->nickname);

            strcpy(sendbuf.msg, recvbuf->msg);

            strcpy(sendbuf.buf, "5发起群聊");
            ret = sendto(*sockfd, &sendbuf, sizeof(sendbuf), 0, (struct sockaddr *)&tmp->client_addr, sizeof(tmp->client_addr));
            bzero(&sendbuf, sizeof(sendbuf));
            if (ret < 0)
            {
                perror("sendto_group_chat");
                return;
            }
        }
        tmp = tmp->next;
    }
    if (1 == flag)
    {
        strcpy(sendbuf.buf, "2群聊成功");
        transmit(ppdb, &sendbuf, recvbuf);//*********************************************************************
        ret = sendto(*sockfd, &sendbuf, sizeof(sendbuf), 0, (struct sockaddr *)tmp_addr, sizeof(*tmp_addr));
        if (ret < 0)
        {
            perror("sendto_group_chat_success");
            return;
        }
    }
    else 
    {
        strcpy(sendbuf.buf, "6群聊失败");
        transmit(ppdb, &sendbuf, recvbuf);//*********************************************************************
        ret = sendto(*sockfd, &sendbuf, sizeof(sendbuf), 0, (struct sockaddr *)tmp_addr, sizeof(*tmp_addr));
        if (ret < 0)
        {
            perror("sendto_group_chat_faliure");
            return;
        }
    }
}
void file_transfer(sqlite3 *ppdb, Userinfo *recvbuf, Node **head, struct sockaddr_in *tmp_addr, int *sockfd)//注意这个head传参
{
    int ret, flag = 0;
    Userinfo sendbuf = {0};
    bzero(&sendbuf, sizeof(sendbuf));

    Node *tmp = (*head)->next;
    while (tmp != (*head))
    {
        if (!strcmp(tmp->nickname, recvbuf->to_nickname))
        {
            flag = 1;
            strcpy(sendbuf.tmp_name, recvbuf->nickname);
            strcpy(sendbuf.file_name, recvbuf->file_name);//拷贝文件名
            strcpy(sendbuf.file_content, recvbuf->file_content);//拷贝文件内容
            strcpy(sendbuf.buf, "7传输文件");
            transmit_to(ppdb, &sendbuf, recvbuf);//*********************************************************************
            ret = sendto(*sockfd, &sendbuf, sizeof(sendbuf), 0, (struct sockaddr *)&tmp->client_addr, sizeof(tmp->client_addr));
            bzero(&sendbuf, sizeof(sendbuf));
            if (ret < 0)
            {
                perror("sendto_group_chat");
                return;
            }
        }
        tmp = tmp->next;
    }

    if (1 == flag)
    {
        strcpy(sendbuf.buf, "2文件传输成功");
        transmit(ppdb, &sendbuf, recvbuf);//*********************************************************************
        ret = sendto(*sockfd, &sendbuf, sizeof(sendbuf), 0, (struct sockaddr *)tmp_addr, sizeof(*tmp_addr));
        if (ret < 0)
        {
            perror("sendto_file_transfer_success");
            return;
        }
    }
    else 
    {
        strcpy(sendbuf.buf, "6文件传输失败");
        transmit(ppdb, &sendbuf, recvbuf);//*********************************************************************
        ret = sendto(*sockfd, &sendbuf, sizeof(sendbuf), 0, (struct sockaddr *)tmp_addr, sizeof(*tmp_addr));
        if (ret < 0)
        {
            perror("sendto_file_transfer_faliure");
            return;
        }
    }
}
void online_number(sqlite3 *ppdb, Userinfo *sendbuf, Userinfo *recvbuf, Node **head)//查看在线人数以及打印名单
{

    bzero(&sendbuf->online_nickname, sizeof(sendbuf->online_nickname));
    sendbuf->online_number = 0;
    Node *tmp = (*head)->next;
    printf("****************&&&&&&&&&&&&&&&&&&1\n");
    while (tmp != *head)
    {
        printf("****************&&&&&&&&&&&&&&&&&&&2\n");
    //  strcpy(sendbuf->online_nickname[sendbuf->online_number], tmp->nickname);//指针并没有malloc,等我有空malloc一下试试
    //  sendbuf->online_nickname[sendbuf->online_number] = tmp->nickname;
    //  sendbuf->online_nickname[sendbuf->online_number] = tmp->nickname;//这样的话只能传送地址，地址中的信息传递不了
        strcpy(sendbuf->online_nickname[sendbuf->online_number], tmp->nickname);//数组越界：之前定义数组char online_nickname[100][100]?    
        printf("***********************&&&&&&&&&&3\n");

        printf("tmp->nickname:%s\n", tmp->nickname);

        printf("online_nickname:%s\n", sendbuf->online_nickname[sendbuf->online_number]);

        sendbuf->online_number++;
        tmp = tmp->next;
    }
    strcpy(sendbuf->buf, "4在线人数");
    transmit(ppdb, sendbuf, recvbuf);//*********************************************************************
}
void give_like(sqlite3 *ppdb, Userinfo *recvbuf, Node **head, struct sockaddr_in *tmp_addr, int *sockfd)
{
    int ret, i;
    int nrow;
    int ncolumn;
    char cuff[1024];
    char *errmsg = NULL;
    char **dbresult = NULL;
    Userinfo sendbuf = {0};
    bzero(&sendbuf, sizeof(sendbuf));//应该多余吧

    sprintf(cuff, "select likes from save_info where nickname = '%s'", recvbuf->to_nickname);
    ret = sqlite3_get_table(ppdb, cuff, &dbresult, &nrow, &ncolumn, &errmsg);
    if (ret != SQLITE_OK)
    {
        printf("select failure : %d(%s)\n", ret, errmsg);
        return;
    }

    if (1 == nrow)//只要此用户注册过，就为其点赞
    {
        sprintf(cuff, "update save_info set likes = likes + %d where nickname = '%s'", 1, recvbuf->to_nickname);
        ret = sqlite3_exec(ppdb, cuff, NULL, NULL, &errmsg);
        if (ret != SQLITE_OK)
        {
            printf("update failure : %d(%s)\n", ret, errmsg);
            return;
        }

        Node *tmp = (*head)->next;
        while (tmp != (*head))//遍历登录用户
        {
            printf("$$$$$$$$$$##########$$$$$$$$$$$2\n");
            if (!strcmp(tmp->nickname, recvbuf->to_nickname))//若登录，则向其发送提醒消息
            {
                printf("$$$$$$$$$$$$$$$$$#################$$$$$$$$$$$$$3\n");
                strcpy(sendbuf.buf, "8已为该登录用户点赞");

                transmit_to(ppdb, &sendbuf, recvbuf);//*********************************************************************

                sendbuf.likes = *(dbresult[1]);
                strcpy(sendbuf.tmp_name, recvbuf->nickname);

                ret = sendto(*sockfd, &sendbuf, sizeof(sendbuf), 0, (struct sockaddr *)&tmp->client_addr, sizeof(tmp->client_addr));
                bzero(&sendbuf, sizeof(sendbuf));
                if (ret < 0)
                {
                    perror("sendto_give_like");
                    return;
                }
                break;
            }
            tmp = tmp->next;
        }
        strcpy(sendbuf.buf, "9点赞成功");
        transmit(ppdb, &sendbuf, recvbuf);//*********************************************************************
        ret = sendto(*sockfd, &sendbuf, sizeof(sendbuf), 0, (struct sockaddr *)tmp_addr, sizeof(*tmp_addr));
        if (ret < 0)
        {
            perror("sendto_give_like_success");
            return;
        }
    }
    else
    {
        strcpy(sendbuf.buf, "10点赞失败");
        transmit(ppdb, &sendbuf, recvbuf);//*********************************************************************
        ret = sendto(*sockfd, &sendbuf, sizeof(sendbuf), 0, (struct sockaddr *)tmp_addr, sizeof(*tmp_addr));
        if (ret < 0)
        {
            perror("sendto_give_like_failure");
            return;
        }
    }
}
void change_character_signature(sqlite3 *ppdb, Userinfo *recvbuf, struct sockaddr_in *tmp_addr, int *sockfd)//修改个性签名
{
    int ret;
    char moto[1024];
    char *errmsg = NULL;
    Userinfo sendbuf = {0};


    sprintf(moto, "update save_info set moto = '%s' where nickname = '%s'", recvbuf->moto, recvbuf->nickname);

    ret = sqlite3_exec(ppdb, moto, NULL, NULL, &errmsg);
    if (ret != SQLITE_OK)
    {
        printf("update failure : %d(%s)\n", ret, errmsg);
        return;
    }

    strcpy(sendbuf.moto, recvbuf->moto);
    strcpy(sendbuf.buf, "11个性签名修改成功");
        transmit(ppdb, &sendbuf, recvbuf);//*********************************************************************
    ret = sendto(*sockfd, &sendbuf, sizeof(sendbuf), 0, (struct sockaddr *)tmp_addr, sizeof(*tmp_addr));
    if (ret < 0)
    {
        perror("sendto_change_character_signature_");
        return;
    }
}
void register_member(sqlite3 *ppdb, Userinfo *recvbuf, struct sockaddr_in *tmp_addr, int *sockfd)//处理注册会员
{
    int ret;
    char member[1024];
    char *errmsg = NULL;
    Userinfo sendbuf = {0};

    sprintf(member, "update save_info set vip = '%s' where nickname = '%s'", recvbuf->vip, recvbuf->nickname);

    ret = sqlite3_exec(ppdb, member, NULL, NULL, &errmsg);
    if (ret < 0)
    {
        perror("sqlite3_exec_register_member");
        return;
    }

    transmit(ppdb, &sendbuf, recvbuf);//*********************************************************************
    strcpy(sendbuf.vip, "荣耀会员");
    strcpy(sendbuf.buf, "12注册会员成功");


    ret = sendto(*sockfd, &sendbuf, sizeof(sendbuf), 0, (struct sockaddr *)tmp_addr, sizeof(*tmp_addr));
    if (ret < 0)
    {
        perror("sendto_register_member");
        return;
    }
}
void shut_up_person(sqlite3 *ppdb, Userinfo *recvbuf, Node **head, struct sockaddr_in *tmp_addr, int *sockfd)//指定用户禁言（只针对群聊）
{
    int ret, i;
    int nrow;
    int ncolumn;
    char cuff[1024];
    char *errmsg = NULL;
    char **dbresult = NULL;
    Userinfo sendbuf = {0};
    bzero(&sendbuf, sizeof(sendbuf));//应该多余吧

    sprintf(cuff, "select shut_up from save_info where nickname = '%s'", recvbuf->to_nickname);
    ret = sqlite3_get_table(ppdb, cuff, &dbresult, &nrow, &ncolumn, &errmsg);
    if (ret != SQLITE_OK)
    {
        printf("select failure : %d(%s)\n", ret, errmsg);
        return;
    }

    if (1 == nrow)//只要此用户注册过，就可以禁言
    {
        sprintf(cuff, "update save_info set shut_up = '%s' where nickname = '%s'", recvbuf->shut_up, recvbuf->to_nickname);
        ret = sqlite3_exec(ppdb, cuff, NULL, NULL, &errmsg);
        if (ret != SQLITE_OK)
        {
            printf("update failure : %d(%s)\n", ret, errmsg);
            return;
        }

        Node *tmp = (*head)->next;
        while (tmp != (*head))//遍历登录用户
        {
            printf("$$$$$$$$$$##########$$$$$$$$$$$2\n");
            if (!strcmp(tmp->nickname, recvbuf->to_nickname))//若登录，则向其发送提醒消息
            {
                printf("$$$$$$$$$$$$$$$$$#################$$$$$$$$$$$$$3\n");
                strcpy(sendbuf.buf, "13已将该登录用户禁言");


                transmit_to(ppdb, &sendbuf, recvbuf);//*********************************************************************

                strcpy(sendbuf.tmp_name, recvbuf->nickname);

                ret = sendto(*sockfd, &sendbuf, sizeof(sendbuf), 0, (struct sockaddr *)&tmp->client_addr, sizeof(tmp->client_addr));
                bzero(&sendbuf, sizeof(sendbuf));
                if (ret < 0)
                {
                    perror("sendto_shut_up");
                    return;
                }
                break;
            }
            tmp = tmp->next;
        }
        strcpy(sendbuf.buf, "14禁言成功");
        transmit(ppdb, &sendbuf, recvbuf);//*********************************************************************
        ret = sendto(*sockfd, &sendbuf, sizeof(sendbuf), 0, (struct sockaddr *)tmp_addr, sizeof(*tmp_addr));
        if (ret < 0)
        {
            perror("sendto_shut_up__success");
            return;
        }
    }
    else
    {
        strcpy(sendbuf.buf, "15禁言失败");
        transmit(ppdb, &sendbuf, recvbuf);//*********************************************************************
        ret = sendto(*sockfd, &sendbuf, sizeof(sendbuf), 0, (struct sockaddr *)tmp_addr, sizeof(*tmp_addr));
        if (ret < 0)
        {
            perror("sendto_shut_up_failure");
            return;
        }
    }
}
void shut_up_all(sqlite3 *ppdb, Userinfo *recvbuf, Node **head, struct sockaddr_in *tmp_addr, int *sockfd)//全员禁言（只针对群聊）
    //新注册用户还能群聊，真尴尬！！！
{
    int ret, i, flag = 0;
    char sql[1024];
    Userinfo sendbuf = {0};


    sprintf(sql, "update save_info set shut_up = '%s' where nickname != '%s'", recvbuf->shut_up, recvbuf->nickname);
    ret = sqlite3_exec(ppdb, sql, NULL, NULL, NULL);
    if (ret < 0)
    {
        perror("sqlite3_exec_shut_up_all");
        return;
    }

    strcpy(sendbuf.buf, "16全员禁言成功");    
    transmit(ppdb, &sendbuf, recvbuf);//*********************************************************************


    ret = sendto(*sockfd, &sendbuf, sizeof(sendbuf), 0, (struct sockaddr *)tmp_addr, sizeof(*tmp_addr));
    if (ret < 0)
    {
        perror("sendto_shut_up_all_success");
        return;
    }


    Node *tmp = (*head)->next;//如果用户在线， 就发消息通知
    while (tmp != *head)
    {
        if (tmp->client_addr.sin_port != tmp_addr->sin_port)
        {
            flag = 1;
            strcpy(sendbuf.tmp_name, recvbuf->nickname);

            strcpy(sendbuf.buf, "17本群开始禁言");
            transmit_to(ppdb, &sendbuf, recvbuf);//*********************************************************************
            ret = sendto(*sockfd, &sendbuf, sizeof(sendbuf), 0, (struct sockaddr *)&tmp->client_addr, sizeof(tmp->client_addr));
            bzero(&sendbuf, sizeof(sendbuf));
            if (ret < 0)
            {
                perror("sendto_group_chat");
                return;
            }
        }
        tmp = tmp->next;
    }
}   

void remove_banned(sqlite3 *ppdb, Userinfo *recvbuf, Node **head, struct sockaddr_in *tmp_addr, int *sockfd)//指定用户解禁（只针对群聊）
{
    int ret, i;
    int nrow;
    int ncolumn;
    char cuff[1024];
    char *errmsg = NULL;
    char **dbresult = NULL;
    Userinfo sendbuf = {0};

    sprintf(cuff, "select shut_up from save_info where nickname = '%s'", recvbuf->to_nickname);
    ret = sqlite3_get_table(ppdb, cuff, &dbresult, &nrow, &ncolumn, &errmsg);
    if (ret != SQLITE_OK)
    {
        printf("select failure : %d(%s)\n", ret, errmsg);
        return;
    }

    if (1 == nrow)//只要此用户注册过，就可以解禁
    {
        sprintf(cuff, "update save_info set shut_up = '%s' where nickname = '%s'", recvbuf->shut_up, recvbuf->to_nickname);
        ret = sqlite3_exec(ppdb, cuff, NULL, NULL, &errmsg);
        if (ret != SQLITE_OK)
        {
            printf("update failure : %d(%s)\n", ret, errmsg);
            return;
        }

        Node *tmp = (*head)->next;
        while (tmp != (*head))//遍历登录用户
        {
            printf("$$$$$$$$$$##########$$$$$$$$$$$2\n");
            if (!strcmp(tmp->nickname, recvbuf->to_nickname))//若登录，则向其发送提醒消息
            {
                printf("$$$$$$$$$$$$$$$$$#################$$$$$$$$$$$$$3\n");
                strcpy(sendbuf.buf, "18已将该登录用户禁言");

                transmit_to(ppdb, &sendbuf, recvbuf);//*********************************************************************


                strcpy(sendbuf.tmp_name, recvbuf->nickname);

                ret = sendto(*sockfd, &sendbuf, sizeof(sendbuf), 0, (struct sockaddr *)&tmp->client_addr, sizeof(tmp->client_addr));
                bzero(&sendbuf, sizeof(sendbuf));
                if (ret < 0)
                {
                    perror("sendto_remove_banned");
                    return;
                }
                break;
            }
            tmp = tmp->next;
        }
        strcpy(sendbuf.buf, "19解禁成功");
        transmit(ppdb, &sendbuf, recvbuf);//*********************************************************************
        ret = sendto(*sockfd, &sendbuf, sizeof(sendbuf), 0, (struct sockaddr *)tmp_addr, sizeof(*tmp_addr));
        if (ret < 0)
        {
            perror("sendto_shut_up__success");
            return;
        }
    }
    else
    {
        strcpy(sendbuf.buf, "20解禁失败");
        transmit(ppdb, &sendbuf, recvbuf);//*********************************************************************
        ret = sendto(*sockfd, &sendbuf, sizeof(sendbuf), 0, (struct sockaddr *)tmp_addr, sizeof(*tmp_addr));
        if (ret < 0)
        {
            perror("sendto_shut_up_failure");
            return;
        }
    }
}
void remove_banned_all(sqlite3 *ppdb, Userinfo *recvbuf, Node **head, struct sockaddr_in *tmp_addr, int *sockfd)//全员解禁（只针对群聊）
{
    int ret, i, flag = 0;
    char sql[1024];
    Userinfo sendbuf = {0};


    sprintf(sql, "update save_info set shut_up = '%s' where nickname != '%s'", recvbuf->shut_up, recvbuf->nickname);
    ret = sqlite3_exec(ppdb, sql, NULL, NULL, NULL);
    if (ret < 0)
    {
        perror("sqlite3_exec_shut_up_all");
        return;
    }

    strcpy(sendbuf.buf, "21全员解禁成功");    
    transmit(ppdb, &sendbuf, recvbuf);//*********************************************************************


    ret = sendto(*sockfd, &sendbuf, sizeof(sendbuf), 0, (struct sockaddr *)tmp_addr, sizeof(*tmp_addr));
    if (ret < 0)
    {
        perror("sendto_shut_up_all_success");
        return;
    }


    Node *tmp = (*head)->next;//如果用户在线， 就发消息通知
    while (tmp != *head)
    {
        if (tmp->client_addr.sin_port != tmp_addr->sin_port)
        {
            flag = 1;
            strcpy(sendbuf.tmp_name, recvbuf->nickname);

            strcpy(sendbuf.buf, "22本群已被解禁");
            transmit_to(ppdb, &sendbuf, recvbuf);//*********************************************************************
            ret = sendto(*sockfd, &sendbuf, sizeof(sendbuf), 0, (struct sockaddr *)&tmp->client_addr, sizeof(tmp->client_addr));
            bzero(&sendbuf, sizeof(sendbuf));
            if (ret < 0)
            {
                perror("sendto_group_chat");
                return;
            }
        }
        tmp = tmp->next;
    }
}   
void kicking(sqlite3 *ppdb, Userinfo *recvbuf, Node **head, struct sockaddr_in *tmp_addr, int *sockfd)//踢人（强制下线）
{
    int ret, i;
    int nrow;
    int ncolumn;
    char cuff[1024];
    char *errmsg = NULL;
    char **dbresult = NULL;
    Userinfo sendbuf = {0};
    Userinfo RecvBuf = {0};

    sprintf(cuff, "select shut_up from save_info where nickname = '%s'", recvbuf->to_nickname);//
    ret = sqlite3_get_table(ppdb, cuff, &dbresult, &nrow, &ncolumn, &errmsg);
    if (ret != SQLITE_OK)
    {
        printf("select failure : %d(%s)\n", ret, errmsg);
        return;
    }

    if (1 == nrow)//注册过（判断此用户是否注册过）
    {
        Node *tmp = *head;
        while (tmp->next != *head)//判断该用户是否已登录
        {
            if (!strcmp(tmp->next->nickname, recvbuf->to_nickname))//若登录，则向其发送提醒消息
            {

                strcpy(sendbuf.buf, "23已将该登录用户强制下线");

                transmit_to(ppdb, &sendbuf, recvbuf);//*********************************************************************
                strcpy(sendbuf.tmp_name, recvbuf->nickname);

                ret = sendto(*sockfd, &sendbuf, sizeof(sendbuf), 0, (struct sockaddr *)&tmp->next->client_addr, sizeof(tmp->next->client_addr));
                Node *p = tmp->next;//释放节点必须要在发送数据后，否则节点地址及内容就消失了，无法传送到指定客户端
                tmp->next = p->next;
                free(p);

                bzero(&sendbuf, sizeof(sendbuf));
                if (ret < 0)
                {
                    perror("sendto_remove_banned");
                    return;
                }
                strcpy(sendbuf.buf, "24踢人成功");
                transmit(ppdb, &sendbuf, recvbuf);//*********************************************************************


                ret = sendto(*sockfd, &sendbuf, sizeof(sendbuf), 0, (struct sockaddr *)tmp_addr, sizeof(*tmp_addr));
                bzero(&sendbuf, sizeof(sendbuf));
                if (ret < 0)
                {
                    perror("sendto_shut_up__success");
                    return;
                }
                bzero(&sendbuf,sizeof(sendbuf));

                Node *temp = (*head)->next;
                while (temp != *head)
                {
                    if (strcmp(temp->nickname, recvbuf->nickname))
                    {
                        strcpy(sendbuf.tmp_name, recvbuf->to_nickname);

                        strcpy(sendbuf.buf, "29好友下线通知");
                        strcpy(RecvBuf.nickname, temp->nickname);
                        transmit(ppdb, &sendbuf, &RecvBuf);//*********************************************************************
                        ret = sendto(*sockfd, &sendbuf, sizeof(sendbuf), 0, (struct sockaddr *)&temp->client_addr, sizeof(temp->client_addr));
                        bzero(&sendbuf, sizeof(sendbuf));
                        bzero(&RecvBuf, sizeof(RecvBuf));
                        if (ret < 0)
                        {
                            perror("sendto_group_chat");
                            return;
                        }
                    }
                    temp = temp->next;
                }

                return;
            }
            tmp = tmp->next;
        }
        strcpy(sendbuf.buf, "25踢人失败");//注册但未登录
        transmit(ppdb, &sendbuf, recvbuf);//*********************************************************************
        ret = sendto(*sockfd, &sendbuf, sizeof(sendbuf), 0, (struct sockaddr *)tmp_addr, sizeof(*tmp_addr));
        bzero(&sendbuf, sizeof(sendbuf));
        if (ret < 0)
        {
            perror("sendto_shut_up__success");
            return;
        }
        return;
    }
    else//没注册过
    {
        strcpy(sendbuf.buf, "26踢人失败");
        transmit(ppdb, &sendbuf, recvbuf);//*********************************************************************
        ret = sendto(*sockfd, &sendbuf, sizeof(sendbuf), 0, (struct sockaddr *)tmp_addr, sizeof(*tmp_addr));
        if (ret < 0)
        {
            perror("sendto_shut_up_failure");
            return;
        }
    }
}
void offline(sqlite3 *ppdb, Userinfo *recvbuf, Node **head, struct sockaddr_in *tmp_addr, int *sockfd)//主动下线（不终止客户端）
{
    int ret;
    Userinfo sendbuf = {0};
    bzero(&sendbuf, sizeof(sendbuf));
    Userinfo RecvBuf = {0};

    Node *tmp = (*head)->next;
    while (tmp != *head)
    {
        if (strcmp(tmp->nickname, recvbuf->nickname))
        {
            strcpy(sendbuf.tmp_name, recvbuf->nickname);

            strcpy(sendbuf.buf, "29好友下线通知");
            strcpy(RecvBuf.nickname, tmp->nickname);
            transmit(ppdb, &sendbuf, &RecvBuf);//*********************************************************************
            ret = sendto(*sockfd, &sendbuf, sizeof(sendbuf), 0, (struct sockaddr *)&tmp->client_addr, sizeof(tmp->client_addr));
            bzero(&sendbuf, sizeof(sendbuf));
            bzero(&RecvBuf, sizeof(RecvBuf));
            if (ret < 0)
            {
                perror("sendto_group_chat");
                return;
            }
        }
        tmp = tmp->next;
    }

    Node *temp = *head;//这种方式较好
    while (temp->next != *head)
    {
        if (!strcmp(temp->next->nickname, recvbuf->nickname))
        {
            Node *p = temp->next;
            temp->next = p->next;
            free(p);
            break;
        }
        temp = temp->next;
    }
    strcpy(sendbuf.buf, "27下线成功");//
    ret = sendto(*sockfd, &sendbuf, sizeof(sendbuf), 0, (struct sockaddr *)tmp_addr, sizeof(*tmp_addr));
    if (ret < 0)
    {
        perror("sendto_offline");
        return;
    }
}
void terminate_client(sqlite3 *ppdb, Userinfo *recvbuf, Node **head, int *sockfd)//主动下线（终止客户端）
{
    int ret;
    Userinfo sendbuf = {0};
    bzero(&sendbuf, sizeof(sendbuf));
    Userinfo RecvBuf = {0};

    Node *tmp = (*head)->next;
    while (tmp != *head)
    {
        if (strcmp(tmp->nickname, recvbuf->nickname))
        {
            strcpy(sendbuf.tmp_name, recvbuf->nickname);

            strcpy(sendbuf.buf, "29好友下线通知");
            strcpy(RecvBuf.nickname, tmp->nickname);
            transmit(ppdb, &sendbuf, &RecvBuf);//*********************************************************************
            ret = sendto(*sockfd, &sendbuf, sizeof(sendbuf), 0, (struct sockaddr *)&tmp->client_addr, sizeof(tmp->client_addr));
            bzero(&sendbuf, sizeof(sendbuf));
            bzero(&RecvBuf, sizeof(RecvBuf));
            if (ret < 0)
            {
                perror("sendto_group_chat");
                return;
            }
        }
        tmp = tmp->next;
    }

    Node *temp = *head;//这种方式较好
    while (temp->next != *head)
    {
        if (!strcmp(temp->next->nickname, recvbuf->nickname))
        {
            Node *p = temp->next;
            temp->next = p->next;
            free(p);
            break;
        }
        temp = temp->next;
    }
}

void friends_online_notification(sqlite3* ppdb, Userinfo *recvbuf, Node **head, struct sockaddr_in *tmp_addr, int *sockfd)//好友上线通知
{
    int ret;
    Userinfo sendbuf = {0};
    bzero(&sendbuf, sizeof(sendbuf));

    Userinfo RecvBuf = {0};

    Node *tmp = (*head)->next;
    while (tmp != *head)
    {
        if (strcmp(tmp->nickname, recvbuf->nickname))//链表中所有人除了自己
        {
            strcpy(sendbuf.tmp_name, recvbuf->nickname);

            strcpy(sendbuf.buf, "28好友上线通知");
            strcpy(RecvBuf.nickname, tmp->nickname);
            transmit(ppdb, &sendbuf, &RecvBuf);//*********************************************************************
            ret = sendto(*sockfd, &sendbuf, sizeof(sendbuf), 0, (struct sockaddr *)&tmp->client_addr, sizeof(tmp->client_addr));
            bzero(&sendbuf, sizeof(sendbuf));
            bzero(&RecvBuf, sizeof(RecvBuf));
            if (ret < 0)
            {
                perror("sendto_group_chat");
                return;
            }
        }
        tmp = tmp->next;
    }
}
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <string.h>
#include <stdlib.h>
#include "server.h"

#define PORT 8888
int main()
{
    int sockfd, length, ret, position;
    struct sockaddr_in server_addr;
//  struct sockaddr_in client_addr[100] = {0};//一次性记忆客户端，通过find_addr函数寻找,服务器停止后释放client_addr[100]中保存的内容
    struct sockaddr_in tmp_addr;
    char admin[512];

    Userinfo Sendbuf = {0};
    Userinfo Recvbuf = {0};
//  Userinfo recordbuf[100] = {0};
    sqlite3 *ppdb = NULL;

    char account[20] = "88888888";//初始化管理员信息
    char password[20] = "88888888";
    char nickname[100] = "浮生流年";
    char moto[256] = "山上山，水中水";
    int likes = 8888;
    char vip[20] = "至尊会员";
    char qq_email[64] = "1186461326";
    char administrator[20] = "管理员";
    char shut_up[20] = "未禁";

    Node *head = (Node *)malloc(sizeof(Node));
    if (NULL == head)
    {
        printf("Malloc Failure!\n");
        return;
    }
    head->next = head;

    ret = sqlite3_open("user.db", &ppdb);
    if (ret != SQLITE_OK)
    {
        perror("sqlite3_open");
        exit(1);
    }

    ret = sqlite3_exec(ppdb, "create table if not exists save_info(account text primary key, password text, nickname text, moto text, likes integer, vip text, qq_email text, administrator text, shut_up text);", NULL, NULL, NULL);
    if (ret != SQLITE_OK)
    {
        perror("sqlite3_exec_create_table");
        exit(1);
    }

    sprintf(admin, "insert into save_info values('%s', '%s', '%s', '%s', '%d', '%s', '%s', '%s', '%s')", account, password, nickname,
            moto, likes, vip, qq_email, administrator, shut_up);//服务器启动后自行生成一个管理员帐号
    ret = sqlite3_exec(ppdb, admin, NULL, NULL, NULL);
    if (ret != SQLITE_OK)
    {
        perror("sqlite3_exec_insert into");
        exit(1);
    }
    sockfd = socket(PF_INET, SOCK_DGRAM, 0);
    if (-1 == sockfd)
    {
        perror("socket");
        exit(1);

    }

    bzero(&server_addr, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = PORT;
    server_addr.sin_addr.s_addr = inet_addr("127.0.0.1");

    ret = bind(sockfd, (struct sockaddr *)&server_addr, sizeof(server_addr));
    if (ret < 0)
    {
        perror("bind");
        exit(1);
    }
while (1)//此程序默认所有登录用户都在一个群里，暂无加群功能
    {
        length = sizeof(tmp_addr);
        ret = recvfrom(sockfd, &Recvbuf, sizeof(Recvbuf), 0, (struct sockaddr *)&tmp_addr, &length);
        if (ret < 0)
        {
            perror("recvfrom");
            exit(1);
        }

        switch (Recvbuf.flag)
        {
            case 1://注册
                server_save_info(ppdb, &Recvbuf, &Sendbuf);
                ret = sendto(sockfd, &Sendbuf, sizeof(Sendbuf), 0, (struct sockaddr *)&tmp_addr, sizeof(tmp_addr));
                if (ret < 0)
                {
                    perror("sendto_server_save_info");
                    break;
                }
                bzero(&Recvbuf, sizeof(Recvbuf));
                bzero(&Sendbuf, sizeof(Sendbuf));
                if (ret < 0)
                {
                        perror("sendto_server_register");
                    exit(1);
                }
                break;
            case 2://登录
                server_login(ppdb, &Recvbuf, &Sendbuf, &head, &tmp_addr);
                bzero(&Recvbuf, sizeof(Recvbuf));
                ret = sendto(sockfd, &Sendbuf, sizeof(Sendbuf), 0, (struct sockaddr *)&tmp_addr, sizeof(tmp_addr));
                if (ret < 0)
                {
                        perror("sendto_server_login");
                    exit(1);
                }
                bzero(&Sendbuf, sizeof(Sendbuf));
                break;
            case 3 ://忘记密码
                forgot_password(ppdb, &Recvbuf, &head, &tmp_addr, &sockfd);
                break;
            case 4://私聊
                private_chat(ppdb, &Recvbuf, &head, &tmp_addr, &sockfd);
                bzero(&Recvbuf, sizeof(Recvbuf));
                break;
            case 5://群聊
                group_chat(ppdb, &Recvbuf, &head, &tmp_addr, &sockfd);
                bzero(&Recvbuf, sizeof(Recvbuf));
                break;
            case 6://文件传输
                file_transfer(ppdb, &Recvbuf, &head, &tmp_addr, &sockfd);
                bzero(&Recvbuf, sizeof(Recvbuf));
                break;
            case 7://在线人数
                bzero(&Sendbuf, sizeof(Sendbuf));
                online_number(ppdb, &Sendbuf, &Recvbuf, &head);

        //      printf("%s\n", Sendbuf.online_nickname[0]);
                ret = sendto(sockfd, &Sendbuf, sizeof(Sendbuf), 0, (struct sockaddr *)&tmp_addr, sizeof(tmp_addr));
                if (ret < 0)
                {
                    perror("sendto_onine_number");
                    break;
                }
                break;
            case 8://查看聊天记录（融合了）
                break;
            case 9://快捷消息（融合了）
                break;
            case 10://点赞
                give_like(ppdb, &Recvbuf, &head, &tmp_addr, &sockfd);
                break;
            case 11://修改签名
                change_character_signature(ppdb, &Recvbuf, &tmp_addr, &sockfd);
                break;
            case 12://vip（充钱）
                register_member(ppdb, &Recvbuf, &tmp_addr, &sockfd);
                break;
            case 13://指定用户禁言（管理员权限）（只针对群聊,不影响私聊）
                shut_up_person(ppdb, &Recvbuf, &head, &tmp_addr, &sockfd);
                break;
            case 14://全员禁言（管理员权限）（注册过但没登录的也要禁言，确保用户上线后处于被动静默状态）（只针对群聊,不影响私聊）
                shut_up_all(ppdb, &Recvbuf, &head, &tmp_addr, &sockfd);
                break;
            case 15://指定用户解禁 （管理员权限）（只针对群聊，不影响私聊）
                remove_banned(ppdb, &Recvbuf, &head, &tmp_addr, &sockfd);
                break;
            case 16://全员解禁（管理员权限）（注册过但没登录的也要解禁，确保用户上线后处于言论自由状态）（只针对群聊,不影响私聊）
                remove_banned_all(ppdb, &Recvbuf, &head, &tmp_addr, &sockfd);
                break;
            case 17://踢人（管理员权限）（不终止客户端程序运行）
                kicking(ppdb, &Recvbuf, &head, &tmp_addr, &sockfd);
                break;
            case 18://退出（下线）不终止客户端
                offline(ppdb, &Recvbuf, &head, &tmp_addr, &sockfd);
                break;
            case 19://退出（下线）终止客户端
                terminate_client(ppdb, &Recvbuf, &head, &sockfd);   
                break;
            case 20:transmit_back(ppdb, &Recvbuf, &tmp_addr, &sockfd);//处理客户端因误操作或重复操作而导致信息丢失
                break;
            case 21://好友上线通知
                friends_online_notification(ppdb, &Recvbuf, &head, &tmp_addr, &sockfd);
                break;
        }
    }

    close(sockfd);
    return 0;
}
浮生卍流年
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
【Linux】udp服务器实现大型网络聊天室
Sxy_wspsby的博客
07-18 1336
根据上一篇文章中对于英汉互译和远程操作的两个小功能大家应该已经学会了，我们的目的是让大家可以深刻的理解udp服务器所需要的接口已经实现的简单步骤，下面我们开始实现网络聊天室。一、udp服务器实现大型网络聊天室。
项目：UDP聊天室
m0_73731708的博客
09-14 319
3.建立传送消息的结构体，结构体分为三部分，分别是消息类型，昵称和消息正文。聊天：服务器只需要把某个客户端的聊天消息转发给所有其它客户端。退出：服务器删除退出客户端的地址，并把退出消息发送给其它客户端。4.客户端运行时，首先发送链接类型信息，进行链接。UDP客户端不会直接互连，所以不会获知其它客户端地址，所有客户端地址存储在服务器端。2.服务器采用有头单向链表，存储每个客户端的IP地址，链表节点结构体如下。登录：服务器存储新的客户端的地址。把某个客户端登录的消息发给其它客户端。服务器如何存储客户端的地址？
用UDP协议实现发送接收的网络聊天室
最新发布
多多的博客
04-03 7717
UDP协议是面向无连接的"面向无连接的"通常指的是一种网络通信模式，也称为无连接通信或者数据报通信。在这种模式下，通信的两个端点之间不需要建立持续的连接，而是通过将数据分成小块（数据包）并单独发送来进行通信。每个数据包都包含了足够的信息（如源地址、目标地址、序列号等）来独立地到达目的地，并且可能以不同的路径到达。无连接通信的优点包括简单、灵活和高效，因为不需要在通信的开始和结束时建立和释放连接。它适用于需要在网络中传输少量数据或需要快速发送数据的场景，比如实时音视频传输、互联网电话、在线游戏等。
基于UDP的网络聊天室
electriclover的博客
10-12 823
基于UDP的网络聊天室
【计算机网络】UDP服务器实现网络聊天室
m0_73209194的博客
08-08 228
上一篇文章我们简单了解了一下什么是套接字编程，这篇文章我们利用UDP套接字来实现一个简单的网络聊天室。
基于UDP的简易网络聊天室
laoKdx的博客
08-12 1716
基于UDP的简易聊天室
C#实现UDP简单聊天室功能（winform版）
11-22
开发工具使用的是VS2017，基于UDP协议实现的一个简单聊天室功能，包括客户端和服务器端，首先运行服务器端，接着调试->启动新实例开启多个客户端，每开启一个客户端，服务器端会显示XXX连接等提示。客户端发送消息给...
udp网络聊天室.rar
01-09
使用udp协议，多进程方式的服务器循环处理客户的消息请求，对不同的消息给与不同的相应
基于UDP协议的聊天程序
06-03
java环境下的基于UDP协议的聊天程序，udp协议聊天程序 具体功能： 1、实现多客户端之间的群聊功能； 2、客户端、服务器端均能显示在线用户列表； 3、服务器负责转发聊天消息；
基于UDP的群聊聊天室
04-13
udp协议，分为服务器端和客户端，命令行演示。
android手机网络聊天室
04-08
本作品是完成android手机网络聊天室的设计，服务器开启后，客户端将绑定到本地的IP和端口，主要界面只有一个，以下是任务目标。 1）服务器端肯定要使用多线程技术 2）服务器端收到任何一个用户发来的消息肯定要转发...
计算机网络编程udp视频聊天
10-07
计算机网络编程多人视频聊天，基于udp协议的多人网络视频聊天系统视频传输协议
Java网络编程 - 基于UDP协议 实现简单的聊天室程序
热门推荐
LaterEqualsNever
01-28 2万+
最近比较闲，一直在抽空回顾一些Java方面的技术应用。 今天没什么事做，基于UDP协议，写了一个非常简单的聊天室程序。 现在的工作，很少用到socket，也算是对Java网络编程方面的一个简单回忆。 先看一下效果： 实现的效果可以说是非常非常简单，但还是可以简单的看到一个实现原理。 “聊天室001”的用户，小红和小绿相互聊了两句，“聊天室002”的小黑无人理会，在一旁寂寞着。
UDP实现网络聊天室
gqggg的博客
08-12 258
聊天室
用UDP协议实现最简单的“聊天室”功能
MMT的专栏
08-17 1万+
小弟新人一枚，刚刚学习了网络编程的基础，就试着用UDP协议实现一个简单的“聊天室”，在写代码过程中也是各种出错，还好最终是实现了各种最基本的功能，在此记录一下当时写代码时的各种问题，希望跟我一样的新人能够避免某些常见问题，同时也希望能够得到大神的指点，看看代码还有哪里可以更加精简，更加效率。     首先我先来介绍一下实现这个聊天室的服务器端和客户端的大概流程，一会会把流程图传上来。
基于UDP的简单聊天室
IT呵呵哒的博客
04-15 4873
聊天室功能：        1.其他用户上线通知。        2.其他用户下线通知。        3.获取在线列表。        4.用户之间点对点聊天。实现思想：        1.服务器端主要是解析客户端发送过来的各种指令，并作出相应的处理和回应。        2.客户端采用select管理套接口IO和标准输入IO，当有事件发生，做出相应的处理。        3.采用链表存储每个客...
UDP协议网络编程及聊天室案例
weixin_43218601的博客
11-16 497
一.UDP协议 UDP协议是无连接通信协议，即在数据传输时，数据的发送端和接收端不建立逻辑连接。简单来说，当一台计算机向另外一台计算机发送数据时，发送端不会确认接收端是否存在，就会发出数据，同样接收端在收到数据时，也不会向发送端反馈是否收到数据。由于使用UDP协议消耗资源小，通信效率高，所以通常都会用于音频、视频和普通数据的传输例如视频会议都使用UDP协议，因为这种情况即使偶尔丢失一两个数据包，也不会对接收结果产生太大影响。但是在使用UDP协议传送数据时，由于UDP的面向无连接性，不能保证数据的完整性，因
UDP聊天器（新手小结）
ALL_P的博客
03-02 350
在了解tcp和udp之前我们应该先了解基本信息 1.IP ip地址：用来在网络中标记一台电脑 每一个IP地址包括两部分：网络地址和主机地址 2.端口 通俗来讲端口就好一个房子的门，是出入这间房子的必经之路。端口是通过端口号来标记的，端口号只有整数，范围是从0到65535 3.socket socket(简称 套接字) 是进程间通信的一种方式，它与其他进程间通信的一个主要不同是 它能实现不同主机间的...
多用户udp网络聊天室
06-03
好的，您想了解多用户UDP网络聊天室方面的知识，我可以为您提供一些基本的信息。 UDP（User Datagram Protocol，用户数据报协议）是一种无连接的传输层协议，它不保证数据传输的可靠性和顺序性，但具有较高的传输...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

浮生卍流年

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值