socket套接字-TCP \ UDP

socket套接字编程

　　目标： 根据socket模块提供的接口函数，进行组合使 用完成基于tcp或者udp的网路编程。

　　套接字 ： 完成上述目标的一种编程手段，编程方案

套接字分类：
　　流式套接字（SOCK_STREAM）: 传输层基于tcp协议 的套接字编程方案。
　　数据报套接字（SOCK_DGRAM）: 传输层基于udp协议的套接字编程方案。
　　底层套接字（SOCK_RAM）：访问底层协议的套接字编程。

* 面向连接的传输--tcp协议--可靠地--流式套接字
* 面向无连接传输--udp协议--不可靠--数据报套接字

-------------------------------------------------------------------

本地套接字

linux 文件
　　b（块设备文件） c（字符设备文件） d（目录）
　　-（普通文件） l（链接） s（套接字） p（管道）

作用：用于本地不同的程序间进行通信

创建流程
　　1.创建本地套接字
　　sockfd = socket(AF_UNIX,SOCK_STREAM)
　　2.绑定本地套接字文件
　　* 选定文件位置和名称
　　* sockfd.bind(path)
　　3. 监听 listen()
　　4. 消息收发， recv send

　　

from socket import *
import os

#确定套接字文件
sock_file = './sock_file'

#判断文件是否已经存在
if os.path.exists(sock_file):
    os.remove(sock_file)

#创建本地套接字
sockfd = socket(AF_UNIX,SOCK_STREAM)

#绑定套接字文件
sockfd.bind(sock_file)

#监听
sockfd.listen(3)

#消息收发
while True:
    c,addr = sockfd.accept()
    while True:
        data = c.recv(1024)
        if data:
            print(data.decode())
            c.send(b"Receive")
        else:
            break 
    c.close()
sockfd.close()

　　

from socket import * 

#确保通信两端用的是同一个套接字文件
sock_file = "./sock_file"

#创建本地套接字
sockfd = socket(AF_UNIX,SOCK_STREAM)

#连接另一端
sockfd.connect(sock_file)

#收发消息
while True:
    msg = input(">>")
    if msg:
        sockfd.send(msg.encode())
        print(sockfd.recv(1024).decode())
    else:
        break 

sockfd.close()

 

os.path.exists(path)
    功能 ： 判断一个文件是否存在
    参数：目标文件
    返回值 ： 存在返回True 否则 False

os.remove() os.unlink()
    功能 ： 删除一个文件
    参数 ： 目标文件

传输层-TCP

tcp协议的数据传输 (面向连接的传输服务)

　　传输特征 ： 提供可靠的数据传输，可靠性指数据传输过程中无丢失，无失序，无差错，无重复。

　　实现手段： 数据传输断开前都需要进行传输和断开的确认

三次握手 ： tcp传输在数据传输前建立连接的过程 1. 客户端向服务器发送连接请求 2. 服务器收到请求后，回复确认消息，表示允许连接 3. 客户端收到服务器回复，进行最终标志发送确认连接 四次挥手 ： tcp传输在连接断开前进行断开确认的过程 1. 主动发发送报文告知被动方要断开连接 2. 被动方收到请求后立即返回报文告知已经准备断开 3. 被动方准备就绪后再次发送报文告知可以断开 4. 主动方发送消息，确认最终断开

应用情况 ： 适用于传输较大的文件，网络情况良好，需要保证传输可靠性的情况。
　　 比如： 网页的获取，文件下载，邮件传输，登录注册

 

tcp套接字服务端编程

　　import socket

　　1. 创建套接字

　　sockfd = socket.socket(socket_family = AF_INET,
　　socket_type = SOCK_STREAM,
　　proto = 0)
　　　　功能 ： 创建套接字
　　　　参数 ： socket_family : 选择地址族类型 AF_INET
　　　　　　　    socket_type : 套接字类型 SOCK_STREAM 流式
　　　　　　　　SOCK_DGRAM 数据报
　　　　　　　　proto : 选择子协议类型 通常为0
　　　　返回值 ： 返回套接字对象

　　2. 绑定服务端地址
　　sockfd.bind(addr)
　　　　功能 ： 绑定IP地址
　　　　参数 ： 元组 （ip，port）

