&&国之画&&&& &&
版权所有 京ICP备号-2
迷上了代码！　　TCP/IP，UDP，三阶段握手，SYN扫描，FIN扫描，秘密扫描，间接扫描，诱骗扫描，指纹，协作扫描。&&&
--------------------------------------------------------------------------------
端口扫描技术
　　第一部分，我们讲述TCP连接的建立过程（通常称作三阶段握手），然后讨论与扫描程序有关的一些实现细节。&
　　然后，简单介绍一下经典的扫描器（全连接）以及所谓的SYN（半连接）扫描器。&
　　第三部分主要讨论间接扫描和秘密扫描，还有隐藏攻击源的技术。&
　　秘密扫描基于FIN段的使用。在大多数实现中，关闭的端口对一个FIN 段返回一个RST，但是打开的端口通常丢弃这个段，不作任何回答。间接扫描，就像它的名字，是用一个欺骗主机来帮助实施，这台主机通常不是自愿的。&
第四部分介绍了一种与应用协议有关扫描。这些扫描器通常利用协议实现中的一些缺陷或者错误。认证扫描（ident scanning）也被成为代理扫描(proxy scanning)。&
　　最后一部分，介绍了另外一些扫描技术。考虑了一些不是基于TCP端口和主要用来进行安全扫描的扫描工具（例如SATAN）。另外分析了使用扫描器的栈指纹。栈指纹通过检测主机TCP并将应答跟已知操作TCP/IP协议栈应答相比较，解决了识别操作系统的问题。
一：TCP/IP相关问题&
连接端及标记&
　　IP地址和端口被称作套接字，它代表一个TCP连接的一个连接端。为了获得TCP服务，必须在发送机的一个端口上和接收机的一个端口上建立连接。TCP连接用两个连接端来区别，也就是（连接端1，连接端2）。连接端互相发送数据包。&
　　一个TCP数据包包括一个TCP头，后面是选项和数据。一个TCP头包含6个标志位。它们的意义分别为：&
SYN: 标志位用来建立连接，让连接双方同步序列号。如果SYN＝1而ACK=0，则表示该数据包为连接请求，如果SYN=1而ACK=1则表示接受连接。&
FIN: 表示发送端已经没有数据要求传输了，希望释放连接。&
RST: 用来复位一个连接。RST标志置位的数据包称为复位包。一般情况下，如果TCP收到的一个分段明显不是属于该主机上的任何一个连接，则向远端发送一个复位包。&
URG: 为紧急数据标志。如果它为1，表示本数据包中包含紧急数据。此时紧急数据指针有效。&
ACK: 为确认标志位。如果为1，表示包中的确认号时有效的。否则，包中的确认号无效。&
PSH: 如果置位，接收端应尽快把数据传送给应用层。&
TCP连接的建立&
　　TCP是一个面向连接的可靠传输协议。面向连接表示两个应用端在利用TCP传送数据前必须先建立TCP连接。 TCP的可靠性通过校验和，定时器，数据序号和应答来提供。通过给每个发送的字节分配一个序号，接收端接收到数据后发送应答，TCP协议保证了数据的可靠传输。数据序号用来保证数据的顺序，剔除重复的数据。在一个TCP会话中，有两个数据流（每个连接端从另外一端接收数据，同时向对方发送数据），因此在建立连接时，必须要为每一个数据流分配ISN（初始序号）。为了了解实现过程，我们假设客户端C希望跟服务器端S建立连接，然后分析连接建立的过程（通常称作三阶段握手）：
1： C --SYN XXà S&
2： C ?-SYN YY/ACK XX+1------- S&
3： C ----ACK YY+1--à S&
1：C发送一个TCP包（SYN 请求）给S，其中标记SYN（同步序号）要打开。SYN请求指明了客户端希望连接的服务器端端口号和客户端的ISN（XX是一个例子）。&
2：服务器端发回应答，包含自己的SYN信息ISN（YY）和对C的SYN应答，应答时返回下一个希望得到的字节序号（YY+1）。&
3：C 对从S 来的SYN进行应答，数据发送开始。&
一些实现细节&
大部分TCP/IP实现遵循以下原则：&
1：当一个SYN或者FIN数据包到达一个关闭的端口，TCP丢弃数据包同时发送一个RST数据包。&
2：当一个RST数据包到达一个监听端口，RST被丢弃。&
3：当一个RST数据包到达一个关闭的端口，RST被丢弃。&
4：当一个包含ACK的数据包到达一个监听端口时，数据包被丢弃，同时发送一个RST数据包。&
5：当一个SYN位关闭的数据包到达一个监听端口时，数据包被丢弃。&
6：当一个SYN数据包到达一个监听端口时，正常的三阶段握手继续，回答一个SYN|ACK数据包。&
7：当一个FIN数据包到达一个监听端口时，数据包被丢弃。&FIN行为&（关闭得端口返回RST，监听端口丢弃包），在URG和PSH标志位置位时同样要发生。所有的URG，PSH和FIN，或者没有任何标记的TCP数据包都会引起&FIN行为&。
二：全TCP连接和SYN扫描器&
全TCP连接&
　　全TCP连接是长期以来TCP端口扫描的基础。扫描主机尝试（使用三次握手）与目的机指定端口建立建立正规的连接。连接由系统调用connect()开始。对于每一个监听端口，connect()会获得成功，否则返回－1，表示端口不可访问。由于通常情况下，这不需要什么特权，所以几乎所有的用户（包括多用户环境下）都可以通过connect来实现这个技术。&
　　这种扫描方法很容易检测出来（在日志文件中会有大量密集的连接和错误记录）。Courtney,Gabriel和TCP Wrapper监测程序通常用来进行监测。另外，TCP Wrapper可以对连接请求进行控制，所以它可以用来阻止来自不明主机的全连接扫描。&
TCP SYN扫描&
　　在这种技术中，扫描主机向目标主机的选择端口发送SYN数据段。如果应答是RST，那么说明端口是关闭的，按照设定就探听其它端口；如果应答中包含SYN和ACK，说明目标端口处于监听状态。由于所有的扫描主机都需要知道这个信息，传送一个RST给目标机从而停止建立连接。由于在SYN扫描时，全连接尚未建立，所以这种技术通常被称为半打开扫描。SYN扫描的优点在于即使日志中对扫描有所记录，但是尝试进行连接的记录也要比全扫描少得多。缺点是在大部分操作系统下，发送主机需要构造适用于这种扫描的IP包，通常情况下，构造SYN数据包需要超级用户或者授权用户访问专门的系统调用。
三：秘密扫描与间接扫描
秘密扫描技术&
　　由于这种技术不包含标准的TCP三次握手协议的任何部分，所以无法被记录下来，从而必SYN扫描隐蔽得多。另外，FIN数据包能够通过只监测SYN包的包过滤器。&
　　秘密扫描技术使用FIN数据包来探听端口。当一个FIN数据包到达一个关闭的端口，数据包会被丢掉，并且回返回一个RST数据包。否则，当一个FIN数据包到达一个打开的端口，数据包只是简单的丢掉（不返回RST）。&
Xmas和Null扫描是秘密扫描的两个变种。Xmas扫描打开FIN，URG和PUSH标记，而Null扫描关闭所有标记。这些组合的目的是为了通过所谓的FIN标记监测器的过滤。&
　　秘密扫描通常适用于UNIX目标主机，除过少量的应当丢弃数据包却发送reset信号的操作系统（包括CISCO，BSDI，HP/UX，MVS和IRIX）。在Windows95/NT环境下，该方法无效，因为不论目标端口是否打开，操作系统都发送RST。&
　　跟SYN扫描类似，秘密扫描也需要自己构造IP 包。
　　间接扫描的思想是利用第三方的IP（欺骗主机）来隐藏真正扫描者的IP。由于扫描主机会对欺骗主机发送回应信息，所以必须监控欺骗主机的IP行为，从而获得原始扫描的结果。间接扫描的工作过程如下：&
假定参与扫描过程的主机为扫描机，隐藏机，目标机。扫描机和目标记的角色非常明显。隐藏机是一个非常特殊的角色，在扫描机扫描目的机的时候，它不能发送任何数据包（除了与扫描有关的包）。
四：认证扫描和代理扫描
　　到目前为止，我们分析的扫描器在设计时都只有一个目的：判断一个主机中哪个端口上有进程在监听。然而，最近的几个新扫描器增加了其它的功能，能够获取监听端口的进程的特征和行为。&
　　认证扫描是一个非常有趣的例子。利用认证协议，这种扫描器能够获取运行在某个端口上进程的用户名（userid）。认证扫描尝试与一个TCP端口建立连接，如果连接成功，扫描器发送认证请求到目的主机的113TCP端口。认证扫描同时也被成为反向认证扫描，因为即使最初的RFC建议了一种帮助服务器认证客户端的协议，然而在实际的实现中也考虑了反向应用（即客户端认证服务器）。
　　文件传输协议（FTP）支持一个非常有意思的选项：代理ftp连接。这个选项最初的目的（RFC959）是允许一个客户端同时跟两个FTP服务器建立连接，然后在服务器之间直接传输数据。然而，在大部分实现中，实际上能够使得FTP服务器发送文件到Internet的任何地方。许多攻击正是利用了这个缺陷。最近的许多扫描器利用这个弱点实现ftp代理扫描。&
　　ftp端口扫描主要使用ftp代理服务器来扫描tcp端口。扫描步骤如下：&
　　1：假定S是扫描机，T是扫描目标，F是一个ftp服务器，这个服务器支持代理选项，能够跟S和T建立连接。&
　　2：S与F建立一个ftp会话，使用PORT命令声明一个选择的端口（称之为p－T）作为代理传输所需要的被动端口。&
　　3：然后S使用一个LIST命令尝试启动一个到p－T的数据传输。&
　　4：如果端口p－T确实在监听，传输就会成功（返回码150和226被发送回给S）。否则S回收到&425无法打开数据连接&的应答。&
　　5：S持续使用PORT和LIST命令，直到T上所有的选择端口扫描完毕。&
　　FTP代理扫描不但难以跟踪，而且当ftp服务器在_blank&&防火墙后面的时候
五：其它扫描方法
如果需要扫描一个主机上甚至整个子网上的成千上万个端口，首先判断一个主机是否开机就非常重要了。这就是Ping扫描器的目的。主要由两种方法用来实现Ping扫描。&
　　1：真实扫描：例如发送ICMP请求包给目标IP地址，有相应的表示主机开机。&
　　2：TCP Ping：例如发送特殊的TCP包给通
参考知识库
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：243次
排名：千里之外[转载]基于TCP/IP协议的Socket&JAVA编程
基于TCP/IP协议的Socket编程
1 TCP/IP协议
2 套接字（Socket）
&2.1 Client/Server模式
&2.2 套接字（Socket）概念
3 Socket类和ServerSocket类
&3.1 Socket类
&3.2 ServerSocket类
4 Socket编程应用举例
&4.1 Socket编程的基本步骤
&4.2单客户/服务器Socket编程应用举例
&4.3多客户/服务器Socket编程应用举例本章小结
TCP/IP协议
TCP/IP协议（传输控制协议/网际协议）是一种网络通信协议，是一种面向连接的可靠的传输协议。它规范了网络上的所有通信设备，尤其是一个主机与另一个主机之间的数据传输格式以及传送方式。TCP/IP是Internet的基础协议。
TCP/IP协议的基本传输单位是数据包（datagram）。TCP协议负责把数据分成若干个datagram，并给每个datagram加上包头；IP在每个包头上再加上接收端主机地址，以确定数据传输的目的地。如果传输过程中出现数据丢失或数据失真等异常情况，TCP协议会自动要求数据重发，并重新分包。TCP保证数据传输的质量，IP协议保证数据的传输。
TCP/IP协议数据的传输是基于TCP/IP模型的4层结构：应用层、传输层、网络层和网络接口层。
& 在TCP/IP协议组中两种主要协议
1、传输层协议
有两个主要的传输层协议：传输控制协议（TCP）和用户数据报协议（UDP）。
（1）传输控制协议（TCP）TCP传输数据建立在面向连接的基础上，实现了一种“虚电路”的概念。双方通信之前，先建立连接，然后双方即可在其上发送数据流，发送完毕后再关闭连接。这种数据交换方式的优点是效率高，缺点是建立连接和关闭连接需要额外的开销。
&（1）TCP协议主要提供下列服务：
可靠的数据传输
面向连接的虚电路
缓冲的传输
重新排序
多路复用技术
高效的、全双工传输
流量控制
TCP协议提供的是一种可靠的数据流服务。得到的是一个顺序的无差错的数据流。
（2）用户数据报协议（UDP）。UDP是比TCP简单得多的协议，是对IP协议组的扩充。
由于大多数网络应用程序都在同一台机器上运行，计算机上必须能够确保目的地址机器上的软件程序能从源地址机器处获得数据包，以及源计算机能收到正确的回复。这是通过使用UDP
的“端口号”完成的。源端口号标识了请求域名服务的本地计算机的应用程序，同时需要将所有由目的主机生成的响应包都指定到源主机的这个端口上。
&（3）UDP与TCP比较
与TCP不同，UDP提供的是面向无连接、“不可靠”的数据报服务。它不提供对IP
协议的可靠机制、流控制以及错误恢复功能等。
由于UDP比较简单，比TCP负载消耗少。主要用于不需要TCP排序和流量控制能力而是自己完成这些功能的应用程序。&
2、应用层协议
在应用层中定义了许多高层协议：
（1）TELNET（远程终端访问）。TELNET连接是一个TCP连接。允许一台计算机上的用户登录到远程计算机上并进行交互。支持终端到终端的连接及进程到进程分布式计算的通信。
（2）FTP（文件传输协议）FTP使得主机间可以共享文件。FTP使用TCP生成一个虚拟连接用于控制信息，然后再生成一个单独的TCP连接用于数据传输。FTP主要提供文件共享、支持间接使用远程计算机、使用户不因各类主机文件存储器系统的差异而受影响、可靠且有效的传输数据等功能。
（3）SMTP（简单邮件传输协议）SMTP支持在因特网上传递电子邮件，用于可靠且有效的数据传输。它保证把各种类型的电子邮件通过这一协议从一台邮件服务器发送到另一台邮件服务器上。
（4）DNS（域名服务）DNS提供域名到IP地址的转换，允许对域名资源进行分散管理。
（5）HTTP（超文本传输协议）是Web浏览器和Web服务器之间通信的标准协议。它指明客户端如何与服务器建立连接，客户端如何从服务器请求数据，服务器如何响应请求，最后连接如何关闭等。HTTP连接是一个TCP连接。
TCP/IP模型中还有其他一些协议，如地址解析协议（ARP）、因特网控制消息协议（ICMP）等。
套接字（Socket）
套接字允许程序员把网络连接当成一个流（Stream），并向这个流读写字节。Socket对程序员掩盖了网络的低层细节，如纠错、包大小、包重传、网络地址等。本节将介绍Client/Server模式、套接字（Socket）概念。
&2.1 Client/Server模式
计算机网络最重要的3个功能是数据通信、资源共享和分布处理。为了满足这些功能需求，计算机网络产生了两种重要的应用模式：客户端/服务器（Client/Server，C/S）模式和浏览器/服务器（Brower/Server，B/S）模式。采用何种应用模式在编程实现时非常重要。下面将主要介绍C/S模式。
在C/S模式下，客户向服务器发出服务请求，服务器接收到请求后，提供相应的服务。其工作方式可通过现实生活中一个例子来说明。在一个酒店中，顾客向服务员点菜，服务员把点菜单通知厨师，厨师按点菜单做好菜后让服务员端给顾客，这就是一种C/S工作方式。如果把酒店看作一个系统，服务员就是客户端，厨师就是服务器，这种系统分工和协同工作的方式就是C/S的工作模式。
由此可见，工作在C/S模式下的系统被分成两大部分：
（1）客户端部分：为每个用户所专有的，负责执行前台功能。
（2）服务器部分：由多个用户共享的信息与功能，招待后台服务。
& C/S模式建立的基础C/S模式的建立基于以下两点：
一是建立网络的起因是网络中软硬件资源、运算能力和信息不均等，需要共享，从而造就拥有众多资源的主机提供服务，资源较少的客户请求服务这一非对等作用。
二是网间进程通信完全是异步的，相互通信的进程既不存在父子关系，又不共享内存缓冲区，因此需要一种机制为希望通信的进程建立联系，为二者的数据交换提供同步，这就是基于C/S的TCP/IP。
基于C/S模式系统结构
C/S模式在操作过程中采取“请求/响应”的工作模式。当用户需要访问服务器资源时由客户端发出请求，服务器接收到请求后做出响应，然后执行相应的服务，把执行结果返回到客户端，再由客户端作一定处理后返回给用户。执行过程如下：
（1）服务器侦听相应端口的请求；
（2）客户端发出一个请求；
（3）服务器接收到此请求；
（4）服务器处理这个请求，并把处理结果返回给客户端。&
从上面所描述的过程可知：客户与服务器进程的作用是非对称的，因此编码不同。服务进程一般是先于客户请求而启动的。只要系统运行，该服务进程一直存在，直到正常或强迫终止。&
套接字（Socket）概念
数据在Internet中是以有限大小的分组的形式传输的。一个分组是一个数据报，包括首部和负载。首部包含目的的地址和端口、源地址和端口以及用于保证可靠传输的各种其他管理信息。负载包含数据本身。但由于分组长度有限，通常必须将数据分解为多个分组，在目的地再重新组合。在传输过程中，有可能发生一个或多个分组丢失或被破坏的情况，此时就需要重传分组。或者分组乱序到达，则需要重新排序。这些工作将是非常繁重的。
幸运的是，套接字（Socket）的出现使我们不必关心这些事情，我们只需要把网络看成一个流，就象对文件操作一样对这个流进行操作就行了。
套接字（Socket）是网络协议传输层提供的接口。Socket是两个程序之间进行双向数据传输的网络通讯端点，有一个地址和一个端口号来标识。每个服务程序在提供服务时都要在一个端口进行，而想使用该服务的客户机也必须连接该端口。
基于Socket的点对点通信&
& 目前共有两种套接字
流套接字提供一个面向连接的、可靠的数据传输服务，保证数据无差错、无重复、按顺序发送。具有流量控制功能。数据被看作字节流，无长度限制。TCP即是一种基于流套接字的通信协议。
数据报套接字提供一个面向无连接的数据传输服务，不保证数据传输是可靠的、有序的、无重复的。UDP即是一种基于数据报套接字的通信协议。
本章主要介绍基于TCP/IP协议的C/S模式下的Socket编程。
基于TCP/IP的Socket通信模式&
在该种模式下，Socket可以看成是在两个程序进行通信连接中的一个端点，一个程序将一段信息写入Socket中，该Socket将这段信息发送到另外一个Socket中，使这段信息能传送到其他程序。每一个基于TCP/IP的程序都赋予了一个端口号（0~65535），通过不同的端口号，区别服务器上运行的每一个应用程序和所提供的服务。值得注意的是，习惯上将低于1024的端口号保留给系统服务使用。
在两个网络应用程序发送和接收信息时都需建立一个可靠的连接，流套接字依靠TCP来保证信息正确到达目的地。实际上，IP分组有可能在网络中丢失或者在传送过程中发生错误。当任何一种情况发生时，作为接收方的TCP将请求发送方TCP重发这个IP分组。因此，两个流套接字之间建立的连接是可靠的连接。
& Socket可进行的基本操作
（1）连接远程主机
（2）发送数据
（3）接收数据
（4）关闭连接
（5）绑定端口
（6）侦听入站数据
（7）在所绑定端口上接收远程主要的连接
& 利用Socket编程的一般步骤:
& （1）分别为服务器和客户端创建Socket对象，建立Socket连接。
（2）打开连接到Socket的输入输出流。Socket对象包含两个流：一个是输入流，表示流入的数据流，其作用是接收数据；一个是输出流，表示流出的数据流，其作用是向外发送数据，其流操作与I/O流相同。
& （3）按照一定的协议对Socket进行读/写操作，在本章里是基于TCP/IP协议；
& （4）读/写操作结束后，关闭Socket连接。
Socket类和ServerSocket类
在Java语言中，服务器端Socket使用ServerSocket类，客户端Socket使用Socket类，由此来区别服务器端和客户端。&
& 3.1 Socket类
java.net
.Socket类是Java用来实现客户端TCP操作的基础类，在Java编程中一切与TCP有关的操作包括连接的建立、传输、连接关闭及Socket选项的设置都由Socket类负责，这个类本身使用直接代码通过主机操作系统的本地TCP栈进行通信。Socket类的输入输出都是通过流来实现的。&Socket类常用方法如下:
& 1．Socket类的构造函数
（1）public Socket(String host,int port) throws
UnknownHostException,
IOException功能：在客户端以指定的服务器host和端口号port创建一个Socket对象，并向服务器发出连接请求。
参数：
& host：服务器主机名。
& port：端口号。
若域名服务器无法解析该服务器名或域名服务器没有运行，此时host无法可知，则抛出UnknownHostException异常；若生成Socket时发生I/O错误则抛出IOException异常。
（2）public Socket(InetAddress address,int port) throws
IOException功能：在客户端以指定的服务器地址address和端口号port创建一个Socket对象，并向服务器发出连接请求。
参数：
& address：服务器IP地址。
& port：端口号。
若生成Socket时发生I/O错误则抛出IOException异常。
（3）public Socket(String host,int port,boolean stream) throws
IOException功能：在客户端以指定的服务器host和端口号port创建Socket对象，并向服务器发出连接请求。如果stream值为true，则创建流Socket对象，否则创建数据报Socket
参数：
& host：服务器名。
& port：端口号。
& stream：创建流Socket对象或创建数据报Socket对象的标志。
若生成Socket时发生I/O错误则抛出IOException异常。
（4）public Socket(InetAddress address,int port,boolean stream)
IOException功能：在客户端以指定的服务器IP地址address和端口号port创建Socket对象，并向服务器发出连接请求。如果stream值为true，则创建流Socket对象，否则创建数据报Socket
参数：
& address：服务器IP地址。
& port：端口号。
& stream：创建流Socket对象或创建数据报Socket对象的标志。
若生成Socket时发生I/O错误则抛出IOException异常。
（5）public Socket(InetAddress address,int port,InetAddress
localAddr,int localPort) throws
IOException功能：生成一个Socket并且连接到由address指定的服务器的端口port上。该Socket将捆绑到由localAddr指定的本地主机的localPort端口上。
参数：
& address：服务器IP地址。
& port：端口号。
& localAddr：本地主机的IP地址。
& localPort：本地主机上的端口号。
若生成Socket时发生I/O错误则抛出IOException异常。
（6）public Socket(String host,int port, InetAddress
localAddr,int localPort) throws
IOException功能：生成一个Socket并且连接到由host指定的服务器的端口port上。该Socket将捆绑到由localAddr指定的本地主机的localPort端口上。
参数：
& host：服务器名。
& port：端口号。
& localAddr：本地主机的IP地址。
& localPort：本地主机上的端口号。
若生成Socket时发生I/O错误则抛出IOException异常。
（7）protected Socket(SocketImpl impl) throws
SocketException功能：根据用户指定的SocketImpl生成一个无连接的socket。
参数：
& impl：子类希望用在Socket上的SocketImpl 实例。
建立无连接失败时抛出SocketException异常。
客户端流Socket的创建可通过使用Socket类的构造函数完成。构造函数不仅可以创建Socket对象，并且会尝试连接服务器端的Socket。可通过这个方法测试某个端口的连接是否允许。
2．与Socket数据读写有关的常用方法
（1）public InetAddress getInetAddress()
功能：获取创建socket连接时指定服务器的IP地址。
（2）public InetAddress getLocalAddress()
功能：获取创建socket连接时客户端主机的IP地址。
（3）public int getPort()
功能：获取创建Socket连接时指定的服务器的端口号。
（4）public int getLocalPort()
&&
功能：获取创建Socket连接时客户端的端口号。
（5）public InputStream getInputStream() throws IOException
&& 功能：为当前的socket对象创建输入流。
（6）public OutputStream getOutputStream() throws IOException
&& 功能：为当前的socket对象创建输出流。
（7）public String toString()
功能：转换该Socket成一个String.字符串表示。
3．关闭Socket连接的方法
public synchronized void close() throws IOException
& 功能：关闭建立的Socket连接。当通信结束时，应调用该方法关闭Socket连接。
若在关闭Socket连接时发生I/O错误则抛出IOException异常。
//创建socket连接后获取socket连接的相关信息
import java.net.*;
import java.io.*;
public class SocketInfo {
&public static void main(String args[]){
&&Socket sktobj = new
Socket(");
&&System.out.println("1:connect
to "+sktobj.getInetAddress()+"on port "+sktobj.getPort());
&&System.out.println("2:from port
"+sktobj.getLocalPort()+"
of"+sktobj.getLocalAddress());&
&catch(UnknownHostException
e){System.out.println(e);}
&catch(IOException
e){System.out.println(e);}
&运行结果:
//客户端向服务器发送一个字符串，服务器接收并返回
import java.net.*;
import java.io.*;
public class SocketAppClient{
&public static void main(String args[]){
&int port=134;
&&Socket sc = new
Socket("127.0.0.1",port);//创建本地socket连接
&&OutputStream out =
sc.getOutputStream();
&&DataOutputStream dout = new
DataOutputStream(out);
&&&&//获取输出流，并创建相应的数据输出流
&&dout.writeUTF("Tom");&&//将tom写入输出流
&&InputStream in =
sc.getInputStream();
&&DataInputStream din = new
DataInputStream(in);
&&&&//获取输入流，并创建相应的数据输入流
&&String str =
din.readUTF();
&&System.out.println(str);
&&in.close();
&&out.close();
&&sc.close();
&catch(UnknownHostException
e){System.out.println(e);}
&catch(IOException
e){System.out.println(e);}
运行结果:单方通信,缺服务器
&3.2 ServerSocket类
ServerSocket类用在服务器端，侦听和响应客户端的连接请求，并接收客户端发送的数据。ServerSocket类的主要任务是在服务器端耐心地等候客户端的连接请求，一旦客户端应用程序申请建立一个Socket连接,ServerSocket类就会通过accept()方法返回一个对应的服务器端Socket对象，以便进行直接通信。从两台计算机连接成功时起，服务器端与客户端就得到了一个真正的“Socket-Socket”连接。
& 1．ServerSocket类构造函数
（1）public ServerSocket(int port) throws IOException
功能：创建一个指定端口号的服务器端的socket。请求连接队列的最大队列长度为50，若连接请求到达时队列已满，则拒绝连接。端口号为0指在任何空闲端口上创建socket。
& 参数： port：端口号。
 若无法创建Socket并绑定于所请求的端口号则抛出IOException异常。
（2）public ServerSocket(int port,int backlog) throws
IOException
功能：创建一个指定端口号的服务器端的socket。请求连接队列的最大队列长度设置为backlog，若连接请求到达时队列已满，则拒绝连接。端口号为0指在任何空闲端口上创建socket。
& 参数：
&& port：端口号。
&& backlog：请求连接队列的最大长度。
若无法创建Socket并绑定于所请求的端口号则抛出IOException异常。
（3）public ServerSocket(int port,int backlog,InetAddress
bindAddr) throws IOException
功能：创建一个指定端口号的服务器端的socket。请求连接队列的最大队列长度设置为backlog，若连接请求到达时队列已满，则拒绝连接。端口号为0指在任何空闲端口上创建socket。与其它构造函数不同的是，该构造函数要指定要绑定到的本地IP地址。主要用于在多IP地址系统上运行的服务器。此时，它允许先把所侦听的地址，服务器Socket只在指定的地址侦听入站连接，不会侦听通过主机其他地址进入的连接。其他构造函数默认绑定本地主机的所有IP地址。当bindAddr为null时，缺省地接受对任何所有本地IP地址的连接。
& 参数：
&& port：端口号。
&& backlog：请求连接队列的最大长度。
bindAddr:将捆绑到的本地IP地址.
若无法创建Socket并绑定于所请求的端口号则抛出IOException异常。
//采用ServerSocket类查询端口号为130~140的端口号中哪个端口可创建连接。
import java.net.*;
import java.io.*;
public class PortScan2{
&public static void main(String args[]){
&&String host="localhost";
&&&for(int
i=130;i&140;i++)
&&&&&try{ServerSocket
a=new ServerSocket(i);
&&&&&//在端口号i创建连接
&&&&&&System.out.println("there
is a server on port:"+i);
&&&&//若可以创建连接，则输出提示信息
&&&&&}catch(IOException
e){System.out.println(e);
&&&&}//若端口已被占用，则抛出异常
&运行结果:断口号为135的端口已被占用,当试图在端口135建立连接时抛出异常,即端口已被绑定.
2．ServerSocket类的常用方法
（1）public InetAddress getInetAddress()功能：获取服务器端Socket的IP地址。
（2）public int getLocalPort()功能：获取服务器正侦听的端口号。
（3）public Socket accept() throws
IOException功能：在服务器端指定端口侦听客户端发出的连接请求并与之连接。该方法一直阻塞直到连接成功。该方法返回一个新的Socket对象，通过该对象与客户端进行通信。若等待连接时发生I/O错误则抛出IOException异常。
（4）public String
toString()功能：返回该socket的字符串表示&
3．关闭Socket连接的方法
public void close() throws IOException
功能：关闭该socket连接。当服务器需要关闭，不处理任何其他入站连接时，调用该方法。
若关闭socket时发生I/O错误则抛出IOException异常。
//与8.2对应的服务器端程序
import java.net.*;
import java.io.*;
public class SocketAppServer{
&public static void main(String args[]){
&&ServerSocket ss =
&&int port = 134;
&&String hello = "From
Server:Hello World!";
&&&ss = new
ServerSocket(port);
&&&&&//建立服务器Socket连接，其侦听端口为port，port与客户端相同
&&catch(IOException e){
&&&System.out.println(e);//若端口已被占用，则抛出异常
&&&System.exit(1);
&&while(true){
&&&System.out.println("正在等待连接端口port="
+ port + "...");
&&&Socket cs =
ss.accept();
&&&InputStream
in = cs.getInputStream();
&&&DataInputStream
din = new DataInputStream(in);
&&&&//获取输入流，并创建相应的数据输入流
&&&String name =
din.readUTF();
&&&OutputStream
out = cs.getOutputStream();
&&&DataOutputStream
dout = new DataOutputStream(out);
&&&&//获取输出流，并创建相应的数据输出流
&&&dout.writeUTF(hello+"Your
name:" + name);//将字符串写入输出流
&&&System.out.println("已成功连接端口port="
&&&System.out.println("=========================================");
&&&in.close();
&&&out.close();
&&&cs.close();
&&catch(IOException e){
&&&System.out.println(e);//若端口已被占用，则抛出异常
(1)首先运行例4的服务器端程序
(2)运行例2的客户端程序
图 8 客户端
图 9 服务器端变化
Socket编程应用举例
&4.1 Socket编程的基本步骤
1．服务器端应用程序编写步骤
（1）创建一个等待连接的ServerSocket对象，如Sersocket；
（2）调用Sersocket对象的accept()方法侦听接收客户端的连接请求。当侦听到一个客户的连接请求时，连接成功，并返回一个用于通信的Socket对象；
（3）创建与Socket对象绑定的输入输出流，并建立相应的数据输入输出流；
（4）通过数据输入输出流与客户端进行数据读写，完成双向通信；
（5）当客户端断开连接时，关闭各个流对象，结束通信。（2）~（5）可循环执行。
2．客户端应用程序编写步骤
（1）创建指定服务器上指定端口号的Socket对象；
（2）创建与Socket对象绑定的输入输出流，并建立相应的数据输入输出流；
（3）通过数据输入输出流与服务器端进行数据读写，完成双向通信；
（4）通过调用close()方法关闭与服务器端的连接，并关闭各个流对象，结束通信。&
&&4.2单客户/服务器Socket编程应用举例
【例 5】
编写一个基于TCP协议的Socket网络点对点聊天程序，可实现客户端和服务器端信息的互发。
1．服务器端程序talkserver.java
//点对点聊天程序,服务器端
import java.net.*;
import java.io.*;
public class talkserver{
&public static void main(String args[]){
&&ServerSocket server =
&&S//中间字符串
&&int port = 2000;
&&String hello = "From
Server:Hello World!";
&&&server = new
ServerSocket(port);
&&&&&//建立服务器Socket连接，其侦听端口为port，port与客户端相同
&&&System.out.println("正在等待连接端口port="
+ port + "...");
&&&socket =
server.accept();
&&&System.out.println("已成功连接端口port="
&&&System.out.println("=========================================");
&&&InputStream
in = socket.getInputStream();
&&&DataInputStream
din = new DataInputStream(in);
&&&&//获取输入流，并创建相应的数据输入流
&&&OutputStream
out = socket.getOutputStream();
&&&DataOutputStream
dout = new DataOutputStream(out);
&&&&//获取输出流，并创建相应的数据输出流
&&&BufferedReader
sin = new BufferedReader(new InputStreamReader(System.in));
&&&System.out.println("请等待客户发送信息...");
&&while(true){
&&&System.out.println("");
din.readUTF();&&//读入从client传来的字符串
&&&System.out.println("从客户端接收的信息为:"
+ s);//显示字符串
&&&if(s.trim().equals("BYE"))
{System.out.print("通话结束" );}
&&&System.out.println("");
&&&System.out.print("请输入要发送的信息:"
);//显示字符串
sin.readLine();&&//读入从client传来的字符串
&&&dout.writeUTF(s);
&&&if(s.trim().equals("BYE"))
{System.out.print("通话结束" );}
&&&din.close();
&&&dout.close();
&&&in.close();
&&&out.close();
&&&socket.close();
&&catch(IOException e){
&&&System.out.println("Error"
+ e);//若端口已被占用，则抛出异常
&&&System.exit(1);
程序首先在端口2000上创建一个等待连接请求的ServerSocket对象sever:
server=new ServerSocket(2000);
接着调用Server对象的accept()方法等待某客户程序发出的连接请求。该方法一直阻塞直到有客户连接到该端口。一旦有客户发送正确请求，则连接成功，accept()方法返回一个Socket对象,于是得到一个新的用于通信的Socket对象,通信链路建立成功.然后利用Socket类提供的getInputStream()和getOutputStream()方法创建与Socket对象绑定的输入/输出流.此后即可与客户进行通信,直到客户端断开连接即关闭各个流结束通信.
2．客户端程序talkclient.java
import java.net.*;
import java.io.*;
public class talkclient{
&public static void main(String args[]){
&&int port = 2000;
&&&//向本地服务器申请连接
&&&//注意端口号要和服务器的一致
&&&socket = new
Socket("localhost",port);//localhost=127.0.0.1
&&&System.out.println("连接成功");
&&&System.out.println("=========================================");
&&&System.out.println("");
&&&//获得对应Socket的输入/输出流
&&&InputStream
in = socket.getInputStream();
&&&DataInputStream
din = new DataInputStream(in);
&&&&//获取输入流，并创建相应的数据输入流
&&&OutputStream
out = socket.getOutputStream();
&&&DataOutputStream
dout = new DataOutputStream(out);
&&&&//获取输出流，并创建相应的数据输出流
&&&BufferedReader
sin = new BufferedReader(new InputStreamReader(System.in));
&&while(true){
&&&&System.out.print("请输入要发送的信息:"
);//显示字符串
sin.readLine();&&//读入从client传来的字符串
&&&&dout.writeUTF(s);
&&&&if(s.trim().equals("BYE"))
{System.out.print("通话结束" );}
&&&&System.out.println("");
din.readUTF();&&//读入从client传来的字符串
&&&&System.out.println("从服务器接收的信息为:"
+ s);//显示字符串
&&&&if(s.trim().equals("BYE"))
{System.out.print("通话结束" );}
&&&&System.out.println("");
&&&din.close();
&&&dout.close();
&&&in.close();
&&&out.close();
&&&socket.close();
&&catch(IOException e){
&&&System.out.println("Error"
+ e);//若端口已被占用，则抛出异常
&&&System.exit(1);
(1)&运行服务器端程序talkserver.java
(2)运行客户端程序talkclient.java
(3)客户端向服务端发送信息
(4)结束连接
4.3多客户/服务器Socket编程应用举例
【例 6】
多客户/服务器程序。
1．服务器端程序
（1）ServerSocketThread.java：线程类的子类，为客户提供服务的所有操作都封装在该类中，该类的构造函数ServerSocketThread(Socket
s)接收一个Socket对象,用来与客户进行数据通信。
import java.net.*;
import java.io.*;
public class ServerSocketThread extends Thread{
&&private S
&&private DataInputStream
&&private DataOutputStream
ServerSocketThread(Socket s) throws IOException{
&&&socket =
&&&din = new
DataInputStream(socket.getInputStream());
&&&dout = new
DataOutputStream(socket.getOutputStream());
&&&start();
&&public void run(){
&&&System.out.println("连接成功");
&&&System.out.println("=========================================");
&&&System.out.println("请等待客户发送信息...");
&&&System.out.println("");
&&&while(true){
&&&&BufferedReader
sin = new BufferedReader(new InputStreamReader(System.in));
&&&&System.out.println("");
din.readUTF();&&//读入从client传来的字符串
&&&&System.out.println("从客户端接收的信息为:"
+ str);//显示字符串
&&&&if(str.trim().equals("BYE"))
{System.out.print("通话结束" );}
&&&&System.out.println("");
&&&&System.out.print("请输入要发送的信息:"
);//显示字符串
sin.readLine();&&//读入从键盘传来的字符串
&&&&dout.writeUTF(str);
&&&&dout.flush();&
.cn/s/blog_82f2fcrr.html
&&&&if(str.trim().equals("BYE"))
{System.out.print("通话结束" );}
&&&din.close();
&&&dout.close();
&&&socket.close();
&&&catch(IOException
&&&&System.out.println("Error"
+ e);//若端口已被占用，则抛出异常
&&&&System.exit(1);
（2）MultitalkServer.java：是一个应用程序，通过一个无限循环,等待并侦听多个客户的连接请求,每个客户的连接都由服务器端的一个单独线程来处理,实现了多用户/服务器之间的通信。
import java.net.*;
import java.io.*;
public class MultitalkServer{
&public static void main(String args[]){
&int port = 2000;
&&System.out.println("正在等待连接...");
&&ServerSocket server = new
ServerSocket(port);
&&Socket socket =
&&while(true){
&&&socket =
server.accept();
ServerSocketThread(socket);//侦听连接请求,等待连接
&&catch(IOException e){
&&&&System.out.println("Error"
+ e);//若端口已被占用，则抛出异常
&&&&System.exit(1);
2．客户端程序
（1）ClientSocketThread.java：客户端线程子类，实现和服务器的数据通信
import java.net.*;
import java.io.*;
public class ClientSocketThread extends Thread{
&&private S
&&private DataInputStream
&&private DataOutputStream
ClientSocketThread(InetAddress addr,int port,String clientname)
throws IOException{
&&&super(clientname);
&&&socket = new
Socket(addr,port);
&&&din = new
DataInputStream(socket.getInputStream());
&&&dout = new
DataOutputStream(socket.getOutputStream());
&&&start();
&&public void run(){
&&&System.out.println(getName());
&&&BufferedReader
sin = new BufferedReader(new InputStreamReader(System.in));
&&&System.out.println("连接成功");
&&&System.out.println("=========================================");
&&&System.out.println("");
&&&while(true){
&&&&System.out.println("");
&&&&System.out.print("请输入要发送的信息:"
);//显示字符串
sin.readLine();&&//读入从client传来的字符串
&&&&dout.writeUTF(str);
&&&&dout.flush();
&&&&if(str.trim().equals("BYE"))
{System.out.print("通话结束" );}
&&&&System.out.println("");
din.readUTF();&&//读入从client传来的字符串
&&&&System.out.println("从客户端接收的信息为:"
+ str);//显示字符串
&&&&if(str.trim().equals("BYE"))
{System.out.print("通话结束" );}
&&&din.close();
&&&dout.close();
&&&socket.close();
&&&catch(IOException
&&&&System.out.println("Error"
+ e);//若端口已被占用，则抛出异常
&&&&System.exit(1);
（2）TalkClient1.java和TalkClient2.java：建立和服务器通信的客户1和客户2
//------------------------------TalkClient1.java--------------------------------------------
&import java.net.*;
import java.io.*;
public class talkClient1{
&public static void main(String args[]){
&&int port = 2000;
ClientSocketThread(InetAddress.getLocalHost(),port,"客户端1");
&&catch(IOException e){
&&&&System.out.println("Error"
+ e);//若端口已被占用，则抛出异常
&&&&System.exit(1);
//-------------------------TalkClient2.java--------------------------------------
import java.net.*;
import java.io.*;
public class talkClient2{
&public static void main(String args[]){
&&int port = 2000;
ClientSocketThread(InetAddress.getLocalHost(),port,"客户端2");
&&catch(IOException e){
&&&&System.out.println("Error"
+ e);//若端口已被占用，则抛出异常
&&&&System.exit(1);
&小结:主要内容
TCP/IP协议
Client/Server模式
套接字（Socket）概念
Socket类
ServerSocket类
基于TCP协议的Socket编程的基本步骤
单客户/服务器Socket编程应用
多客户/服务器Socket编程应用
TCP协议的基本流程图，以及三次握手机制
常见的使用tcp协议的有ftp，smtp，telnet,snmp等。
三次握手机制
四次交互关闭
MSL,最长分节生命周期，maximum segment
lifetime，每个TCP实现都必须有个MSL值，它代表IP数据包能
在互联网上生存的最长时间。
TTL,Time to
life是IP协议包中的一个值,它告诉网络,数据包(例如ICMP包)在网络中的时间是否太长而应
被丢弃。有很多原因使包在一定时间内不能被传递到目的地。
MTU ，最大传输单元，maximum transport
unit，由链路层规定。一个IP数据包传出时，如果大于MTU，则会执行分片，各分片在到达目的地前是不会进行重组的。另外，IPV4主机和路由都可能对数据包执行分片，但是IPV6只有主机会在数据包产生时执行分片，IPV6路由器是不会对过路的数据包进行分片的。
MSS，最大分节大小，maximux segment size, 能接受的每个tcp分节中的最大数据量。
TCP，传输控制协议，transport control protocol
UDP，用户数据报协议，userdata protocol
ICMP ，网际控制消息协议，internet control message
ARP， 地址解析协议， address resolv protocol
以上网友发言只代表其个人观点，不代表新浪网的观点或立场。