操作系统基础
操作系统:(Operating System,简称OS)是管理和控制计算机硬件与软件资源的计算机程序,是直接运行在“裸机”上的最基本的系统软件,任何其他软件都必须在操作系统的支持下才能运行。
操作系统应该分成两部分功能
隐藏了丑陋的硬件调用接口(键盘、鼠标、音箱等等怎么实现的,就不需要你管了),为应用程序员提供调用硬件资源的更好,更简单,更清晰的模型(系统调用接口)。应用程序员有了这些接口后,就不用再考虑操作硬件的细节,专心开发自己的应用程序即可。
例如:操作系统提供了文件这个抽象概念,对文件的操作就是对磁盘的操作,有了文件我们无需再去考虑关于磁盘的读写控制(比如控制磁盘转动,移动磁头读写数据等细节),
将应用程序对硬件资源的竞态请求变得有序化
例如:很多应用软件其实是共享一套计算机硬件,比方说有可能有三个应用程序同时需要申请打印机来输出内容,那么a程序竞争到了打印机资源就打印,然后可能是b竞争到打印机资源,也可能是c,这就导致了无序,打印机可能打印一段a的内容然后又去打印c…,操作系统的一个功能就是将这种无序变得有序。
socket
回顾一下五层通讯流程
但实际上从传输层开始以及以下,都是操作系统帮咱们完成的,下面的各种包头封装的过程
Socket又称为套接字,它是应用层与TCP/IP协议族通信的中间软件抽象层,它是一组接口。在设计模式中,Socket其实就是一个门面模式,它把复杂的TCP/IP协议族隐藏在Socket接口后面,对用户来说,一组简单的接口就是全部,让Socket去组织数据,以符合指定的协议。当我们使用不同的协议进行通信时就得使用不同的接口,还得处理不同协议的各种细节,这就增加了开发的难度,软件也不易于扩展(就像我们开发一套公司管理系统一样,报账、会议预定、请假等功能不需要单独写系统,而是一个系统上多个功能接口,不需要知道每个功能如何去实现的)。于是UNIX BSD就发明了socket这种东西,socket屏蔽了各个协议的通信细节,使得程序员无需关注协议本身,直接使用socket提供的接口来进行互联的不同主机间的进程的通信。这就好比操作系统给我们提供了使用底层硬件功能的系统调用,通过系统调用我们可以方便的使用磁盘(文件操作),使用内存,而无需自己去进行磁盘读写,内存管理。socket其实也是一样的东西,就是提供了tcp/ip协议的抽象,对外提供了一套接口,同过这个接口就可以统一、方便的使用tcp/ip协议的功能了。
其实站在你的角度上看,socket就是一个模块。我们通过调用模块中已经实现的方法建立两个进程之间的连接和通信。也有人将socket说成ip+port,因为ip是用来标识互联网中的一台主机的位置,而port是用来标识这台机器上的一个应用程序。 所以我们只要确立了ip和port就能找到一个应用程序,并且使用socket模块来与之通信。
套接字家族
套接字起源于 20 世纪 70 年代加利福尼亚大学伯克利分校版本的 Unix,即人们所说的 BSD Unix。 因此,有时人们也把套接字称为“伯克利套接字”或“BSD 套接字”。一开始,套接字被设计用在同 一台主机上多个应用程序之间的通讯。这也被称进程间通讯,或 IPC。套接字有两种(或者称为有两个种族),分别是基于文件型的和基于网络型的。
基于文件类型的套接字家族
套接字家族的名字:AF_UNIX
unix一切皆文件,基于文件的套接字调用的就是底层的文件系统来取数据,两个套接字进程运行在同一机器,可以通过访问同一个文件系统间接完成通信
基于网络类型的套接字家族
套接字家族的名字:AF_INET
(还有AF_INET6被用于ipv6,还有一些其他的地址家族,不过,他们要么是只用于某个平台,要么就是已经被废弃,或者是很少被使用,或者是根本没有实现,所有地址家族中,AF_INET是使用最广泛的一个,python支持很多种地址家族,但是由于我们只关心网络编程,所以大部分时候我么只使用AF_INET)
套接字的工作流程(基于TCP和 UDP两个协议)
TCP和UDP对比
TCP协议下的socket
服务器端先初始化Socket,然后与端口绑定(bind),对端口进行监听(listen),调用accept阻塞,等待客户端连接。在这时如果有个客户端初始化一个Socket,然后连接服务器(connect),如果连接成功,这时客户端与服务器端的连接就建立了。客户端发送数据请求,服务器端接收请求并处理请求,然后把回应数据发送给客户端,客户端读取数据,最后关闭连接,一次交互结束
1 2 3 4 5 6 7 8 9 10 11 12 13
| import socket socket.socket(socket_family,socket_type,protocal=0)
tcpSock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
udpSock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
tcpSock = socket(AF_INET, SOCK_STREAM)
|
服务端套接字函数
s.bind() |
绑定(主机,端口号)到套接字 |
s.listen() |
开始TCP监听 |
s.accept() |
被动接受TCP客户的连接,(阻塞式)等待连接的到来 |
客户端套接字函数
s.connect() |
主动初始化TCP服务器连接 |
s.connect_ex() |
connect()函数的扩展版本,出错时返回出错码,而不是抛出异常 |
公共用途的套接字函数
s.recv() |
接收TCP数据 |
s.send() |
发送TCP数据(send在待发送数据量大于己端缓存区剩余空间时,数据丢失,不会发完) |
s.sendall() |
发送完整的TCP数据(本质就是循环调用send,sendall在待发送数据量大于己端缓存区剩余空间时,数据不丢失,循环调用send直到发完) |
s.recvfrom() |
接收UDP数据 |
s.sendto() |
发送UDP数据 |
s.getpeername() |
连接到当前套接字的远端的地址 |
s.getsockname() |
当前套接字的地址 |
s.getsockopt() |
返回指定套接字的参数 |
s.setsockopt() |
设置指定套接字的参数 |
s.close() |
关闭套接字 |
面向锁的套接字方法
s.setblocking() |
设置套接字的阻塞与非阻塞模式 |
s.settimeout() |
设置阻塞套接字操作的超时时间 |
s.gettimeout() |
得到阻塞套接字操作的超时时间 |
面向文件的套接字的函数
s.fileno() |
套接字的文件描述符 |
s.makefile() |
创建一个与该套接字相关的文件 |
第一版,单个客户端与服务端通信
服务端
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
| import socket
phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
phone.bind(('127.0.0.1',8080))
phone.listen(5)
conn, client_addr = phone.accept() print(conn, client_addr, sep='\n')
from_client_data = conn.recv(1024) print(from_client_data.decode('utf-8'))
conn.send(from_client_data.upper())
conn.close()
phone.close()
|
客户端
1 2 3 4 5 6 7 8 9 10 11 12 13
| import socket
phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
phone.connect(('127.0.0.1',8080))
phone.send('hello'.encode('utf-8'))
from_server_data = phone.recv(1024)
print(from_server_data)
phone.close()
|
第二版,通信循环
服务端
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
| import socket
phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM) phone.bind(('127.0.0.1',8080)) phone.listen(5)
conn,client_addr = phone.accept() print(conn,client_addr,sep='\n')
while 1: try: from_client_data = conn.recv(1024) print(from_client_data.decode('utf-8'))
conn.send(from_client_data.upper()) except ConnectionResetError: break
conn.close() phone.close()
|
客户端
1 2 3 4 5 6 7 8 9 10 11 12 13
| import socket
phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM) phone.connect(('127.0.0.1',8080))
while 1: client_data = input('>>> ') phone.send(client_data.encode('utf-8'))
from_server_data = phone.recv(1024) print(from_server_data.decode('utf-8'))
phone.close()
|
第三版, 通信,连接循环
服务端
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
| import socket
phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM) phone.bind(('127.0.0.1',8080)) phone.listen(5)
while 1: conn,client_addr = phone.accept() print(conn,client_addr,sep='\n')
while 1: try: from_client_data = conn.recv(1024) print(from_client_data.decode('utf-8'))
conn.send(from_client_data.upper()) except: break
conn.close() phone.close()
|
客户端
1 2 3 4 5 6 7 8 9 10 11 12 13 14
| import socket
phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM) phone.connect(('127.0.0.1',8080))
while 1: client_data = input('>>> ') phone.send(client_data.encode('utf-8')) if client_data == 'q':break
from_server_data = phone.recv(1024) print(from_server_data.decode('utf-8'))
phone.close()
|
远程执行命令的示例:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
| import socket import subprocess
phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
phone.bind(('127.0.0.1', 8080))
phone.listen(5)
while 1: conn, client_addr = phone.accept() print(client_addr)
while 1: try: cmd = conn.recv(1024) ret = subprocess.Popen(cmd.decode('utf-8'), shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE) correct_msg = ret.stdout.read() error_msg = ret.stderr.read() conn.send(correct_msg + error_msg) except ConnectionResetError: break
conn.close() phone.close()
|
客户端
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
| import socket
phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
phone.connect(('127.0.0.1', 8080))
while 1: cmd = input('>>>') phone.send(cmd.encode('utf-8'))
from_server_data = phone.recv(1024)
print(from_server_data.decode('gbk'))
phone.close()
|
UDP协议下的socket
udp是无链接的,先启动哪一端都不会报错
服务器端先初始化Socket,然后与端口绑定(bind),recvform接收消息,这个消息有两项,消息内容和对方客户端的地址,然后回复消息时也要带着你收到的这个客户端的地址,发送回去,最后关闭连接,一次交互结束
服务端
1 2 3 4 5 6 7
| import socket udp_sk = socket.socket(type=socket.SOCK_DGRAM) udp_sk.bind(('127.0.0.1',9000)) msg,addr = udp_sk.recvfrom(1024) print(msg) udp_sk.sendto(b'hi',addr) udp_sk.close()
|
客户端
1 2 3 4 5 6
| import socket ip_port=('127.0.0.1',9000) udp_sk=socket.socket(type=socket.SOCK_DGRAM) udp_sk.sendto(b'hello',ip_port) back_msg,addr=udp_sk.recvfrom(1024) print(back_msg.decode('utf-8'),addr)
|
类似于qq聊天的代码示例
服务端
1 2 3 4 5 6 7 8 9 10 11
| import socket ip_port=('127.0.0.1',8081) udp_server_sock=socket.socket(socket.AF_INET,socket.SOCK_DGRAM) udp_server_sock.bind(ip_port)
while True: qq_msg,addr=udp_server_sock.recvfrom(1024) print('来自[%s:%s]的一条消息:\033[1;34;43m%s\033[0m' %(addr[0],addr[1],qq_msg.decode('utf-8'))) back_msg=input('回复消息: ').strip()
udp_server_sock.sendto(back_msg.encode('utf-8'),addr)
|
客户端
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29
| import socket BUFSIZE=1024 udp_client_socket=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
qq_name_dic={ 'taibai':('127.0.0.1',8081), 'Jedan':('127.0.0.1',8081), 'Jack':('127.0.0.1',8081), 'John':('127.0.0.1',8081), }
while True: while 1: qq_name=input('请选择聊天对象: ').strip() if qq_name not in qq_name_dic: print('没有这个聊天对象') continue break while True: msg='发给'+ qq_name + ': ' + input('请输入消息,回车发送,输入q结束和他的聊天: ').strip() if msg == 'q':break if not msg:continue udp_client_socket.sendto(msg.encode('utf-8'),qq_name_dic[qq_name])
back_msg,addr=udp_client_socket.recvfrom(BUFSIZE) print('来自[%s:%s]的一条消息:\033[1;34;43m%s\033[0m' %(addr[0],addr[1],back_msg.decode('utf-8')))
udp_client_socket.close()
|
自制时间服务器
服务端
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
| from socket import * from time import strftime import time ip_port = ('127.0.0.1', 9000) bufsize = 1024
tcp_server = socket(AF_INET, SOCK_DGRAM) tcp_server.setsockopt(SOL_SOCKET,SO_REUSEADDR,1) tcp_server.bind(ip_port)
while True: msg, addr = tcp_server.recvfrom(bufsize) print('===>', msg.decode('utf-8')) stru_time = time.localtime() if not msg: time_fmt = '%Y-%m-%d %X' else: time_fmt = msg.decode('utf-8') back_msg = strftime(time_fmt,stru_time) print(back_msg,type(back_msg)) tcp_server.sendto(back_msg.encode('utf-8'), addr)
tcp_server.close()
|
客户端
1 2 3 4 5 6 7 8 9 10 11 12
| from socket import * ip_port=('127.0.0.1',9000) bufsize=1024
tcp_client=socket(AF_INET,SOCK_DGRAM)
while True: msg=input('请输入时间格式(例%Y %m %d)>>: ').strip() tcp_client.sendto(msg.encode('utf-8'),ip_port)
data=tcp_client.recv(bufsize) print('当前日期:',str(data,encoding='utf-8'))
|
粘包
每个 socket 被创建后,都会分配两个缓冲区,输入缓冲区和输出缓冲区。
write()/send() 并不立即向网络中传输数据,而是先将数据写入缓冲区中,再由TCP协议将数据从缓冲区发送到目标机器。一旦将数据写入到缓冲区,函数就可以成功返回,不管它们有没有到达目标机器,也不管它们何时被发送到网络,这些都是TCP协议负责的事情。
TCP协议独立于 write()/send() 函数,数据有可能刚被写入缓冲区就发送到网络,也可能在缓冲区中不断积压,多次写入的数据被一次性发送到网络,这取决于当时的网络情况、当前线程是否空闲等诸多因素,不由程序员控制。
read()/recv() 函数也是如此,也从输入缓冲区中读取数据,而不是直接从网络中读取。
这些I/O缓冲区特性可整理如下:
- I/O缓冲区在每个TCP套接字中单独存在;
- I/O缓冲区在创建套接字时自动生成;
- 即使关闭套接字也会继续传送输出缓冲区中遗留的数据;
- 关闭套接字将丢失输入缓冲区中的数据。
两种情况下会发生粘包
- 接收方没有及时接收缓冲区的包,造成多个包接收(客户端发送了一段数据,服务端只收了一小部分,服务端下次再收的时候还是从缓冲区拿上次遗留的数据,产生粘包)
服务端
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
| import socket import subprocess
phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
phone.bind(('127.0.0.1', 8080))
phone.listen(5)
while 1: conn, client_addr = phone.accept() print(client_addr)
while 1: try: cmd = conn.recv(1024) ret = subprocess.Popen(cmd.decode('utf-8'), shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE) correct_msg = ret.stdout.read() error_msg = ret.stderr.read() conn.send(correct_msg + error_msg) except ConnectionResetError: break
conn.close() phone.close()
|
客户端
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
| import socket
phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
phone.connect(('127.0.0.1',8080))
while 1: cmd = input('>>>') phone.send(cmd.encode('utf-8'))
from_server_data = phone.recv(1024)
print(from_server_data.decode('gbk'))
phone.close()
|
- 发送端需要等缓冲区满才发送出去,造成粘包(发送数据时间间隔很短,数据也很小,会合到一起,产生粘包)
服务端
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
| import socket
phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
phone.bind(('127.0.0.1', 8080))
phone.listen(5)
conn, client_addr = phone.accept()
frist_data = conn.recv(1024) print('1:',frist_data.decode('utf-8')) second_data = conn.recv(1024) print('2:',second_data.decode('utf-8'))
conn.close() phone.close()
|
客户端
1 2 3 4 5 6 7 8 9 10
| import socket
phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
phone.connect(('127.0.0.1', 8080))
phone.send(b'hello') phone.send(b'world')
phone.close()
|
粘包的解决方案
struct模块
该模块可以把一个类型,如数字,转成固定长度的bytes
1 2 3 4 5 6 7 8 9 10
| import struct
ret = struct.pack('i', 183346) print(ret, type(ret), len(ret))
ret1 = struct.unpack('i',ret)[0] print(ret1, type(ret1), len(ret1))
|
方案一:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40
| import socket import subprocess import struct
phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
phone.bind(('127.0.0.1', 8080))
phone.listen(5)
while 1: conn, client_addr = phone.accept() print(client_addr)
while 1: try: cmd = conn.recv(1024) ret = subprocess.Popen(cmd.decode('utf-8'), shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE) correct_msg = ret.stdout.read() error_msg = ret.stderr.read()
total_size = len(correct_msg) + len(error_msg) header = struct.pack('i', total_size)
conn.send(header)
conn.send(correct_msg) conn.send(error_msg) except ConnectionResetError: break
conn.close() phone.close()
|
客户端
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
| import socket import struct
phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
phone.connect(('127.0.0.1', 8080))
while 1: cmd = input('>>>').strip() if not cmd: continue phone.send(cmd.encode('utf-8'))
header = phone.recv(4)
total_size = struct.unpack('i', header)[0]
recv_size = 0 res = b''
while recv_size < total_size: recv_data = phone.recv(1024) res += recv_data recv_size += len(recv_data)
print(res.decode('gbk'))
phone.close()
|
方案二:可自定制报头
整个流程的大致解释:
我们可以把报头做成字典,字典里包含将要发送的真实数据的描述信息(大小啊之类的),然后json序列化,然后用struck将序列化后的数据长度打包成4个字节。
我们在网络上传输的所有数据 都叫做数据包,数据包里的所有数据都叫做报文,报文里面不止有你的数据,还有ip地址、mac地址、端口号等等,其实所有的报文都有报头,这个报头是协议规定的,看一下
发送时:
先发报头长度
再编码报头内容然后发送
最后发真实内容
接收时:
先手报头长度,用struct取出来
根据取出的长度收取报头内容,然后解码,反序列化
从反序列化的结果中取出待取数据的描述信息,然后去取真实的数据内容
服务端
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52
| import socket import subprocess import struct import json
phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
phone.bind(('127.0.0.1', 8080))
phone.listen(5)
while 1: conn, client_addr = phone.accept() print(client_addr)
while 1: try: cmd = conn.recv(1024) ret = subprocess.Popen(cmd.decode('utf-8'), shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE) correct_msg = ret.stdout.read() error_msg = ret.stderr.read()
total_size = len(correct_msg) + len(error_msg)
header_dict = { 'md5': 'fdsaf2143254f', 'file_name': 'f1.txt', 'total_size': total_size, }
header_dict_json = json.dumps(header_dict) bytes_headers = header_dict_json.encode('utf-8')
header_size = len(bytes_headers)
header = struct.pack('i', header_size)
conn.send(header)
conn.send(bytes_headers)
conn.send(correct_msg) conn.send(error_msg) except ConnectionResetError: break
conn.close() phone.close()
|
客户端
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36
| import socket import struct import json
phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
phone.connect(('127.0.0.1', 8080))
while 1: cmd = input('>>>').strip() if not cmd: continue phone.send(cmd.encode('utf-8'))
header_size = struct.unpack('i', phone.recv(4))[0]
header_bytes = phone.recv(header_size)
header_dict = json.loads(header_bytes.decode('utf-8'))
total_size = header_dict['total_size']
recv_size = 0 res = b''
while recv_size < total_size: recv_data = phone.recv(1024) res += recv_data recv_size += len(recv_data)
print(res.decode('gbk'))
phone.close()
|
FTP上传下载文件的代码(简单版)
服务端
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29
| import socket import struct import json sk = socket.socket()
buffer = 1024 sk.bind(('127.0.0.1',8090)) sk.listen()
conn,addr = sk.accept()
head_len = conn.recv(4) head_len = struct.unpack('i',head_len)[0] json_head = conn.recv(head_len).decode('utf-8') head = json.loads(json_head) filesize = head['filesize'] with open(head['filename'],'wb') as f: while filesize: if filesize >= buffer: content = conn.recv(buffer) f.write(content) filesize -= buffer else: content = conn.recv(buffer) f.write(content) break
conn.close() sk.close()
|
客户端
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44
| import os import json import socket import struct sk = socket.socket() sk.connect(('127.0.0.1',8090)) buffer = 1024 head = { 'filepath':r'C:\Users\Aaron\Desktop\新建文件夹', 'filename':'config', 'filesize':None, }
file_path = os.path.join(head['filepath'],head['filename']) filesize = os.path.getsize(file_path) head['filesize'] = filesize
json_head = json.dumps(head) bytes_head = json_head.encode('utf-8') print(json_head) print(bytes_head)
head_len = len(bytes_head) pack_len = struct.pack('i',head_len) print(head_len) print(pack_len) sk.send(pack_len) sk.send(bytes_head)
with open(file_path,'rb') as f: while filesize: if filesize >= buffer: content = f.read(buffer) sk.send(content) filesize -= buffer else: content = f.read(filesize) sk.send(content) break
sk.close()
|