关于C语言实现去中心化的网络设计 — P2P的代码实现

最新推荐文章于 2023-08-08 18:35:34 发布
最新推荐文章于 2023-08-08 18:35:34 发布
阅读量1.1k 收藏 13
点赞数 1
分类专栏： 算法基础 socket
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jenie/article/details/106838821
版权

 

 

 

 

 

 

 

 

 

 

 

那我们如何来进行检测呢，如图所示

 

 

 

 

如何穿透

 

 

 

 

 

 

 

 

见证奇迹的时候到了。先实现个,整个代码逻辑和实现都是按原理方式实现

udp.h

 

​​



#ifndef __UDP_H__
#define __UDP_H__


#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>

#include <time.h>

typedef unsigned int U32;
typedef unsigned short U16;
typedef unsigned char U8;
typedef volatile long UATOMIC;
typedef void* (*KING_CALLBACK)(void *arg);

typedef enum {
	KING_RESULT_FAILED = -1,
	KING_RESULT_SUCCESS = 0,
} KING_RESULT;

typedef enum {
	KING_STATUS_NULL,
	KING_STATUS_LOGIN,
	KING_STATUS_HEARTBEAT,
	KING_STATUS_CONNECT,
	KING_STATUS_MESSAGE,
	KING_STATUS_NOTIFY,
	KING_STATUS_P2P_CONNECT,
	KING_STATUS_P2P_MESSAGE,
} KING_STATUS_SET;

#define KING_CLIENT_MAX				1024
#define KING_CLIENT_ADDR_LENGTH		6


#define KING_BUFFER_LENGTH		512

#define KING_NUMBER_ID_LENGTH			4

typedef struct _CLIENT_TABLE {
	U8 addr[KING_CLIENT_ADDR_LENGTH]; 
	U32 client_id;
	long stamp;
} client_table;



/**************************** status define ****************************/


#define KING_PROTO_LOGIN_REQ				0x01
#define KING_PROTO_LOGIN_ACK				0x81


#define KING_PROTO_HEARTBEAT_REQ			0x02
#define KING_PROTO_HEARTBEAT_ACK			0x82


#define KING_PROTO_CONNECT_REQ				0x11
#define KING_PROTO_CONNECT_ACK				0x91

#define NTY_PROTO_NOTIFY_REQ				0x12
#define NTY_PROTO_NOTIFY_ACK				0x92

#define NTY_PROTO_P2P_CONNECT_REQ			0x13
#define NTY_PROTO_P2P_CONNECT_ACK			0x93

#define NTY_RPORO_MESSAGE_REQ				0x21
#define NTY_RPORO_MESSAGE_ACK				0xA1


/**************************** context define ****************************/

#define KING_PROTO_BUFFER_VERSION_IDX		0
#define KING_PROTO_BUFFER_STATUS_IDX		1

#define KING_PROTO_BUFFER_LENGTH_IDX		(KING_PROTO_BUFFER_STATUS_IDX+1)
#define KING_PROTO_BUFFER_SELFID_IDX		(KING_PROTO_BUFFER_LENGTH_IDX+2)

//login
#define KING_PROTO_LOGIN_SELFID_IDX			KING_PROTO_BUFFER_SELFID_IDX 

//heartbeat
#define KING_PROTO_HEARTBEAT_SELFID_IDX		KING_PROTO_BUFFER_SELFID_IDX

//connect
#define KING_PROTO_CONNECT_SELFID_IDX		KING_PROTO_BUFFER_SELFID_IDX
#define KING_PROTO_CONNECT_OTHERID_IDX		(KING_PROTO_BUFFER_SELFID_IDX+KING_NUMBER_ID_LENGTH)

//notify
#define KING_PROTO_NOTIFY_SELFID_IDX			KING_PROTO_BUFFER_SELFID_IDX
#define KING_PROTO_NOTIFY_ADDR_IDX			(KING_PROTO_BUFFER_SELFID_IDX+KING_NUMBER_ID_LENGTH)

