码迷,mamicode.com
首页 > 其他好文 > 详细

socket 套接字

时间:2017-05-14 23:38:30      阅读:292      评论:0      收藏:0      [点我收藏+]

标签:for   优化算法   就会   odi   切换目录   面向连接   端口   上传下载   put   

套接字基础

c/s架构        client ---------internet------------server
server端:
力求一直提供服务
要绑定一个唯一的地址,让客户端能够明确的找到

客户端/服务器基于网络进行通信,所以要遵询互联网协议
ios五层协议:图

TCP/IP协议族包括传输层、网络层、链路层
tcp协议传输数据: 以太网头 + IP头 + tcp头 + 数据
udp协议传输数据: 以太网头 + IP头 + udp头 + 数据

socket是什么:
定义:源IP地址和目的IP地址以及源端口号和目的端口号的组合称为套接字。其用于标识客户端请求的服务器和服务。

Socket是应用层与TCP/IP协议族通信的中间软件抽象层,它是一组接口。在设计模式中,Socket其实就是一个门面模式,
它把复杂的TCP/IP协议族隐藏在Socket接口后面,对用户来说,一组简单的接口就是全部,让Socket去组织数据,以符合指定的协议。
所以,我们无需深入理解tcp/udp协议,socket已经为我们封装好了,我们只需要遵循socket的规定去编程,
写出的程序自然就是遵循tcp/udp标准的。

socket=ip+port,ip是用来标识互联网中的一台主机的位置,而port是用来标识这台机器上的一个应用程序,ip地址是配置到网卡
上的,而port是应用程序开启的,ip与port的绑定就标识了互联网中独一无二的一个应用程序

socket工作流程:
先从服务器端说起。服务器端先初始化Socket,然后与端口绑定(bind),对端口进行监听(listen),调用accept阻塞,等待客户端连接。
在这时如果有个客户端初始化一个Socket,然后连接服务器(connect),如果连接成功,这时客户端与服务器端的连接就建立了。
客户端发送数据请求,服务器端接收请求并处理请求,然后把回应数据发送给客户端,客户端读取数据,最后关闭连接,一次交互结束
技术分享
 1 #基于tcp的服务端
 2 import socket
 3 phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
 4 phone.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
 5 phone.bind((127.0.0.1,8080))
 6 phone.listen(5)
 7 
 8 print(start.....)
 9 while True:#链接循环        一台客户端中断链接时,不至于服务端也停止运行
10     conn,addr = phone.accept()       #等待电话链接
11     print(电话线路是,conn)
12     print(客户端手机号,addr)
13     while True:# 通信循环
14         try:         #应对windows系统
15             #print("等待接收")
16             data = conn.recv(1024)
17             if not data : break           #应对linux系统  #如果不加,那么正在链接的客户端突然断开,recv便不再阻塞,死循环发生
18             print(客户端发来的消息,data.decode(utf8))
19             s =  input("....")
20             conn.send(s.encode(utf8))
21         except Exception:
22             break
23     conn.close()
24 phone.close()
View Code
技术分享
 1 #基于tcp的客户端
 2 import socket
 3 phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
 4 phone.connect((127.0.0.1,8080))
 5 
 6 while True:
 7     msg = input(>> :).strip()
 8     if not msg: continue
 9     phone.send(msg.encode(utf8))
10     print(has send=========>)
11     data = phone.recv(1024)
12     print(has recv==========>)
13     print(data)
14 
15 
16 phone.close()
View Code

 



1.tcp协议:

(1)如果收消息缓冲区里的数据为空,那么recv就会阻塞(阻塞很简单,就是一直在等着收)

(2)只不过tcp协议的客户端send一个空数据就是真的空数据,客户端即使有无穷个send空,也跟没有一个样。

(3)tcp基于链接通信

