学习笔记：UDP实现进程心跳检测

最新推荐文章于 2024-09-07 11:33:31 发布
最新推荐文章于 2024-09-07 11:33:31 发布
阅读量7.9k 收藏 41
点赞数 6
分类专栏： 编程语言 文章标签： 心跳检测 UDP
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010312436/article/details/82020412
版权

思路：

UDP服务器端：服务器维护一个client链表，当有client连接创建新节点保存客户主机名和地址，并保存心跳时间heart_beat_time。

当客户端发起一次心跳，服务器收到心跳包更新client节点的心跳时间。服务定时去检测client链表里的每个client的心跳时间，如果心跳时间和当前时间的时间差超过一定的时间间隔，就认为该client已经掉线。

UDP客户端：定时发送心跳包。

服务端代码:

#include <stdio.h>  
#include <stdlib.h>  
#include <string.h>  
#include <sys/types.h>  
#include <sys/socket.h>  
#include <arpa/inet.h>  
#include <unistd.h>  
#include <signal.h>
#include <time.h>
#include <sys/timerfd.h>
#include <pthread.h>
#include <sys/epoll.h>

#define UDP_PORT_NUM   (8888)
  
#define CLIENT_LOGIN    100  
#define CLIENT_CHAT     200  
#define CLIENT_QUIT     300  
  
#define SERVER_CHAT     400  
#define SERVER_QUIT     500  
  
#define PRINT_ONLINE    600  
#define PRIVATE_CHAT    700

#define HEART_BEAT      800

static int s_epoll_fd = -1;

typedef enum
{
	E_CLIENT_OFF_LINE = 0,
	E_CLIENT_ON_LINE
}eClientSatus;

struct node   
{  
    char name[20];					// client name
    struct sockaddr_in client_addr; // client addr
	eClientSatus client_status;		// client status
	struct timespec heart_beat_time; 		// each heart beat update this time
    struct node *next;  
};  
  
struct message  
{  
    long type;  
    char name[20];  
    char peer_name[20];  
    char mtext[512];  
};  
  
struct node *create_list(void);  
void insert_list(struct node *, char *, struct sockaddr_in *);  
void delete_list(struct node *, char *);  
  
void recv_message(int , struct node *);  
void send_message(int , struct sockaddr_in *, pid_t );  
  
void client_login(int , struct node *, struct message *, struct sockaddr_in *);  
void client_chat(int , struct node *, struct message *);  
void client_quit(int , struct node *, struct message *);  
void server_chat(int , struct node *, struct message *);  
void server_quit(int , struct node *, struct message *);  
  
void brocast_msg(int , struct node *, struct message *);  
void print_online(int , struct node *, struct message *);  
void private_chat(int , struct node *, struct message *);  
  
void father_func(int sig_no)  
{  
    return ;  
}

/* return ms */
static int calcProcessTime(int *pStartMs)
{
	struct timespec endTime;
	clock_gettime(CLOCK_REALTIME, &endTime);
	if(pStartMs){
		return endTime.tv_sec * 1000 + endTime.tv_nsec / 1000000 - *pStartMs;
	}
	return endTime.tv_sec * 1000 + endTime.tv_nsec / 1000000;
}

static void epollAddEvent(int epollFd, int addFd, int state)
{
	struct epoll_event ev;
	ev.events = state;
	ev.data.fd = addFd;
	epoll_ctl(epollFd, EPOLL_CTL_ADD, addFd, &ev);
	return;
}

void* monitor_thread(void* user)
{
	struct node *head = (struct node *)user;
	struct epoll_event events[1] = {0};
	int cnt = 0;
	while(1)
	{
		int ms = 0;
		ms = calcProcessTime(NULL);
		int fireEvents = epoll_wait(s_epoll_fd, events, 1, -1);
		ms = calcProcessTime(&ms);
		if(fireEvents > 0){
			printf("monitor time out: %d ms\n", ms);
			uint64_t exp;
			ssize_t size = read(events[0].data.fd, &exp, sizeof(uint64_t));
			if(size != sizeof(uint64_t)) {
				printf("read error!\n");
			}

			struct node *p = head;
			struct timespec nowTime;
			clock_gettime(CLOCK_REALTIME, &nowTime);

			while (p != NULL){
				/* if 10 second not receive client heart beat, we think the client is offline */
		        if(p->client_status == E_CLIENT_ON_LINE) {
					int duration = (nowTime.tv_sec * 1000 + nowTime.tv_nsec / 1000000) - (p->heart_beat_time.tv_sec * 1000 + p->heart_beat_time.tv_nsec / 1000000);
					if (duration > 10000) {
						p->client_status = E_CLIENT_OFF_LINE;
						printf("client: %s had off line\n", p->name);
					}
		        }
				p = p->next;
		    }  
			printf("All client check finished\n");
			
		}
		else{
			printf("fireEvents = %d", fireEvents);
		}
	}
}
  
