socket编程。怎么实现数据包的转发？C语言版的。

Posted 2023-03-25

比如说多个客户端之间的通信。服务器怎么实现数据的转发？

我也不知道····只好复制一份···共同学习~~ 要写网络程序就必须用Socket，这是程序员都知道的。而且，面试的时候，我们也会问对方会不会Socket编程？一般来说，很多人都会说，Socket编程基本就是listen，accept以及send，write等几个基本的操作。是的，就跟常见的文件操作一样，只要写过就一定知道。对于网络编程，我们也言必称TCP/IP，似乎其它网络协议已经不存在了。对于TCP/IP，我们还知道TCP和UDP，前者可以保证数据的正确和可靠性，后者则允许数据丢失。最后，我们还知道，在建立连接前，必须知道对方的IP地址和端口号。除此，普通的程序员就不会知道太多了，很多时候这些知识已经够用了。最多，写服务程序的时候，会使用多线程来处理并发访问。我们还知道如下几个事实：1。一个指定的端口号不能被多个程序共用。比如，如果IIS占用了80端口，那么Apache就不能也用80端口了。2。很多防火墙只允许特定目标端口的数据包通过。3。服务程序在listen某个端口并accept某个连接请求后，会生成一个新的socket来对该请求进行处理。于是，一个困惑了我很久的问题就产生了。如果一个socket创建后并与80端口绑定后，是否就意味着该socket占用了80端口呢？如果是这样的，那么当其accept一个请求后，生成的新的socket到底使用的是什么端口呢（我一直以为系统会默认给其分配一个空闲的端口号）？如果是一个空闲的端口，那一定不是80端口了，于是以后的TCP数据包的目标端口就不是80了--防火墙一定会组织其通过的！实际上，我们可以看到，防火墙并没有阻止这样的连接，而且这是最常见的连接请求和处理方式。我的不解就是，为什么防火墙没有阻止这样的连接？它是如何判定那条连接是因为connet80端口而生成的？是不是TCP数据包里有什么特别的标志？或者防火墙记住了什么东西？后来，我又仔细研读了TCP/IP的协议栈的原理，对很多概念有了更深刻的认识。比如，在TCP和UDP同属于传输层，共同架设在IP层（网络层）之上。而IP层主要负责的是在节点之间（End to End）的数据包传送，这里的节点是一台网络设备，比如计算机。因为IP层只负责把数据送到节点，而不能区分上面的不同应用，所以TCP和UDP协议在其基础上加入了端口的信息，端口于是标识的是一个节点上的一个应用。除了增加端口信息，UPD协议基本就没有对IP层的数据进行任何的处理了。而TCP协议还加入了更加复杂的传输控制，比如滑动的数据发送窗口（Slice Window），以及接收确认和重发机制，以达到数据的可靠传送。不管应用层看到的是怎样一个稳定的TCP数据流，下面传送的都是一个个的IP数据包，需要由TCP协议来进行数据重组。所以，我有理由怀疑，防火墙并没有足够的信息判断TCP数据包的更多信息，除了IP地址和端口号。而且，我们也看到，所谓的端口，是为了区分不同的应用的，以在不同的IP包来到的时候能够正确转发。TCP/IP只是一个协议栈，就像操作系统的运行机制一样，必须要具体实现，同时还要提供对外的操作接口。就像操作系统会提供标准的编程接口，比如Win32编程接口一样，TCP/IP也必须对外提供编程接口，这就是Socket编程接口--原来是这么回事啊！在Socket编程接口里，设计者提出了一个很重要的概念，那就是socket。这个socket跟文件句柄很相似，实际上在BSD系统里就是跟文件句柄一样存放在一样的进程句柄表里。这个socket其实是一个序号，表示其在句柄表中的位置。这一点，我们已经见过很多了，比如文件句柄，窗口句柄等等。这些句柄，其实是代表了系统中的某些特定的对象，用于在各种函数中作为参数传入，以对特定的对象进行操作--这其实是C语言的问题，在C++语言里，这个句柄其实就是this指针，实际就是对象指针啦。现在我们知道，socket跟TCP/IP并没有必然的联系。Socket编程接口在设计的时候，就希望也能适应其他的网络协议。所以，socket的出现只是可以更方便的使用TCP/IP协议栈而已，其对TCP/IP进行了抽象，形成了几个最基本的函数接口。比如create，listen，accept，connect，read和write等等。现在我们明白，如果一个程序创建了 参考技术A 网络的Socket数据传输是一种特殊的I/O，Socket也是一种文件描述符。Socket也具有一个类似于打开文件的函数调用Socket()，该函数返回一个整型的Socket描述符，随后的连接建立、数据传输等操作都是通过该Socket实现的。

