python网络编程——socket基础篇

python的网络编程比c语言简单许多, 封装许多底层的实现细节, 方便程序员使用的同时, 也使程序员比较难了解一些底层的东西。

1 TCP/IP

　　要想理解socket，首先得熟悉一下TCP/IP协议族，TCP/IP（Transmission Control Protocol/Internet Protocol）即传输控制协议/网间协议，定义了主机如何连入因特网及数据如何在它们之间传输的标准，从字面意思来看TCP/IP是TCP和IP协议的合称，但实际上TCP/IP协议是指因特网整个TCP/IP协议族。不同于ISO模型的七个分层，TCP/IP协议参考模型把所有的TCP/IP系列协议归类到四个抽象层中： 
　　应用层：TFTP，HTTP，SNMP，FTP，SMTP，DNS，Telnet等等 
　　传输层：TCP，UDP 
　　网络层：IP，ICMP，OSPF，EIGRP，IGMP 
　　数据链路层：SLIP，CSLIP，PPP，MTU 
　　每一抽象层建立在低一层提供的服务上，并且为高一层提供服务，看起来大概是这样子的 
　　

　

　在TCP/IP协议中两个因特网主机通过两个路由器和对应的层连接。各主机上的应用通过一些数据通道相互执行读取操作，如下图所示：

　　

2 socket概念　

Socket(中文译为套接字)是操作系统内核中的一个数据结构，它几乎是所有网络通信的基础。网络通信，归根到底还是进程间的通信（不同计算机上的进程间通信, 又称为网络通信, IP协议进行的主要是端到端通信）。在网络中，每一个节点（计算机或路由）都有一个网络地址，也就是IP地址。两个进程通信时，首先要确定各自所在的网络节点的网络地址。但是，网络地址只能确定进程所在的计算机，而一台计算机上很可能同时运行着多个进程，所以仅凭网络地址还不能确定到底是和网络中的哪一个进程进行通信，因此套接字中还需要包括其他的信息，也就是端口号(PORT)。在一台计算机中，一个端口号一次只能分配给一个进程，也就是说，在一台计算机中，端口号和进程之间是一 一对应的关系。

socket使用(IP地址，协议，端口号)来标识一个进程。所以，使用端口号和网络地址的组合可以唯一的确定整个网络中的一个网络进程。

端口号的范围从0~65535，一类是由互联网指派名字和号码公司ICANN负责分配给一些常用的应用程序固定使用的“周知的端口”，其值一般为0~1023, 用户自定义端口号一般大于等于1024

    每一个socket都用一个半相关描述{协议、本地地址、本地端口}来表示；一个完整的套接字则用一个相关描述{协议、本地地址、本地端口、远程地址、远程端口}来表示。socket也有一个类似于打开文件的函数调用，该函数返回一个整型的socket描述符，随后的连接建立、数据传输等操作都是通过socket描述符来实现的。

      网络上的两个程序通过一个双向的通信连接实现数据的交换，这个连接的一端称为一个socket。socket通常也称作“套接字”，用于描述IP地址和端口，是一个通信链的句柄，应用程序通常通过“套接字”向网络发出请求或者应答网络请求。socket起源于Unix，而Unix/Linux基本哲学之一就是“一切皆文件”，对于文件用打开、读写、关闭模式来操作，socket就是该模式在网络上的一个实现，即socket是一种特殊的文件。两个程序通过“网络”交互数据就使用socket，它只负责两件事：建立连接，传递数据；同时socket在收发数据时遵循的原则：有发就有收，收发必相等！ 
　　文件读写和socket收发数据的区别：
　　- file模块是针对某个指定文件进行打开、读写、关闭 
　　- socket模块是针对服务器端和客户端socket进行打开(连接)、读写(收发)、关闭(断开) 
　　  

2.1 Socket类型

socket类型在Liunx和Python中是一样的, 只是Python中的类型都定义在socket模块中, 调用方式socket.SOCK_XXXX。

1、流式socket(SOCK_STREAM)用于TCP通信

流式套接字提供可靠的、面向连接的通信流；它使用TCP协议，从而保证了数据传输的正确性和顺序性。

2、数据报socket(SOCK_DGRAM)用于UDP通信

