Socket发送和接收变长结构体

最新推荐文章于 2020-11-29 04:51:20 发布
最新推荐文章于 2020-11-29 04:51:20 发布
阅读量3.3k 收藏 10
点赞数 3
分类专栏： Socket C++

//Server端代码

[cpp] view plain copy print ?
  1. #include<stdio.h>   
  2. #include<stdlib.h>   
  3. #include<string.h>   
  4. #include<sys/types.h>   
  5. #include<netinet/in.h>   
  6. #include<sys/socket.h>   
  7.   
  8.   
  9. #include<unistd.h>   
  10. //使用不定长的结构体发送数据的关键在于：结构体变量必须分配到堆中，而不是栈中   
  11. //即只能用malloc或者new来给结构体分配空间   
  12. typedef struct Node  
  13. {  
  14.     int nodeSize;  
  15.     int bufSize;  
  16.     char buf[0];             //用0字节表示该结构体不定长   
  17. } Node;  
  18.   
  19. int main()  
  20. {  
  21.     int sockfd,new_fd;  
  22.     struct sockaddr_in server_addr;  
  23.     struct sockaddr_in client_addr;  
  24.   
  25.     if((sockfd = socket(AF_INET,SOCK_STREAM,0)) == -1)  
  26.     {  
  27.         printf("socket error!\n");  
  28.         exit(1);  
  29.     }  
  30.     server_addr.sin_family = AF_INET;  
  31.     server_addr.sin_port = htons(5050);  
  32.     server_addr.sin_addr.s_addr = INADDR_ANY;  
  33.     bzero(&(server_addr.sin_zero),8);  
  34.   
  35.     if(bind(sockfd,(struct sockaddr *)&server_addr,sizeof(server_addr)) == -1)  
  36.     {  
  37.         printf("bind error!\n");  
  38.         exit(1);  
  39.     }  
  40.     if(listen(sockfd,100) == -1)  
  41.     {  
  42.         printf("listen error!\n");  
  43.         exit(1);  
  44.     }  
  45.     printf("Server is listening:\n");  
  46.     while(1)  
  47.     {  
  48.         int sin_size = sizeof(struct sockaddr_in);  
  49.         if((new_fd = accept(sockfd,(struct sockaddr *)&client_addr,(socklen_t *)&sin_size)) == -1)  
  50.         {  
  51.             printf("accept error!\n");  
  52.             exit(1);  
  53.         }  
  54.         int recvSize = 0;//data total length   
  55.         if(recv(new_fd,(char *)&recvSize,sizeof(recvSize),0) == -1)  
  56.         {  
  57.             printf("recv error!\n");  
  58.             exit(1);  
  59.         }  
  60.         int leftSize = sizeof(char) * (recvSize - sizeof(int));  
  61.         char *dataBuf = (char *)malloc(leftSize);  
  62.         memset(dataBuf,0,leftSize);  
  63.         if(recv(new_fd,dataBuf,leftSize,0) == -1)  
  64.         {  
  65.             printf("recv error!\n");  
  66.             exit(1);  
  67.         }  
  68.         close(new_fd);  
  69.         Node *p = (Node *)malloc(sizeof(char) * recvSize);  
  70.         p->nodeSize = recvSize;  
  71.         memcpy((char *)(&p->bufSize),dataBuf,leftSize);  
  72.         printf("nodeSize = %d\n",p->nodeSize);  
  73.         printf("bufSize = %d\n",p->bufSize);  
  74.         printf("buf = %s\n",p->buf);  
  75.     }  
  76.   
  77.     return 0;  
  78. }  
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<sys/types.h>
#include<netinet/in.h>
#include<sys/socket.h>


#include<unistd.h>
//使用不定长的结构体发送数据的关键在于：结构体变量必须分配到堆中，而不是栈中
//即只能用malloc或者new来给结构体分配空间
typedef struct Node
{
	int nodeSize;
	int bufSize;
	char buf[0];             //用0字节表示该结构体不定长
} Node;