基于链接,则需要listen(backlog),指定半连接池的大小
基于链接,必须先运行的服务端,然后客户端发起链接请求
对于mac系统:如果一端断开了链接,那另外一端的链接也跟着完蛋recv将不会阻塞,收到的是空(解决方法是:服务端在收消息后加上
if判断,空消息就break掉通信循环)
对于windows/linux系统:如果一端断开了链接,那另外一端的链接也跟着完蛋recv将不会阻塞,收到的是空(解决方法是:服务端通信
循环内加异常处理,捕捉到异常后就break掉通讯循环)

技术分享
#基于udp的服务端
from socket import *
ip_port = (127.0.0.1,8080)
Bufsize = 1024
t = socket(AF_INET,SOCK_DGRAM)
t.bind(ip_port)
while True:
    msg,addr = t.recvfrom(Bufsize)
    print(msg.decode(utf8),addr)
    msg = input(>> :).strip()
    t.sendto(msg.encode(utf8),addr)
View Code
技术分享
 1 #基于udp的客户端
 2 from socket import *
 3 ip_port = (127.0.0.1,8080)
 4 Bufsize = 1024
 5 t = socket(AF_INET,SOCK_DGRAM)
 6 
 7 
 8 while True:
 9     msg = input(>>:).strip()
10     # if not msg:continue
11     t.sendto(msg.encode(utf8),ip_port)
12 
13     back_msg,addr = t.recvfrom(Bufsize)
14     print(back_msg.decode(utf8),addr)
15 
16 # send(bytes_data):发送数据流,数据流bytes_data若为空,自己这段的缓冲区也为空,操作系统不会控制tcp协议发空包
17 # sendinto(bytes_data,ip_port):发送数据报,bytes_data为空,还有ip_port,所有即便是发送空的bytes_data,数据报其实也
18 # 不是空的,自己这端的缓冲区收到内容,操作系统就会控制udp协议发包。
View Code

 


2.udp协议

(1)如果如果收消息缓冲区里的数据为“空”,recvfrom也会阻塞

(2)只不过udp协议的客户端sendinto一个空数据并不是真的空数据(包含:空数据+地址信息,得到的报仍然不会为空),所以客户端
只要有一个sendinto(不管是否发送空数据,都不是真的空数据),服务端就可以recvfrom到数据。

(3)udp无链接

无链接,因而无需listen(backlog),更加没有什么连接池之说了
无链接,udp的sendinto不用管是否有一个正在运行的服务端,可以己端一个劲的发消息,只不过数据丢失
recvfrom收的数据小于sendinto发送的数据时,在mac和linux系统上数据直接丢失,在windows系统上发送的比接收的大直接报错
只有sendinto发送数据没有recvfrom收数据,数据丢失

####################发消息,都是将数据发送到己端的发送缓冲中,收消息都是从己端的缓冲区中收
只有TCP有粘包现象,UDP永远不会粘包

两种情况下会发生粘包:
11发送端需要等缓冲区满才发送出去,造成粘包(发送数据时间间隔很短,数据了很小,会合到一起,产生粘包)
22接收方不及时接收缓冲区的包,造成多个包接收(客户端发送了一段数据,服务端只收了一小部分,服务端下次再收的时候还是从
缓冲区拿上次遗留的数据,产生粘包)


TCP(transport control protocol,传输控制协议)是面向连接的,面向流的,提供高可靠性服务。收发两端(客户端和服务器端)都
要有一一成对的socket,因此,发送端为了将多个发往接收端的包,更有效的发到对方,使用了优化方法(Nagle算法),将多次间隔较
小且数据量小的数据,合并成一个大的数据块,然后进行封包。这样,接收端,就难于分辨出来了,必须提供科学的拆包机制。
即面向流的通信是无消息保护边界的。

UDP(user datagram protocol,用户数据报协议)是无连接的,面向消息的,提供高效率服务。不会使用块的合并优化算法,, 由于
UDP支持的是一对多的模式,所以接收端的skbuff(套接字缓冲区)采用了链式结构来记录每一个到达的UDP包,在每个UDP包中就有了消
息头(消息来源地址,端口等信息),这样,对于接收端来说,就容易进行区分处理了。 即面向消息的通信是有消息保护边界的。