数据报套接字定义了一种无连接的服务；它使用数据报协议UDP，数据通过相互独立的报文进行传输，是无序的，并且不保证是可靠、无差错的传输。

3、原始socket(SOCK_RAW)用于新的网络协议实现的测试等

原始套接字，普通的套接字无法处理ICMP、IGMP等网络报文，而SOCK_RAW可以, 其次，SOCK_RAW也可以处理特殊的IPv4报文；此外，利用原始套接字，用户可以通过IP_HDRINCL套接字选项构造IP头。

3 Socket编程

TCP/UDP Socket是一种基于Client-Server的编程模型，服务端监听客户端的连接请求，一旦建立连接即可以进行数据传输。那么对TCP/UDP Socket编程的介绍也分为客户端和服务端：

3.1 TCP Socket通信

如下图所示，TCP通信的基本步骤如下：
    
服务端：socket---bind---listen---while(True){---accept----recv---send---}---close
    
客户端：socket----------------------------------connect---send---recv-------close

   1、socket函数
   使用给定的地址族、套接字类型、协议编号（默认为0）来创建套接字。

 socket.socket([family[, type[, proto]]])
 family : AF_INET (默认ipv4), AF_INET6(ipv6) or AF_UNIX(Unix系统进程间通信).
 type : SOCK_STREAM (TCP), SOCK_DGRAM(UDP) .
 protocol : 一般为0或者默认

 如果socket创建失败会抛出一个socket.error异常</code>

2、服务器端函数

   (1)bind函数
     将套接字绑定到地址, python下以元组（host,port）的形式表示地址。

 #python
 s.bind(address)
 s为socket.socket()返回的套接字对象
 address为元组（host,port）
 host: ip地址, 为一个字符串
 post: 自定义主机号, 为整型</code>

     (2)listen函数
     使服务器的这个端口和IP处于监听状态，等待网络中某一客户机的连接请求。如果客户端有连接请求，端口就会接受这个连接。

 #python
 s.listen(backlog)
 s为socket.socket()返回的套接字对象
 backlog : 操作系统可以挂起的最大连接数量。该值至少为1，大部分应用程序设为5就可以了</code>

     (3)accept函数
     接受远程计算机的连接请求，建立起与客户机之间的通信连接。服务器处于监听状态时，如果某时刻获得客户机的连接请求，此时并不是立即处理这个请求，而是将这个请求放在等待队列中，当系统空闲时再处理客户机的连接请求。

 #python
 s.accept()
 s为socket.socket()返回的套接字对象
 返回（conn,address）,其中conn是新的套接字对象，可以用来接收和发送数据。address是连接客户端的地址</code>

3 客户端函数

   connect函数
  
用来请求连接远程服务器

 #python
 s.connect(address)
 s为socket.socket()返回的套接字对象
 address : 格式为元组（hostname,port），如果连接出错，返回socket.error错误</code>

4 通用函数

   (1)recv函数

接收远端主机传来的数据

 #python
 s.recv(bufsize[,flag])
 s为socket.socket()返回的套接字对象
 bufsize : 指定要接收的数据大小
 flag : 提供有关消息的其他信息，通常可以忽略
 返回值为数据以字符串形式</code>

(2)send函数
    
发送数据给指定的远端主机

 #python
 s.send(string[,flag])
 s为socket.socket()返回的套接字对象
 string : 要发送的字符串数据
 flag : 提供有关消息的其他信息，通常可以忽略
 返回值是要发送的字节数量，该数量可能小于string的字节大小。
 s.sendall(string[,flag])
 #完整发送TCP数据。将string中的数据发送到连接的套接字，但在返回之前会尝试发送所有数据。
 返回值 : 成功返回None，失败则抛出异常。</code>

(3)close函数

关闭套接字

 #python
 s.close()
 s为socket.socket()返回的套接字对象</code>

5 带异常处理的客户端服务端TCP连接

在进行网络编程时, 最好使用大量的错误处理, 能够尽量的发现错误, 也能够使代码显得更加严谨。