int main()
{
	int sockfd,new_fd;
	struct sockaddr_in server_addr;
	struct sockaddr_in client_addr;

	if((sockfd = socket(AF_INET,SOCK_STREAM,0)) == -1)
	{
		printf("socket error!\n");
		exit(1);
	}
	server_addr.sin_family = AF_INET;
	server_addr.sin_port = htons(5050);
	server_addr.sin_addr.s_addr = INADDR_ANY;
	bzero(&(server_addr.sin_zero),8);

	if(bind(sockfd,(struct sockaddr *)&server_addr,sizeof(server_addr)) == -1)
	{
		printf("bind error!\n");
		exit(1);
	}
	if(listen(sockfd,100) == -1)
	{
		printf("listen error!\n");
		exit(1);
	}
	printf("Server is listening:\n");
	while(1)
	{
		int sin_size = sizeof(struct sockaddr_in);
		if((new_fd = accept(sockfd,(struct sockaddr *)&client_addr,(socklen_t *)&sin_size)) == -1)
		{
			printf("accept error!\n");
			exit(1);
		}
		int recvSize = 0;//data total length
		if(recv(new_fd,(char *)&recvSize,sizeof(recvSize),0) == -1)
		{
			printf("recv error!\n");
			exit(1);
		}
		int leftSize = sizeof(char) * (recvSize - sizeof(int));
		char *dataBuf = (char *)malloc(leftSize);
		memset(dataBuf,0,leftSize);
		if(recv(new_fd,dataBuf,leftSize,0) == -1)
		{
			printf("recv error!\n");
			exit(1);
		}
		close(new_fd);
		Node *p = (Node *)malloc(sizeof(char) * recvSize);
		p->nodeSize = recvSize;
		memcpy((char *)(&p->bufSize),dataBuf,leftSize);
		printf("nodeSize = %d\n",p->nodeSize);
		printf("bufSize = %d\n",p->bufSize);
		printf("buf = %s\n",p->buf);
	}

	return 0;
}


//Client端代码

[cpp] view plain copy print ?
  1. #include<stdio.h>   
  2. #include<stdlib.h>   
  3. #include<string.h>   
  4. #include<sys/types.h>   
  5. #include<arpa/inet.h>   
  6. #include<netinet/in.h>   
  7. #include<sys/socket.h>   
  8.   
  9.   
  10. #include<unistd.h>   
  11.   
  12. typedef struct Node  
  13. {  
  14.     int nodeSize;  
  15.     int bufSize;  
  16.     char buf[0];  
  17. } Node;  
  18.   
  19. int main()  
  20. {  
  21.     int sockfd,new_fd;  
  22.     struct sockaddr_in server_addr;  
  23.   
  24.     if((sockfd = socket(AF_INET,SOCK_STREAM,0)) == -1)  
  25.     {  
  26.         printf("socket error!\n");  
  27.         exit(1);  
  28.     }  
  29.     server_addr.sin_family = AF_INET;  
  30.     server_addr.sin_port = htons(5050);  
  31.     server_addr.sin_addr.s_addr = inet_addr("127.0.0.1");  
  32.     bzero(&(server_addr.sin_zero),8);  
  33.   
  34.     if(connect(sockfd,(struct sockaddr *)&server_addr,sizeof(server_addr)) == -1)  
  35.     {  
  36.         printf("connect error!\n");  
  37.         exit(1);  
  38.     }  
  39.     printf("Client is connecting\n");  
  40.     const char *tmp = "this is a test!";  
  41.     int tmpLen = strlen(tmp);  
  42.     Node *dataBuf = (Node *)malloc(sizeof(Node) + tmpLen + 1);  
  43.     dataBuf->nodeSize = sizeof(Node) + tmpLen + 1;  
  44.     dataBuf->bufSize = tmpLen;  
  45.     memset(dataBuf->buf,0,tmpLen + 1);  
  46.     memcpy(dataBuf->buf,tmp,tmpLen + 1);  
  47.     printf("nodeSize = %d\n",dataBuf->nodeSize);  
  48.     printf("bufSize = %d\n",dataBuf->bufSize);  
  49.     printf("buf = %s\n",dataBuf->buf);  
  50.     if(send(sockfd,(char *)dataBuf,dataBuf->nodeSize,0) == -1)  
  51.     {  
  52.         printf("send error!\n");  
  53.         exit(1);  
  54.     }  
  55.     close(sockfd);  
  56.     return 0;  
  57. }  
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<sys/types.h>
#include<arpa/inet.h>
#include<netinet/in.h>
#include<sys/socket.h>


#include<unistd.h>

typedef struct Node
{
	int nodeSize;
	int bufSize;
	char buf[0];
} Node;