发送方引起的粘包是由TCP协议本身造成的,TCP为提高传输效率,发送方往往要收集到足够多的数据后才发送一个TCP段。若连续几次
需要send的数据都很少,通常TCP会根据优化算法把这些数据合成一个TCP段后一次发送出去,这样接收方就收到了粘包数据

所谓粘包问题主要还是因为接收方不知道消息之间的界限,不知道一次性提取多少字节的数据所造成的。
技术分享
 1 import socket,time
 2 
 3 phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
 4 #绑定电话卡
 5 ip_port=(127.0.0.1,8080)
 6 phone.bind(ip_port)
 7 phone.listen(5)
 8 conn,addr=phone.accept()
 9 
10 data1=conn.recv(1024)
11 print(第一个包,data1)
12 data2=conn.recv(1024)
13 print(第二个包,data2)
14 
15 
16 data1=conn.recv(1) #b‘h‘
17 print(第一个包,data1)
18 time.sleep(5)                      #利用time来解决粘包问题
19 data2=conn.recv(1024) #b‘elloworldSB‘
20 print(第二个包,data2)
View Code
技术分享
 1 import socket,time
 2 
 3 phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
 4 
 5 ip_port=(127.0.0.1,8080)
 6 phone.connect(ip_port)
 7 
 8 
 9 phone.send(helloworld.encode(utf-8))
10 time.sleep(3)              #利用time来解决粘包问题
11 phone.send(SB.encode(utf-8))
View Code
利用struct解决粘包问题
技术分享
 1 from socket import *
 2 import subprocess
 3 import struct
 4 import json
 5 t = socket(AF_INET,SOCK_STREAM)
 6 t.bind((192.168.184.128,8080))
 7 t.listen(5)
 8 
 9 while True:  #链接循环
10     conn,addr = t.accept()
11     while True: # 通信循环
12         try:
13             cmd = conn.recv(1024)
14             if not cmd:break
15             res = subprocess.Popen(cmd.decode(utf8),
16                                    shell = True,
17                                    stdout = subprocess.PIPE,
18                                    stderr= subprocess.PIPE)
19             out_res = res.stdout.read()
20             err_res = res.stderr.read()
21             data_size = len(out_res)+len(err_res)
22             head_dic = {data_size:data_size}
23             head_json = json.dumps(head_dic)
24             head_bytes = head_json.encode(utf8)
25             #发送报头的长度
26             head_len = len(head_bytes)
27             conn.send(struct.pack(i,head_len))  #该模块将一串数字打包以固定长度(4个字节)发送给客户端
28             #发送报头
29             conn.send(head_bytes)
30             #发送数据部分
31             conn.send(out_res) # linux环境中 多个命令用分号隔开的情况
32             conn.send(err_res)
33         except Exception:
34             break
35     conn.close()    #通信完成,关闭链接
36 t.close()
View Code
技术分享
 1 from socket import *
 2 import struct
 3 import json
 4 t =socket(AF_INET,SOCK_STREAM)
 5 t.connect((192.168.184.128,8080))
 6 
 7 while True:  #通信循环
 8     #发消息
 9     cmd = input(>>> :)
10     if not cmd: continue
11     t.send(bytes(cmd,encoding=utf8))
12     #收报头的长度
13     head_struct=t.recv(4)
14     head_len = struct.unpack(i,head_struct)
15     #收报头
16     head_bytes = t.recv(head_len)
17     head_json = head_bytes.decode(utf8)
18 
19     head_dic = json.loads(head_json)
20     print(head_dic)
21     data_size = head_dic[data_size]
22 
23     #收数据
24     recv_size = 0
25     recv_data = b‘‘
26     while recv_size < data_size:
27 
28         data = t.recv(1024)
29         recv_size += len(data)
30         recv_data += data
31     print(recv_data.decode(utf8))         #基于windows的shell 用GBK解码
32                                         #基于linux的shell 用utf8解码
33 
34 t.close()
View Code