//p2p connect
#define KING_PROTO_P2P_CONNECT_SELFID_IDX	KING_PROTO_BUFFER_SELFID_IDX

//p2p connect ack
#define KING_PROTO_P2P_CONNECT_ACK_SELFID_IDX	KING_PROTO_BUFFER_SELFID_IDX


//message
#define KING_RPORO_MESSAGE_SELFID_IDX		KING_PROTO_BUFFER_SELFID_IDX
#define KING_PROTO_MESSAGE_OTHERID_IDX		(KING_RPORO_MESSAGE_SELFID_IDX+KING_NUMBER_ID_LENGTH)
#define KING_RPORO_MESSAGE_CONTENT_IDX		(KING_PROTO_MESSAGE_OTHERID_IDX+KING_NUMBER_ID_LENGTH)

//message ack
#define KING_RPORO_MESSAGE_ACK_SELFID_IDX	KING_PROTO_BUFFER_SELFID_IDX




static unsigned long cmpxchg(UATOMIC *addr, unsigned long _old, unsigned long _new) {
	U8 res;

	__asm__ volatile (
        "lock; cmpxchg %3, %1;sete %0;"
        : "=a" (res)
        : "m" (*addr), "a" (_old), "r" (_new)
        : "cc", "memory");

	return res;
}



static long time_genrator(void) {
	static long lTimeStamp = 0;
	static long timeStampMutex = 0;

	if(cmpxchg(&timeStampMutex, 0, 1)) {
		lTimeStamp = time(NULL);
		timeStampMutex = 0;
	}

	return lTimeStamp;
}



static int addr_to_array(U8 *array, struct sockaddr_in *p_addr) {
	int i = 0;

	for (i = 0;i < 4;i ++) {
		array[i] = *((unsigned char*)(&p_addr->sin_addr.s_addr) + i);
	}

	for (i = 0;i < 2;i ++) {
		array[4+i] = *((unsigned char*)(&p_addr->sin_port)+i);
	}
}

static int array_to_addr(U8 *array, struct sockaddr_in *p_addr) {
	int i = 0;
	
	for (i = 0;i < 4;i ++) {
		*((unsigned char*)(&p_addr->sin_addr.s_addr) + i) = array[i];
	}
	for (i = 0;i < 2;i ++) {
		*((unsigned char*)(&p_addr->sin_port)+i) = array[4+i];
	}
}





static int king_send_login(int sockfd, int self_id, struct sockaddr_in *paddr) {

	U8 buffer[KING_BUFFER_LENGTH] = {0};

	buffer[KING_PROTO_BUFFER_STATUS_IDX] = KING_PROTO_LOGIN_REQ;
	*(int *)(buffer+KING_PROTO_LOGIN_SELFID_IDX) = self_id;

	int n = KING_PROTO_LOGIN_SELFID_IDX + KING_NUMBER_ID_LENGTH;
	n = sendto(sockfd, buffer, n, 0, (struct sockaddr*)paddr, sizeof(struct sockaddr_in));
	if (n < 0) {
		perror("sendto");
	}
	
	return n;

}

static int king_send_heartbeat(int sockfd, int self_id, struct sockaddr_in *paddr) {
	
	U8 buffer[KING_BUFFER_LENGTH] = {0};

	buffer[KING_PROTO_BUFFER_STATUS_IDX] = KING_PROTO_HEARTBEAT_REQ;
	*(int *)(buffer+KING_PROTO_HEARTBEAT_SELFID_IDX) = self_id;

	int n = KING_PROTO_HEARTBEAT_SELFID_IDX + KING_NUMBER_ID_LENGTH;
	n = sendto(sockfd, buffer, n, 0, (struct sockaddr*)paddr, sizeof(struct sockaddr_in));
	if (n < 0) {
		perror("sendto");
	}
	
	return n;
}

