python 在一个非套接字上尝试了一个操作_Python网络编程笔记（二）：TCP
IP层需要解决两个问题：
通过多路复用，区分不同应用程序的数据包
通过可靠传输，修复错误
两个主要协议：用户数据包协议(UDP)、传输控制协议(TCP)，UDP用端口多路复用，解决问题一。TCP可以同时解决这两个问题。
TCP
TCP工作原理
每个TCP数据包都有一个序列号，接收方通过序列号排序，和发现丢失数据包。
序列号不是整数，使用计数器。新序列号 = 旧序列号 + 数据包长度
初始序列号随机
不锁步通信，无需等待响应一口气发送多个数据包。某一时刻发送方希望同时传输的最大数据量叫做TCP窗口(window)的大小
接收方的TCP可以通过控制发送方的窗口大小来减缓或暂停连接，即流量控制(flow control)
如果包被丢弃，TCP会假定网络很拥挤，会减少发送量。对于无线网这种噪声很大的环境来说，TCP是个灾难。
何时使用TCP
几乎所有情况下。
例外：
如果客户端只需向服务器发送单个较小请求，并且请求完成后无需通信，不需长连接，此时使用TCP大材小用了。
TCP建立连接至少三个包(SYN， SYN-ACK， ACK)，结束连接三或四个包(FIN，FIN-ACK，ACK)。这样单个请求至少6个包。
如果短时间内发送许多单独请求，可以用TCP。这时建立连接的开销可以被平均掉。
当丢包发生时，如果应用程序有比TCP重传更聪明的做法时。比如音频信号，一直重传丢失的1秒数据毫无必要。
TCP套接字的含义
TCP的connect()与UDP的connnect()不一样的：
TCP的是必须，建立连接；UDP的不必须，可以用sendto()指定地址。
TCP的connect()可能失败，因为真的在通信，建立连接。而UDP只是本机上记录下对方地址，并无通信。
套接字分类
被动套接字/监听套接字：只用来接收连接请求，不发送和接收数据。
主动套接字/连接套接字：只用于与特定一个远程主机通信，发送和接收数据。
一个被动套接字，可以有N个主动套接字。
Talk is Cheap， Show Me the Code
#!/usr/bin/env python3
# Foundations of Python Network Programming, Third Edition
# https://github.com/brandon-rhodes/fopnp/blob/m/py3/chapter03/tcp_sixteen.py
# Simple TCP client and server that send and receive 16 octets
import argparse, socket
def recvall(sock, length):
data = b''
while len(data) < length:
more = sock.recv(length - len(data))
if not more:
raise EOFError('was expecting %d bytes but only received'
' %d bytes before the socket closed'
% (length, len(data)))
data += more
return data
def server(interface, port):
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
// 设置SO_REUSEADDR，确保套接字的端口在等待关闭状态时可以使用，否则OS需要几分钟后才使端口可用
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
sock.bind((interface, port))
// sock是监听套接字, listen的参数为等待连接的最大数。
sock.listen(1)
print('Listening at', sock.getsockname())
while True:
print('Waiting to accept a new connection')
// 监听套接字sock调用accept()后新建了一个主动套接字sc
sc, sockname = sock.accept()
print('We have accepted a connection from', sockname)
print(' Socket name:', sc.getsockname())
print(' Socket peer:', sc.getpeername())
message = recvall(sc, 16)
print(' Incoming sixteen-octet message:', repr(message))
sc.sendall(b'Farewell, client')
sc.close()
print(' Reply sent, socket closed')
// 由于TCP可靠性，客户端代码简单多了
def client(host, port):
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect((host, port)) // 相比于UDP，这里可能会失败
print('Client has been assigned socket name', sock.getsockname())
sock.sendall(b'Hi there, server')
reply = recvall(sock, 16)
print('The server said', repr(reply))
sock.close()
if __name__ == '__main__':
choices = {'client': client, 'server': server}
parser = argparse.ArgumentParser(description='Send and receive over TCP')
parser.add_argument('role', choices=choices, help='which role to play')
// 绑定接口与UDP类似，区分自环接口127.0.0.1和空
parser.add_argument('host', help='interface the server listens at;'
' host the client sends to')
parser.add_argument('-p', metavar='PORT', type=int, default=1060,
help='TCP port (default 1060)')
args = parser.parse_args()
function = choices[args.role]
function(args.host, args.p)
send(), sendall()和recv(), recvall()
TCP将数据看做流，会自行将流分割为多个数据包，因此可能发一半数据。而UDP的发送是原子性的，发送这个，接收这个。一次TCP send()时，操作系统网络栈会遇到三种情况：
要发送数据立即被网络栈接收。send()立即返回，返回值是数据串长度。
网卡正忙，发送缓冲区满，系统也不分配额外空间，send()会阻塞进程，暂停程序。
介于两者，缓冲区几乎满了，但是还能放一点，放不全。则send()返回已经接收的长度。其余数据等待。
所以使用send()要循环判断其返回，比较麻烦，python提供了C写的sendall()，做这个循环。
recv()情况类似，如果接收缓冲区只有部分数据，也会立即返回。因此代码里有recvall()，保证一个循环内接收定长数据。标准库不提供，是因为用定长数据的太少了，而且很多数据需要边传边用，这种方案不具有普适性了。
死锁
上例是读取完整个数据流后再响应，缺点是如果流很大，内存可能就不够了。聪明点的做法时每次只读取并处理N字节的小型数据块。
考虑客户端大量数据要发送，客户端都来不及recv, 接收缓冲区就会被填满。此时服务器会探测到，然后阻塞send, 最终服务端发送缓冲区也满了，无法发送。服务器的接收缓冲区也会被填满，最终双方缓冲区都满，死锁。(即通信双方都忙着写数据，来不及读)
避免死锁：
将套接字选项的阻塞关闭。
使用某种技术同时处理来自多个输入的数据，比如多线程、多进程，select()， poll()等系统调用
UDP不会出现这种情况，接收不了就会丢弃。
已关闭连接，半关闭连接
套接字默认是双向的，shutdown()可以控制关闭任一方向。参数有三个：
SHUT_WR: 最常用，表示调用方将不再向套接字写入，而对方也不会再读取任何数据。
SHUT_RD: 关闭接收方向的数据流。
SHUT_RDWR: 关闭两个方向。与close()区别在于，close只关闭调用它的进程与套接字的关系，其他进程依旧可以用这个套接字。而这个就比较厉害了，全部关闭。
像使用文件一样使用TCP流
f = sock.makefile(), 然后就可以使用 read() 和 write(), 底层会调用 recv() 和 send()