下面用Socket实现一个windows下的c语言socket通信例子，用客户端传递一个字符串，服务器端进行接收。

【服务器端】
#include "stdafx.h"
#include <stdio.h>
#include <winsock2.h>
#include <winsock2.h>
#define SERVER_PORT 5208 //侦听端口
void main()

WORD wVersionRequested;
WSADATA wsaData;
int ret, nLeft, length;
SOCKET sListen, sServer; //侦听套接字，连接套接字
struct sockaddr_in saServer, saClient; //地址信息
char *ptr;//用于遍历信息的指针
//WinSock初始化
wVersionRequested=MAKEWORD(2, 2); //希望使用的WinSock DLL 的版本
ret=WSAStartup(wVersionRequested, &wsaData);
if(ret!=0)

printf("WSAStartup() failed!\n");
return;

//创建Socket,使用TCP协议
sListen=socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if (sListen == INVALID_SOCKET)

WSACleanup();
printf("socket() faild!\n");
return;

//构建本地地址信息
saServer.sin_family = AF_INET; //地址家族
saServer.sin_port = htons(SERVER_PORT); //注意转化为网络字节序
saServer.sin_addr.S_un.S_addr = htonl(INADDR_ANY); //使用INADDR_ANY 指示任意地址

//绑定
ret = bind(sListen, (struct sockaddr *)&saServer, sizeof(saServer));
if (ret == SOCKET_ERROR)

printf("bind() faild! code:%d\n", WSAGetLastError());
closesocket(sListen); //关闭套接字
WSACleanup();
return;


//侦听连接请求
ret = listen(sListen, 5);
if (ret == SOCKET_ERROR)

printf("listen() faild! code:%d\n", WSAGetLastError());
closesocket(sListen); //关闭套接字
return;


printf("Waiting for client connecting!\n");
printf("Tips: Ctrl+c to quit!\n");
//阻塞等待接受客户端连接
while(1)//循环监听客户端，永远不停止

length = sizeof(saClient);
sServer = accept(sListen, (struct sockaddr *)&saClient, &length);
if (sServer == INVALID_SOCKET)

printf("accept() faild! code:%d\n", WSAGetLastError());
closesocket(sListen); //关闭套接字
WSACleanup();
return;

char receiveMessage[5000];
nLeft = sizeof(receiveMessage);
ptr = (char *)&receiveMessage;
while(nLeft>0)

//接收数据
ret = recv(sServer, ptr, 5000, 0);
if (ret == SOCKET_ERROR)

printf("recv() failed!\n");
return;

if (ret == 0) //客户端已经关闭连接

printf("Client has closed the connection\n");
break;

nLeft -= ret;
ptr += ret;

printf("receive message:%s\n", receiveMessage);//打印我们接收到的消息。


// closesocket(sListen);
// closesocket(sServer);
// WSACleanup();

【客户端】
#include "stdafx.h"
#include <stdio.h>
#include <stdlib.h>
#include <winsock2.h>
#define SERVER_PORT 5208 //侦听端口
void main()

