socket

2018/07/03 23:38
阅读数 9

大致上一切网络皆socket(套接字)

socket是应用层与TCP/IP协议的封装,留给使用者一个编程接口(API借口),用来实现网络上两个进程之间的数据交互,连接的一端称为一个socket。

 

服务端套接字函数:

 

  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.close() 关闭套接字

其它功能:

参数一:地址簇   socket.AF_INET IPv4(默认)   socket.AF_INET6 IPv6   socket.AF_UNIX 只能够用于单一的Unix系统进程间通信 参数二:类型   socket.SOCK_STREAM  流式socket ,
for TCP (默认)   socket.SOCK_DGRAM   数据报式socket , for UDP   socket.SOCK_RAW 原始套接字,普通的套接字无法处理ICMP、IGMP等网络报文,而SOCK_RAW可以;其次,SOCK_RAW也可以处理特殊的IPv4报文;此外,利用原始套接字,可以通过IP_HDRINCL套接字选项由用户构造IP头。   socket.SOCK_RDM 是一种可靠的UDP形式,即保证交付数据报但不保证顺序。SOCK_RAM用来提供对原始协议的低级访问,在需要执行某些特殊操作时使用,如发送ICMP报文。SOCK_RAM通常仅限于高级用户或管理员运行的程序使用。   socket.SOCK_SEQPACKET 可靠的连续数据包服务 参数三:协议   0  (默认)与特定的地址家族相关的协议,如果是 0 ,则系统就会根据地址格式和套接类别,自动选择一个合适的协议

 

 

service端:


import socket
sk = socket.socket()#创建对象
sk.bind(('127.0.0.1',9999,))#绑定地址,内部IP是元祖所以加括号,最好在后面加逗号(表示是元祖)
sk.listen(5)#监听传入连接数最大为5,第6个直接断开
#接收客户端请求

while True:
    conn, address = sk.accept()#接收客户端请求(阻塞),等待连接. conn新的套接字对象接收发送数据,address连接客户端地址
    conn.sendall(bytes("欢迎光临",encoding="utf-8"))#py3需要已字节的形式发送内容,用户连接过来时给他发一条信息
    while True:
        print("正在等待Client输入内容......")
        ret_bytes = conn.recv(1024)#接收客户端发送过来的内容
        ret_str = str(ret_bytes,encoding="utf-8")#转为字符串类型
        print(ret_str)## 输出用户发送过来的内容
        if ret_str == "q":#如果输入q退出
            break
        inp = input("Service请输入要发送的内容>>>")
        conn.sendall(bytes(inp,encoding="utf-8"))#给客户端发送内容
    print(address,conn)

client端:
import socket obj = socket.socket() obj.connect(('127.0.0.1',9999,))#连接到address处的套接字 #recv阻塞等待用户发出去 ret_bytes = obj.recv(1024)#接收数据,因为服务端发送过来的是字节,所以需要把字节转换为字符串进行输出,最大接收1024字节(最大接收1024*8,就是8K),超过下次连接 ret_str = str(ret_bytes,encoding="utf-8") print(ret_str)# 输出内容 while True: inp = input("Client请输入要发送的内容>>> ")#当进入连接的时候,提示让用户输入内容 if inp == "q":#如果输入q则退出 obj.sendall(bytes(inp,encoding="utf-8"))# 把q发送给服务端 break#退出当前while else: obj.sendall(bytes(inp,encoding="utf-8"))#否则就把用户输入的内容发送给用户 print("正在等待Server输入内容......")#等待服务端回答 ret = str(obj.recv(1024),encoding="utf-8")#获取服务端发送过来的结果 print(ret) obj.close()#连接完成之后关闭链接

 socket上传文件

server:
import socket

sk = socket.socket()
sk.bind(("127.0.0.1",9999,))
sk.listen(5)
while True:
    conn, address = sk.accept()
    conn.sendall(bytes("欢迎登陆老男孩FTP",encoding="utf-8"))
    file_size = str(conn.recv(1024),encoding="utf-8")
    print(file_size)
    total_size = int(file_size)
    has_recv = 0
    f = open("new.jpg","wb")#上传的新文件
    while True:
        if total_size == has_recv:
            break
        data = conn.recv(1024)
        f.write(data)
        has_recv += len(data)
    f.close()


client:

import  socket, os
obj = socket.socket()
obj.connect(("127.0.0.1",9999,))
ret_bytes = obj.recv(1024)
ret_str = str(ret_bytes,encoding="utf-8")
print(ret_str)