服务器端代码

 <code>#服务器端
 #!/usr/bin/env python
 # -*- coding:utf-8 -*-

 import sys
 import socket   #socket模块

 BUF_SIZE = 1024  #设置缓冲区大小
 server_addr = ('127.0.0.1', 8888)  #IP和端口构成表示地址
 try :
   server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)  #生成一个新的socket对象
 except socket.error, msg :
     print "Creating Socket Failure. Error Code : " + str(msg[0]) + " Message : " + msg[1]
     sys.exit()
 print "Socket Created!"
 server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)  #设置地址复用
 try :
     server.bind(server_addr)  #绑定地址
 except socket.error, msg :
   print "Binding Failure. Error Code : " + str(msg[0]) + " Message : " + msg[1]
   sys.exit()
 print "Socket Bind!"
 server.listen(5)  #监听, 最大监听数为5
 print "Socket listening"
 while True:
     client, client_addr = server.accept()  #接收TCP连接, 并返回新的套接字和地址, 阻塞函数
     print 'Connected by', client_addr
     while True :
         data = client.recv(BUF_SIZE)  #从客户端接收数据
         print data
         client.sendall(data)  #发送数据到客户端
 server.close()</code>

客户端代码

 <code>#客户端
 #!/usr/bin/env python
 # -*- coding:utf-8 -*-

 import sys
 import socket

 BUF_SIZE = 1024  #设置缓冲区的大小
 server_addr = ('127.0.0.1', 8888)  #IP和端口构成表示地址
 try :
     client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)  #返回新的socket对象
 except socket.error, msg :
     print "Creating Socket Failure. Error Code : " + str(msg[0]) + " Message : " + msg[1]
     sys.exit()
 client.connect(server_addr)  #要连接的服务器地址
 while True:
     data = raw_input("Please input some string > ")
     if not data :
         print "input can't empty, Please input again.."
         continue
     client.sendall(data)  #发送数据到服务器
     data = client.recv(BUF_SIZE)  #从服务器端接收数据
     print data
 client.close()</code>

3.2 Socket UDP通信

UDP通信流程图如下：

服务端：socket---bind---recvfrom---sendto---close

客户端：socket----------sendto---recvfrom---close

     (1)socket函数，同上

     (2)sendto函数
    
发送UDP数据, 将数据发送到套接字

 #Python
 s.sendto(string[,flag],address)
 s为socket.socket()返回的套接字对象
 address : 指定远程地址, 形式为（ipaddr，port）的元组
 flag : 提供有关消息的其他信息，通常可以忽略
 返回值 : 发送的字节数。</code>

(3)recvfrom函数
   
接受UDP套接字的数据, 与recv()类似

 #Python
 s.recvfrom(bufsize[.flag])
 返回值 : （data,address）元组, 其中data是包含接收数据的字符串，address是发送数据的套接字地址
 bufsize : 指定要接收的数据大小
 flag : 提供有关消息的其他信息，通常可以忽略</code>

(4)close函数，同上

    (5)简单的客户端服务器UDP连接

    服务器端代码

 <code>#服务器端
 #!/usr/bin/env python
 # -*- coding:utf-8 -*-

 import socket

 BUF_SIZE = 1024  #设置缓冲区大小
 server_addr = ('127.0.0.1', 8888)  #IP和端口构成表示地址
 server = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)  #生成新的套接字对象
 server.bind(server_addr)  #套接字绑定IP和端口
 while True :
     print "waitting for data"
     data, client_addr = server.recvfrom(BUF_SIZE)  #从客户端接收数据
     print 'Connected by', client_addr, ' Receive Data : ', data
     server.sendto(data, client_addr)  #发送数据给客户端
 server.close()</code>

客户端代码

 <code>#客户端
 #!/usr/bin/env python
 # -*- coding:utf-8 -*-

 import socket
 import struct

 BUF_SIZE = 1024  #设置缓冲区
 server_addr = ('127.0.0.1', 8888)  #IP和端口构成表示地址
 client = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)  #生成新的套接字对象

 while True :
     data = raw_input('Please Input data > ')
     client.sendto(data, server_addr)  #向服务器发送数据
     data, addr = client.recvfrom(BUF_SIZE)  #从服务器接收数据
     print "Data : ", data
 client.close()</code>

4 Python Socket更多功能

sk = socket.socket(socket.AF_INET,socket.SOCK_STREAM,0)

函数socket.socket创建一个socket对象，返回该对象的socket描述符，该socket描述符将在后面的相关函数中使用。

参数一：地址簇

