socket套接字编程

socket套接字编程

客户端/服务器架构

 

1.硬件C/S架构(打印机)
2.软件C/S架构
　　互联网中处处是C/S架构
　　如黄色网站是服务端，你的浏览器是客户端（B/S架构也是C/S架构的一种）
　　腾讯作为服务端为你提供视频，你得下个腾讯视频客户端才能看它的视频）
C/S架构与socket的关系：
我们学习socket就是为了完成C/S架构的开发

 

        详见网络通信原理

 

socket是什么

Socket是应用层与TCP/IP协议族通信的中间软件抽象层，它是一组接口。在设计模式中，Socket其实就是一个门面模式，它把复杂的TCP/IP协议族隐藏在Socket接口后面，对用户来说，一组简单的接口就是全部，让Socket去组织数据，以符合指定的协议。

所以，我们无需深入理解tcp/udp协议，socket已经为我们封装好了，我们只需要遵循socket的规定去编程，写出的程序自然就是遵循tcp/udp标准的。

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

而程序的pid是同一台机器上不同进程或者线程的标识

 

套接字的工作流程

 

先从服务器端说起。服务器端先初始化Socket，然后与端口绑定(bind)，对端口进行监听(listen)，调用accept阻塞，等待客户端连接。在这时如果有个客户端初始化一个Socket，然后连接服务器(connect)，如果连接成功，这时客户端与服务器端的连接就建立了。客户端发送数据请求，服务器端接收请求并处理请求，然后把回应数据发送给客户端，客户端读取数据，最后关闭连接，一次交互结束。

 

socket()模块函数用法

import socket

socket.socket(socket_family,socket_type,protocal=0)

socket_family 可以是 AF_UNIX 或 AF_INET。
socket_type 可以是 SOCK_STREAM 或 SOCK_DGRAM。protocol 一般不填,默认值为 0。

获取tcp/ip套接字
tcpSock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

获取udp/ip套接字
udpSock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)


服务端套接字函数
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()        创建一个与该套接字相关的文件

　　

基于TCP的套接字

        tcp是基于链接的，必须先启动服务端，然后再启动客户端去链接服务端

 

        tcp服务端
ss = socket() #创建服务器套接字
ss.bind()      #把地址绑定到套接字
ss.listen()      #监听链接
inf_loop:      #服务器无限循环
    cs = ss.accept() #接受客户端链接
    comm_loop:         #通讯循环
        cs.recv()/cs.send() #对话(接收与发送)
    cs.close()    #关闭客户端套接字
ss.close()        #关闭服务器套接字(可选)
 
        tcp客户端        
cs = socket()    # 创建客户套接字
cs.connect()    # 尝试连接服务器
comm_loop:        # 通讯循环
    cs.send()/cs.recv()    # 对话(发送/接收)
cs.close()            # 关闭客户套接字

　　

简单的套接字通信通信

（socket通信流程与打电话流程类似））

#_*_coding:utf-8_*_
__author__ = 'Linhaifeng'
import socket
ip_port=('127.0.0.1',9000)  #电话卡
BUFSIZE=1024                #收发消息的尺寸
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM) #买手机
s.bind(ip_port) #手机插卡
s.listen(5)     #手机待机


conn,addr=s.accept()            #手机接电话
# print(conn)
# print(addr)
print('接到来自%s的电话' %addr[0])

msg=conn.recv(BUFSIZE)             #听消息,听话
print(msg,type(msg))

conn.send(msg.upper())          #发消息,说话

conn.close()                    #挂电话

s.close()                       #手机关机

 

#_*_coding:utf-8_*_
__author__ = 'Linhaifeng'
import socket
ip_port=('127.0.0.1',9000)
BUFSIZE=1024
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)

s.connect_ex(ip_port)           #拨电话

s.send('linhaifeng nb'.encode('utf-8'))         #发消息,说话(只能发送字节类型)

feedback=s.recv(BUFSIZE)                           #收消息,听话
print(feedback.decode('utf-8'))

s.close()                                       #挂电话

　　加上链接循环于通信循环

import socket
ip_port = ('127.0.0.1',8080) #电话卡
buf_size = 1024

server = socket.socket(socket.AF_INET,socket.SOCK_STREAM)#买手机
server.bind(ip_port)# 手机插上电话卡
server.listen(5) #手机待机

while True:                     #新增接收链接循环,可以不停的接电话
    conn,addr = server.accept() #手机接电话
    print('接%s的电话' %addr[0])

    while True:                  #新增通信循环,可以不断的通信,收发消息
        msg = conn.recv(buf_size)#听消息
        if len(msg) == 0 :break # 如果不加这一行，接受不到消息容易发生死循环
        print(msg,type(msg))

        conn.send(msg.upper()) # 回消息，把接受到的值返回成大写
    conn.close()
server.close()

import socket
ip_port = ('127.0.0.1',8080) #电话卡
buf_size = 1024 #接受消息的长度
client = socket.socket(socket.AF_INET,socket.SOCK_STREAM)#买手机

client.connect(ip_port)

