第7讲 传送——(4)原始套接字编程
C语言网络编程套接字和常用协议
C语言网络编程套接字和常用协议网络编程是现代计算机科学中非常重要的一个领域，通过网络编程可以实现不同设备之间的数据传输与通信。
C语言作为一种强大的编程语言，在网络编程方面也有着广泛的应用。
本文将介绍C语言网络编程中常用的套接字和协议。
一、套接字(Socket)基础概念套接字是计算机网络中进行网络通信的一种方式，可以看做是网络中两个应用程序之间的一个端点。
套接字使用IP地址和端口号来唯一标识一个通信节点。
在C语言中，套接字相关的操作需要通过系统调用函数来实现。
1. 创建套接字在C语言中，创建套接字需要使用socket()函数，该函数返回一个套接字描述符，可以用于后续的通信操作。
常见的套接字类型包括流套接字(SOCK_STREAM)和数据报套接字(SOCK_DGRAM)等。
2. 绑定套接字绑定套接字可以将套接字地址和具体的IP地址以及端口号关联起来，从而能够监听特定的网络地址。
在C语言中，可以使用bind()函数来绑定套接字。
3. 监听连接如果希望接受其他应用程序的连接请求，可以使用listen()函数来监听特定的套接字。
4. 接受连接一旦有连接请求到达监听套接字，可以使用accept()函数来接受连接请求，返回一个新的套接字描述符，用于与客户端进行通信。
5. 发起连接如果希望主动向其他应用程序发起连接请求，可以使用connect()函数来建立连接。
6. 数据传输已建立连接的套接字可以通过read()和write()等函数进行数据的读取和写入操作，实现数据的传输。
二、网络协议在网络编程中，协议起到了关键的作用，它定义了数据的传输方式、格式和规则，确保网络通信的可靠性和正确性。
下面是常用的网络协议：1. TCP/IP协议TCP/IP协议是互联网上最常用的协议之一，它基于TCP传输协议和IP网络协议。
TCP协议提供了一种可靠的数据传输方式，确保数据的有序、完整、无差错地传输；而IP协议则负责数据在网络中的传输。
利用流式套接字实现文件的传输
if(iResult!=nFileLen){printf("读入文件错误！\n");return 0;}memset(sendline,0,MAXLINE);memset(recvline,0,MAXLINE);while(i!=nFileLen){recvline[i]=*buff;i++;buff++;}//文件名传输结束sprintf(sendline,"%s#%d%s",file,nFileLen,recvline);iResult=send(s,sendline,sizeof(sendline),0);if(iResult==SOCKET_ERROR){printf("send函数调用错误，错误号：%d",WSAGetLastError());return -1;}fclose(fp);printf("文件发送完成！\n");return iResult;}服务器：int tcp_server_fun_echo(SOCKET s){FILE *fp;int i=0;char flong[4];int iResult = 0;uint32_t nFileLen=1;char recvline[MAXLINE];char file[10];memset(file,0,sizeof(file));memset(recvline,0,sizeof(recvline));for(;;){iResult=recv(s,&file[i],1,0);if(iResult==SOCKET_ERROR){printf("recv函数调用错误，错误号：%d",WSAGetLastError());return -1;}if(file[i]=='#')break;elsei++;}file[i]='\0';fp=fopen(file,"w+");if(fp==NULL)printf("文件打开失败！");//接收文件长度iResult=recv(s,flong,4,0);if(iResult==SOCKET_ERROR){printf("recv函数调用错误，错误号：%d",WSAGetLastError());return -1;}sscanf(flong,"%d",&nFileLen);iResult=recv(s,recvline,nFileLen,0);if(iResult==SOCKET_ERROR){printf("recv函数调用错误，错误号：%d",WSAGetLastError());return -1;}fputs(recvline,fp);fclose(fp);printf("文件接收成功！\n");return iResult;}头文件（上次的实验报告中已经写过）：#ifndef p_h//预处理指令，防止重复包含头文件#include<>#include<>#include<>#include<>#include<>#pragma coment(lib,"")using namespace std;class CSocketFrame{public:int start_up();i nt clean_up();i nt set_address(char *hname,char *sname,struct sockaddr_in *sap,char *protocol);i nt quit(SOCKET s);S OCKET tcp_server(ULONG uIP,USHORT uPort);S OCKET tcp_server(char *hname,char *sname);S OCKET tcp_client(char *hname,char *sname);S OCKET tcp_client(ULONG uIP,USHORT uPort);};int CSocketFrame::start_up(void){WORD wVersionRequested;WSADATA wsaData;int iResult;wVersionRequested=MAKEWORD(2,2);iResult=WSAStartup(wVersionRequested,&wsaData);if(iResult!=0){printf("WSAStartup 调用错误，错误号:%d\n",WSAGetLastError());return -1;}/*if(LOBYTE!=2||HIBYTE!=2)){printf("无法找到可用的WSD版本\n");WSACleanup();return -1;//告诉用户无法找到可用的WSD}else{printf("初始化成功！\n");} */return 0;}int CSocketFrame::clean_up(void){int iResult;iResult=WSACleanup();if(iResult==SOCKET_ERROR){//WSACleanup()调用失败printf("WSACleanup 调用错误，错误号:%d\n",WSAGetLastError());return -1;}elseprintf("Winsocket dll释放成功！\n") ;return 0;}int CSocketFrame::set_address(char *hname,char *sname,struct sockaddr_in *sap,char *protocol) {struct servent *sp;struct hostent *hp;char *endptr;unsigned short port;unsigned long ulAddr=INADDR_NONE;//将地址结构socketsddr_in初始化为0，并将地址族设为AF_INETmemset(sap,0,sizeof(*sap));sap->sin_family=AF_INET;if(hname!=NULL){//如果hname不为空，转化地址格式ulAddr=inet_addr(hname);if(ulAddr==INADDR_NONE||ulAddr==INADDR_ANY){//调用错误，调用gethostbyname获得主机地址hp=gethostbyname(hname);if(hp==NULL){printf("未知的主机名，错误号：%d\n",WSAGetLastError());return -1;}sap->sin_addr=*(struct in_addr *)hp->h_addr;}elsesap-> }else//如果调用者没有指明一个主机名或地址，则设为通配地址sap->=htonl(INADDR_ANY);//尝试转换sname为一个整数port=(unsigned short)strtol(sname,&endptr,0);if(*endptr=='\0'){//如果成功转化为网络字节序sap->sin_port=htons(port);}else{//如果失败，则假定是一个服务名称，通过getservbyname()函数获得端口号sp=getservbyname(sname,protocol);if(sp==NULL){printf("未知服务，错误号：%d\n",WSAGetLastError());return -1;}sap->sin_port=sp->s_port;}return 0;}int CSocketFrame::quit(SOCKET s){int iResult=0;iResult=closesocket(s);if(iResult==SOCKET_ERROR){printf("closesocket 调用错误，错误号:%d\n",WSAGetLastError());return -1;}iResult=clean_up();return iResult;}SOCKET CSocketFrame::tcp_server(char *hname,char *sname){SOCKET ListenSocket;int iResult=0;sockaddr_in local;const int on=1;//为服务器的本机地址设置用户输入的地址以及端口号if(set_address(hname,sname,&local,(char*)"tcp")!=0)return -1;//创建套接字ListenSocket=socket(AF_INET,SOCK_STREAM,0);if(ListenSocket==INVALID_SOCKET){printf("socket函数调用错误，错误号：%d\n",WSAGetLastError());WSACleanup();return -1;}//绑定服务器地址iResult=bind(ListenSocket,(struct sockaddr *) & local,sizeof(local));if(iResult==-1){printf("bind函数调用错误！错误号：%d\n",WSAGetLastError());closesocket(ListenSocket);WSACleanup();return -1;}//设置函数为监听状态，监听队列长度为NLISTENiResult=listen(ListenSocket,SOMAXCONN);if(iResult==SOCKET_ERROR){printf("Listen函数调用错误！错误号：%d\n",WSAGetLastError());quit(ListenSocket);return -1;}return ListenSocket;}SOCKET CSocketFrame::tcp_server(ULONG uIP,USHORT uPort){SOCKET ListenSocket=INVALID_SOCKET;int iResult=0;sockaddr_in local;const int on=1;//为服务器的本机地址设置用户输入的地址以及端口号memset(&local,0,sizeof(local));=AF_INET;=htons(uPort);ListenSocket=socket(AF_INET,SOCK_STREAM,0);if(ListenSocket==INVALID_SOCKET){printf("socket函数调用错误，错误号：%d\n",WSAGetLastError());clean_up();return -1;}//绑定服务器地址iResult=bind(ListenSocket,(struct sockaddr *) & local,sizeof(local));if(iResult==SOCKET_ERROR){printf("bind函数调用错误！错误号：%d\n",WSAGetLastError());quit(ListenSocket);return -1;}//设置函数为监听状态，监听队列长度为NLISTENiResult=listen(ListenSocket,SOMAXCONN);if(iResult==SOCKET_ERROR){printf("Listen函数调用错误！错误号：%d\n",WSAGetLastError());quit(ListenSocket);return -1;}return ListenSocket;}SOCKET CSocketFrame::tcp_client(char *hname,char *sname){int iResult=0;struct sockaddr_in peer;SOCKET ClientSocket;//为服务器的地址peer设置用户输入的地址以及端口号if(set_address(hname,sname,&peer,(char *)"tcp")!=0)return -1;//创建套接字ClientSocket=socket(AF_INET,SOCK_STREAM,0);if(ClientSocket==INVALID_SOCKET){printf("socket函数调用错误，错误号：%d\n",WSAGetLastError());clean_up();return -1;}//请求建立连接iResult=connect(ClientSocket,(struct sockaddr *) & peer,sizeof(peer));if(iResult==SOCKET_ERROR){printf("connect函数调用错误！错误号：%d\n",WSAGetLastError());quit(ClientSocket);return -1;}return ClientSocket;}SOCKET CSocketFrame::tcp_client(ULONG uIP,USHORT uPort){int iResult=0;struct sockaddr_in peer;SOCKET ClientSocket;//为服务器的地址peer设置用户输入的地址以及端口号memset(&peer,0,sizeof(peer));=AF_INET;=htons(uPort);//创建套接字ClientSocket=socket(AF_INET,SOCK_STREAM,0);if(ClientSocket==INVALID_SOCKET){printf("socket函数调用错误，错误号：%d\n",WSAGetLastError());clean_up();。
socket套接字的概念
socket套接字的概念套接字（socket）是网络编程中的一个重要概念，用于在不同节点之间建立通信连接，实现数据的传输和通信的实时交互。
下面我们从以下几个方面来介绍套接字的概念及其作用。
一、套接字的定义和作用套接字是一种抽象数据类型，用于表示一个网络通信的端点，可以理解为给应用程序提供了一种接口，使其能够通过网络与其他应用程序进行通信。
套接字是应用层与传输层间交互的一种方式，它提供了一种可靠的、面向连接的、双向数据传输的网络通信服务。
二、套接字的类型由于套接字在不同情况下有不同的用途，因此其类型也有所差异。
在Unix系统中，套接字一般分为以下几种类型：1. 流式套接字（SOCK_STREAM）：基于TCP协议，提供面向连接的可靠数据传输服务。
它是一种面向字节流的套接字类型，可用于实现长连接。
2. 数据报套接字（SOCK_DGRAM）：基于UDP协议，提供无连接的、不可靠的数据传输服务。
它是一种面向数据包的套接字类型，可用于实现短连接或者需要时间敏感的场景。
3. 原始套接字（SOCK_RAW）：提供完全自由的数据包传输服务，在传输层及以下各层的数据包都可以被访问到。
它可以用于网络协议的实现及测试。
4. 信号套接字（SOCK_SEQPACKET）：提供可靠的面向连接的数据传输服务，接收方只能够依次按短的数据包与发送方通信，保证数据的有序性。
三、套接字的编程接口套接字编程接口提供了开发人员在应用程序中使用网络通信技术的一套标准API，其主要包括以下几个方面：1. 套接字的创建和销毁：通过socket函数创建套接字，然后使用close 函数释放套接字资源。
2. 套接字的命名：使用bind函数将套接字与本地的IP地址和端口号进行绑定。
3. 套接字的连接：使用connect函数将套接字连接到远程主机的IP地址和端口号。
4. 数据的读取和写入：使用read和write函数进行数据的收发操作。
5. 套接字的监听：使用listen函数将套接字置于被动监听状态，等待远程客户端的连接请求。
第8章 原始套接字编程-Windows网络编程基础教程(第2版)-杨传栋-清华大学出版社
➢ 原始套接字是在传输层之下使用的套接字，原始套接所提供 的特殊功能主要包括：
1）可对ICMP、IGMP等较低层次的协议直接访问，直接发 送或接收ICMP、IGMP等协议的报文。
2）能够接收一些TCP/IP栈不能处理的特殊的IP分组，通常 是网络核心不能识别IP分组的协议字段。
3）通过设置原始套接字的IP_HDRINCL选项，可以发送用 户自定义分组首部的IP分组，因此可编写测试基于IP的高 层网络协议。
如果参数protocol指定为IPPROTO_ICMP或 IPPROTO_UDP等这种即不是IPPROTO_IP（值为0）也不 是IPPROTO_RAW（值为255）的值，发送数据时，系统 将会按照该参数指定的协议类型自动构造IP分组首部，而 不用自己填充。
接收数据时，系统只会将首部协议字段值和该参数值相同 的IP分组交给该原始套接字。因此，一般来说，要想接收 或发送哪个协议的数据包，就应该在创建套接字时将参数 protocol指定为哪个协议。
8.2 原始套接字的通信流程
➢ 原始套接字的通信是基于IP 分组的，因而是无连接、 不可靠的，其编程流程与 数据报套接字类似。
➢ 一般情况下，WinSock的 原始套接字只能接收到运 载ICMP报文、IGMP报文 和TCP/IP不能识别内容的 IP分组，要想接收运载TCP 报文段和UDP数据报的IP 分组，需要对原始套接字 的选项进行设置。
创建一个原始套接字时，如果将参数protocol指定为 IPPROTO_RAW，则所创建的原始套接字只能用来发送IP 包，而不能接收任何数据，而且要发送的数据需要自己填 充IP首部。
如果将参数protocol指定为IPPROTO_IP，则所创建的原 始套接字可用于接收任何IP分组，但IP分组的校验和验证 和协议分析等需要由程序自己完成。
网络编程基础教程
网络编程基础教程在现代计算机科学中，网络编程一直是重要的部分。
无论是我们日常使用的社交网络、购物网站，还是各种金融交易和数据传输，都不可缺少网络编程的支持。
因此，对于计算机科学学习者来说，学好网络编程是非常必要的。
基本概念网络编程是指在网络上实现不同计算机之间数据交换的过程。
它涉及到多个主题，包括网络基础架构、编程模型、网络协议、套接字等。
在网络编程中，套接字是重要的概念。
套接字是协议的一种实现，它在网络套接字上提供了一种应用接口，用于发送和接收数据。
编程模型在网络编程中，有两种主要的编程模型：客户端-服务器模型和点对点（P2P）模型。
在客户端-服务器模型中，客户端向服务器发送请求，并获得服务器的响应。
这种模型是现代网络中最常见的编程模型。
在点对点模型中，每个计算机都可以作为客户端和服务器，它们可以在互相之间进行通信。
网络协议网络协议是网络编程的基础。
一个协议定义了一组规则，用于在网络上通信。
TCP/IP是最常用的网络协议，它提供了一种可靠的数据传输方式。
其它常见的协议包括HTTP、FTP和SMTP等。
套接字编程套接字编程是网络编程中最重要的部分。
套接字是网络编程中传输数据的主要方法。
当应用程序需要与另一个应用程序进行通信时，它会创建一个套接字用于在网络上传输数据。
在套接字编程中，有两种类型的套接字：流式套接字和数据报套接字。
流式套接字是一种经典的套接字类型，它使用TCP/IP协议在网络上进行数据传输。
这种套接字可以实现可靠数据传输，且可以在收到数据并发送响应后关闭连接。
数据报套接字是另一种套接字类型，它使用UDP协议在网络上进行数据传输。
这种套接字比流式套接字更加灵活，但也更加不可靠。
数据报套接字适用于需要快速传输数据的应用程序。
总结网络编程是现代计算机科学中最重要的部分之一。
学好网络编程需要我们掌握一个广泛的知识范围，包括网络基础架构、编程模型、网络协议、套接字编程等。
在学习过程中，我们应该重视实践，多写网络编程相关的代码，不断提高自己的编程技能。
C语言网络编程详解
C语言网络编程详解网络编程是计算机科学中的重要领域，而C语言作为一种广泛使用的编程语言，也在网络编程中扮演着重要的角色。
本文将详细介绍C 语言网络编程的相关知识和技巧，帮助读者更好地理解和应用该领域的知识。
1. 网络编程概述网络编程是指利用计算机网络进行程序开发和通信的过程。
它主要涉及到数据传输、网络协议、套接字等概念。
C语言提供了一系列函数和库来支持网络编程，如socket函数、bind函数、listen函数等。
2. 套接字编程套接字（socket）是进行网络通信的一种机制。
C语言提供了一组函数用于创建、设置和管理套接字。
通过使用这些函数，我们可以建立起客户端和服务器之间的通信连接，实现数据的收发和传输。
2.1 套接字基础在进行网络编程之前，我们需要了解基本的套接字概念和操作。
首先，我们需要创建一个套接字，可以是TCP套接字或者UDP套接字。
然后，我们可以使用bind函数将套接字与IP地址和端口号绑定。
接下来，我们可以使用listen函数开始监听来自客户端的连接请求。
2.2 TCP编程TCP（传输控制协议）是一种可靠的连接协议，适用于需要保证数据可靠传输的场景。
在C语言中，我们可以使用socket函数创建一个TCP套接字。
然后，通过accept函数接受来自客户端的连接请求，使用send和recv函数进行数据的发送和接收。
2.3 UDP编程UDP（用户数据报协议）是一种无连接的协议，适用于需要快速传输数据的场景。
在C语言中，我们可以使用socket函数创建一个UDP 套接字。
与TCP不同的是，UDP不需要先建立连接，可以直接使用sendto和recvfrom函数进行数据的发送和接收。
3. 网络编程实例为了更好地理解和应用C语言网络编程，下面将通过两个实例来演示TCP和UDP编程的基本过程。
3.1 TCP编程实例假设我们要实现一个简单的聊天室程序，服务器接收来自不同客户端的消息，并转发给其他客户端。
套接字通信过程
套接字（Socket）通信是一种网络通信协议，它允许不同的计算机或设备之间进行数据交换。
套接字通信的过程可以分为以下几个步骤：1. 建立连接：首先，双方需要通过某种方式（如TCP协议、UDP协议等）建立通信连接。
这个过程需要指定通信的端口号、IP地址等信息，以确保双方可以找到彼此并进行通信。
2. 发送数据：一旦建立了连接，就可以开始发送数据了。
发送方需要将数据打包成适当的数据格式，并通过套接字发送到对方。
这个过程需要遵循一定的数据传输协议，以确保数据能够正确地被对方接收。
3. 接收数据：对方收到数据后，会将其解包并返回给发送方。
这个过程需要保证数据的完整性，以避免数据丢失或损坏。
4. 关闭连接：当通信结束后，双方需要关闭连接以释放资源。
关闭连接的方式可以是主动断开连接，也可以是等待对方断开连接。
下面是一个简单的套接字通信过程的示例：（1）客户端程序创建一个套接字并连接到服务器。
（2）客户端程序向服务器发送一条消息，消息包含一些数据和请求。
（3）服务器接收到消息后，将其解析并执行相应的操作，然后将结果返回给客户端程序。
（4）客户端程序接收到结果后，将其打包成适当的数据格式并发送回给服务器。
（5）服务器收到消息后，将其解包并存储起来，然后关闭连接。
需要注意的是，套接字通信的过程可能会涉及到多线程、异步通信等复杂的问题，需要根据具体的应用场景和需求进行设计和实现。
此外，为了保证通信的安全性和可靠性，还需要考虑使用加密算法、身份验证、数据校验等技术手段。
总之，套接字通信是一种非常灵活和强大的网络通信方式，它可以让不同的计算机或设备之间进行高效的数据交换和协作。
在实际应用中，需要根据具体的需求和场景选择合适的套接字协议和实现方式，以确保通信的可靠性和安全性。
三种基本网络传送模式的编程实现与分析
课 程设 计 。教 学过 程 中发现 套接 字编程 令不 少 同学望 而 生 畏 。因此 ， 中以 引 导学 生快 速 入 门 为 目的 ， 要 阐述 了三种 文 简
基本网络传送模式单播 、 组播和广播的编程实现思路和要点 ， 包括基于 Ｔ Ｐ的服务程序和客户程序 ， Ｃ 基于 Ｕ Ｐ的单播 、 Ｄ 组 播和广播收发程序的编写， 及多线程的实现框架等。此外 ， 探讨了结合网络监听工具的网络编程调试方法。在课程设计 中尝试先向学生介绍采用基本网络传送模式的应用程序的编写 ， 再鼓励学生采用文中的调试方法独立编写稍稍复杂的小
套接字编程实验报告
一、实验目的1. 理解套接字编程的基本原理和概念。
2. 掌握TCP和UDP协议在套接字编程中的应用。
3. 能够使用套接字编程实现简单的网络通信。
二、实验环境1. 操作系统：Windows 102. 编程语言：C3. 开发环境：Visual Studio 2019三、实验内容1. 创建套接字2. 绑定套接字3. 监听套接字4. 接受连接5. 发送数据6. 接收数据7. 关闭套接字四、实验步骤1. 创建套接字```c#include <stdio.h>#include <stdlib.h>#include <sys/socket.h>#include <netinet/in.h>#include <string.h>int main() {int sockfd;sockfd = socket(AF_INET, SOCK_STREAM, 0); if (sockfd < 0) {perror("socket error");exit(1);}printf("Socket created successfully\n"); return 0;}```2. 绑定套接字```c#include <stdio.h>#include <stdlib.h>#include <sys/socket.h>#include <netinet/in.h>#include <string.h>int main() {int sockfd;struct sockaddr_in servaddr;sockfd = socket(AF_INET, SOCK_STREAM, 0);if (sockfd < 0) {perror("socket error");exit(1);}memset(&servaddr, 0, sizeof(servaddr));servaddr.sin_family = AF_INET;servaddr.sin_port = htons(8080);servaddr.sin_addr.s_addr = htonl(INADDR_ANY);if (bind(sockfd, (struct sockaddr )&servaddr, sizeof(servaddr)) < 0) {perror("bind error");exit(1);}printf("Socket bound successfully\n");return 0;}```3. 监听套接字```c#include <stdio.h>#include <stdlib.h>#include <sys/socket.h>#include <netinet/in.h>#include <string.h>int main() {int sockfd, newsockfd;struct sockaddr_in servaddr, cliaddr;socklen_t len;sockfd = socket(AF_INET, SOCK_STREAM, 0);if (sockfd < 0) {perror("socket error");exit(1);}memset(&servaddr, 0, sizeof(servaddr));servaddr.sin_family = AF_INET;servaddr.sin_port = htons(8080);servaddr.sin_addr.s_addr = htonl(INADDR_ANY);if (bind(sockfd, (struct sockaddr )&servaddr, sizeof(servaddr)) < 0) {perror("bind error");exit(1);}listen(sockfd, 5);printf("Socket listening on port 8080\n");len = sizeof(cliaddr);newsockfd = accept(sockfd, (struct sockaddr )&cliaddr, &len);if (newsockfd < 0) {perror("accept error");exit(1);}printf("Connection accepted from %s:%d\n",inet_ntoa(cliaddr.sin_addr), ntohs(cliaddr.sin_port)); return 0;}```4. 接受连接```c#include <stdio.h>#include <stdlib.h>#include <sys/socket.h>#include <netinet/in.h>#include <string.h>int main() {int sockfd, newsockfd;struct sockaddr_in servaddr, cliaddr;socklen_t len;sockfd = socket(AF_INET, SOCK_STREAM, 0);if (sockfd < 0) {perror("socket error");exit(1);}memset(&servaddr, 0, sizeof(servaddr));servaddr.sin_family = AF_INET;servaddr.sin_port = htons(8080);servaddr.sin_addr.s_addr = htonl(INADDR_ANY);if (bind(sockfd, (struct sockaddr )&servaddr, sizeof(servaddr)) < 0) {perror("bind error");exit(1);}listen(sockfd, 5);printf("Socket listening on port 8080\n");len = sizeof(cliaddr);newsockfd = accept(sockfd, (struct sockaddr )&cliaddr, &len);if (newsockfd < 0) {perror("accept error");exit(1);}printf("Connection accepted from %s:%d\n",inet_ntoa(cliaddr.sin_addr), ntohs(cliaddr.sin_port));return 0;}```5. 发送数据```c#include <stdio.h>#include <stdlib.h>#include <sys/socket.h>#include <netinet/in.h>#include <string.h>int main() {int sockfd, newsockfd;struct sockaddr_in servaddr, cliaddr;socklen_t len;char buffer[1024];sockfd = socket(AF_INET, SOCK_STREAM, 0);if (sockfd < 0) {perror("socket error");exit(1);}memset(&servaddr, 0, sizeof(servaddr));servaddr.sin_family = AF_INET;servaddr.sin_port = htons(8080);servaddr.sin_addr.s_addr = htonl(INADDR_ANY);if (bind(sockfd, (struct sockaddr )&servaddr, sizeof(servaddr)) < 0) {perror("bind error");exit(1);}listen(sockfd, 5);printf("Socket listening on port 8080\n");len = sizeof(cliaddr);newsockfd = accept(sockfd, (struct sockaddr )&cliaddr, &len); if (newsockfd < 0) {perror("accept error");exit(1);}printf("Connection accepted from %s:%d\n",inet_ntoa(cliaddr.sin_addr), ntohs(cliaddr.sin_port));memset(buffer, 0, sizeof(buffer));read(newsockfd, buffer, sizeof(buffer));printf("Received: %s\n", buffer);write(newsockfd, "Hello, client!", strlen("Hello, client!")); close(newsockfd);close(sockfd);return 0;}```6. 接收数据```c#include <stdio.h>#include <stdlib.h>#include <sys/socket.h>#include <netinet/in.h>#include <string.h>int main() {int sockfd, newsockfd;struct sockaddr_in servaddr, cliaddr;socklen_t len;char buffer[1024];sockfd = socket(AF_INET, SOCK_STREAM, 0);if (sockfd < 0) {perror("socket error");exit(1);}memset(&servaddr, 0, sizeof(servaddr));servaddr.sin_family = AF_INET;servaddr.sin_port = htons(8080);servaddr.sin_addr.s_addr = htonl(INADDR_ANY);if (bind(sockfd, (struct sockaddr )&servaddr, sizeof(servaddr)) < 0) {perror("bind error");exit(1);}listen(sockfd, 5);printf("Socket listening on port 8080\n");len = sizeof(cliaddr);newsockfd = accept(sockfd, (struct sockaddr )&cliaddr, &len);if (newsockfd < 0) {perror("accept error");exit(1);}printf("Connection accepted from %s:%d\n",inet_ntoa(cliaddr.sin_addr), ntohs(cliaddr.sin_port));memset(buffer, 0, sizeof(buffer));read(newsockfd, buffer, sizeof(buffer));printf("Received: %s\n", buffer);write(newsockfd, "Hello, client!", strlen("Hello, client!")); close(newsockfd);close(sockfd);return 0;}```7. 关闭套接字```c#include <stdio.h>#include <stdlib.h>#include <sys/socket.h>#include <netinet/in.h>#include <string.h>int main() {int sockfd, newsockfd;struct sockaddr_in servaddr, cliaddr;socklen_t len;char buffer[1024];sockfd = socket(AF_INET, SOCK_STREAM, 0);if (sockfd < 0) {perror("socket error");exit(1);}memset(&servaddr, 0, sizeof(servaddr));servaddr.sin_family = AF_INET;servaddr.sin_port = htons(8080);servaddr.sin_addr.s_addr = htonl(INADDR_ANY);if (bind(sockfd, (struct sockaddr )&servaddr, sizeof(servaddr)) < 0) {perror("bind error");exit(1);}listen(sockfd, 5);printf("Socket listening on port 8080\n");len = sizeof(cliaddr);newsockfd = accept(sockfd, (struct sockaddr )&cliaddr, &len);if (newsockfd < 0) {perror("accept error");exit(1);}printf("Connection accepted from %s:%d\n",inet_ntoa(cliaddr.sin_addr), ntohs(cliaddr.sin_port));memset(buffer, 0, sizeof(buffer));read(newsockfd, buffer, sizeof(buffer));printf("Received: %s\n", buffer);write(newsockfd, "Hello, client!", strlen("Hello, client!"));close(newsockfd);close(sockfd);return 0;}```五、实验总结通过本次实验，我们掌握了套接字编程的基本原理和概念，学会了如何使用套接字实现简单的网络通信。
北京理工大学-毕业论文-网络数据获取与分析软件设计
摘要随着信息化发展，网络安全问题日渐突出，网络攻击日益泛滥，所以网络信息安全就变的非常重要。
网络主机必须有足够的安全措施，否则网络的价值就会贬值。
从网络防护技术看，实施网络安全防护的基本技术措施是获取和过滤网络协议数据包，对数据包内容进行分析，从而发现非法或者恶意的行为，这种网络数据获取与分析技术也是目前基于内容检查的网络安全设备所采用的主要技术。
针对网络协议分析的迫切需求，设计开发可扩展的、界面友好的网络数据获取与分析软件，对信息网络的安全防护具有重要的现实意义。
本设计就是为了给网络使用者提供一个有用的网络数据包分析工具，其有四个主要功能：数据包的捕获、数据包解析、数据包信息分析和数据包信息的显示。
通过对所在机器的网上设置为混杂模式，探索局域网络里所有经过的数据包，并实现了数据包捕获、解析、信息分析、信息显示，为使用者了解当前的网络数据包状况提供了很好的参考。
关键词：数据包捕获数据包分析 TCP/IP协议嗅探器原始套接字ABSTRACTWith the development of information industry，the problem of network security becomes more and more serious．The increasing proliferation of network attacks．So the network information security becomes very important．Web hosting must have adequate security measure，otherwise the value of network will depreciate．In terms of network defense technology, the basic technical measures of implementing network security defense is capturing and filtering network protocol data packets，and then analyze the data packets contents，so as to discover illegal or malicious behavior，also，network packet capture and analysis technique is major technique being adopted by network safety based on content inspection so for．According to the urgent demand of network packet capture and analysis，the design and development of protocol software with extensible function and friendly interface has important practical significance on security defense of specialized information network．This system is developed in order to provide a useful Internet users of network packet analysis tool．This system has four main functions：packet capture，packet analysis，packet analysis and display information packets in—formation．System based on the Internet where machine Settings for mixed mode，explore the local area network packets，and after all，realized the packet capture，information analysis，information shows that for users understand cur—rent network packets provide a good reference．Key words：Packet Capture；Packet Analysis；Protocol Analysis; Sniffer; Raw Socket目录第1章引言1.1课题来源和背景随着网络技术在国内的普及，网络在日常工作中发挥着越来越重要的作用，而企事业单位的内网更成为日常工作中不可或缺的重要组成部分。
什么叫套接字
什么叫套接字
名词解释：源IP地址和⽬的IP地址以及源端⼝号和⽬的端⼝号的组合称为套接字。
其⽤于标识客户端请求的服务器和服务。
套接字，是⽀持的⽹络通信的基本操作单元，可以看做是不同主机之间的进程进⾏双向通信的端点，简单的说就是通信的两⽅的⼀种约定，⽤套接字中的相关函数来完成通信过程。
如何标⽰⼀个主机上的特定进程呢？使⽤IP:PORT，即IP地址和端⼝号，⼀般地说，每个进⾏⽹络通信的应⽤程序都要占⽤主机上的⼀个端⼝。
举个例⼦，使⽤TCP进⾏通信，需要建⽴连接，⽐如主机A上的进程a和主机B上的进程b进⾏通信，A、B之间的连接如何标⽰？使⽤四元组<A的IP，a所占⽤的端⼝，B的IP，b所占⽤的端⼝>
IP:PORT就确定了⼀个socket，在⼀个TCP连接中，她就像⼀个插⼝，注意，叫做插⼝，套接字也就是类似的意思。
你把应⽤程序插⼊到这个插座，就可以和连接的另外⼀⽅对话了。
⾄于socket命名，是有历史由来的，不过我们学⽹络编程，其实不必纠结于此，so it is just a name。
套接字
套接字：通信端点16.2.1 什么是套接字套接字是一种具有之前所说的“通信端点”概念的计算机网络数据结构。
网络化的应用程序在开始任何通讯之前都必需要创建套接字。
就像电话的插口一样，没有它就完全没办法通信。
套接字起源于20世纪70年代加州大学伯克利分校版本的Unix，即人们所说的BSD Unix。
因此，有时人们也把套接字称为“伯克利套接字”或“BSD套接字”。
一开始，套接字被设计用在同一台主机上多个应用程序之间的通讯。
这也被称作进程间通讯，或IPC。
套接字有两种，分别是基于文件型的和基于网络型的。
Unix套接字是我们要介绍的第一个套接字家族。
其“家族名”为AF_UNIX（在POSIX1.g标准中也叫AF_LOCAL），表示“地址家族：UNIX”。
包括Python在内的大多数流行平台上都使用术语“地址家族”及其缩写“AF”。
而老一点的系统中，地址家族被称为“域”或“协议家族”，并使用缩写“PF”而不是“AF”。
同样的，AF_LOCAL（在2000-2001年被列为标准）将会代替AF_UNIX。
不过，为了向后兼容，很多系统上，两者是等价的。
Python自己则仍然使用AF_UNIX。
由于两个进程都运行在同一台机器上，而且这些套接字是基于文件的。
所以，它们的底层结构是由文件系统来支持的。
这样做相当有道理，因为，同一台电脑上，文件系统的确是不同的进程都能访问的。
另一种套接字是基于网络的，它有自己的家族名字：AF_INET，或叫“地址家族：Internet”。
还有一种地址家族AF_INET6被用于网际协议第6版（IPv6）寻址上。
还有一些其他的地址家族，不过，它们要么是只用在某个平台上，要么就是已经被废弃，或是很少被使用，或是根本就还没有实现。
所有地址家族中，AF_INET是使用最广泛的一个。
Python 2.5中加入了一种Linux套接字的支持：AF_NETLINK（无连接(稍后讲解)）套接字家族让用户代码与内核代码之间的IPC可以使用标准BSD套接字接口。
套接字编程实验总结
套接字编程实验总结套接字编程是计算机网络编程中非常重要的一部分，通过套接字可以实现不同计算机之间的通信与数据交换。
在进行套接字编程的实验过程中，我深刻体会到了其重要性及应用价值。
下面我将结合自己的实验经历，总结出一些关键的要点和经验。
我在实验中学习到了如何创建套接字、绑定地址和端口、监听连接请求以及接受和发送数据等基本操作。
这些操作是套接字编程的基础，也是我们进行网络通信必须掌握的内容。
在实验中，我通过不断地练习和调试，逐渐掌握了这些操作的技巧和方法。
我发现在套接字编程实验中，错误处理是非常重要的。
由于网络环境的不确定性，很容易出现各种错误，比如连接超时、数据丢失等。
因此，在编写代码时，我要注意添加足够的错误处理机制，及时捕获和处理各种异常情况，以确保程序的稳定性和可靠性。
我还学习到了如何利用多线程和多进程来实现并发通信。
在实际应用中，通常需要同时处理多个连接请求，这时就需要使用多线程或多进程来实现并发处理。
通过实验，我掌握了多线程和多进程编程的基本原理和方法，能够有效地提高程序的运行效率和响应速度。
我还了解到了套接字编程中一些高级特性的应用，比如SSL加密、非阻塞IO、UDP通信等。
这些特性可以进一步提升网络通信的安全性和效率，对于一些对数据传输要求较高的应用场景非常有用。
总的来说，通过套接字编程实验，我不仅学到了网络编程的基础知识和技能，还提升了自己的问题解决能力和编程能力。
在未来的学习和工作中，我将继续深入研究网络编程领域，不断提升自己的技术水平，为实现更复杂的网络应用做好准备。
希望我的总结和经验能够对其他同学在学习套接字编程时有所帮助，共同进步，共同成长。
tcp 协议的理解及套接口编程
TCP 协议的理解及套接口编程1. 什么是TCP协议TCP（Transmission Control Protocol）即传输控制协议，是一种面向连接的、可靠的、基于字节流的传输层通信协议。
它是互联网协议套件（TCP/IP协议栈）中的重要组成部分，负责在网络上建立可靠的连接并传输数据。
2. TCP协议的特点TCP协议是一种面向连接的协议，它要求在数据传输之前，客户端和服务器端需要建立连接。
在连接建立后，TCP协议的双方都可以发送和接收数据，而且数据传输是可靠的，不会有丢失或重复的情况发生。
TCP协议还具有流量控制和拥塞控制的功能，可以有效地调节数据传输的速度，保证网络的稳定运行。
3. TCP协议的工作原理在使用TCP协议进行通信时，首先需要通过三次握手建立连接。
客户端发送一个SYN包给服务器端，服务器端接收到后回复一个SYN+ACK包给客户端，最后客户端再回复一个ACK包给服务器端，这样连接就建立起来了。
在数据传输过程中，TCP协议会对数据进行分段，每个数据段都会包含序列号和确认号，来保证数据的可靠传输。
当数据传输完毕后，还需要通过四次挥手来终止连接，以确保双方都知道连接已经关闭。
4. TCP套接口编程TCP套接口编程是指利用TCP协议进行网络编程的技术。
在C/C++语言中，可以使用Socket编程来实现TCP套接口编程。
首先需要创建一个Socket套接字，并指定套接字的类型为SOCK_STREAM，代表使用TCP协议。
通过套接字的bind、listen、accept、connect等方法进行连接的建立和数据的传输。
5. 对TCP协议的个人理解TCP协议作为互联网中最重要的通信协议之一，它的可靠性和稳定性都非常值得肯定。
在日常的网络通信中，大部分的数据传输都是基于TCP协议完成的。
TCP协议的工作原理虽然复杂，但是却能够为用户提供稳定、安全的通信环境。
在进行TCP套接口编程时，需要注意网络数据的安全性和稳定性，确保数据传输的实时性和正确性。
进程间的通信—套接字（socket）
进程间的通信—套接字（socket） 前⾯说到的进程间的通信，所通信的进程都是在同⼀台计算机上的，⽽使⽤socket进⾏通信的进程可以是同⼀台计算机的进程，也是可以是通过⽹络连接起来的不同计算机上的进程。
通常我们使⽤socket进⾏⽹络编程，这⾥将会简单地讲述如何使⽤socket进⾏简单的⽹络编程。
⼀、什么是socket socket，即套接字是⼀种通信机制，凭借这种机制，客户/服务器（即要进⾏通信的进程）系统的开发⼯作既可以在本地单机上进⾏，也可以跨⽹络进⾏。
也就是说它可以让不在同⼀台计算机但通过⽹络连接计算机上的进程进⾏通信。
也因为这样，套接字明确地将客户端和服务器区分开来。
⼆、套接字的属性套接字的特性由3个属性确定，它们分别是：域、类型和协议。
1、套接字的域 它指定套接字通信中使⽤的⽹络介质，最常见的套接字域是AF_INET，它指的是Internet⽹络。
当客户使⽤套接字进⾏跨⽹络的连接时，它就需要⽤到服务器计算机的IP地址和端⼝来指定⼀台联⽹机器上的某个特定服务，所以在使⽤socket作为通信的终点，服务器应⽤程序必须在开始通信之前绑定⼀个端⼝，服务器在指定的端⼝等待客户的连接。
另⼀个域AF_UNIX表⽰UNIX⽂件系统，它就是⽂件输⼊/输出，⽽它的地址就是⽂件名。
2、套接字类型 因特⽹提供了两种通信机制：流（stream）和数据报（datagram），因⽽套接字的类型也就分为流套接字和数据报套接字。
这⾥主要讲流套接字。
流套接字由类型SOCK_STREAM指定，它们是在AF_INET域中通过TCP/IP连接实现，同时也是AF_UNIX中常⽤的套接字类型。
流套接字提供的是⼀个有序、可靠、双向字节流的连接，因此发送的数据可以确保不会丢失、重复或乱序到达，⽽且它还有⼀定的出错后重新发送的机制。
与流套接字相对的是由类型SOCK_DGRAM指定的数据报套接字，它不需要建⽴连接和维持⼀个连接，它们在AF_INET中通常是通过UDP/IP协议实现的。
网络编程--Socket（套接字）
⽹络编程--Socket（套接字）⽹络编程⽹络编程的⽬的就是指直接或间接地通过⽹络协议与其他计算机进⾏通讯。
⽹络编程中有两个主要的问题，⼀个是如何准确的定位⽹络上⼀台或多台主机，另⼀个就是找到主机后如何可靠⾼效的进⾏数据传输。
在TCP/IP协议中IP层主要负责⽹络主机的定位，数据传输的路由，由IP地址可以唯⼀地确定Internet上的⼀台主机。
⽽TCP层则提供⾯向应⽤的可靠的或⾮可靠的数据传输机制，这是⽹络编程的主要对象，⼀般不需要关⼼IP层是如何处理数据的。
⽬前较为流⾏的⽹络编程模型是客户机/服务器（C/S）结构。
即通信双⽅⼀⽅作为服务器等待客户提出请求并予以响应。
客户则在需要服务时向服务器提出申请。
服务器⼀般作为守护进程始终运⾏，监听⽹络端⼝，⼀旦有客户请求，就会启动⼀个服务进程来响应该客户，同时⾃⼰继续监听服务端⼝，使后来的客户也能及时得到服务。
在Internet上IP地址和主机名是⼀⼀对应的，通过域名解析可以由主机名得到机器的IP，由于机器名更接近⾃然语⾔，容易记忆，所以使⽤⽐IP地址⼴泛，但是对机器⽽⾔只有IP地址才是有效的标识符。
通常⼀台主机上总是有很多个进程需要⽹络资源进⾏⽹络通讯。
⽹络通讯的对象准确的讲不是主机，⽽应该是主机中运⾏的进程。
这时候光有主机名或IP地址来标识这么多个进程显然是不够的。
端⼝号就是为了在⼀台主机上提供更多的⽹络资源⽽采取得⼀种⼿段，也是TCP层提供的⼀种机制。
只有通过主机名或IP地址和端⼝号的组合才能唯⼀的确定⽹络通讯中的对象：进程。
套接字所谓socket通常也称作"套接字"，⽤于描述IP地址和端⼝，是⼀个通信链的句柄。
应⽤程序通常通过"套接字"向⽹络发出请求或者应答⽹络请求。
套接字可以根据通信性质分类，这种性质对于⽤户是可见的。
应⽤程序⼀般仅在同⼀类的套接字间进⾏通信。
不过只要底层的通信协议允许，不同类型的套接字间也照样可以通信。
套接字编程实验报告
Programing 实验物联2班201208080228 赵智慧一、实验题目：利用套接字编程，编写出TCP和UDP的客户机、服务器程序进行交互二、实验代码：1.TCP服务器：package TCP;import java.io.BufferedReader;import java.io.IOException;import java.io.InputStreamReader;import .ServerSocket;import .Socket;public class TCPServer {public static void main(String[] args) throws IOException{ServerSocket server=new ServerSocket(7999);System.out.println("server ok");Socket socket=server.accept();BufferedReader bf=new BufferedReader(new InputStreamReader(socket.getInputStream()));String str=bf.readLine();while(str!=null){System.out.println(str);str=bf.readLine();}}}2.TCP客户机：package TCP;import java.io.BufferedReader;import java.io.DataOutputStream;import java.io.IOException;import java.io.InputStreamReader;import java.io.OutputStream;import java.io.PrintWriter;import .Socket;import .UnknownHostException;public class TCPClient {public static void main(String[] args) throws UnknownHostException, IOException{String sentence;InputStreamReader isr = new InputStreamReader(System.in);BufferedReader inFromUser = new BufferedReader(isr);Socket clientSocket = new Socket("127.0.0.1",7999);sentence = inFromUser.readLine();OutputStream os = clientSocket.getOutputStream();PrintWriter oos=new PrintWriter(os);os.write(sentence.getBytes());clientSocket.close();}}3.UDP服务器：package UDP;import .DatagramPacket;import .DatagramSocket;import .InetAddress;import .SocketException;public class UDPServer {public static void main(String[] args) throws Exception{DatagramSocket serverSocket = new DatagramSocket(9876); //所有发送和接收的数据都将通过该套接字//因为UDP无连接，所以无需创建一个新的套接字监听新的请求byte[] receive1 = new byte[1024];byte[] receive2 = new byte[1024];byte[] send1 = new byte[1024];byte[] send2 = new byte[1024];byte[] send3 = new byte[1024];while(true){DatagramPacket receivePacket = new DatagramPacket(receive1, receive1.length);serverSocket.receive(receivePacket);String str = new String(receivePacket.getData()); //从分组中提取出数据，并存入str中InetAddress ip = receivePacket.getAddress(); //提取IP地址int port = receivePacket.getPort(); //提取客户机端口号String ask = "请选择:1.将其转化为大写 2.将a字符替换为c字符";send1 = ask.getBytes();DatagramPacket sendPacket1 = new DatagramPacket(send1, send1.length, ip,port);serverSocket.send(sendPacket1);DatagramPacket receivePacket2 = new DatagramPacket(receive2, receive2.length);serverSocket.receive(receivePacket2);String str2 = new String(receivePacket2.getData());if(str2.toCharArray()[0]=='1'){String capitalizedSentence = str.toUpperCase();send3 = capitalizedSentence.getBytes();DatagramPacket sendPacket3 = new DatagramPacket(send3, send3.length, ip,port);serverSocket.send(sendPacket3);}else{String change = str.replace('a', 'c');send2 = change.getBytes();DatagramPacket sendPacket2 = newDatagramPacket(send2, send2.length, ip,port);serverSocket.send(sendPacket2);}}}}4.ＵＤＰ客户机：package UDP;import java.io.BufferedReader;import java.io.IOException;import java.io.InputStreamReader;import .DatagramPacket;import .DatagramSocket;import .InetAddress;import .SocketException;import .UnknownHostException;public class UDPClient {public static void main(String[] args) throws IOException{InputStreamReader isr = new InputStreamReader(System.in);BufferedReader inFromUser = new BufferedReader(isr);DatagramSocket clientSocket = new DatagramSocket(); //客户机套接字InetAddress IPAddress = InetAddress.getByName("127.0.0.1");byte[] sendData1 = new byte[1024];byte[] sendData2 = new byte[1024];byte[] receiveData1 = new byte[1024];byte[] receiveData2 = new byte[1024];String sentence = inFromUser.readLine();sendData1 = sentence.getBytes();DatagramPacket sendPacket = new DatagramPacket(sendData1, sendData1.length,IPAddress,9876);clientSocket.send(sendPacket);DatagramPacket receivePacket1 = new DatagramPacket(receiveData1, receiveData1.length);clientSocket.receive(receivePacket1);String modifiedData1 = new String(receivePacket1.getData());System.out.println("Server:"+modifiedData1);String sentence2 = inFromUser.readLine();sendData2 = sentence2.getBytes();DatagramPacket sendPacket2 = new DatagramPacket(sendData2, sendData2.length,IPAddress,9876);clientSocket.send(sendPacket2);DatagramPacket receivePacket2 = new DatagramPacket(receiveData2, receiveData2.length);clientSocket.receive(receivePacket2);String modifiedData2 = new String(receivePacket2.getData());System.out.println("Server:"+modifiedData2);clientSocket.close();}}三、实验分析：TCP提供可靠的数据传输，而UDP提供不可靠的运输服务，在套接字编程方面，UDP 客户机使用的是DatagramSocket，而TCP客户机使用的是Socket。
套接字通信原理
套接字通信原理套接字通信原理套接字（Socket）是一种在计算机网络中进行进程间通信的机制。
套接字通信可以被看做是一种面向流的、双向的、可靠的高层次通信协议。
它的基本原理是通过一个标志符描述对一个网络连接的请求，从而在网络上建立一条连接，并进行数据传输。
套接字通信的原理可以简单地描述为客户端和服务器之间的数据传输。
在套接字系统中，客户端通过IP地址和端口号来连接服务器端。
服务器端监听固定的端口，在服务器端接收到客户端发送的请求后，就可以和客户端进行相应的数据传输。
套接字通信可以使用不同的协议来进行数据传输，其中最常用的是TCP及UDP协议。
套接字通信的实现分为四个步骤，包括初始化、发送数据、接收数据和关闭连接。
在进行初始化时，客户端需要定义一个标识符来标识网络连接。
服务器端需要在进行初始化时激活监听进程，等待客户端的连接请求。
其次，在发送数据时，客户端需要将数据发送给服务器，服务器需要接收并处理这些数据，并向客户端返回结果。
接收数据的过程和发送数据的过程类似，客户端需要接收结果，服务器需要将结果返回给客户端。
最后，在关闭连接时，需要将已经建立的套接字通道断开，释放资源。
套接字通信的优点在于它具有可靠、灵活、可扩展性高等特点。
在进行数据传输时，套接字通信可以通过内存映射和缓存等操作来提高数据传输效率和速度，同时它还可以支持多颗处理器同时工作，以提高系统的并发处理能力。
总的来说，套接字通信是一种高效、可靠、灵活的进程间通信方式。
它广泛应用于各类网络应用程序，例如Web服务器、邮件系统、即时通讯等。
在未来，随着互联网的发展，套接字通信将会成为越来越重要的通信方式。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
原始套接字输入
使用原始套接字接收数据是在无连接的方 式下进行数据接收，原始套接字很可能接 收到很多非预期的数据报 考虑数据过滤能力
原始套接字输出
发送数据的目标
连接模式：在connect中指明 非连接模式：在sendto中指明
发送数据的内容
IP首部 UDP首部 UDP数据 IP_HDRINCL选项未开启 IP_HDRINCL选项开启
a）IPv4标志字段可置0，告知内核设置 b）IPv4头部校验和字段置0，总是由内核计算并存储 c）IPv4选项字段可选
原始套接字输出
发送数据——sendto
int sendto(SOCKET s, const char FAR* buf, int len, int flags, const struct sockaddr FAR* to, int tolen) Buf的内容：
1.原始套接字的能力
2.原始套接字编程模型
3.原始套接字创建、输入与输出
原始套接字创建——1）创建函数
SOCK_RAW
SOCKET socket( int af, int type, int protocol )
协议 IPPROTO_IP IPPROTO_ICMP IPPROTO_IGMP BTHPROTO_RFCOMM IPPROTO_IPV4 IPPROTO_TCP IPPROTO_UDP IPPROTO_ IPV6 IPPROTO_ ICMPV6 IPPROTO_ RAW 值 0 1 2 3 4 6 17 41 58 255 IP协议 ICMP协议 IGMP协议 蓝牙通信协议 IPv4协议 TCP协议 UDP协议 IPv6协议 ICMPv6协议 原始IP包 含义
增加了与原始套接字定义相关的协议首部，如IP头、 UDP头、TCP头、ICMP头等。
· 如果指明了IP_HDRINCL选项，则包括IP头； · 否则协议头部信息与 socket函数protocol 字段相符。
Windows对原始套接字的限制
在Windows7、Windows Vista、Windows XP SP2和Windows XP SP3中，通过原始套接字发送数 据的能力受到了诸多限制，这些限制主要包括：
原始套接字创建——2）IP首部控制
说明
套接字选项有两种类型 设置或禁止特征/行为的布尔选项
设置：Optval指向一个非零整数 禁止：optval指向一个等于零的整数 Optlen等于整型数的长度
要求整数值或结构的选项
Optval指向一个包含选项要求值的整数或结构 Optlen为此整数或结构的长度
原始套接字创建——2）IP首部控制
①
TCP/IP协议实现
网络
原始套接字输入
接收到的类型
包括IP头部在内的完整数据报（ IPv4） 内核把哪些接收到的 IP数据报传递到原始套接口？ ≠UDP分组和TCP分组 ≠片段分组 =内核处理后的ICMP、IGMP分组 =不认识其协议字段的所有IP数据报
一个原始套接口能够收到哪些数据？
SOCKET（协议）：匹配数据报的协议字段 Bind：匹配数据报的宿IP地址
原始套接字的适用场合
（1）特殊用途的探测应用 （2）基于数据包捕获的应用 （3）特殊用途的传输应用
1.原始套接字的能力
2.原始套接字编程模型
原始套接字编程模型
发送数据过程：
①socket初始化 ②创建套接字，指定使用原始套接字进行通信，指 定IP头选项； ③指定目的地址和通信端口； ④填充头和数据； ⑤发送数据； ⑥关闭套接字； ⑦结束对windows sockets dll的使用。
原始套接字输入
接收到的内容
包括IP头部在内的完整数据报（IPv4）
原始套接字输入
接收到的类型
应用程序接收缓存 拷 贝
应用程序接收缓存 拷 贝
应用程序实现
recvfrom()
recvfrom()
原始套接口接收缓存
原始套接口接收缓存 套接口实现
②
流式套接口 接 收 接 收 原始套接口 数据报套接口 接 收
原始套接字的能力
应用程序
标准套接字 应用程序环境 系统环境 UDP
原始套接字
TCP
网络内核
IP
原始套接字的能力
原始套接字提供普通TCP和UDP套接字不 提供的以下三种能力
读写ICMPv4、IGMPv4和ICMPv6等分组。 读写内核不处理其协议字段的IPv4数据报。 控制IPv4头部。
原始套接字的能力
详细代码见教材
原始套接字创建——3）端点地址关联
Bind
功能：指定从这个原始套接字发送的所有数据报的源 IP地址 作用范围：原始套接字不存在端口号概念，bind函数 仅仅设置本地地址
Connect
功能：指定从这个原始套接字发送的所有数据报的宿 IP地址 作用范围：原始套接字不存在端口号概念，connect 函数仅设置远端IP地址
创建者的权限——administrator
原始套接字创建——2）IP首部控制
IP_HDRINCL选项
函数定义：int setsockopt( SOCKET s, int level, int optname, const char* optval, int optlen ); 输入参数： s：套接字描述符； level：选项定义的层次，如IPPROTO_IP； optname：指定套接字选项的名字 optval：指向请求选项数据缓冲区的指针； optlen：选项数据optval缓冲区的长度。 返回值： 正确：0；错误：SOCKET_ERROR （WSAGetLastError） 功能：为套接字相关的选项设置当前值。 说明：套接字选项有两种类型：设置或禁止特征
原始套接字编程模型
接收数据过程：
①socket初始化 ②创建套接字，指定使用原始套接字进行通信； ③设置接收选项； ④接收数据； ⑤过滤数据； ⑥关闭套接字； ⑦结束对windows sockets dll的使用。
问题1：原始套接字与流式套接字和数据报套接字 在编程过程中增加了哪些附加操作？
问题2：应用程序能够接收到哪些数据？
Windows在Server版的操作系统中对原始套接字支持 较好，上述限制不适用于Windows Server 2003、 Windows Server 2008、以及Windows SP2以 前的操作系统。
1.原始套接字的能力
2.原始套接字编程模型
3.原始套接字创建、输入与输出
4.程序举例
程序示例
举例：
布尔选项设置： BOOL blnFlag=TRUE; setsockopt(sock, IPPROTO_IP, IP_HDRINCL, (char *)&blnFlag, sizeof(blnFlag); 整数值选项设置： 例1：int ttl = 7 ; // TTL value. setsockopt(sock, IPPROTO_IP, IP_TTL, (char *)&ttl, sizeof(ttl)) 例2：nTimeOver=1000; setsockopt(sock, SOL_SOCKET, SO_SNDTIMEO, (char*)&nTimeOver,sizeof(nTimeOver))
Connect：匹配数据报的源IP地址
原始套接字输入
既然原始套接字能够接收到的数据报文是有限制 的，那么如何在第一个层次上扩展原始套接口被 复制的数据种类呢？
套接字控制命令SIO_RCVALL
使用方法 1. 创建原始套接字，由于IPv6尚未实现SIO_RCVALL，因而 套接字地址簇必须是AF_INET，协议必须是IPPROTO_IP； 2. 将套接字绑定到指定的本地接口； 3. 调用WSAIoctl为套接字设置SIO_RCVALL I/O控制命令； 4. 调用接收函数，捕获IP数据报。
TCP的数据不能通过原始套接字发送； 如果源IP地址不正确，则UDP的数据不能通过原始套接字发送。所谓 不正确是指为数据报设置的源地址不属于本机有效的IP地址，这样限制 了恶意代码通过伪造源IP地址进行拒绝服务攻击的能力，同时还限制了 发送IP欺骗数据包的能力； 当设置协议类型为IPPROTO_TCP时，不允许将原始套接字绑定到本 地地址（当协议类型为其它协议时，绑定是允许的）。
Windows网络编程基础
第7讲 原始套接字编程
内容提要
1、原始套接字的能力 2、原始套接字编程模型 3、原始套接字创建、输入与输出 4、程序举例
1.原始套接字的能力
原始套接字的能力
Question? 怎样发送一个自定义的IP数据包？ 怎样接收ICMP协议承载的差错报文？ 怎样使主机捕获网络中其它主机间的报文？ 怎样伪装本地的IP地址？ 怎样模拟TCP或UDP协议的行为实现对协议的灵活操 控？