static int king_send_connect(int sockfd, int self_id, int other_id, struct sockaddr_in *paddr) {
	
	U8 buffer[KING_BUFFER_LENGTH] = {0};

	buffer[KING_PROTO_BUFFER_STATUS_IDX] = KING_PROTO_CONNECT_REQ;
	*(int *)(buffer+KING_PROTO_CONNECT_SELFID_IDX) = self_id;
	*(int *)(buffer+KING_PROTO_CONNECT_OTHERID_IDX) = other_id;

	int n = KING_PROTO_CONNECT_OTHERID_IDX + KING_NUMBER_ID_LENGTH;
	n = sendto(sockfd, buffer, n, 0, (struct sockaddr*)paddr, sizeof(struct sockaddr_in));
	if (n < 0) {
		perror("sendto");
	}
	
	return n;	
}

static int king_send_p2pconnect(int sockfd, int self_id, struct sockaddr_in *paddr) {

	U8 buffer[KING_BUFFER_LENGTH] = {0};
	
	buffer[KING_PROTO_BUFFER_STATUS_IDX] = NTY_PROTO_P2P_CONNECT_REQ;
	*(int *)(buffer+KING_PROTO_P2P_CONNECT_SELFID_IDX) = self_id;

	int n = KING_PROTO_P2P_CONNECT_SELFID_IDX + KING_NUMBER_ID_LENGTH;
	n = sendto(sockfd, buffer, n, 0, (struct sockaddr*)paddr, sizeof(struct sockaddr_in));
	if (n < 0) {
		perror("sendto");
	}
	
	return n;

}

static int king_send_p2pconnectack(int sockfd, int self_id, struct sockaddr_in *paddr) {

	U8 buffer[KING_BUFFER_LENGTH] = {0};
	
	buffer[KING_PROTO_BUFFER_STATUS_IDX] = NTY_PROTO_P2P_CONNECT_ACK;
	*(int *)(buffer+KING_PROTO_P2P_CONNECT_ACK_SELFID_IDX) = self_id;

	int n = KING_PROTO_P2P_CONNECT_ACK_SELFID_IDX + KING_NUMBER_ID_LENGTH;
	n = sendto(sockfd, buffer, n, 0, (struct sockaddr*)paddr, sizeof(struct sockaddr_in));
	if (n < 0) {
		perror("sendto");
	}
	
	return n;

}


static int king_client_send_message(int sockfd, int self_id, int other_id, struct sockaddr_in *paddr, U8 *msg, int length) {
	U8 buffer[KING_BUFFER_LENGTH] = {0};

	buffer[KING_PROTO_BUFFER_STATUS_IDX] = NTY_RPORO_MESSAGE_REQ; 
	*(int *)(buffer+KING_RPORO_MESSAGE_SELFID_IDX) = self_id;
	*(int *)(buffer+KING_PROTO_MESSAGE_OTHERID_IDX) = other_id;

	memcpy(buffer+KING_RPORO_MESSAGE_CONTENT_IDX, msg, length);

	int n = KING_RPORO_MESSAGE_CONTENT_IDX + length;
	*(U16*)(buffer+KING_PROTO_BUFFER_LENGTH_IDX) = (U16) n;
	
	n = sendto(sockfd, buffer, n, 0, (struct sockaddr*)paddr, sizeof(struct sockaddr_in));
	if (n < 0) {
		perror("sendto");
	}
	return n;
}

static int king_send_messageack(int sockfd, int self_id, struct sockaddr_in *paddr) {

	U8 buffer[KING_BUFFER_LENGTH] = {0};
	
	buffer[KING_PROTO_BUFFER_STATUS_IDX] = NTY_RPORO_MESSAGE_ACK;
	*(int *)(buffer+KING_RPORO_MESSAGE_ACK_SELFID_IDX) = self_id;

	int n = KING_RPORO_MESSAGE_ACK_SELFID_IDX + KING_NUMBER_ID_LENGTH;
	n = sendto(sockfd, buffer, n, 0, (struct sockaddr*)paddr, sizeof(struct sockaddr_in));
	if (n < 0) {
		perror("sendto");
	}
	
	return n;

}




client_table table[KING_CLIENT_MAX] = {0};
int client_count = 0;