size = os.stat("f.jpg").st_size#获取图片的字节大小
obj.sendall(bytes(str(size), encoding="utf-8"))

with open("f.jpg","rb") as f:
    for line in f :
        obj.sendall(line)
obj.close()

粘包:

只有TCP有粘包现象,UDP永远不会粘包。

TCP(传输控制协议)是面向连接,提供高可靠性服务。收发两端(客户端和服务器端)都要有一一成对的socket,发送端为了将多个发往接收端的包,更有效的发到对方,使用了优化方法(Nagle算法),将多次间隔较小且数据量小的数据,合并成一个大的数据块,然后进行封包。这样,接收端,就难于分辨出来了,就会粘包

UDP(用户数据报协议)是无连接的,面向消息的,提供高效率服务。不会使用块的合并优化算法,, 由于UDP支持的是一对多的模式.会丢数据,不可靠
 
tcp的协议数据不会丢,没有收完包,下次接收,会继续上次继续接收,己端总是在收到ack时才会清除缓冲区内容。数据是可靠的,但是会粘包。

两种情况下会发生粘包:

1.发送端需要等本机的缓冲区满了以后才发送出去,造成粘包(发送数据时间间隔很端,数据很小,会合在一个起,产生粘包)

2.接收端不及时接收缓冲区的包,造成多个包接受(客户端发送一段数据,服务端只收了一小部分,服务端下次再收的时候还是从缓冲区拿上次遗留的数据 ,就产生粘包)

解决粘包方法:

为字节流加上自定义固定长度报头,报头中包含字节流长度,然后依次send到对端,对端在接受时,先从缓存中取出定长的报头,然后再取真实数据。

  使用struct模块

  该模块可以把一个类型,如数字,转成固定长度的bytes字节

  >>> res=struct.pack('i',1111111111111)  #打包成固定长度的bytes

  >>> struct.unpack(“I”,res)             #解包

#服务端
import struct   #导入模块
import socket   #导入模块
import json     #导入模块
import subprocess   #导入模块
din=socket.socket(socket.AF_INET,socket.SOCK_STREAM)   #基于网络家族以流的方式创建一个链接路
ip=('127.0.0.1',8080)  #设定服务端唯一的地址
din.bind(ip)  #绑定地址
din.listen(5)  #激活启动,设置链接池最大缓数量
while True:
    conn,addr=din.accept()   #等待接受数据链接
    print('------->>>')
    while True:
        try:   #开始捕捉异常,在windows中使用
            dr=conn.recv(1024)   #接收内容并赋值给dr
            res=subprocess.Popen(dr.decode('utf-8'),shell=True,stdout=subprocess.PIPE,stderr=subprocess.PIPE)   #设置一个管道,把对的内容一个对的管道中,把错误的放进一个错误的管道中。
            dui=res.stdout.read()  #读取标准输出的内容并赋值给dui
            cuo=res.stderr.read()  #读取错误输出的内容并赋值给cuo
            data_lik=len(dui)+len(cuo)  #计算标准输出和错误输出的总长度并赋值给data_lik
            head_dic={'data_lik':data_lik}  #自己顶一个字典 并赋值给head_dic
            head_json=json.dumps(head_dic)  #把自己定义的字典进行一个序列化
            head_bytes=head_json.encode('utf-8')  #把序列化后的内容进行转码 ,因为网络传输都是通过字节进行传输
            head_len=len(head_bytes)  #把转换成字节码的长度拿到 并赋值给head_len
            #发送报头长度
            conn.send(struct.pack('i',head_len))  #发送自己定义的报头长度
            # 发送报头
            conn.send(head_bytes)       #发送自己定义的报头
            #发送真是数据  
            conn.send(dui)              #发送真实的数据
            conn.send(cuo)              #发送真实的数据
        except Exception:               #结束捕捉异常
            break                       #跳出
    conn.close()                        #断开链接
din.close()                             #关闭连接