　　　　localhost  或 127.0.0.1    可以被本机用 127.0.0.1
　　　　192.168.205.127            可以被所有人用192.168.205.127访问
　　　　0.0.0.0                    可以被所有人用192.168.205.127访问
　　　　0.0.0.0                    也可被自己用127.0.0.1访问

 

　　3. 设置监听套接字
　　sockfd.listen(n)
　　　　功能：将套接字设置为监听套接字，创建监听队列
　　　　参数：n 表示监听队列大小

　　　　* 一个监听套接字可以连接多个客户端套接字

 

　　4. 等待处理客户端连接请求
　　connfd，addr = sockfd.accept()
　　　　功能 ： 阻塞等待处理客户端连接
　　　　返回值： connfd 客户端连接套接字
　　　　addr 连接的客户端地址

　　　　* 阻塞函数 ： 程序运行过程中遇到阻塞函数则暂停运行，直到某种阻塞条件达成再继续运行。

 

　　5. 消息收发

　　data = connfd.recv(buffersize)
　　　　　功能 ： 接收对应客户端消息
　　　　　参数 ： 一次最多接收多少字节
　　　　　返回值 ： 接收到的内容

　　　　　* 如果没有消息则会阻塞

　　n = connfd.send(data)
　　　　功能 ： 发送消息给对应客户端
　　　　参数 ： 要发送的内容，必须是bytes格式
　　　　返回值 ： 返回实际发送消息的大小

　　6. 关闭套接字
　　sockfd.close()
　　　　功能： 关闭套接字

# -*- coding: utf-8 -*-

from socket import *


# 创建套接字
s = socket(AF_INET, SOCK_STREAM)

# 绑定服务端地址
s.bind(('127.0.0.1', 8888))

# 设置监听套接字
s.listen(5)

# 循环 等待处理客户端的连接请求
while True:
    print('Waiting for connect...')
    connfd, addr = s.accept()
    print('Connect from', addr)
    while True:
        # 接收客户端消息
        data = connfd.recv(1024).decode()
        if not data:
            break
        print(data)
        # 向客户端发送消息
        n = connfd.send(b'Rrceive your message')
        print("发送%d字节" % n)
    connfd.close()

# 关闭套接字
s.close()

-------------------------------------------------------------------

tcp客户端
　　1. 创建套接字
　　* 必须相同类型的套接字才能通信
　　2. 建立连接
　　sockfd.connect(servr_addr)
　　　　功能 ： 建立连接
　　　　参数 ： 元组， 服务端地址
　　3. 消息收发
　　* 消息收发要和服务端配合，避免两边都出现recv阻塞
　　4. 关闭套接字

 

# -*- coding: utf-8 -*-

from socket import *

# 创建套接字
s = socket(AF_INET, SOCK_STREAM)

# 发起连接
server_addr = ('127.0.0.1', 8888)
s.connect(server_addr)

while True:
    # 消息发送接收
    data = input('发送>>:')
    s.send(data.encode())
    if not data:
        break
    else:
        data = s.recv(1024)
        print('接收到>>:', data.decode())

--------------------------------------------------------------------

套接字传输注意事项
1. 监听套接字存在客户端即可发起连接，但是最终连接的处理需要accept进行处理
2. 如果连接的另外一段退出，则recv会立即返回空子串不再阻塞。
3. 当连接的另一端退出时，再试图send发送就会产生BrokenPipeError


网络收发缓冲区

缓冲区作用 ：协调收发（处理）速度
              减少交互次数

send和recv实际上是和缓冲区进行交互，发送缓冲区满时就无法发送，接收缓冲区满时recv才阻塞


TCP粘包

产生原因：
tcp套接字以字节流方式传输，没有消息边界
发送和接收并不能保证每次发送都及时的被接收

影响：如果每次发送内容表达一个独立的含义此时可能需要处理粘包防止产生歧义

处理方法：
1. 每次发送的消息添加结尾标志 （人为增加消息边界）
2. 发送数据结构体
3. 协调收发速度，每次发送后都预留接收时间

传输层-UDP

udp协议的传输 (面向无连接的传输服务)

　　传输特点 ： 不保证传输的可靠性，传输过程没有连接和断开的流程，数据收发自由。

　　使用情况 ： 网络情况较差，对传输可靠性要求不高，需要提升传输效率。不便连接，需要灵活收发消息。
　　　　 比如：网络视频，群聊，广播发送

 