static int get_index_by_clientid(int client_id) {
	int i = 0;

	int now_count = client_count;
	for (i = 0;i < now_count;i ++) {
		if (table[i].client_id == client_id) return i;
	}
}


static int king_send_message(int sockfd, int client_id, U8 *buffer, int length) {

	int index = get_index_by_clientid(client_id);
	struct sockaddr_in c_addr;
	c_addr.sin_family = AF_INET;
	array_to_addr(table[index].addr, &c_addr);

	int n = sendto(sockfd, buffer, length, 0, (struct sockaddr*)&c_addr, sizeof(c_addr));
	if (n < 0) {
		perror("sendto");
	}
	return n;
}


static int king_send_notify(int sockfd, int client_id, int self_id) {

	U8 buffer[KING_BUFFER_LENGTH] = {0};

	int index = get_index_by_clientid(self_id);

	buffer[KING_PROTO_BUFFER_STATUS_IDX] = NTY_PROTO_NOTIFY_REQ;
	*(int*)(buffer+KING_PROTO_NOTIFY_SELFID_IDX) = self_id;
	memcpy(buffer+KING_PROTO_NOTIFY_ADDR_IDX, table[index].addr, KING_CLIENT_ADDR_LENGTH);

	index = get_index_by_clientid(client_id);
	struct sockaddr_in c_addr;
	c_addr.sin_family = AF_INET;
	array_to_addr(table[index].addr, &c_addr);

	int n = KING_PROTO_NOTIFY_ADDR_IDX + KING_CLIENT_ADDR_LENGTH;
	n = sendto(sockfd, buffer, n, 0, (struct sockaddr*)&c_addr, sizeof(c_addr));
	if (n < 0) {
		perror("sendto");
	}

	return n;
}





#endif

 

server.c



#include "udp.h"



int king_buffer_parser(int sockfd, U8 *buffer, U32 length, struct sockaddr_in *addr) {

	U8 status = buffer[KING_PROTO_BUFFER_STATUS_IDX];

	printf("king_buffer_parser --> %x\n", status);

	switch (status) {
		case KING_PROTO_LOGIN_REQ: {
#if 1
			int old = client_count;
			int now = old+1;
			if(0 == cmpxchg((UATOMIC*)&client_count, old, now)) { 
				printf("client_count --> %d, old:%d, now:%d\n", client_count, old, now);
				return KING_RESULT_FAILED;
			}
#else
			client_count = client_count+1;
			int now = client_count;
#endif
			U8 array[KING_CLIENT_ADDR_LENGTH] = {0};
			addr_to_array(array, addr);

			printf("login --> %d.%d.%d.%d:%d\n", *(unsigned char*)(&addr->sin_addr.s_addr), *((unsigned char*)(&addr->sin_addr.s_addr)+1),													
				*((unsigned char*)(&addr->sin_addr.s_addr)+2), *((unsigned char*)(&addr->sin_addr.s_addr)+3),													
				addr->sin_port);
			
			table[now].client_id =  *(U32*)(buffer+KING_PROTO_LOGIN_SELFID_IDX);
			memcpy(table[now].addr, array, KING_CLIENT_ADDR_LENGTH);

			break;
		}
		case KING_PROTO_HEARTBEAT_REQ: {

			int client_id = *(unsigned int*)(buffer+KING_PROTO_HEARTBEAT_SELFID_IDX);
			int index = get_index_by_clientid(client_id);

			table[index].stamp = time_genrator();
			
			break;
		}
		case KING_PROTO_CONNECT_REQ: {

			int client_id = *(unsigned int*)(buffer+KING_PROTO_CONNECT_SELFID_IDX);
			int other_id = *(unsigned int*)(buffer+KING_PROTO_CONNECT_OTHERID_IDX);

			king_send_notify(sockfd, other_id, client_id);
			
			break;
		}
		case NTY_RPORO_MESSAGE_REQ: {

			U8 *msg = buffer+KING_RPORO_MESSAGE_CONTENT_IDX;
			int client_id = *(unsigned int*)(buffer+KING_RPORO_MESSAGE_SELFID_IDX);
			int other_id = *(unsigned int*)(buffer+KING_PROTO_MESSAGE_OTHERID_IDX);
			
			printf(" from client:%d --> %s\n", client_id, msg);
#if 0
			king_send_message(sockfd, other_id, buffer, length);
#endif
			break;
		}
	} 

	return KING_RESULT_SUCCESS;
}