WORD wVersionRequested;
WSADATA wsaData;
int ret;
SOCKET sClient; //连接套接字
struct sockaddr_in saServer; //地址信息
char *ptr;
BOOL fSuccess = TRUE;
//WinSock初始化
wVersionRequested = MAKEWORD(2, 2); //希望使用的WinSock DLL的版本
ret = WSAStartup(wVersionRequested, &wsaData);
if(ret!=0)

printf("WSAStartup() failed!\n");
return;

//确认WinSock DLL支持版本2.2
if(LOBYTE(wsaData.wVersion)!=2 || HIBYTE(wsaData.wVersion)!=2)

WSACleanup();
printf("Invalid WinSock version!\n");
return;

//创建Socket,使用TCP协议
sClient = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if (sClient == INVALID_SOCKET)

WSACleanup();
printf("socket() failed!\n");
return;

//构建服务器地址信息
saServer.sin_family = AF_INET; //地址家族
saServer.sin_port = htons(SERVER_PORT); //注意转化为网络节序
saServer.sin_addr.S_un.S_addr = inet_addr("192.168.1.127");
//连接服务器
ret = connect(sClient, (struct sockaddr *)&saServer, sizeof(saServer));
if (ret == SOCKET_ERROR)

printf("connect() failed!\n");
closesocket(sClient); //关闭套接字
WSACleanup();
return;


char sendMessage[]="hello this is client message!";
ret = send (sClient, (char *)&sendMessage, sizeof(sendMessage), 0);
if (ret == SOCKET_ERROR)

printf("send() failed!\n");

else
printf("client info has been sent!");
closesocket(sClient); //关闭套接字
WSACleanup();

socket 通信粘包怎么处理

一、socket 通信粘包的处理方法：

1、对于发送方引起的粘包现象，用户可通过编程设置来避免，TCP提供了强制数据立即传送的操作指令push，TCP软件收到该操作指令后，就立即将本段数据发送出去，而不必等待发送缓冲区满；

2、对于接收方引起的粘包，则可通过优化程序设计、精简接收进程工作量、提高接收进程优先级等措施，使其及时接收数据，从而尽量避免出现粘包现象；

3、由接收方控制，将一包数据按结构字段，人为控制分多次接收，然后合并，通过这种手段来避免粘包。

二、实现代码：

三、方法注意事项：

1、第一种编程设置方法虽然可以避免发送方引起的粘包，但它关闭了优化算法，降低了网络发送效率，影响应用程序的性能，一般不建议使用。

2、第二种方法只能减少出现粘包的可能性，但并不能完全避免粘包，当发送频率较高时，或由于网络突发可能使某个时间段数据包到达接收方较快，接收方还是有可能来不及接收，从而导致粘包；

3、第三种方法虽然避免了粘包，但应用程序的效率较低，对实时应用的场合不适合。

四、实验环境

1、硬件环境：服务器：pentium 350 微机 、客户机：pentium 166微机、网络平台：由10兆共享式hub连接而成的局域网；

2、软件环境：操作系统：windows 98 、编程语言：visual c++ 5.0

参考技术A 在用golang开发人工客服系统的时候碰到了粘包问题，那么什么是粘包呢？例如我们和客户端约定数据交互格式是一个json格式的字符串：
"Id":1,"Name":"golang","Message":"message"
当客户端发送数据给服务端的时候，如果服务端没有及时接收，客户端又发送了一条数据上来，这时候服务端才进行接收的话就会收到两个连续的字符串，形如：
"Id":1,"Name":"golang","Message":"message""Id":1,"Name":"golang","Message":"message"
如果接收缓冲区满了的话，那么也有可能接收到半截的json字符串，酱紫的话还怎么用json解码呢？真是头疼。以下用golang模拟了下这个粘包的产生。
备注：下面贴的代码均可以运行于golang 1.3.1，如果发现有问题可以联系我。
粘包示例server.go
//粘包问题演示服务端

package main

import (

"fmt"

"net"

"os"

)

func main()

netListen, err := net.Listen("tcp", ":9988")

CheckError(err)

defer netListen.Close()