while True:             #新增通信循环,客户端可以不断发收消息
    msg = input('>>>:  ')
    if len(msg) == 0:continue
    client.send(msg.encode('utf-8')) # 发消息，只能发送字节类型

    data = client.recv(buf_size) # 接受消息，不能超过BUF_SIZE
    print(data.decode('utf-8'))

client.close()

远程执行命令

远程执行命令很简单，无非就是把客户端发送过来(recv接受)的消息转换成命令执行（subprocress函数用来执行命令），然后把执行结果（send传送）在送回客户端

import socket

import subprocess
ip_port = ('127.0.0.1',8080) #电话卡
buf_size = 1024

server = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
server.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)

server.bind(ip_port)
server.listen(5)
while True:
    conn, addr = server.accept()
    print(conn,addr)

    while True:
        msg =  conn.recv(buf_size).strip()
        if not msg: break

        res = subprocess.Popen(msg.decode('utf-8'),shell=True,
                               stderr=subprocess.PIPE,
                               stdout=subprocess.PIPE)
        stdout = res.stdout.read()
        stderr = res.stderr.read()

        conn.send(stdout+stderr)

    conn.close()
server.close()

先让用户输入消息，然后把用户输入的消息送到服务端（send）,然后服务端处理之后，客户端在recv接受。

import socket
ip_port = ('127.0.0.1',8080) #电话卡
buf_size = 1024

client = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
client.connect(ip_port)

while True:
    cmd = input('>>> ')
    if not cmd :continue

    client.send(cmd.encode('utf-8'))
    date = client.recv(buf_size)
    print(date.decode('gbk'))

client.close()

粘包现象

　　#只有TCP有粘包现象，UDP永远不会粘包。
　　所谓粘包问题主要还是因为接收方不知道消息之间的界限，不知道一次性提取多少字节的数据所造成的。
　　可以这样说客户端发送过来的数据过长超过了服务端接受数据长度的范围造成的，当然也有可能是服务端给客户端发送数据过长。

　　两种情况下会发生粘包。

　　　　1.发送端需要等缓冲区满才发送出去，造成粘包（发送数据时间间隔很短，数据了很小，会合到一起，产生粘包）

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

#上面的远程执行命令就是一个粘包现象，之所以发生粘包现象是因为命令执行之后显示的数据过长，而客户端能接受的长度之后1024个，服务端发送过来的数据有的超过1024个字节，客户端就无法全部接受。这是就发生了客户端接受数据不完全，就产生了粘包现象。

import socket
import struct
import json
import subprocess
phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)

ip_port = ('127.0.0.1',8080)
phone.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)

phone.bind(ip_port)

phone.listen(5)

while True:
    conn, addr = phone.accept()
    print('clirnt addr', addr)

    while True:
        try:
            cmd = conn.recv(1024)
            #cmd接受用户传送过来的命令
            res = subprocess.Popen(cmd.decode('utf-8'),
                                    shell = True,
                                    stdout = subprocess.PIPE,
                                    stderr = subprocess.PIPE)
            #处理命令 stdout是处理命令之后的结果，stderr是错误的而结果
            out_res = res.stdout.read()
            err_res = res.stderr.read()
            data_size = len(out_res)+len(err_res)#利用字符串拼接把结果长度赋值给data_size

            #
            head_dic = {'data_size':data_size}#将data_size打包成字典方便以后使用
            head_json = json.dumps(head_dic)#利用json将字典序列化成head_json
            head_bytes = head_json.encode('utf-8')#将序列化后的head_json赋值给head_bytes


            head_len = len(head_bytes)#将报头的长度求出来

            # 将报头的长度head_len利用struct模块压缩成固定长度的字符串（这里压缩成了4个长度）
            conn.send(struct.pack('i',head_len))#先把固定长度的报头传送过去


            #然后再把json序列化后的字典传送过去，在客户端处理之后会获取到结果的长度，这样客户端就知道要接受多少长度的结果了
            conn.send(head_bytes)
            #以下就是结果
            conn.send(out_res)
            conn.send(err_res)

        except Exception:
            break
    conn.close()
phone.close()

import socket
import struct
import json
phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 拨通电话
ip_port = ('127.0.0.1', 8080)
phone.connect(ip_port)
# 通信循环
while True:
    # 发消息
    cmd = input('>>: ').strip()
    if not cmd: continue
    phone.send(bytes(cmd, encoding='utf-8'))

    # part1:先收报头的长度
    head_struct=phone.recv(4)

    #将接受的固定长度的报头解压缩获取到把头的长度
    head_len=struct.unpack('i',head_struct)[0]

    # part2:再收报头l
    head_bytes=phone.recv(head_len)
    #将包头转码之后获取到被json序列化的字典，然后利用loads将字典转换成真是想要的结果的长度
    head_json=head_bytes.decode('utf-8')
    head_dic = json.loads(head_json)
    data_size = head_dic['data_size']#data_size就是要接受结果的长度

    #part3：收数据
    recv_size = 0
    recv_data = b''
    #循环收数据
    while recv_size < data_size:#0 500000
        data = phone.recv(1024)#1024
        recv_size += len(data)#
        recv_data += data

    print(recv_data.decode('gbk'))



phone.close()

 博客来自于

Study Hard And Make Procress Every!