一、引子
先大概浏览一下网络模型
网络模型一般是指 OSI 七层参考模型和 TCP/IP 五层参考模型。
每一层实现各自的功能和协议，并且都为上一层提供业务功能。为了提供这种业务功能，下一层将上一层中的数据并入到本层的数据域中，然后通过加入报头或报尾来实现该层业务功能，该过程叫做数据封装。用户的数据要经过一次次包装，最后转化成可以在网络上传输的信号，发送到网络上。当到达目标计算机后，再执行相反的数据拆包过程。
物理层： 主要定义物理设备标准，如网线的接口类型、光纤的接口类型、各种传输介质的传输速率等。
主要作用是将数据最终编码为用 0、1 标识的比特流，通过物理介质传输，这一层的数据叫做比特。
数据链路层：主要将接收到的数据进行 MAC 地址（网卡地址）的封装与解封装。
常把这一层的数据叫做帧。这一层常工作的设备是交换机。
网络层：主要将接收到的数据进行 IP 地址的封装与解封装。
常把这一层的数据叫做数据包。这一层设备是路由器。
传输层：定义了一些数据传输的协议和端口号。
主要将接收的数据进行分段和传输，到达目的地址后在进行重组。常把这一层的数据叫做段。
会话层：通过传输层建立数据传输的通路。
主要在系统之间发起会话或者接收会话请求。
表示层：主要进行对接收数据的解释、加密与解密、压缩与解压缩。
确保一个系统的应用层发送的数据能被另一个系统的应用层识别。
应用层：主要是为一些终端应用程序提供服务。直接面对着用户的。
二、socket概念
socket本质上就是在2台网络互通的电脑之间，架设一个通道，两台电脑通过这个通道来实现数据的互相传递。 我们知道网络 通信 都 是基于 ip+port 方能定位到目标的具体机器上的具体服务，操作系统有0-65535个端口，每个端口都可以独立对外提供服务，如果 把一个公司比做一台电脑 ，那公司的总机号码就相当于ip地址， 每个员工的分机号就相当于端口， 你想找公司某个人，必须 先打电话到总机，然后再转分机 。
建立一个socket必须至少有2端， 一个服务端，一个客户端， 服务端被动等待并接收请求，客户端主动发起请求， 连接建立之后，双方可以互发数据。
三、Socket 参数方法
socket(family,type[,protocal]) 使用给定的地址族、套接字类型、协议编号（默认为0）来创建套接字。
| sk = socket.socket(socket.AF_INET,socket.SOCK_STREAM,0)
sk.bind(address) sk.listen(backlog) sk.setblocking(bool) sk.accept() sk.connect(address) sk.connect_ex(address) sk.close() sk.recv(bufsize[,flag]) sk.recvfrom(bufsize[.flag]) sk.send(string[,flag]) sk.sendall(string[,flag]) sk.sendto(string[,flag],address) sk.settimeout(timeout) sk.getpeername() sk.getsockname() sk.fileno() | |
|
发送文件 ，但目前多数情况下并无什么用。 |
四、Socket编程思路
TCP服务端：
1 创建套接字，绑定套接字到本地IP与端口
# socket.socket(socket.AF_INET,socket.SOCK_STREAM) , s.bind()
2 开始监听连接 #s.listen()
3 进入循环，不断接受客户端的连接请求 #s.accept()
4 然后接收传来的数据，并发送给对方数据 #s.recv() , s.sendall()
5 传输完毕后，关闭套接字 #s.close()
TCP客户端:
1 创建套接字，连接远端地址
# socket.socket(socket.AF_INET,socket.SOCK_STREAM) , s.connect()
2 连接后发送数据和接收数据 # s.sendall(), s.recv()
3 传输完毕后，关闭套接字 #s.close()
先简单实现一个socket传输实例，需要分别实现一个服务端与客户端,服务端可以将客户端传过来的字母转换为大写然后传给客户端
SocketServer.py
import subprocess
import socket
server = socket.socket()#获得socket实例
server.bind(('localhost',6969)) #绑定要监听ip port端口
server.listen(5) #监听
print("等待客户端的连接...")
while True:
conn, addr = server.accept() # #接受并建立与客户端的连接,程序在此处开始阻塞,只到有客户端连接进来...conn就是客户端连过来而在服务器端为其生成的一个连接实例
print("新连接:",addr )
while True:
data = conn.recv(1024)
print("recv:",data)
if not data:#防止客户端断开后，服务端死循环
print("client has lost...")
break
# res = subprocess.getoutput(data).read()
# conn.send(res)
print("收到消息:",data)
conn.send(data.upper())
server.close()SocketClient.py
import socket
client = socket.socket()#声明socket类型，同时生成socket连接对象
client.connect(("localhost",9998)) #连接服务端
while True: #支持多次交互
msg = input(">>:").strip()
if len(msg) == 0:continue
client.send( msg.encode("utf-8") )
data = client.recv(1024)
print("来自服务器:",data.decode())
client.close()
注意了， 此时服务器端依然只能同时为一个客户服务，其他客户来了，得排队(连接挂起)。
五、SocketServer实现并发
The socketserver module simplifies the task of writing network servers.
There are four basic concrete server classes:
class socketserver.TCPServer(server_address, RequestHandlerClass, bind_and_activate=True)
This uses the Internet TCP protocol, which provides for continuous streams of data between the client and server. If bind_and_activate is true, the constructor automatically attempts to invoke server_bind() andserver_activate(). The other parameters are passed to the BaseServer base class.
class socketserver.UDPServer(server_address, RequestHandlerClass, bind_and_activate=True)
This uses datagrams, which are discrete packets of information that may arrive out of order or be lost while in transit. The parameters are the same as for TCPServer.
class socketserver.UnixStreamServer(server_address, RequestHandlerClass, bind_and_activate=True)
class socketserver.UnixDatagramServer(server_address, RequestHandlerClass,bind_and_activate=True)
These more infrequently used classes are similar to the TCP and UDP classes, but use Unix domain sockets; they’re not available on non-Unix platforms. The parameters are the same as for TCPServer.
These four classes process requests synchronously; each request must be completed before the next request can be started. This isn’t suitable if each request takes a long time to complete, because it requires a lot of computation, or because it returns a lot of data which the client is slow to process. The solution is to create a separate process or thread to handle each request; the ForkingMixIn and ThreadingMixIn mix-in classes can be used to support asynchronous behaviour.
There are five classes in an inheritance diagram, four of which represent synchronous servers of four types:
+------------+
| BaseServer |
+------------+
|
v
+-----------+ +------------------+
| TCPServer |------->| UnixStreamServer |
+-----------+ +------------------+
|
v
+-----------+ +--------------------+
| UDPServer |------->| UnixDatagramServer |
+-----------+ +--------------------+
Note that UnixDatagramServer derives from UDPServer, not from UnixStreamServer — the only difference between an IP and a Unix stream server is the address family, which is simply repeated in both Unix server classes.
class socketserver.ForkingMixIn
class socketserver.ThreadingMixIn
Forking and threading versions of each type of server can be created using these mix-in classes. For instance, ThreadingUDPServer is created as follows:
class ThreadingUDPServer(ThreadingMixIn, UDPServer):
pass
The mix-in class comes first, since it overrides a method defined in UDPServer. Setting the various attributes also changes the behavior of the underlying server mechanism.
class socketserver.ForkingTCPServer
class socketserver.ForkingUDPServer
class socketserver.ThreadingTCPServer
class socketserver.ThreadingUDPServer
These classes are pre-defined using the mix-in classes.
Request Handler Objects
class socketserver.BaseRequestHandler
This is the superclass of all request handler objects. It defines the interface, given below. A concrete request handler subclass must define a new handle() method, and can override any of the other methods. A new instance of the subclass is created for each request.
setup()
Called before the handle() method to perform any initialization actions required. The default implementation does nothing.
handle()
This function must do all the work required to service a request. The default implementation does nothing. Several instance attributes are available to it; the request is available as self.request; the client address as self.client_address; and the server instance as self.server, in case it needs access to per-server information.
The type of self.request is different for datagram or stream services. For stream services,self.request is a socket object; for datagram services, self.request is a pair of string and socket.
finish()
Called after the handle() method to perform any clean-up actions required. The default implementation does nothing. If setup() raises an exception, this function will not be called.
创建socketsever
1，First, you must create a request handler处理类 class by subclassing the BaseRequestHandler class and overriding覆盖 its handle() method; this method will process incoming requests.
你必须自己创建一个请求处理类，并且这个类要继承BaseRequestHandler,并且还有重写父类里的handle()
2，Second, you must instantiate实例化 one of the server classes, passing it the server’s address and the request handler class.
你必须实例化TCPServer ，并且传递server ip 和 你上面创建的请求处理类 给这个TCPServer
3，Then call the handle_request() or serve_forever() method of the server object to process one or many requests.
server.handle_request() #只处理一个请求
server.serve_forever() #处理多个一个请求，永远执行
4，Finally, call server_close() to close the socket.
socketserver.TCPServer Example
server side
import socketserver
class MyTCPHandler(socketserver.BaseRequestHandler):
"""
The request handler class for our server.
It is instantiated once per connection to the server, and must
override the handle() method to implement communication to the client.
"""
def handle(self):
while True:
self.data = self.request.recv(1024).strip()
print("{} wrote:".format(self.client_address[0]))
print(self.data)
if not self.data:
print(self.client_address,"断开了")
break
# just send back the same data, but upper-cased
self.request.sendall(self.data.upper())
if __name__ == "__main__":
HOST, PORT = "localhost", 9999
# Create the server, binding to localhost on port 9999
server = socketserver.TCPServer((HOST, PORT), MyTCPHandler)
# Activate the server; this will keep running until you
# interrupt the program with Ctrl-C
server.serve_forever()client side
import socket
import sys
HOST, PORT = "localhost", 9999
data = " ".join(sys.argv[1:])
# Create a socket (SOCK_STREAM means a TCP socket)
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
try:
# Connect to server and send data
sock.connect((HOST, PORT))
sock.sendall(bytes(data + "\n", "utf-8"))
# Receive data from the server and shut down
received = str(sock.recv(1024), "utf-8")
finally:
sock.close()
print("Sent: {}".format(data))
print("Received: {}".format(received))| 上面这个例子你会发现，依然不能实现多并发，在server端做一下更改就可以了，客户端每连进一个来，服务器端就会分配一个新的线程来处理这个客户端的请求 |
把
| 1 |
|
改成
| 1 |
|
六、实现一个简单的SSH
import socket,os,time
server = socket.socket() #1实例化socket
server.bind(('localhost',9999) ) #2绑定端口
server.listen() #3监听
while True:
conn, addr = server.accept()
print("new conn:",addr)
while True:
print("等待新指令")
data = conn.recv(1024)
if not data:
print("客户端已断开")
break
print("执行指令:",data)
cmd_res = os.popen(data.decode()).read() #接受字符串，执行结果也是字符串
print("before send",len(cmd_res))
if len(cmd_res) == 0:
cmd_res = "cmd has no output..."
conn.send(str(len(cmd_res.encode())).encode("utf-8")) #先发大小给客户端
# time.sleep(0.5) #否则上下两个send操作会粘包
client_atk = conn.recv(1024); #wait client to confirm
print("ack from client:",client_atk)
conn.send(cmd_res.encode("utf-8"))
print("send done")
# os.path.isfile()
# os.stat("sock")
server.close()import socket
client = socket.socket()
#client.connect(('192.168.16.200',9999))
client.connect(('localhost',9999))
while True:
cmd = input(">>:").strip()
if len(cmd) == 0: continue
client.send(cmd.encode("utf-8"))
cmd_res_size = client.recv(1024) #接受命令结果的长度
print("命令结果大小:",cmd_res_size)
client.send("准备好接收，可以发送".encode("utf-8"))
received_size = 0
received_data = b''
while received_size < int(cmd_res_size.decode()) :
data = client.recv(1024)
received_size += len(data) #每次收到的有可能小于1024，所以必须用len判断
#print(data.decode())
received_data += data
else:
print("cmd res receive done...",received_size)
print(received_data.decode())
client.close()
七、利用socket进行文件、图片等传输
传输文件主要分以下两步：
- 将要传输的文件的基本信息发送到接收端（文件名、大小等其他信息）
- 发送端读取文件内容并发送过去,接受端将缓存里面的内容写入文件
注：以下发送文件代码参考：http://www.mamicode.com/info-detail-1346172.html
发送端代码
#!/usr/bin/env python
# -*- coding=utf-8 -*-
"""
file: send.py
socket client
"""
import socket
import os
import sys
import struct
def socket_client():
try:
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect(('127.0.0.1', 6666))
except socket.error as msg:
print msg
sys.exit(1)
print s.recv(1024)
while 1:
filepath = raw_input('please input file path: ')
if os.path.isfile(filepath):
# 定义定义文件信息。128s表示文件名为128bytes长，l表示一个int或log文件类型，在此为文件大小
fileinfo_size = struct.calcsize('128sl')
# 定义文件头信息，包含文件名和文件大小
fhead = struct.pack('128sl', os.path.basename(filepath),
os.stat(filepath).st_size)
s.send(fhead)
print 'client filepath: {0}'.format(filepath)
fp = open(filepath, 'rb')
while 1:
data = fp.read(1024)
if not data:
print '{0} file send over...'.format(filepath)
break
s.send(data)
s.close()
break
if __name__ == '__main__':
socket_client()
接收端代码
#!/usr/bin/env python
# -*- coding=utf-8 -*-
"""
file: recv.py
socket service
"""
import socket
import threading
import time
import sys
import os
import struct
def socket_service():
try:
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
s.bind(('127.0.0.1', 6666))
s.listen(10)
except socket.error as msg:
print msg
sys.exit(1)
print 'Waiting connection...'
while 1:
conn, addr = s.accept()
t = threading.Thread(target=deal_data, args=(conn, addr))
t.start()
def deal_data(conn, addr):
print 'Accept new connection from {0}'.format(addr)
#conn.settimeout(500)
conn.send('Hi, Welcome to the server!')
while 1:
fileinfo_size = struct.calcsize('128sl')
buf = conn.recv(fileinfo_size)
if buf:
filename, filesize = struct.unpack('128sl', buf)
fn = filename.strip('\00')
new_filename = os.path.join('./', 'new_' + fn)
print 'file new name is {0}, filesize if {1}'.format(new_filename,
filesize)
recvd_size = 0 # 定义已接收文件的大小
fp = open(new_filename, 'wb')
print 'start receiving...'
while not recvd_size == filesize:
if filesize - recvd_size > 1024:
data = conn.recv(1024)
recvd_size += len(data)
else:
data = conn.recv(filesize - recvd_size)
recvd_size = filesize
fp.write(data)
fp.close()
print 'end receive...'
conn.close()
break
if __name__ == '__main__':
socket_service()- 打开两个终端，分别运行
recv.py和send.py脚本，输入待传输文件的全路径和文件名（如：/home/test.txt），你就会在recv.py脚本路径下看到刚输入的传输文件，且文件名为new_****。
https://www.cnblogs.com/fanweibin/p/5053328.html
扫一扫
2163
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