int main(int argc, char *argv[]) {

	printf(" This is a UDP Server\n");

	int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
	if (sockfd < 0) {
		perror("socket");
		exit(0);
	}

	struct sockaddr_in addr;
	addr.sin_family = AF_INET;
	addr.sin_port = htons(atoi(argv[1]));
	addr.sin_addr.s_addr = htonl(INADDR_ANY);

	if (bind(sockfd, (struct sockaddr*)&addr, sizeof(addr)) < 0) {
		perror("bind");
		exit(1);
	}

	char buffer[KING_BUFFER_LENGTH] = {0};
	struct sockaddr_in c_addr;
	
	int n;
	int length = sizeof(struct sockaddr_in);

	
	while(1) {
		n = recvfrom(sockfd, buffer, KING_BUFFER_LENGTH, 0, (struct sockaddr*)&c_addr, &length);
		if (n > 0) {
			buffer[n] = 0x0;

			printf("%d.%d.%d.%d:%d say: %s\n", *(unsigned char*)(&c_addr.sin_addr.s_addr), *((unsigned char*)(&c_addr.sin_addr.s_addr)+1),													
				*((unsigned char*)(&c_addr.sin_addr.s_addr)+2), *((unsigned char*)(&c_addr.sin_addr.s_addr)+3),													
				c_addr.sin_port, buffer);

			int ret = king_buffer_parser(sockfd, buffer, n, &c_addr);
			if (ret == KING_RESULT_FAILED) continue;


			buffer[KING_PROTO_BUFFER_STATUS_IDX] += 0x80;
			n = sendto(sockfd, buffer, n, 0, (struct sockaddr*)&c_addr, sizeof(c_addr));
			if (n < 0) {
				perror("sendto");
				break;
			}

		} else if (n == 0) {
			printf("server closed\n");
		} else {
			perror("recv");
			break;
		}
	}

	return 0;
}

 

client.c


#include "udp.h"
#include <pthread.h>


static int status_machine = KING_STATUS_LOGIN;
static int client_selfid = 0x0;

struct sockaddr_in server_addr;

client_table p2p_clients[KING_CLIENT_MAX] = {0};
static int p2p_count = 0;

static int king_client_buffer_parser(int sockfd, U8 *buffer, U32 length, struct sockaddr_in *addr) {

	U8 status = buffer[KING_PROTO_BUFFER_STATUS_IDX];

	switch (status) {
		case NTY_PROTO_NOTIFY_REQ: {
			struct sockaddr_in other_addr;
			other_addr.sin_family = AF_INET;
			array_to_addr(buffer+KING_PROTO_NOTIFY_ADDR_IDX, &other_addr);

			king_send_p2pconnect(sockfd, client_selfid, &other_addr);
			break;
		}
		case NTY_PROTO_P2P_CONNECT_REQ: {
			int now_count = p2p_count++;

			p2p_clients[now_count].stamp = time_genrator();
			p2p_clients[now_count].client_id = *(int*)(buffer+KING_PROTO_P2P_CONNECT_SELFID_IDX);
			addr_to_array(p2p_clients[now_count].addr, addr);
		
			king_send_p2pconnectack(sockfd, client_selfid, addr);
			printf("Enter P2P Model\n");
			status_machine = KING_STATUS_P2P_MESSAGE;

			break;
		}
		case NTY_PROTO_P2P_CONNECT_ACK: {
			int now_count = p2p_count++;
			
			p2p_clients[now_count].stamp = time_genrator();
			p2p_clients[now_count].client_id = *(int*)(buffer+KING_PROTO_P2P_CONNECT_SELFID_IDX);
			addr_to_array(p2p_clients[now_count].addr, addr);
			
			printf("Enter P2P Model\n");
			status_machine = KING_STATUS_P2P_MESSAGE;
			break;
		}
		case NTY_RPORO_MESSAGE_REQ: {

			U8 *msg = buffer+KING_RPORO_MESSAGE_CONTENT_IDX;
			U32 other_id = *(U32*)(buffer+KING_RPORO_MESSAGE_SELFID_IDX);
			
			printf(" from client:%d --> %s\n", other_id, msg);

			king_send_messageack(sockfd, client_selfid, addr);
			//status_machine = KING_STATUS_P2P_MESSAGE;
			
			break;
		}
		case KING_PROTO_LOGIN_ACK: {
			printf(" Connect Server Success\nPlease Enter Message : ");
			status_machine = KING_STATUS_MESSAGE;
			break;
		}
		case KING_PROTO_HEARTBEAT_ACK:
		case KING_PROTO_CONNECT_ACK:
		case NTY_PROTO_NOTIFY_ACK:
			break;
		case NTY_RPORO_MESSAGE_ACK:
			break;
	}
	
}