Log("Waiting for clients")

for

conn, err := netListen.Accept()

if err != nil

continue



Log(conn.RemoteAddr().String(), " tcp connect success")

go handleConnection(conn)





func handleConnection(conn net.Conn)

buffer := make([]byte, 1024)

for

n, err := conn.Read(buffer)

if err != nil

Log(conn.RemoteAddr().String(), " connection error: ", err)

return



Log(conn.RemoteAddr().String(), "receive data length:", n)

Log(conn.RemoteAddr().String(), "receive data:", buffer[:n])

Log(conn.RemoteAddr().String(), "receive data string:", string(buffer[:n]))





func Log(v ...interface)

fmt.Println(v...)



func CheckError(err error)

if err != nil

fmt.Fprintf(os.Stderr, "Fatal error: %s", err.Error())

os.Exit(1)




复制代码
client.go
//粘包问题演示客户端

package main

import (

"fmt"

"net"

"os"

"time"

)

func sender(conn net.Conn)

for i := 0; i < 100; i++

words := "\"Id\":1,\"Name\":\"golang\",\"Message\":\"message\""

conn.Write([]byte(words))





func main()

server := "127.0.0.1:9988"

tcpAddr, err := net.ResolveTCPAddr("tcp4", server)

if err != nil

fmt.Fprintf(os.Stderr, "Fatal error: %s", err.Error())

os.Exit(1)



conn, err := net.DialTCP("tcp", nil, tcpAddr)

if err != nil

fmt.Fprintf(os.Stderr, "Fatal error: %s", err.Error())

os.Exit(1)



defer conn.Close()

fmt.Println("connect success")

go sender(conn)

for

time.Sleep(1 * 1e9)




复制代码
运行后查看服务端输出：

可以看到json格式的字符串都粘到一起了，有种淡淡的忧伤了——头疼的事情又来了。
粘包产生原因
关于粘包的产生原因网上有很多相关的说明，主要原因就是tcp数据传递模式是流模式，在保持长连接的时候可以进行多次的收和发。如果要深入了解可以看看tcp协议方面的内容。这里推荐下鸟哥的私房菜，讲的非常通俗易懂。
粘包解决办法
主要有两种方法：
1、客户端发送一次就断开连接，需要发送数据的时候再次连接，典型如http。下面用golang演示一下这个过程，确实不会出现粘包问题。
//客户端代码，演示了发送一次数据就断开连接的

package main

import (

"fmt"

"net"

"os"

"time"

)

func main()

server := "127.0.0.1:9988"

for i := 0; i < 10000; i++

tcpAddr, err := net.ResolveTCPAddr("tcp4", server)

if err != nil

fmt.Fprintf(os.Stderr, "Fatal error: %s", err.Error())

os.Exit(1)



conn, err := net.DialTCP("tcp", nil, tcpAddr)

if err != nil

fmt.Fprintf(os.Stderr, "Fatal error: %s", err.Error())

os.Exit(1)



words := "\"Id\":1,\"Name\":\"golang\",\"Message\":\"message\""

conn.Write([]byte(words))

conn.Close()



for

time.Sleep(1 * 1e9)




复制代码
服务端代码参考上面演示粘包产生过程的服务端代码
2、包头+数据的格式，根据包头信息读取到需要分析的数据。形式如下图：

golang粘包问题包头定义

从数据流中读取数据的时候，只要根据包头和数据长度就能取到需要的数据。这个其实就是平时说的协议（protocol），只是这个数据传输协议非常简单，不像tcp、ip等协议有较多的定义。在实际的过程中通常会定义协议类或者协议文件来封装封包和解包的过程。下面代码演示了封包和解包的过程：
protocol.go
//通讯协议处理，主要处理封包和解包的过程

package protocol

import (

"bytes"

"encoding/binary"

)

const (

ConstHeader = "www.01happy.com"

ConstHeaderLength = 15

ConstSaveDataLength = 4

)

//封包

func Packet(message []byte) []byte