int main(int argc, const char *argv[])  
{  
    int socket_fd;  
    pid_t pid;  
    struct sockaddr_in server_addr;  
    struct node *head;  
  
    if (argc < 2){  
        fprintf(stderr, "usages : %s ip\n", argv[0]);  
        exit(-1);  
    }  
  
  	/* create UDP socket */
    if ((socket_fd = socket(AF_INET, SOCK_DGRAM, 0)) < 0){  
        perror("failed to create socket");  
        exit(-1);  
    }  
  
  	/* create client list */
    head = create_list();  
  
    server_addr.sin_family = AF_INET;  
    server_addr.sin_port = htons(UDP_PORT_NUM);  
    server_addr.sin_addr.s_addr = inet_addr(argv[1]);  
  
    if (bind(socket_fd, (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0){  
        perror("failed to bind");  
        exit(-1);  
    }  
  
    if ((pid = fork()) < 0){  
        perror("failed to fork pid");  
        exit(-1);  
    }  

    
    if (pid == 0){
		/* create epoll */
		int epollFd = -1;
		epollFd = epoll_create(1);
		s_epoll_fd = epollFd;
		/* create timer */
		int timerFd = -1;
		timerFd = timerfd_create(CLOCK_MONOTONIC, TFD_CLOEXEC | TFD_NONBLOCK);
		
		/* add timer fd to epoll monitor event */
		epollAddEvent(epollFd, timerFd, EPOLLIN);

		/* create thread to monitor */
		pthread_t threadId = -1;
		pthread_create(&threadId, NULL, &monitor_thread, (void*)head);

		/* create timer, time out is 10 seconds */
		struct itimerspec its;
		its.it_interval.tv_sec = 10; // 10 seconds
		its.it_interval.tv_nsec = 0;
		its.it_value.tv_sec = 10;
		its.it_value.tv_nsec = 0;
		if (timerfd_settime(timerFd, 0, &its, NULL) < 0) {
			fprintf(stderr, "timerfd_settime error\n");
		}
	
        printf("udp server <receive message> running......\n");
        recv_message(socket_fd, head);  
    }
    else{
        printf("udp server <send message> running......\n");
        send_message(socket_fd, &server_addr, pid); 
    }
  
    return 0;  
}  
  
  
struct node *create_list(void)  
{  
    struct node *head;  
  
    head = (struct node *)malloc(sizeof(struct node));  
    head->next = NULL;  
  
    return head;  
}  
  
void insert_list(struct node *head, char *name, struct sockaddr_in *client_addr)  
{  
    if(!head) return;
    struct node *new;  
  
    new = (struct node *)malloc(sizeof(struct node));  
    strcpy(new->name, name);  
    new->client_addr = *client_addr;  
	new->client_status = E_CLIENT_ON_LINE;
	clock_gettime(CLOCK_REALTIME, &new->heart_beat_time);
    new->next = head->next;  
    head->next = new;  
  
    return ;  
}  
  
void delete_list(struct node *head, char *name)  
{  
    if(!head) return;
    struct node *p = head->next;  
    struct node *q = head;  
  
    while (p != NULL){  
        if (strcmp(p->name, name) == 0)  
            break;  
  
        p = p->next;  
        q = q->next;  
    }  
  
    q->next = p->next;  
    p->next = NULL;  
    free(p);  
  
    return ;  
}  
  
void recv_message(int socket_fd, struct node *head)  
{  
    struct message msg;  
    struct sockaddr_in client_addr;  
    int client_addrlen = sizeof(struct sockaddr);  
  
    while (1)  
    {  
        memset(&msg, 0, sizeof(msg));  
        if (recvfrom(socket_fd, &msg, sizeof(msg), 0, (struct sockaddr *)&client_addr, &client_addrlen) < 0){  
            perror("failed to recvform client");  
            exit(-1);  
        }  
  
        switch(msg.type)  
        {  
            case CLIENT_LOGIN:  
                client_login(socket_fd, head, &msg, &client_addr);  
                break;  
  
            case CLIENT_CHAT:  
                client_chat(socket_fd, head, &msg);  
                break;  
  
            case CLIENT_QUIT:  
                client_quit(socket_fd, head, &msg);  
                break;  
  
            case SERVER_CHAT:  
                server_chat(socket_fd, head, &msg);  
                break;  
  
            case SERVER_QUIT:  
                server_quit(socket_fd, head, &msg);  
                break;  
  
            case PRINT_ONLINE:  
                print_online(socket_fd, head, &msg);  
                break;  
  
            case PRIVATE_CHAT:  
                private_chat(socket_fd, head, &msg);  
                break;  

			case HEART_BEAT:
				heart_beat(socket_fd, head, &msg);
				break;
			
            default:  
                break;  
        }  
    }  
  
    return ;  
}  
  
void send_message(int socket_fd, struct sockaddr_in *server_addr, pid_t pid)  
{  
    struct message msg;  
    char buf[512];  
  
    signal(getppid(), father_func);  
      
    while (1)  
    {  
        usleep(500);  
        printf(">");  
        fgets(buf, sizeof(buf), stdin);  
        buf[strlen(buf) - 1] = 0;  
  
        strcpy(msg.mtext, buf);  
        strcpy(msg.name , "server");  
        msg.type = SERVER_CHAT;  
  
        if (strncmp(buf, "quit", 4) == 0){  
            msg.type = SERVER_QUIT;  

            printf("udp server will quit, socket_fd = %d!!!!!\n", socket_fd);
            if (sendto(socket_fd, &msg, sizeof(msg), 0,   
                        (struct sockaddr *)server_addr, sizeof(struct sockaddr)) < 0){  
                perror("failed to send server_quit message");  
                exit(-1);  
            }  
  
            //pause();  
  
            kill(pid, SIGKILL);  
            waitpid(pid, NULL, 0);  
            close(socket_fd);  
            exit(-1);  
        }  
  
        if (sendto(socket_fd, &msg, sizeof(msg), 0, (struct sockaddr *)server_addr, sizeof(struct sockaddr)) < 0){  
            perror("failed to send server_chat message");  
            exit(-1);  
        }  
    }  
  
    return ;  
}  
  
void client_login(int socket_fd, struct node *head, struct message *msg, struct sockaddr_in *client_addr)  
{  
    printf("********Login In Notice********\n");  
    printf("%s has Login In, you can talk to him/her.\n", msg->name);  
    printf("****************************\n");  
  
    insert_list(head, msg->name, client_addr);  
    brocast_msg(socket_fd, head, msg);  
  
    return ;  
}  
  
void client_chat(int socket_fd, struct node *head, struct message *msg)  
{  
    printf("********Group Chat********\n");  
    printf("name: %s\n", msg->name);  
    printf("msg: %s\n", msg->mtext);  
    printf("**************************\n");  
  
    brocast_msg(socket_fd, head, msg);  
  
    return ;  
}  
  
void client_quit(int socket_fd, struct node *head, struct message *msg)  
{  
    printf("*********Quit Msg********\n");  
    printf("%s is Quit\n", msg->name);  
    printf("*************************\n");  
  
    delete_list(head, msg->name);  
    brocast_msg(socket_fd, head, msg);  
  
    return ;  
}  
  
void server_chat(int socket_fd, struct node *head, struct message *msg)  
{  
    printf("********Server Msg*********\n");  
    printf("msg: %s\n", msg->mtext);  
    printf("***************************\n");  
  
    brocast_msg(socket_fd, head, msg);  
  
    return ;  
}  
  
void server_quit(int socket_fd, struct node *head, struct message *msg)  
{  
    brocast_msg(socket_fd, head, msg);  
    kill(getppid(), SIGUSR1);  
  
    return ;  
}  
  
void print_online(int socket_fd, struct node *head, struct message *msg)  
{  
    struct node *p = head->next;  
    struct sockaddr_in my_addr;  
    char buf[512];  
  
    printf("%s is request to print online client\n", msg->name);  
    memset(buf, 0, sizeof(buf));  
  
    while (p != NULL)  
    {  
        if (strcmp(p->name, msg->name) == 0){  
            my_addr = p->client_addr;  
            p = p->next;
            continue;
        }
  
        strcat(buf, p->name);  
        strcat(buf, " ");  
          
        p = p->next;  
    }  
  
    strcpy(msg->mtext, buf);  
    msg->type = PRINT_ONLINE;  
  
    if (sendto(socket_fd, msg, sizeof(struct message), 0,   
                (struct sockaddr *)&my_addr, sizeof(my_addr)) < 0){  
        perror("failed to send print_online message");  
        exit(-1);  
    }  
  
    return ;  
}  
  
void private_chat(int socket_fd, struct node *head, struct message *msg)  
{  
    struct node *p = head->next;  
    struct sockaddr_in *peer_addr = NULL;  
  
    printf("******** Private Msg ********\n");  
    printf("from %s\n", msg->name);  
    printf("to %s\n", msg->peer_name);  
    printf("msg: %s\n", msg->mtext);  
    printf("*****************************\n");  
  
    while (p != NULL)  
    {  
        if (strcmp(p->name, msg->peer_name) == 0){  
            peer_addr = &(p->client_addr);  
            break;  
        }  
  
        p = p->next;  
    }  

    if(!peer_addr){
        printf("[Udp server] user %s is not in online list!!\n", msg->peer_name);
        msg->type = SERVER_CHAT;
        sprintf(msg->mtext, "The one of %s who you want to talk is not exist!!!\n", msg->peer_name);
        p = head->next;
        while (p != NULL){  
            if (strcmp(p->name, msg->name) == 0){  
                peer_addr = &(p->client_addr);  
                break;  
            }  
            p = p->next;  
        }
    }

    if(peer_addr){
        if (sendto(socket_fd, msg, sizeof(struct message), 0,   
                    (struct sockaddr *)peer_addr, sizeof(struct sockaddr_in)) < 0){  
            perror("failed to send private message");  
            exit(-1);  
        }  
    }
  
    return ;  
}  

void heart_beat(int socket_fd, struct node *head, struct message *msg)  
{  
    struct node *p = head->next;    
    printf("%s heart beat ^^^\n", msg->name);  
  
    while (p != NULL)  
    {  
        if (strcmp(p->name, msg->name) == 0){
			p->client_status = E_CLIENT_ON_LINE;
			clock_gettime(CLOCK_REALTIME, &p->heart_beat_time);
        }
          
        p = p->next;  
    }  
  
    return ;  
}  

void brocast_msg(int socket_fd, struct node *head, struct message *msg)  
{  
    struct node *p = head->next;  
  
    while(p != NULL)  
    {  
        if (msg->type == CLIENT_LOGIN){  
            if (strcmp(p->name, msg->name) == 0){  
                p = p->next;  
                continue;  
            }  
        }  
  
        sendto(socket_fd, msg, sizeof(struct message), 0, (struct sockaddr *)&(p->client_addr), sizeof(struct sockaddr));  
        p = p->next;  
    }  
  
    return ;  
}

客户端代码：

#include <stdio.h>  
#include <stdlib.h>  
#include <string.h>  
#include <sys/types.h>  
#include <sys/socket.h>  
#include <arpa/inet.h>  
#include <unistd.h>  
#include <signal.h> 
#include <pthread.h>
#include <sys/timerfd.h>
#include <sys/epoll.h>

#define UDP_PORT_NUM   (8888)

#define CLIENT_LOGIN    100  
#define CLIENT_CHAT     200  
#define CLIENT_QUIT     300  
  
#define SERVER_CHAT     400  
#define SERVER_QUIT     500  
  
#define PRINT_ONLINE    600  
#define PRIVATE_CHAT    700

#define HEART_BEAT      800

static char s_my_name[20];
static int s_server_fd;
static int s_epoll_fd = -1;

struct message  
{  
    long type;  
    char name[20];  
    char peer_name[20];  
    char mtext[512];  
};  
  
void recv_message(int );  
void send_message(int , struct sockaddr_in *, char *, pid_t);  
  
void login_msg(struct message *);  
void group_msg(struct message *);  
void quit_msg(struct message *);  
void server_msg(struct message *);  
void server_quit(void);  
void online_msg(struct message *);  
void private_msg(struct message *);  
  
void print_online(int , struct message *, struct sockaddr_in *);  
void group_chat(int , struct message *, struct sockaddr_in *);  
void private_chat(int ,struct message *, struct sockaddr_in *);  
void client_quit(int , struct message *, struct sockaddr_in *, pid_t );  

static void epollAddEvent(int epollFd, int addFd, int state)
{
	struct epoll_event ev;
	ev.events = state;
	ev.data.fd = addFd;
	epoll_ctl(epollFd, EPOLL_CTL_ADD, addFd, &ev);
	return;
}

void heart_beat(struct sockaddr_in *server_addr)  
{  
	struct message msg;  
    msg.type = HEART_BEAT;  
    strcpy(msg.name, s_my_name);  
  
    if (sendto(s_server_fd, &msg, sizeof(struct message), 0,   
                (struct sockaddr *)server_addr, sizeof(struct sockaddr)) < 0){  
        perror("failed to send online message");  
        return;  
    }  
  
    return ;  
}

void* heart_beat_thread(void* user)
{
	struct sockaddr_in *server_addr = (struct sockaddr_in*)user;
	struct epoll_event events[1] = {0};
	int cnt = 0;
	while(1)
	{
		int fireEvents = epoll_wait(s_epoll_fd, events, 1, -1);
		if(fireEvents > 0){
			printf("I heart beat\n");
			uint64_t exp;
			ssize_t size = read(events[0].data.fd, &exp, sizeof(uint64_t));
			if(size != sizeof(uint64_t)) {
				printf("read error!\n");
			}

			heart_beat(server_addr);
		}
		else{
			printf("fireEvents = %d", fireEvents);
		}
	}
	return NULL;
}

int main(int argc, char *argv[])  
{  
    pid_t pid;  
    int server_fd;  
    struct sockaddr_in server_addr;  
  
    if (argc < 4){  
        fprintf(stderr, "usages: %s ip name heart_beat(seconds)\n", argv[0]);  
        exit(-1);  
    }  

	int heart_beat_period = atoi(argv[3]);
  
    if ((server_fd = socket(AF_INET, SOCK_DGRAM, 0)) < 0){  
        perror("failed to create server_fd");  
        exit(-1);  
    }
	s_server_fd = server_fd;
  
    server_addr.sin_family = AF_INET;  
    server_addr.sin_port = htons(UDP_PORT_NUM);  
    server_addr.sin_addr.s_addr = inet_addr(argv[1]);  
  
    if ((pid = fork()) < 0){  
        perror("failed to fork pid");  
        exit(-1);  
    }  

    memset(s_my_name, '\0', 20);
    memcpy(s_my_name, argv[2], sizeof(char) * (strlen(argv[2]) + 1));
  
    if (pid == 0) { 
		/* create epoll */
		int epollFd = -1;
		epollFd = epoll_create(1);
		s_epoll_fd = epollFd;
		/* create timer */
		int timerFd = -1;
		timerFd = timerfd_create(CLOCK_MONOTONIC, TFD_CLOEXEC | TFD_NONBLOCK);
		
		/* add timer fd to epoll monitor event */
		epollAddEvent(epollFd, timerFd, EPOLLIN);
		
		/* create heart beat thread */
		pthread_t threadId = -1;
		pthread_create(&threadId, NULL, &heart_beat_thread, (void*)&server_addr);

		/* create timer, time out is heart beat seconds */
		struct itimerspec its;
		its.it_interval.tv_sec = heart_beat_period;
		its.it_interval.tv_nsec = 0;
		its.it_value.tv_sec = heart_beat_period;
		its.it_value.tv_nsec = 0;
		if (timerfd_settime(timerFd, 0, &its, NULL) < 0) {
			fprintf(stderr, "timerfd_settime error\n");
		}
		
        recv_message(server_fd);  
	}
	else {
        send_message(server_fd, &server_addr, argv[2], pid);  
	}
  
    return 0;  
}  
  
void recv_message(int server_fd)  
{  
    struct message msg;  
  
    while (1)  
    {  
        memset(&msg, 0, sizeof(msg));  

        int nbytes = 0;
        if ((nbytes = recvfrom(server_fd, &msg, sizeof(msg), 0, NULL, NULL)) < 0){  
            perror("failed to recv server message");  
            exit(-1);  
        }  
  
        switch(msg.type)  
        {  
            case CLIENT_LOGIN:  
                login_msg(&msg);  
                break;  
  
            case CLIENT_CHAT:  
                group_msg(&msg);  
                break;  
  
            case CLIENT_QUIT:  
                quit_msg(&msg);  
                break;  
  
            case SERVER_CHAT:  
                server_msg(&msg);  
                break;  
  
            case SERVER_QUIT:  
                server_quit();  
                break;  
  
            case PRINT_ONLINE:  
                online_msg(&msg);  
                break;  
  
            case PRIVATE_CHAT:  
                private_msg(&msg);  
                break;  
            default:  
                break;  
        }  
    }  
  
    return ;  
}  
  
void send_message(int server_fd, struct sockaddr_in *server_addr, char *name, pid_t pid)  
{  
    struct message msg;  
    char buf[512];  
    int c;  
  
    msg.type = CLIENT_LOGIN;  
    strcpy(msg.name, name);  
  
    if (sendto(server_fd, &msg, sizeof(msg), 0,   
                (struct sockaddr *)server_addr, sizeof(struct sockaddr)) < 0){  
        perror("failed to send login message");  
        exit(-1);  
    }  
  
    while(1)  
    {  
        usleep(500);  
        printf("#####################################\n");  
        printf("the following options can be choose:\n");  
        printf("input 1 is to print online client\n");  
        printf("input 2 is to chat to all the client\n");  
        printf("input 3 is to chat to only one client\n");  
        printf("input q is to quit\n");  
        printf("#####################################\n");  
          
        printf(">");  
        c = getchar();  
        while (getchar() != '\n');   
  
        switch(c)  
        {  
            case '1':  
                print_online(server_fd, &msg, server_addr);  
                break;  
  
            case '2':
                printf("[Notice:]you can input <quit> cmd to close group chat....\n");
                group_chat(server_fd, &msg, server_addr);  
                break;  
  
            case '3':  
                printf("[Notice:]you can input <quit> cmd to close private chat....\n");
                private_chat(server_fd, &msg, server_addr);  
                break;  
  
            case 'q':  
                client_quit(server_fd, &msg, server_addr, pid);  
                break;  
  
            default:  
                break;  
        }  
    }  
  
    return ;  
}  
  
void login_msg(struct message *msg)  
{  
    printf("********Login In Notice********\n");  
    printf("%s has Login In, you can talk to him/her.\n", msg->name);  
    printf("****************************\n");    
  
    return ;  
}  
  
void group_msg(struct message *msg)  
{  
    printf("******** Group Msg ********\n");  
    printf("name: %s\n", msg->name);  
    printf("msg: %s\n", msg->mtext);  
    printf("******** Group Msg ********\n");  
  
    return ;  
}  
  
void quit_msg(struct message *msg)  
{  
    printf("######## Quit Msg ########\n");  
    printf("%s is Quit\n", msg->name);  
    printf("######## Quit Msg ########\n");  
  
    return ;  
}  
  
void server_msg(struct message *msg)  
{  
    printf("******** Server Msg ********\n");  
    printf("msg: %s\n", msg->mtext);  
    printf("******** Server Msg ********\n");  
  
    return ;  
}  
  
void server_quit(void )  
{  
    kill(getppid(), SIGKILL);  
    exit(0);  
}  
  
void online_msg(struct message *msg)  
{  
    printf("******** Clients you can talk to. ********\n");  
    printf("Clients: %s\n", msg->mtext);  
    printf("******** Clients you can talk to. ********\n");  
  
    return ;  
}  
  
void private_msg(struct message *msg)  
{  
    printf("******** Private Msg ********\n");  
    printf("[%s] say: %s\n", msg->name, msg->mtext);  
    printf("******** Private Msg ********\n");  
  
    return ;  
}  
  
void print_online(int server_fd, struct message *msg, struct sockaddr_in *server_addr)  
{  
    msg->type = PRINT_ONLINE;  
  
    if (sendto(server_fd, msg, sizeof(struct message), 0,   
                (struct sockaddr *)server_addr, sizeof(struct sockaddr)) < 0){  
        perror("failed to send online message");  
        exit(-1);  
    }  
  
    return ;  
}  
  
void group_chat(int server_fd, struct message *msg, struct sockaddr_in *server_addr)  
{  
    char buf[512];  
  
    memset(buf, 0, sizeof(buf));  
    printf("*********** Group Chat Room ***********\n");  
    printf("****** Welcome to group chat room ******\n");  
    printf("* if you want to quit, please input quit\n");  
    printf("****************************************\n");  
  
    while(1)  
    {  
        memset(buf, 0, sizeof(buf));  
        usleep(500);  
        printf(">");  
        fgets(buf, sizeof(buf), stdin);  
        buf[strlen(buf) - 1] = 0;  
  
        msg->type = CLIENT_CHAT;  
        strcpy(msg->mtext, buf);  
  
        if (strncmp(buf, "quit", 4) == 0)  
            break;  
  
        if (sendto(server_fd, msg, sizeof(struct message), 0,   
                    (struct sockaddr *)server_addr, sizeof(struct sockaddr)) < 0){  
            perror("failed to send group message");  
            exit(-1);  
        }  
    }  
  
    return ;  
}  
  
void private_chat(int server_fd, struct message *msg, struct sockaddr_in *server_addr)  
{  
    char name[20];  
    char buf[512];  
  
    memset(name, 0, sizeof(name));  
    printf("please input the peer_name\n");  
    printf(">");  
    fgets(name, sizeof(name), stdin);  
    name[strlen(name) - 1] = 0;  

    if(strncmp(s_my_name, name, strlen(name)) == 0){
        printf("you can not talk with yourself!!!!!\n");
        return;
    }
    
    strcpy(msg->peer_name, name);  
    msg->type = PRIVATE_CHAT;  
  
    printf("you want to talk to %s!\n", msg->peer_name);  
  
    while(1)  
    {  
        usleep(500);  
        printf(">");  
        fgets(buf, sizeof(buf), stdin);  
        buf[strlen(buf) - 1] = 0;  
  
        strcpy(msg->mtext, buf);  
  
        if (strncmp(buf, "quit", 4) == 0)  
            break;  
  
        if (sendto(server_fd, msg, sizeof(struct message), 0,   
                    (struct sockaddr *)server_addr, sizeof(struct sockaddr)) < 0){  
            perror("failed to send private message");  
            exit(-1);  
        }  
    }  
  
    return ;  
}  
  
void client_quit(int server_fd, struct message *msg, struct sockaddr_in *server_addr, pid_t pid)  
{  
    msg->type = CLIENT_QUIT;  
  
    if (sendto(server_fd, msg, sizeof(struct message), 0,   
                (struct sockaddr *)server_addr, sizeof(struct sockaddr)) < 0){  
        perror("failed to send quit message");  
        exit(-1);  
    }  
  
    kill(pid, SIGKILL);  
    waitpid(pid, NULL, 0);  
    exit(0);  
}

 

fanchenxinok
关注
专栏目录
Kafka学习笔记
dw147258dw的专栏
06-07 639
4. 如果产生了消息积压，或者是吞吐量不够，可以通过增加主题的分区来解决，但是分区也不是越多越好，如果超过了一定的阈值，可能会导致不升反降，所以需要对硬件资源做一个吞吐量的测试，来找到一个合适的分区阈值区间，分区数过多也可能会导致leader宕机的时候不可用时间变得很长（选主过程）在均衡也可能会导致消息的重复消费。4. 可以根据seek方法进行消息回溯。1. kafka可以配置自动创建主题，如果收到一个未创建的主题消息，会自动创建默认分区数，默认副本数的主题，但是不推荐，推荐使用脚本创建。
springcloud学习笔记之Ribbon组件（含项目）
热门推荐
liushangzaibeijing的博客
06-01 6万+
目录 一、Ribbon简介 二、Ribbon与RestTemplate结合使用 三、Ribbon源码分析 0、问题释疑 1、@LoadBalanced原理探究 1.1、LoadBalancerAutoConfiguration原理分析 1.2、LoadBalancerInterceptor分析 2、核心...
Linux下使用UDP做心跳检测（断线检测）
qq_14976351的专栏
12-07 1万+
本文介绍了心跳包机制、应用场景、两种实现的方法（TCP SO_KEEPALIVE 和应用层方式），并对两种方法的优缺点进行比较，最后结合实际情况，给出相应的客户端和服务器实例程序。
如何保证 UDP 的可靠性传输？
最新发布
编程语言技巧经验分享
09-07 648
这类似于TCP的确认应答机制，但是在应用层内实现的。UDP传输层是一种无连接的、不可靠的传输协议，无法保证数据的可靠传输，只能通过应用层来实现可靠性传输。当接收方来不及接收发送方发来的数据时，则会提示发送方降低发送的速度，防止包丢失。
c# UDP心跳程序
10-26
这是我初学c#时做的一个UDP心跳程序，可以从本地指定端口向目标主机的指定端口发送心跳信息，代码很简单
TCP/UDP区别&&心跳包机制
weixin_34306676的博客
05-22 469
UDP:用户数据报协议:主要用在实时性要求比较高的以及对质量相对较弱的地方.但是面对现在高质量的线路不会容易丢包,除非是一些拥塞条件下,如流媒体 TCP:传输控制协议:是面连接的那么运行环境必然要求其可靠性不可丢包,有良好的拥塞控制机制如 http ftp telnet等 TCP UDP 发送...
android 用UDP做的心跳连接 小示例
weixin_33736649的博客
08-22 164
  推荐几个不错的帖子：  基于Android平台的城市天气预报源码 http://www.eoeandroid.com/thread-193468-1-1.html Android 用opengl 篮球游戏源码 http://www.eoeandroid.com/thread-192486-1-1.html   基于android北京地铁小助手有导航功能http://www...
论文学习笔记：MapReduce
依然的专栏
10-27 3391
前言：Google大数据处理的3篇核心论文 《The Google File System》：http://research.google.com/archive/gfs.html 《MapReduce: Simplified Data Processing on Large Clusters 》：http://research.google.com/archive/mapreduce
Freeswitch学习笔记（二）：常用命令
weixin_42211693的博客
06-07 1671
参考文档mod_commands api文档：mod_dptools app文档。
《计算机网络——自顶向下方法》学习笔记——网络层：控制平面
weixin_45243288的博客
12-16 3334
计算机网络——网络层：控制平面网络层：控制平面概述路由选择算法链路状态路由选择算法距离向量路由选择算法因特网中的自治系统内部的路由选择：OSPFISP之间的路由选择：BGPBGP的作用通告BGP路由信息确定最好的路由IP任播路由选择策略拼装在一起：在因特网中呈现SDN 控制平面SDN 控制平面：SDN 控制器和SDN 网络控制应用程序OpenFlow 协议数据平面和控制平面交互的例子SDN 的过去与未来ICMP： 因特网控制报文协议网络管理和 SNMP网络管理框架简单网络管理协议 网络层：控制平面 控制平面
c# UDP 网络心跳 网络通信实现 初学者源码
06-20
参考网上的文章，在同一窗体中模拟服务端，客户端，压缩包中包含 三个项目，学习UDP编程很好的例子 visual studio 2017
UDP打洞（有心跳包和断网自动连接功能）
12-04
UDP打洞（有心跳包和断网自动连接功能），C++写的，在csdn上下的程序自己修改的
带心跳消息的UDP通信DLL
09-19
自己写的UDP开发工具，在VS上可以直接编译，已经测试过可以使用.如果有问题请联系QQ741131987,共同学习。
Android socket局域网的UDP广播自动连接及TCP/ip通讯与心跳检测
04-03
简单的Android Socket 编程实例，有单独的客户端及服务器端源码。两台Android设备同时连接同一个WiFi或路由器（局域网）；客户端通过UDP广播获取到服务器端的IP地址，通过TCP/IP协议与服务器建立连接。代码实现心跳检测，当服务器断网或是结束进程，客户端可重新连接（重连部分自己实现）；代码有点凌乱，仅供参考！
python 利用udp 发送心跳包
04-12
这是一个用python 写的利用udp 发送心跳包的程序，最初是为一个使用树莓派运行的机器人系统实时状态监控做的。服务端用的是C#，整个监控程序运行非常稳定，现把心跳部份公开希望能混点分数 ^_^
udp心跳包调试
DFminer
10-26 482
我对心跳包监测程序的理解是，遥控台程序只要启动就开始udp发心跳包，并实时监控接收来自车端返回的心跳包，只要收到车端返回的心跳包就与该车建立连接，之后如果超时，就与该车断掉连接。Received from “车的ID”: Heartbeat response，每一帧收到包的当前系统时间，收到当前帧与收到上一帧的时间差。如果需要更详细的性能分析，可能需要使用其他更复杂的监控手段。将日志输出至控制台，同时保存文档到当前目录，当程序开始运行时，会删掉或者说覆盖掉上次输出的文档heartbeat.txt。
Udp心跳包代码
cloud 的学习时代
07-26 3287
//1.client.c #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #define IP "127.0.0.1"
c++ 进程间心跳检测--socket （UDP）
5266的博客
04-09 3795
目录 代码结构如下： 代码解析： check tread: receive tread: send tread: 完整代码工程下载： 编译代码方式： 功能实现：可以检测 进程是否 live 或者 僵死，然后根据具体状态，发signal 处理被检测的进程 demo 有两个进程 一个是 server 另一个是 client (可以有多个)（send && rece...
评论 11
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值