void* king_recv_callback(void *arg) {

	int sockfd = *(int *)arg;
	struct sockaddr_in addr;
	int length = sizeof(struct sockaddr_in);
	U8 buffer[KING_BUFFER_LENGTH] = {0};

	//printf("king_recv_callback --> enter\n");
	
	while (1) {
		int n = recvfrom(sockfd, buffer, KING_BUFFER_LENGTH, 0, (struct sockaddr*)&addr, &length);
		if (n > 0) {
			buffer[n] = 0;

			king_client_buffer_parser(sockfd, buffer, n, &addr);
		} else if (n == 0) {
			printf("server closed\n");
			close(sockfd);
			break;
		} else if (n == -1) {
			perror("recvfrom");
			close(sockfd);
			break;
		}
	}
}


void *king_send_callback(void *arg) {

	int sockfd = *(int *)arg;
	char buffer[KING_BUFFER_LENGTH] = {0};

	//printf("king_send_callback --> enter\n");
	
	while (1) {

		bzero(buffer, KING_BUFFER_LENGTH);
		
		scanf("%s", buffer);
		//getchar();

		if (status_machine == KING_STATUS_MESSAGE) {

			
			printf(" --> please enter bt : ");
			
			int other_id = buffer[1]-0x30;

			if (buffer[0] == 'C') {
				//printf("king_send_connect");
				king_send_connect(sockfd, client_selfid, other_id, &server_addr);
			} else {
				int length = strlen(buffer);
				king_client_send_message(sockfd, client_selfid, other_id, &server_addr, buffer, length);
			}
		
		} else if (status_machine == KING_STATUS_P2P_MESSAGE) {

			printf(" --> please enter message to send : ");
			
			int now_count = p2p_count;
			struct sockaddr_in c_addr;
			c_addr.sin_family = AF_INET;
			array_to_addr(p2p_clients[now_count-1].addr, &c_addr);

 			int length = strlen(buffer);

			king_client_send_message(sockfd, client_selfid, 0, &c_addr, buffer, length);
		}

	}
}


int main(int argc, char *argv[]) {

	printf(" This is a UDP Client\n");

	if (argc != 4) {
		printf("Usage: %s ip port\n", argv[0]);
		exit(1);
	}

	int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
	if (sockfd < 0) {
		perror("socket");
		exit(1);
	}


	pthread_t thread_id[2] = {0};
	KING_CALLBACK cb[2] = {king_send_callback, king_recv_callback};
	int i = 0;

	for (i = 0;i < 2;i ++) {
		int ret = pthread_create(&thread_id[i], NULL, cb[i], &sockfd);
		if (ret) {
			perror("pthread_create");
			exit(1);
		}
		sleep(1);
	}

	server_addr.sin_family = AF_INET;
	server_addr.sin_port = htons(atoi(argv[2]));
	server_addr.sin_addr.s_addr = inet_addr(argv[1]);
	
	client_selfid = atoi(argv[3]);

	king_send_login(sockfd, client_selfid, &server_addr);

	for (i = 0;i < 2;i ++) {
		pthread_join(thread_id[i], NULL);
	}
	
	return 0;
}

 