int main()
{
	int sockfd,new_fd;
	struct sockaddr_in server_addr;

	if((sockfd = socket(AF_INET,SOCK_STREAM,0)) == -1)
	{
		printf("socket error!\n");
		exit(1);
	}
	server_addr.sin_family = AF_INET;
	server_addr.sin_port = htons(5050);
	server_addr.sin_addr.s_addr = inet_addr("127.0.0.1");
	bzero(&(server_addr.sin_zero),8);

	if(connect(sockfd,(struct sockaddr *)&server_addr,sizeof(server_addr)) == -1)
	{
		printf("connect error!\n");
		exit(1);
	}
	printf("Client is connecting\n");
	const char *tmp = "this is a test!";
	int tmpLen = strlen(tmp);
	Node *dataBuf = (Node *)malloc(sizeof(Node) + tmpLen + 1);
	dataBuf->nodeSize = sizeof(Node) + tmpLen + 1;
	dataBuf->bufSize = tmpLen;
	memset(dataBuf->buf,0,tmpLen + 1);
	memcpy(dataBuf->buf,tmp,tmpLen + 1);
	printf("nodeSize = %d\n",dataBuf->nodeSize);
	printf("bufSize = %d\n",dataBuf->bufSize);
	printf("buf = %s\n",dataBuf->buf);
	if(send(sockfd,(char *)dataBuf,dataBuf->nodeSize,0) == -1)
	{
		printf("send error!\n");
		exit(1);
	}
	close(sockfd);
	return 0;
}