#客户端
import struct    #导入模块
import socket    #导入模块
import json      #导入模块
din=socket.socket(socket.AF_INET,socket.SOCK_STREAM)   #基于网络家族和流的方式传输 创建连接
ip=('127.0.0.1',8080)     #设置唯一的地址
din.connect(ip)           #绑定地址
while True:  
    run=input('请输入命令:')      #用户交互界面
    if not run:continue           #判断如果run为空就跳出
    din.send(bytes(run,encoding='utf-8'))   #通过字节形式发送用户输入的的内容
    data=din.recv(4)          #接收内容长度为4,并赋值给data
    head_len=struct.unpack('i',data)[0]  #解报头并索引出值赋值给head_len
    head_bytes=din.recv(head_len)      #接收长度为head_len变量中的值,赋值给head_bytes
    head_json=head_bytes.decode('utf-8')   #把刚刚接收的内容进行转换,转换成utf-8
    head_dic=json.loads(head_json)       #在把转换成utf-8的内容 反序列化成字典的形式
    data_lik=head_dic['data_lik']        #在把字典的查找的值赋值给data_lik
    recv_size=0                         #设定变量并赋值为0
    recv_data=b''                      #设定变量并创建一个空字节的
    while recv_size < data_lik:       #如果变量小于字典查找出来的值时,循环为真。
        data=din.recv(1024)          #接收内容赋值给data
        recv_size+=len(data)        #把得到的内容长度加到变量recv_size中,这样就能实现如果没有取完内容就一直取得效果
        recv_data+=data           #把拿到的值加到新创建的字节中
        print(recv_data.decode('gbk'))   #打印以GBK转码的内容
din.close()   #关闭连接

 socket并发(支持多个客户端请求):

#server端
import socketserver
class MyServer(socketserver.BaseRequestHandler):#定义类方法,必须定义这个类,    通讯作用
    def handle(self):#类中必须定义一个handle方法
        conn = self.request
        conn.sendall(bytes("欢迎来电",encoding="utf-8"))
        while True:
            ret_bytes = conn.recv(1024)
            ret_str = str(ret_bytes, encoding="utf-8")
            if ret_str == "q":
                break
            conn.sendall(bytes(ret_str + "", encoding="utf-8"))

if __name__ == "__main__":
    server = socketserver.ThreadingTCPServer(("127.0.0.1",9999),MyServer)#MyServer是上面的类名
    server.serve_forever()#通讯循环

#客户端
import socket
obj = socket.socket()
obj.connect(('127.0.0.1',9999,))
ret_bytes = obj.recv(1024)
ret_str = str(ret_bytes,encoding="utf-8")
print(ret_str)
while True:
    inp = input("Client请输入要发送的内容>>> ")
    if inp == "q":
        obj.sendall(bytes(inp,encoding="utf-8"))
        break

    else:
        obj.sendall(bytes(inp,encoding="utf-8"))
        print("正在等待Server输入内容......")
        ret = str(obj.recv(1024),encoding="utf-8")
        print(ret)
obj.close()

 基于tornado(web轻量型框架)简易聊天

基于socket,

浏览器输入127.0.0.1:8888,   返回hello world

import tornado.ioloop
import tornado.web

class MainHandler(tornado.web.RequestHandler):
    def get(self):
        self.write("Hello, world")

def make_app():
    return tornado.web.Application([
        (r"/", MainHandler),
    ])

if __name__ == "__main__":
    app = make_app()
    app.listen(8888)
    tornado.ioloop.IOLoop.current().start()

通过sockserver模块进行多线程式(UDP)

#UDP多并发服务端
import socketserver
ip=('127.0.0.1',8080)
class UDPserver(socketserver.BaseRequestHandler):
    def handle(self):
        print(self)
        print(self.request)  #相当于conn
        de=self.request[0]
        print(de.decode('utf-8'))
        # print(self.request[1])
        cou=input('::::')
        self.request[1].sendto(cou.encode('utf-8'),self.client_address)

if __name__ == '__main__':
    din=socketserver.ThreadingUDPServer(ip,UDPserver)
    din.serve_forever()    #链接循环


#UDP多并发客户端 import socket din=socket.socket(socket.AF_INET,socket.SOCK_DGRAM) ip=('127.0.0.1',8080) while True: inp=input('>>') din.sendto(inp.encode('utf-8'),ip) data,addr=din.recvfrom(1024) print(data.decode('utf-8')) din.close()

基于UDP的套接字:

# UDP服务端
import socket
din=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
ip=('127.0.0.1',8080)
din.bind(ip)
while True:
    conn,addr=din.recvfrom(1024)
    print(conn.decode('utf-8'))
    print(addr)
    din.sendto(conn.upper(),addr)


# UDP客户端
import socket
din=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
ip=('127.0.0.1',8080)
while True:
    inp=input('>>>')
    din.sendto(inp.encode('utf-8'),ip)
    data,addr=din.recvfrom(1024)
    print(data.decode('utf-8'))
展开阅读全文
打赏
0
0 收藏
分享
加载中
更多评论
打赏
0 评论
0 收藏
0
分享
返回顶部
顶部