实现完成。收工。。。。后期再讲讲webrtc的时候再讲讲p2p以及更多的知识 。。。。。。

jenie
关注
  • 1
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
P2P之UDP穿透NAT的原理与实现资料+源代码
11-24
在P2P网络中，UDP（User Datagram Protocol）穿透NAT（Network Address Translation）是一项关键技术，它使得位于不同NAT后的设备能够直接通信，从而提高网络效率并降低中心服务器的压力。 NAT是一种网络地址转换...
七、Linux C/C++TCP 点对点(p2p)传输
最新发布
weixin_39858918的博客
02-18 651
Linux C/C++TCP 点对点(p2p)传输
用C语言实现P2P穿透和推送音视频流案例
yinshipin007的博客
04-27 527
穿透：在P2P网络中，由于NAT的存在，直接通信可能会受到限制，需要进行穿透处理。总之，P2P穿透和推送音视频流是一个比较复杂的案例，需要对多个技术点进行深入了解和实践。确定通信协议和传输方式：可以选择TCP或UDP协议进行通信，同时也可以采用一些第三方库来简化传输过程，例如libcurl和libevent等。P2P穿透和推送音视频流是一个较为复杂的案例，需要涉及到网络编程、多线程、音视频编解码等知识。其他：处理音视频流时，可能还需要进行媒体同步和错误处理等操作，具体实现方式可以根据需求进行选择。
基于C语言的P2P软件实现
wm1634208243的博客
07-26 241
P2P(或者说 peer-to-peer)网络是一种基于操作上下文的网络模型，任何一个节点都同时作为客户机和服务器。本论文设计探讨了 P2P 网络的结构和 JXTA 的基本知识，并利用 JXTA 开发出一个组内聊天和共享文件的软件。P2P 是因特网的一种应用模式，其意思是指网络上的任何设备（包括大型机、PC 机、PDA、手机、机顶盒等等）都可以平等地直接进行连接并进行协作。是 peer-to-peer 的缩写，peer 在英语里有"（地位、能力等）同等者"、"同事"和"伙伴"等意义。
linux c实现一个简单P2P通信例程
qq_42161913的博客
08-08 424
linux c实现一个简单P2P通信例程
C语言实现简易p2p项目
AleanSue的博客
03-30 910
客户端： #include<stdio.h> #include<stdlib.h> #include<unistd.h> #include<string.h> #include<assert.h> #include<sys/socket.h> #include<netinet/in.h> #include<arpa/inet.h> #define IPSTR "127.0.0.1" #define PORT
wifi p2p 调试
nilingxi的专栏
03-06 2147
调试p2p功能之前，需要驱动打开p2p的支持，可以用ifconfig -a指令查看是否存在p2p网络节点 1、查看网络节点 341.68< ifconfig -a 341.71> ifconfig -a 341.95> carplay0 Link encap:Ethernet HWaddr DE:8A:1E:E6:91:9F 341.95>...
archive_p2p技术C源代码.zip.zip
09-15
P2P技术的核心在于去中心化，通过直接连接网络中的各个节点来实现数据交换，减少了对中心服务器的依赖，提高了网络效率和可扩展性。 【标签解析】 “c语言”和“游戏”这两个标签揭示了源代码可能的用途。C语言是一...
P2P聊天工具，用C语言编写
05-11
P2P聊天工具的核心思想是去中心化，每个参与者既是服务提供者也是服务消费者。在这款C语言实现的聊天工具中，用户可以直接与其他用户建立连接，进行实时通信，无需通过中央服务器作为中介。这样的设计不仅降低了网络...
p2p通信的简单实现（c语言）
08-02
这是一个在Linux下用C实现的简单的p2p通信的例子，对于初学者来说很有帮助
集成超精简版XMPP客户端和STUN协议，可实现P2P
12-14
集成超精简版XMPP客户端和STUN协议，可实现P2P，具体所实现的功能可查看源码README.txt，希望能帮到有需要的人，随便也可以提点意见和建议哈！ 至于P2P的实现，在我的测试环境下，是使用移动的3G网络，只要一台设备是移动3G网络就可以实现P2P了，结果测试移动3G网络的NAT是开放型的！爽吧~~~
P2P模型研究——KAD协议的算法实现
06-06
通过分析和运行这个项目，我们可以更深入地理解KAD协议的运作原理和C语言在实现P2P网络中的应用。 总结来说，KAD协议的C语言实现是一个涉及网络编程、数据结构、分布式算法的综合实践项目。它不仅需要理解P2P网络的...
p2p断开的两种情况：WLAN_REASON_DISASSOC_DUE_TO_INACTIVITY（4）和WLAN_REASON_DEAUTH_LEAVING（3）
yudelian的博客
12-09 5070
events.c wpas_event_disconnect 流程1： （复现是将p2p client远离GO，知道p2p断开） reason_code 为WLAN_REASON_DEAUTH_LEAVING，就算设置自动回连，也无法进入自动回连流程 if (deauth && reason_code > 0) { if (wpas_p2p_deauth_notif(wpa_s, addr, reason_code, ie, ie_len, locall..
P2P的原理和常见的实现方式
热门推荐
北雨南萍
07-14 1万+
为了项目的后期IM应用，最近在研究libjingle，中间看了也收集了很多资料， 感慨网上很多资料要么太过于纠结协议（如STUN、ICE等）实现细节，要么中间有很多纰漏。 最后去伪存真，归纳总结了一下，希望对以后的同行有些许帮助。 如果有什么需要讨论或者指正的，欢迎留言或者邮件peakflys@gmail.com                             一、P2P实
第六章 P2P原理与实践
weixin_42449639的博客
12-11 416
第六章 P2P原理与实践 P2P概念 P2P，即Peer-to-Peer的缩写，也称“点对点”或“端对端”，学术上常称为“对等计算”。P2P是一种以非集中化方式使用分布式资源来完成一些关键任务的系统和应用。P2P与目前网络中占据主导地位的客户/服务器体系架构相对应。它表示分布式计算中各进程之间是一种对等的关系。 P2P模式与C/S模式的区别 P2P模式中,每一个结点都是信息的发布者和请求者，对等...
P2P 技术概述（一）
yjf147369的博客
10-20 2507
P2P (Peer to Peer，点对点) 是一种分布式网络应用架构，其各个交互实体都是对等的，这里对等是指各交互实体是在网络中同等特权、同等能力的参与者（后面我们会使用对等体称呼这些交互实体或者叫参与者），这些对等体共同形成了一个点对点的节点网络。
P2P网络NAT穿透原理(打洞方案)
07-15 6973
NAT有4种类型：完全锥形NAT(Full Clone NAT)、限制性锥形NAT(Restricted Clone NAT)、端口限制性锥形NAT( Port Restricted Clone NAT)、对称式NAT(Symmetric NAT)，前面3种是锥形NAT(Clone NAT)。
去中心化的网络设计 — P2P的实现
weixin_33989058的博客
09-24 1816
随着区块链的越来越火，去中心化的网络设计再次被拿到技术人员面前。在这里我使用非常通俗的语言，帮大家来理解去中心化的网络设计的基础—网络穿透。再使用代码来实现穿透。如果阐述不到位的地方，欢迎大家抛砖。代码在此： https://github.com/wangbojing/P2PServer 在有中心化服务器的网络中，客户端，服务器，网关构成网络拓扑图。如下图1所示：由于...
C语言实现的简单ping程序设计解析
"这篇文档是关于使用C语言设计和实现ping程序的课程设计，主要涵盖了网络编程的基础知识和ping命令的实现原理。" 在计算机网络中，ping程序是一个至关重要的工具，它允许用户检查网络连接的可达性。本文档详细介绍...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值