udp套接字的服务端

　　1. 创建数据报套接字
　　sockfd = socket(AF_INET,SOCK_DGRAM)

　　2. 绑定地址
　　sockfd.bind(addr)

　　3. 消息的收发

　　data,addr = sockfd.recvfrom(buffersize)
　　　　功能 : 接收UDP消息
　　　　参数 ： 每次最多接收多大的消息
　　　　返回值：data 接收到的数据
　　　　addr 消息发送端的地址

　　　　* 一次接收一个数据报，如果数据报大小大于buffersize则会丢失部分消息

　　sockfd.sendto(data,addr)
　　　　功能 ： 发送udp消息
　　　　参数 ： data 发送的消息 bytes格式
　　　　addr 目标地址
　　　　返回值： 发送的字节数

　　4. 关闭套接字
　　sockfd.close()

# -*- coding: utf-8 -*-

from socket import *

# 创建套接字
s = socket(AF_INET, SOCK_DGRAM)

# 绑定地址
server_addr = ('127.0.0.1', 8888)
s.bind(server_addr)

while True:
    print('Waiting for connect...')
    # 消息接收,
    # 注意一次接收一个数据报,如果数据报大小大于参数,则会丢失部分数据
    data, addr = s.recvfrom(1024)
    print(data.decode())

    # 发送消息
    s.sendto('Recevie your message'.encode(), addr)
s.close()

补充函数
　　sendall(data)
　　　　功能 ： 发送tcp消息
　　　　参数 ： 要发送的内容，bytes格式
　　　　返回值 ： 成功返回 None 失败产生异常

--------------------------------------------------------------------------

udp客户端
　　1. 创建套接字
　　socket(AF_INET,SOCK_DGRAM)
　　2. 消息收发
　　recvfrom/sendto
　　3. 关闭套接字
　　close（）

# -*- coding: utf-8 -*-

from socket import *
import sys

if len(sys.argv) < 3:
    print('''
        argv is error!
        run as
        python udp_client.py 127.0.0.1 8888''')

# 从命令行输入IP,端口
HOST = sys.argv[1]
PORT = int(sys.argv[2])
ADDR = (HOST, PORT)

# 创建套接字
s = socket(AF_INET, SOCK_DGRAM)

while True:
    data = input('发送>>:').encode()
    if not data:
        break
    s.sendto(data, ADDR)
    data1, addr = s.recvfrom(1024)
    print(data1.decode())
s.close()

 

1. sys.argv 属性
    功能 ： 获取命令行参数，得到一个列表

    命令本身是 argv[0]
    后面的参数从argv[1]开始，默认以空格分隔
    使用引号引起来的内容算作一个整体
    命令行参数都以字符串放入列表

2. Linux系统下:
    在程序的第一行加
    #!/usr/bin/env python3
    添加程序的执行权限
    chmod  755  file.py
    修改后即可通过 ./file.py  运行程序
-----------------------------------------------------------------

套接字对象 

s代表一个套接字

s.family  : 获取套接字地址族类型
s.type : 获取套接字类型
s.getsockname() : 获取套接字的绑定地址

s.fileno() : 获取套接字的文件描述符
文件描述符 ： 每一个IO事件操作系统都会分配一个不同的正整数作为编号，改正整数即为这个IO的文件描述符。

* 文件描述符是操作系统识别IO的唯一标志
stdin ---> 0
stdout --> 1
stderr --> 2

s.getpeername() : 获取客户端连接套接字的对应地址

s.setsockopt(level,option,value)
功能：设置套接字选项，丰富或者修改套接字属性功能
参数： level 选项类别   SOL_SOCKET
       option 具体选项
       value  选项值

s.getsockopt(level,option)
功能：获取套接字选项值
参数： level 选项类别   SOL_SOCKET
       option 具体选项
返回值：选项值

* 如果要设置套接字选项，最好在创建套接字之后立即设置

tcp套接字编程和udp套接字编程区别 1. 流式套接字使用字节流的方式传输，数据报套接字以数据报形式传输数据 2. tcp会有粘包现象，udp有消息边界不会形成粘包 3. tcp 可以保障数据传输完整性，udp则不保证 4. tcp 需要进行listen accept 操作，udp不需要 5. tcp收发消息使用新的套接字，recv send。udp使用recvfrom，sendto