　　socket.AF_INET IPv4（默认）
　　socket.AF_INET6 IPv6

　　socket.AF_UNIX 只能够用于单一的Unix系统进程间通信。

参数二：类型

　　socket.SOCK_STREAM　　流式socket , for TCP（默认）
　　socket.SOCK_DGRAM　　 数据报式socket , for UDP

　　socket.SOCK_RAW 原始套接字，普通的套接字无法处理ICMP、IGMP等网络报文，而SOCK_RAW可以；其次，SOCK_RAW也可以处理特殊的IPv4报文；此外，利用原始套接字，可以通过IP_HDRINCL套接字选项由用户构造IP头。
　　socket.SOCK_RDM 是一种可靠的UDP形式，即保证交付数据报但不保证顺序。SOCK_RAM用来提供对原始协议的低级访问，在需要执行某些特殊操作时使用，如发送ICMP报文。SOCK_RAM通常仅限于高级用户或管理员运行的程序使用。
　　socket.SOCK_SEQPACKET 可靠的连续数据包服务。

参数三：协议

　　0　默认值，与特定的地址家族相关的协议,如果是0 ，则系统就会根据地址格式和套接类别,自动选择一个合适的协议。

   sk.bind(address)

　  s.bind(address) 将套接字绑定到地址。address地址的格式取决于地址族。在AF_INET下，以元组（host,port）的形式表示地址。

   sk.listen(backlog)

　　 开始监听传入连接。backlog指定在拒绝连接之前，可以挂起的最大连接数量。backlog等于5，表示内核已经接到了连接请求，但服务器还没有调用accept进行处理的连接个数最大为5，这个值不能无限  大，因为要在内核中维护连接队列。

   sk.setblocking(bool)

　　 是否阻塞（默认True），如果设置False，那么accept和recv时一旦无数据，则报错。

   sk.accept()

　　 接受连接并返回（conn,address）,其中conn是新的套接字对象，可以用来接收和发送数据。address是连接客户端的地址。接收TCP客户的连接（阻塞式）等待连接的到来。

   sk.connect(address)

　　 连接到address处的套接字。一般，address的格式为元组（hostname,port）,如果连接出错，返回socket.error错误。

   sk.connect_ex(address)

　　 同上，只不过会有返回值，连接成功时返回 0 ，连接失败时候返回编码，例如：10061

   sk.close()

　　 关闭套接字

   sk.recv(bufsize[,flag])

　　接受套接字的数据。数据以字符串形式返回，bufsize指定最多可以接收的数量。flag提供有关消息的其他信息，通常可以忽略。

   sk.recvfrom(bufsize[.flag])

　　与recv()类似，但返回值是（data,address）。其中data是包含接收数据的字符串，address是发送数据的套接字地址。

   sk.send(string[,flag])

　　将string中的数据发送到连接的套接字。返回值是要发送的字节数量，该数量可能小于string的字节大小。即：可能未将指定内容全部发送。

   sk.sendall(string[,flag])

　　将string中的数据发送到连接的套接字，但在返回之前会尝试发送所有数据。成功返回None，失败则抛出异常。内部通过递归调用send，将所有内容发送出去。

   sk.sendto(string[,flag],address)

　　将数据发送到套接字，address是形式为（ipaddr，port）的元组，指定远程地址。返回值是发送的字节数。该函数主要用于UDP协议。

   sk.settimeout(timeout)

　　设置套接字操作的超时期，timeout是一个浮点数，单位是秒。值为None表示没有超时期。一般，超时期应该在刚创建套接字时设置，因为它们可能用于连接的操作（如client连接最多等待5s）

   sk.getpeername()

　　返回连接套接字的远程地址。返回值通常是元组（ipaddr,port）。

   sk.getsockname()

　　返回套接字自己的地址。通常是一个元组(ipaddr,port)

   sk.fileno()

　　套接字的文件描述符

sk.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)

   允许后续使用bind()来绑定指定端口并进行监听，即使这个端口最近被其他程序监听。没有这个设置的话，服务不能运行，直到一两分钟后，这个端口不再被之前的程序使用。

参考资料：

http://www.open-open.com/lib/view/open1418369887277.html

http://www.cnblogs.com/wupeiqi/articles/5040823.html

http://www.cnblogs.com/hazir/p/python_socket_programming.html