模拟远程访问ssh

技术分享
 1 from socket import *
 2 import subprocess
 3 t = socket(AF_INET,SOCK_STREAM) #两个参数   基于网络通信的套接字,基于tcp协议的套接字
 4 t.bind((127.0.0.1,8080)) #绑定唯一一个IP地址和端口号     此处为本地回环地址
 5 t.listen(5)  #开启监听    同时允许最多5个客户端访问
 6 
 7 while True:  #链接循环
 8     conn,addr = t.accept()  #等待客户端链接
 9     while True: # 通信循环
10         try:           #应对windows系统   客户端关闭链接的情况下
11             cmd = conn.recv(1024)  #接收客户端消息    每次接收1024字节的数据
12             if not cmd:break   #应对linux系统   服务器不断的接收空
13             res = subprocess.Popen(cmd.decode(utf8),
14                                    shell = True,
15                                    stdout = subprocess.PIPE,
16                                    stderr= subprocess.PIPE)
17             conn.send(res.stdout.read()) # linux环境中 多个命令用分号隔开的情况
18             conn.send(res.stderr.read())
19 
20 
21             err = res.stderr.read()            #只有一个命令的情况下
22             if err :
23                 cmd_res = err
24             else:
25                 cmd_res = res.stdout.read()
26             conn.send(cmd_res)
27         except Exception:
28             break
29     conn.close()    #通信完成,关闭链接
30 t.close()
View Code
技术分享
 1 from socket import *
 2 t =socket(AF_INET,SOCK_STREAM)
 3 t.connect((192.168.184.128,8280))
 4 
 5 while True:  #通信循环
 6     cmd = input(>>> :)
 7     if not cmd: continue
 8     t.send(cmd.encode(utf8))
 9     data = t.recv(1024)
10     print(data.decode(utf8))         #基于windows的shell 用GBK解码
11                                         #基于linux的shell 用utf8解码
12 
13 t.close()
View Code

tcp协议下的并发问题

技术分享
 1 #服务端
 2 import socketserver
 3 
 4 class Ftpserver(socketserver.BaseRequestHandler):  #通信链接
 5     def handle(self):
 6         print(==========>,self)
 7         print(self.request)                 #self.request  ==   conn
 8         while True:
 9             data = self.request.recv(1024)
10             print(data.decode(utf8))
11             data1 =input(>>)
12             self.request.send(data1.encode(utf8))
13 
14 if __name__ == __main__:
15     obj = socketserver.ThreadingTCPServer((127.0.0.1,8080),Ftpserver)
16     obj.serve_forever()#链接循环
View Code

udp协议下的并发问题

技术分享
 1 import socketserver
 2 class Ftpserver(socketserver.BaseRequestHandler):
 3     def handle(self):
 4         print(self.request)
 5         print(self.client_address)
 6         # msg = input(‘>>>:‘)
 7         self.request[1].sendto(self.request[0],self.client_address)
 8 
 9 if __name__ == __main__:
10     obj = socketserver.ThreadingUDPServer((127.0.0.1,8080),Ftpserver)
11     obj.serve_forever()
View Code

FTP上传下载

1. 用户登陆
2. 上传/下载文件
3. 不同用户家目录不同
4. 查看当前目录下文件
5. 充分使用面向对象知识
6. 用户加密认证
7. 多用户同时登陆
8. 每个用户有自己的家目录且只能访问自己的家目录
9. 对用户进行磁盘配额、不同用户配额可不同
10. 用户可以登陆server后,可切换目录
11. 查看当前目录下文件
12. 上传下载文件,保证文件一致性
13. 传输过程中现实进度条
14. 支持断点续传

 

 




socket 套接字

标签:for   优化算法   就会   odi   切换目录   面向连接   端口   上传下载   put   

原文地址:http://www.cnblogs.com/liuguniang/p/6854353.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!