return append(append([]byte(ConstHeader), IntToBytes(len(message))...), message...)



//解包

func Unpack(buffer []byte, readerChannel chan []byte) []byte

length := len(buffer)

var i int

for i = 0; i < length; i = i + 1

if length < i+ConstHeaderLength+ConstSaveDataLength

break



if string(buffer[i:i+ConstHeaderLength]) == ConstHeader

messageLength := BytesToInt(buffer[i+ConstHeaderLength : i+ConstHeaderLength+ConstSaveDataLength])

if length < i+ConstHeaderLength+ConstSaveDataLength+messageLength

break



data := buffer[i+ConstHeaderLength+ConstSaveDataLength : i+ConstHeaderLength+ConstSaveDataLength+messageLength]

readerChannel <- data

i += ConstHeaderLength + ConstSaveDataLength + messageLength - 1





if i == length

return make([]byte, 0)



return buffer[i:]



//整形转换成字节

func IntToBytes(n int) []byte

x := int32(n)

bytesBuffer := bytes.NewBuffer([]byte)

binary.Write(bytesBuffer, binary.BigEndian, x)

return bytesBuffer.Bytes()



//字节转换成整形

func BytesToInt(b []byte) int

bytesBuffer := bytes.NewBuffer(b)

var x int32

binary.Read(bytesBuffer, binary.BigEndian, &x)

return int(x)


复制代码
tips：解包的过程中要注意数组越界的问题；另外包头要注意唯一性。
server.go
//服务端解包过程

package main

import (

"./protocol"

"fmt"

"net"

"os"

)

func main()

netListen, err := net.Listen("tcp", ":9988")

CheckError(err)

defer netListen.Close()

Log("Waiting for clients")

for

conn, err := netListen.Accept()

if err != nil

continue



Log(conn.RemoteAddr().String(), " tcp connect success")

go handleConnection(conn)





func handleConnection(conn net.Conn)

//声明一个临时缓冲区，用来存储被截断的数据

tmpBuffer := make([]byte, 0)

//声明一个管道用于接收解包的数据

readerChannel := make(chan []byte, 16)

go reader(readerChannel)

buffer := make([]byte, 1024)

for

n, err := conn.Read(buffer)

if err != nil

Log(conn.RemoteAddr().String(), " connection error: ", err)

return



tmpBuffer = protocol.Unpack(append(tmpBuffer, buffer[:n]...), readerChannel)





func reader(readerChannel chan []byte)

for

select

case data := <-readerChannel:

Log(string(data))







func Log(v ...interface)

fmt.Println(v...)



func CheckError(err error)

if err != nil

fmt.Fprintf(os.Stderr, "Fatal error: %s", err.Error())

os.Exit(1)




复制代码
client.go
//客户端发送封包

package main

import (

"./protocol"

"fmt"

"net"

"os"

"time"

)

func sender(conn net.Conn)

for i := 0; i < 1000; i++

words := "\"Id\":1,\"Name\":\"golang\",\"Message\":\"message\""

conn.Write(protocol.Packet([]byte(words)))



fmt.Println("send over")



func main()

server := "127.0.0.1:9988"

tcpAddr, err := net.ResolveTCPAddr("tcp4", server)

if err != nil

fmt.Fprintf(os.Stderr, "Fatal error: %s", err.Error())

os.Exit(1)



conn, err := net.DialTCP("tcp", nil, tcpAddr)

if err != nil

fmt.Fprintf(os.Stderr, "Fatal error: %s", err.Error())

os.Exit(1)



defer conn.Close()

fmt.Println("connect success")

go sender(conn)

for

time.Sleep(1 * 1e9)




复制代码
最后
上面演示的两种方法适用于不同的场景。第一种方法比较适合被动型的场景，例如打开网页，用户有请求才处理交互。第二种方法适合于主动推送的类型，例如即时聊天系统，因为要即时给用户推送消息，保持长连接是不可避免的，这时候就要用这种方法。