wujinqiao88
关注
专栏目录
winsock收发结构体
05-10
本文将详细讨论“Winsock收发结构体”这一主题，包括其在C/S（客户端/服务器）架构中的应用，以及如何利用Winsock进行数据的发送和接收。 首先，我们来了解Winsock的基本概念。Winsock，全称为Windows Sockets，是...
利用不定长的结构体发送socket数据
08-02 4582
//Server端代码 #include #include #include #include #include #include #include //使用不定长的结构体发送数据的关键在于：结构体变量必须分配到堆中，而不是栈中 //即只能用malloc或者new来给结构体分配空间 typedef struct Node { int nodeSize; int
Cpp-Socket网络编程（七）网络消息接收长度问题
ljytower的博客
07-28 789
在复杂网络环境下，网络消息的长度并不总是固定的，网络数据包可分为固长数据、变长数据、粘包/拆包、少包/组包等情况。其中，粘包指，例如每次发送500字节数据到客户端或者服务端，但是由于网络延迟等原因，服务器端可能一次收到两个消息，即1000字节，也就是网络数据包粘在一起了，因此需要一个拆包的过程；分包指，例如一次发送1000字节数据，服务器端接收的时候，一开始只接收到500字节的数据，那么服务器端就...
Socket中send方法发送结构体和recv接受结构体
热门推荐
MachiealFactory的博客
11-09 1万+
Linux网络通信 Linux下多客户端聊天软件 Linux程序设计 Linux socket send and recevie structure 　　最近在开发一个Linux下的聊天软件，好久没有做C语言的开发了，感觉到很多东西已经生疏了，这下又碰到用Socket传递结构体的问题，google了一下，发现也有不少朋友遇到同样的问题，所以就打算写出自己的解决办法，跟大家分享。 　　S
C语言 udp socket 发送和接收不定长结构体
cfl927096306的博客
03-06 3381
//socket udp 服务端 #include <stdio.h> #include <unistd.h> #include <sys/types.h> #include <sys/socket.h> #include <arpa/inet.h> #include <stdlib.h> #include <stri...
socket编程技巧（1）tcp接收接口（变长数据定长数据）的编写实例
07-03 683
TCP读取定长数据接口的编写： int readn(int fd,char*bp,size_t len) { 　　int cnt; 　　int rc; 　　 　　cnt=len; 　　while(cnt>0) { 　　　　rc=recv(fd,bp,cnt,0); if(rc<0)//read error ...
Socket编程详解
11-01
每个TCP Socket都有一个发送缓冲区和一个接收缓冲区。发送缓冲区用于暂存等待发送的数据，而接收缓冲区则用于暂存从网络上接收来的数据。对于TCP来说，接收缓冲区的大小实际上决定了窗口大小，从而影响了流量控制...
unix Socket编程
03-02
- 结构体 `sockaddr_un` 是一个变长结构体，适用于 Unix 域通信。 4. **数据链路层 Socket 地址结构** - 结构体 `sockaddr_dl` 用于数据链路层通信，地址簇类型为 `AF_LINK`。 5. **通用 Socket 地址结构** - ...
VC编制Socket客户端
01-19
6. **发送和接收数据**：一旦连接成功，就可以使用`send`函数发送数据到服务器，用`recv`函数接收服务器返回的数据。这两个函数都提供缓冲区和长度参数，用于指定要发送或接收的数据。 7. **关闭Socket**：在完成...
谈起socket编程，大家也许会想起QQ和IE，没错。
12-21
Windows Socket（通常简称Winsock）是Windows平台上实现Socket编程的一组API集合，它利用了Windows系统的消息驱动特性，使得Socket编程变得更加高效和简单。 #### 二、Winsock规范发展 - **Winsock 1.1版**：发布于...
Socket Send带指针的结构体以及不定长数据
05-09 5881
一般来说，我们使用Send发送结构体数据，结构体里面的数据，一般都是用定义好了的char 数组来发送的，如下例子： struct Sendbuf { char encode; //数据编码格式。已定义：0：UTF-8，1：GBK，2：GB2312，3：ISO8859-1 4. char encrypt; //加密类型。0表示不加密 char v
c++ 不定长消息的处理
True Truth
08-22 432
在c++中，使用结构体来对地址上的数据进行标示，一般情况下，这给我们编程带来很大的变量，可以通过一个简单的机构处理千千万的数据。 但是最近我遇到一个难题，在传输结构中，数据不定长。这样的数据就超出了一个结构体的处理范围了。 大致是，我有个程序A，会输出随机的多个结果，将这些结果通过管道传递给另外一个程序B。 在B中我们知道结果的结构但是目前还不知道结果的个数。 这个时候我们可以在B中我们定义一个结...
socket接收不定长数据_听说你还不会Socket编程！
weixin_39945871的博客
11-29 1118
作者：zskingking博客：https://www.jianshu.com/p/b04930d2b85e上周我们描述了传输层协议TCP、UDP，但它们毕竟只是协议，看不见摸不着，那我们怎们通过TCP、和UDP进行实际传输呢？不用着急，等看完这篇文章你一定会明白的。Socket概述Socket中文意思为插座的意思，专业术语称之为套接字，它把TCP/IP封装成了调用接口供开发者调用，也就是说开发者...
Socket通信总结（附C++实现）
冷月宫主的专栏
10-13 5534
文章目录 [隐藏] 一、Socket是什么 二、一些基本概念 三、java socket建立连接的过程   四、Socket 通信示例 五、建立通信链路 六、服务端代码： 七、客户端代码 测试图例：        因为项目需要，服务端需要一个SOCKET来接收客户端的请求，好吧，没办法度娘哇，结果很多都是linux的例子，功夫不负有心人啊
socket包长度问题: send recieve
jasonfqw的专栏
10-13 5651
一个包没有固定长度，以太网限制在46－1500字节，1500就是以太网的MTU，超过这个量，TCP会为IP数据报设置偏移量进行分片传输，现在一般可允许应用层设置8k（NTFS系）的缓冲区，8k的数据由底层分片，而应用看来只是一次发送。windows的缓冲区经验值是4k,Socket本身分为两种，流(TCP)和数据报(UDP)，你的问题针对这两种不同使用而结论不一样。甚至还和你是用阻塞、还是非阻塞S
C++ Socket网络编程1.2版本 多次收发报文升级为一次收发
La745739773的博客
04-06 687
在目前的版本中，将网络数据传输方式改进成为网络数据报文（结构体)的形式传输，但比较不合理的一点是，传输数据的过程中总是要先传输 包头，再传输包体。因此，本节将多次收发报文改进为一次收发报文。 再回顾一下上一节的关键内容： 1、定义了四个网络数据包结构体 //DataPackge struct Login { char userName[32]; char Password[32]; }; st...
如何有效控制c++socket发送和接收数据长度
zhuimr520的博客
08-28 2416
开始c++ 创建socket编程时候，总是定一个足够大的数组来接收数据，从效率上讲是不科学的，如果能控制发多少接收多少是理想状态，下面例子说明： bool CMySocket::Send(const char *pSMsg, int len) { char* sendBuff = new char[len + 4];//申请发送数组，+4是要发送长度所占的字节数 byte lenBuff[4] = { 0 };//长度数组并初始化 int2bytes(len, lenBuff, ...
C语言如何实现可变长结构体
最新发布
05-26
在 C 语言中，结构体的大小是在编译时确定的，无法在运行时动态改变。但是，可以使用指针和动态内存分配来实现可变长结构体。 假设我们有一个包含固定部分和可变部分的结构体，可以定义如下： ``` typedef struct { int fixed_field1; int fixed_field2; int var_length; char dynamic_data[1]; // 可变长数组 } MyStruct; ``` 其中，`dynamic_data` 是一个可变长数组，它的实际长度由 `var_length` 字段指定。为了动态分配内存并创建可变长结构体，我们可以使用 `malloc` 函数来分配内存，并使用指针访问结构体的可变部分。代码示例如下： ``` int var_length = 10; // 假设可变部分的长度为 10 MyStruct* p = (MyStruct*)malloc(sizeof(MyStruct) + var_length - 1); p->var_length = var_length; // 访问可变部分 for (int i = 0; i < var_length; i++) { p->dynamic_data[i] = 'a' + i; } ``` 需要注意的是，在访问可变部分时，要保证不超出分配的内存范围，否则会导致未定义行为。此外，如果需要修改可变部分的大小，需要重新分配内存并将数据复制到新的内存中。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值