pythonnet 网络2
问题：
什么是七层模型
tcp 和udp区别
三次握手和四次挥手
**************************************************
tcp 数据传输：
recv会不断的取出缓冲区中内容，如果一次没有拿完，那么下次会继续收取没拿完的消息；
tcp 粘包
tcp粘包指的是<发送方> 发送若干次数据的时候，因为是数据流的传输方式，导致数据粘在一起，<接收方>一次将多次发送的数据一起接收，传输接收数据的粘连；
粘包是tcp传输特有的现象，因为tcp传输没有消息边界。 如果是发送连续的内容，比如文件等，则粘包没有影响。如果是每次发送为单独需要处理内容则需要处理粘包；
如何处理粘包？
1，将消息格式化；
2，发送消息的同时发送一个消息长度标识；
3，让消息的发送延迟，使接收端每次都能够有时间接收一个消息；
UDP数据表套接字服务端：SERVER
（面向无连接的不可靠的传输服务）
1，创建数据报套接字；
2，绑定本地IP和端口；
3，收发消息；
recvfrom(BUFFERSIZE)
功能：在udp中接收消息；
参数： buffersize 表示一次最多可以接收多少字节的消息；
返回值：data：接收到的消息；
addr ：表示从哪个客户端接收到的消息；
sendto(data, addr)
功能： 向一个网络终端发送消息；
参数：data要发送的消息（bytes）
addr 发送对象的地址；
4，关闭套接字
import sys
sys.argv : 将命令行内容收集为一个列表，每个元素是命令行中的一项；
（命令行传入的内容均为str格式； 命令行内容以空格作为分隔，引号可以合成一个整体；）
#!/usr/bin/python3 import sys print(sys.argv[1]) print(sys.argv[2]) #### # python3 sys_argv.py 192.168.1.10 8888 192.168.1.10 8888
UDP客户端：CLIENT
1，创建数据报套接字
2，消息收发；
3，关闭套接字；
（recvfrom每次只能接收一个数据包，如果数据包的大小超过recvfrom的设置大小，则会出现数据丢失；）
########udp_server########## from socket import * import sys from time import ctime #从命令行传入ＩＰ和端口 HOST = sys.argv[1] PORT = int(sys.argv[2]) ADDR = (HOST,PORT) BUFFERSIZE = 5 #创建数据报套接字 sockfd = socket(AF_INET,SOCK_DGRAM) #绑定本地IP和端口 sockfd.bind(ADDR) #收发消息 while True: data,addr = sockfd.recvfrom(BUFFERSIZE) print("recv from ",addr,':',data.decode()) sockfd.sendto\ (("在 %s 接受到你的消息"%ctime()).encode(),addr) #关闭套接字 sockfd.close() ############udp_client############## from socket import * import sys #从命令行传入服务器的ＩＰ和端口 HOST = sys.argv[1] PORT = int(sys.argv[2]) ADDR = (HOST,PORT) BUFFERSIZE = 1024 #创建数据报套接字 sockfd = socket(AF_INET,SOCK_DGRAM) #消息收发 while True: data = input("消息>>") #输入空客户端退出 if not data: break #此处发送消息给服务器 sockfd.sendto(data.encode(),ADDR) data,addr = sockfd.recvfrom(BUFFERSIZE) print("从服务器接收:",data.decode()) #关闭套接字 sockfd.close() ############### python3 udp_client.py 192.168.1.112 8888 message>> a SERVER recvfrom...: In Sun Jul 1 17:50:05 2018 recvfrom your messages #### # python3 udp_server.py 192.168.1.112 8888 recvfrom: ('192.168.1.112', 56956) : a
总结tcp和udp的区别：
1，tcp是有连接的，udp是无连接的
2，tcp有三次握手四次挥手的过程；而udp没有；
3，tcp是以数据流传输数据，会有粘包；udp是数据报的形式传输数据，没有粘包；
4，tcp的连接需要消耗一定的资源，相比之下udp资源消耗少；
5，tcp保证数据的可靠性，udp不保证；
6，tcp需要listen accept connect； 而 udp 不需要这些操作；
socket模块
套接字属性
getpeername()
功能：用做服务器连接套接字，查看连接的客户端地址；
getsockname()
功能： 获取套接字对应的绑定的地址和端口；
s.type 套接字类型
fileno()
功能：获取套接字的文件描述符号码；
文件描述符：系统会给进程中的每个IO操作对象匹配一个 >=0 的正整数作为标号，我们称之为该IO操作的文件描述符。一个进程中的所有IO的文件描述符不会重复；
setsockopt(level, optname, value)
功能： 设置套接字选项，可以增加或改变套接字的功能；
参数：level 要定义的选项类型；
例如： SOL_SOCKET 、 IPPROTO_IP、 IPPROTO_TCP
optname 每种类型都有具体的选项，根据具体需求选择选项 ， 进行设置；
例如： SOL_SOCKET ---> SO_REUSERADDR (#将端口号设置为立即重用(SOL_SOCKET,SO_REUSEADDR,1) )
value 将选择的现象设置为什么值；
getsockopt(level, optname)
功能：获取相应选项的值
参数：level 要获取的选项类型
optname 每种类型都有具体的选项，根据具体需求选择要获取的选项；
返回值：获取到的值；
######tcp_server##### from socket import * import time HOST = '192.168.1.112' PORT = 8888 ADDR = (HOST,PORT) BUFFERSIZE = 1024 sockfd = socket(AF_INET,SOCK_STREAM) print("您的套接字是：",sockfd.type) print("sockfd 的 file num:",sockfd.fileno()) #将端口号设置为立即重用 sockfd.setsockopt\ (SOL_SOCKET,SO_REUSEADDR,1) print("获取选项值：",sockfd.\ getsockopt(SOL_SOCKET,SO_REUSEADDR)) sockfd.bind(ADDR) sockfd.listen(5) print("您的套接字地址是：",sockfd.getsockname()) while True: print("wait for connect......") conn,addr = sockfd.accept() #使用getpeername获取链接的客户端的地址 print("connect from ",conn.getpeername()) while True: data = conn.recv(BUFFERSIZE) if not data: break print("接受到：",data.decode()) n = conn.send(b"Recv your message\n") print("发送了 %d 字节的数据"%n) conn.close() # 表示和客户端断开连接 sockfd.close() # 不能再使用sockfd ######tcp_client###### cat tcp_client.py #!/usr/local/bin/python3 from socket import * import time HOST = '192.168.1.112' PORT = 8888 ADDR = (HOST,PORT) connfd = socket(AF_INET,SOCK_STREAM) connfd.connect(ADDR) while True: data = input('send>>>') if not data: break connfd.sendall(data.encode()) data = connfd.recv(1024) print('client recv:',data.decode()) connfd.close()
socket服务器模型：
硬件服务器 ： 计算机主机 IBM HP
集成 分布式
软件服务器 ： 网络服务器，提供后端逻辑服务和请求处理的程序集合及架构
例如 web服务器等
服务器架构 c/s b/s 服务器的组织形式
服务器追求 ： 更快速， 更安全，并发量更大
fork
1， 创建套接字 绑定 监听；
2，接收客户端连接请求 创建新的进程；
3，主进程继续接收下一个客户端连接请求，子进程处理客户端事件；
4， 有客户端断开，则关闭响应的子进程；
##########fork_tcp_server############ from socket import * import os import signal #有客户端断开则关闭相应的子进程 def handler(c): while True: data = c.recv(BUFFERSIZE).decode() if not data: break print("服务器收到：",data) c.send(b'receive your message') c.close() os._exit(0) #创建套接字 绑定 监听 HOST = '192.168.1.112' PORT = 8888 ADDR = (HOST,PORT) BUFFERSIZE = 1024 #创建tcp套接字 s = socket() s.setsockopt(SOL_SOCKET,SO_REUSEADDR,1) s.bind(ADDR) s.listen(5) #做僵尸进程的处理 signal.signal(signal.SIGCHLD,signal.SIG_IGN) #接收客户端连接请求 创建新的进程 while True: try: c,addr = s.accept() except KeyboardInterrupt: print("服务器结束") s.close() os._exit(0) except Exception: continue print("接收到客户端链接 ＞",c.getpeername()) pid = os.fork() if pid < 0: print("创建子进程失败") continue #子进程处理客户端事件 elif pid == 0: s.close() print('处理客户端请求事件') handler(c) # 处理客户端的函数 #主进程继续接收下一个客户端连接请求 else: c.close() continue #########tcp_client######## # cat tcp_server.py #!/usr/local/bin/python3 from socket import * HOST = '127.0.0.1' PORT = 8888 ADDR = (HOST,PORT) BUFFERSIZE = 1024 sockfd = socket(AF_INET, SOCK_STREAM) sockfd.bind(ADDR) sockfd.listen(5) while True: print('wait for connect....') conn,addr = sockfd.accept() print('connect from',addr) while True: data = conn.recv(BUFFERSIZE) if not data: break print('connect:',data.decode()) n = conn.send(b'Recv your message.\n') print('send.. %d'%n) conn.close() sockfd.close()
threading
1, 创建套接字 ， 绑定， 监听；
2，接收客户端连接请求， 创建新的线程；
3，主线程继续接收下一个客户端连接请求；分支线程处理客户端事件；
练习
########threading_tcp_server####### from socket import * import threading import os #有客户端断开则关闭相应的子线程 def handler(c): while True: data = c.recv(BUFFERSIZE).decode() if not data: break print("服务器收到：",data) c.send(b'receive your message') c.close() #创建套接字 绑定 监听 HOST = '127.0.0.1' PORT = 8888 ADDR = (HOST,PORT) BUFFERSIZE = 1024 #创建tcp套接字 s = socket() s.setsockopt(SOL_SOCKET,SO_REUSEADDR,1) s.bind(ADDR) s.listen(5) #接收客户端连接请求 创建新的线程 while True: try: c,addr = s.accept() except KeyboardInterrupt: print("服务器结束") s.close() os._exit(0) except Exception: continue print("接收到客户端链接 ＞",c.getpeername()) #分支线程处理客户端事件 t = threading.Thread\ (target = handler,args = (c,)) t.setDaemon(True) t.start() #主线程继续接收下一个客户端连接请求 ##########tcp_client################# # cat tcp_client.py #!/usr/local/bin/python3 from socket import * import time HOST = '127.0.0.1' PORT = 8888 ADDR = (HOST,PORT) connfd = socket(AF_INET,SOCK_STREAM) connfd.connect(ADDR) while True: data = input('send>>>') if not data: break connfd.sendall(data.encode()) data = connfd.recv(1024) print('client recv:',data.decode()) connfd.close()
socketserver模块 （python2 SocketServer）
'DatagramRequestHandler',
'ForkingMixIn',
'ForkingTCPServer',
'ForkingUDPServer',
'StreamRequestHandler',
'TCPServer',
'ThreadingMixIn',
'ThreadingTCPServer',
'ThreadingUDPServer',
'UDPServer',
三部分：
多进程/多线程 TCP/UDP streamhandler/datagramhandler
ForkingMixIn TCPServer StreamRequestHandler
ThreadingMixIn UDPServer DatagramRequestHandler
组合如下：
‘ThreadingTCPServer’ = ThreadingMixIn + TCPServer
‘ThreadingUDPServer’ = ThreadingMixIn + UDPServer
ForkingTCPServer = ForkingMixIn + TCPServer
ForkingUDPServer = ForkingMixIn + UDPServer
步骤：
1， 创建服务器类；
2，创建处理类；
3，使用创建的服务器类来生产服务器；
# fork + tcp 并发
########socket_server######### # fork + tcp 并发 from socketserver import * #创建服务器类 class Server(ThreadingMixIn,TCPServer): pass # class Server(ForkingTCPServer): # pass #创建处理类 class Handler(StreamRequestHandler): #当有客户端链接时候调用该函数自动处理 #客户段请求事件 def handle(self): print("connect from ",self.client_address) while True: #self.request 为tcp中为我们自动生成的 #和客户端交互的套接字 data = self.request.recv(1024).decode() if not data: break print("服务器收到：",data) self.request.send(b'receive your message') #使用创建的服务器类来生产服务器 server = Server(('172.60.50.218',9999),Handler) #运行服务器 server.serve_forever() #########tcp_client######## # cat tcp_client.py #!/usr/local/bin/python3 from socket import * import time HOST = '127.0.0.1' PORT = 8889 ADDR = (HOST,PORT) connfd = socket(AF_INET,SOCK_STREAM) connfd.connect(ADDR) while True: data = input('send>>>') if not data: break connfd.sendall(data.encode()) data = connfd.recv(1024) print('client recv:',data.decode()) connfd.close()
# fork + udp
##########fork_udp_server############# # fork + udp from socketserver import * class Server(ForkingUDPServer): pass class Handler(DatagramRequestHandler): #udp无连接所以request的含义不同 def handle(self): data = self.rfile.readline() print("接受到了：",data.decode()) self.wfile.write(b"receive message") server = Server(('0.0.0.0',8888),Handler) server.serve_forever() ###########udp_client############## # cat udp_client.py #!/usr/local/bin/python3 from socket import * import sys HOST = sys.argv[1] PORT = int(sys.argv[2]) ADDR = (HOST,PORT) BUFFERSIZE = 1024 sockfd = socket(AF_INET, SOCK_DGRAM) while True: data = input("message>> ") if not data: break sockfd.sendto(data.encode(),ADDR) data,addr = sockfd.recvfrom(BUFFERSIZE) print('SERVER recvfrom...: ', data.decode()) sockfd.close()
思考：ftp传输