socket套接字编程 HTTP协议

socket套接字编程
 
套接字介绍
 
1. 套接字 ： 实现网络编程进行数据传输的一种技术手段
 
2. Python实现套接字编程：import  socket
 
3. 套接字分类
>流式套接字(SOCK_STREAM): 以字节流方式传输数据，实现tcp网络传输方案。(面向连接--tcp协议--可靠的--流式套接字)
 
>数据报套接字(SOCK_DGRAM):以数据报形式传输数据，实现udp网络传输方案。(无连接--udp协议--不可靠--数据报套接字)
 

 

 tcp套接字编程
 
服务端流程
 

from socket import * 

#创建流式套接字
sockfd = socket(AF_INET,SOCK_STREAM,0)

#绑定ＩＰ端口
sockfd.bind(('127.0.0.1',8888))

#设置监听套接字，创建监听队列
sockfd.listen(5)

while True:
    print("waiting for connect....")
    #等待客户端链接
    connfd,addr = sockfd.accept()
    print("connect from",addr)

    while True:
        #收发消息
    
        data = connfd.recv(1024)

        if not data:
            break   
        
        print(data.decode())

        #发消息
        connfd.send('来,确认下眼神'.encode())
    #关闭套接字
    connfd.close()

sockfd.close()

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

2. 绑定地址
>本地地址 ： 'localhost' , '127.0.0.1'
>网络地址 ： '172.40.91.185'
>自动获取地址： '0.0.0.0'
 

sockfd.bind(addr)
功能： 绑定本机网络地址
参数： 二元元组 (ip,port)  ('0.0.0.0',8888)
```
 
3. 设置监听
sockfd.listen(n)
功能 ： 将套接字设置为监听套接字，确定监听队列大小
参数 ： 监听队列大小
```
4. 等待处理客户端连接请求
connfd,addr = sockfd.accept()
功能： 阻塞等待处理客户端请求
返回值： connfd  客户端连接套接字
         addr  连接的客户端地址
```
5. 消息收发
data = connfd.recv(buffersize)
功能 : 接受客户端消息
参数 ：每次最多接收消息的大小
返回值： 接收到的内容
 
n = connfd.send(data)
功能 : 发送消息
参数 ：要发送的内容  bytes格式
返回值： 发送的字节数
```
            
6. 关闭套接字 
sockfd.close()
功能：关闭套接字
```
 客户端流程  

# 接受的客户端


from socket import * 

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

#发起连接
sockfd.connect(('127.0.0.1',8888))

while True:
    msg = input("发消息>>  ")
    #发送消息
    sockfd.send(msg.encode())
    if not msg:
        break

    #接收消息
    data = sockfd.recv(1024)
    print(data.decode())

# msg = input("Msg>>")
# scorfd.send(msg.encode())

# data = sockfd.recv(1024)
# print(data.decode())

#关闭
sockfd.close()

           
1. 创建套接字
>注意:只有相同类型的套接字才能进行通信
            
2. 请求连接

sockfd.connect(server_addr)
功能：连接服务器
参数：元组  服务器地址

3. 收发消息
>注意： 防止两端都阻塞，recv send要配合
 
4. 关闭套接字
 
 
tcp 套接字数据传输特点
 
>* tcp连接中当一端退出，另一端如果阻塞在recv，此时recv会立即返回一个空字串。
 
>* tcp连接中如果一端已经不存在，仍然试图通过send发送则会产生BrokenPipeError
 
>* 一个监听套接字可以同时连接多个客户端，也能够重复被连接
 
网络收发缓冲区
 
1. 网络缓冲区有效的协调了消息的收发速度
2. send和recv实际是向缓冲区发送接收消息，当缓冲区不为空recv就不会阻塞。
    
 tcp粘包
 
 socket.time.sleep(0.1)
>原因：tcp以字节流方式传输，没有消息边界。多次发送的消息被一次接收，此时就会形成粘包。
 
>影响：如果每次发送内容是一个独立的含义，需要接收端独立解析此时粘包会有影响。
 
>处理方法
>>1. 人为的添加消息边界
>>2. 控制发送速度
 
 
UDP套接字编程
 
服务端流程
 
 

from socket import * 
import sys 
from time import ctime 


ADDR = ('127.0.0.1',8888)
BUFFERSIZE = 1024

#创建数据报套接字
sockfd = socket(AF_INET,SOCK_DGRAM)
#绑定地址
sockfd.bind(ADDR)

#收发消息
while True:
    data,addr = sockfd.recvfrom(BUFFERSIZE)
    print('recv from %s:%s'%(addr,data.decode()))
    sockfd.sendto
    (("[%s] 接收到消息"%ctime()).encode(),addr)
    
sockfd.close()




#服务端，　udp
from socket import * 

HOST = '127.0.0.1'
PORT = 9999
ADDR = (HOST, PORT)
#创建数据报套接字
sockfd = socket(AF_INET,SOCK_DGRAM)
#绑定地址
sockfd.bind(ADDR)
#收发消息
while True:
    data,addr = sockfd.recvfrom(1024)
    print('Receive from %s:%s' % (addr,data.decode()))
    # sockfd.sendto(("[%s] 接收到消息"%ctime()).encode(),addr)
    sockfd.sendto("收到消息".encode(), addr)
sockfd.close()

    
1. 创建数据报套接字
sockfd = socket(AF_INET,SOCK_DGRAM)
2. 绑定地址 
sockfd.bind(addr)
3. 消息收发        
data,addr = sockfd.recvfrom(buffersize)
功能： 接收UDP消息
参数： 每次最多接收多少字节
返回值： data  接收到的内容
    addr  消息发送方地址
 
n = sockfd.sendto(data,addr)
功能： 发送UDP消息
参数： data  发送的内容 bytes格式
    addr  目标地址
返回值：发送的字节数

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

客户端流程
 

from socket import * 
import sys 

#从命令行传入ＩＰ和端口
#python3 udp_server.py 172.60.50.42 8888
if len(sys.argv) < 3:
    print('''
           argv is error!!!
           input as 
           python3 udp_server.py 172.60.50.42 4260
           ''')

HOST = sys.argv[1]
PORT = int(sys.argv[2])
ADDR = (HOST,PORT)
BUFFERSIZE = 1024

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

while True:
    data = input("消息>>")
    #直接回车退出
    if not data:
        break
    sockfd.sendto(data.encode(),ADDR)
    data,addr = sockfd.recvfrom(BUFFERSIZE)
    print('从服务器收到：',data.decode())
sockfd.close()


#客户端
from socket import * 
import sys 

#命令行输入服务器地址
if len(sys.argv) < 3:
    print('''argv is error !!
        start as
        python3 udp_client.py 127.0.0.1 8888
        ''')
    # raise

HOST = sys.argv[1]
PORT = int(sys.argv[2])#字符串转int类型
ADDR = (HOST,PORT)

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

while True:
    data = input("消息:   ")
    if not data:
        break
    sockfd.sendto(data.encode(),ADDR)
    data,addr = sockfd.recvfrom(1024)
    print("从服务端收到：　", data.decode())

sockfd.close()

# $ python3 udp_client.py 127.0.0.1 8888
#要加ip名和端口名才能运行

1. 创建套接字
2. 收发消息
3. 关闭套接字
---------------
>总结 ：tcp套接字和udp套接字编程区别
>>1. 流式套接字是以字节流方式传输数据，数据报套接字以数据报形式传输
>>2. tcp套接字会有粘包，udp套接字有消息边界不会粘包
>>3. tcp套接字保证消息的完整性，udp套接字则不能
>>4. tcp套接字依赖listen accept建立连接才能收发消息，udp套接字则不需要
>>5. tcp套接字使用send，recv收发消息，udp套接字使用sendto，recvfrom
---------------------  

socket套接字属性 
【1】 sockfd.type  套接字类型
 
【2】 sockfd.family 套接字地址类型
 
【3】 sockfd.getsockname() 获取套接字绑定地址
 
【4】 sockfd.fileno() 获取套接字的文件描述符
 
【5】 sockfd.getpeername() 获取连接套接字客户端地址
 
【6】 sockfd.setsockopt(level,option,value)
        功能：设置套接字选项
        参数： level  选项类别   SOL_SOCKET
            option 具体选项内容
            value  选项值
 
【7】 sockfd.getsockopt(level,option)  
        功能 ： 获取套接字选项值
 

UDP套接字广播

#广播接收端   与udp的

from socket import *

HOST = ''
PORT = 8880

#创建数据报套接字
s = socket(AF_INET,SOCK_DGRAM)#加默认参数0变成流式套接字SOCK_STREAM
#固定接收端的端口号
s.bind((HOST,PORT))
#设置套接字可以接收广播， 有此后变成与udp不同
s.setsockopt(SOL_SOCKET,SO_BROADCAST,1)#broadcast
#设置套接字保护端口号
s.setsockopt(SOL_SOCKET,SO_REUSEADDR,1)#reuseaddr


# while True:
#     try:
#         message,addr = s.recvfrom(1024)
#         print("从{}获取信息{}:".
#             format(addr,message.decode()))#decode将“字节流”按照某种规则转换成'文本'  str变unicode
#         s.sendto(b"I am here",addr)
#     except (KeyboardInterrupt,SyntaxError):#从终端ctrl+c的错
#         raise
#     except Exception as e:
#         print(e)

# s.close()

while True:
    try:
        message,addr = s.recvfrom(1024)
        print("获取信息: {}".
            format(message.decode()))#decode将“字节流”按照某种规则转换成'文本'  str变unicode
        s.sendto(b"I am here",addr)
    except (KeyboardInterrupt,SyntaxError):#从终端ctrl+c的错
        raise#raise 引发一个异常
    except Exception as e:#异常类
        print(e)

s.close()

# 发送端

from socket import *
from time import sleep 

#发送广播的地址
#<broadcast>
dest = ('176.122.14.255',8880)#端口号9999一致
#创建数据报套接字
s = socket(AF_INET,SOCK_DGRAM)#dgram
#设置能够发送广播
s.setsockopt(SOL_SOCKET,SO_BROADCAST,1)#broadcast

while True:
    sleep(2)
    s.sendto("什么鬼啊aaaaaa啦啦啦啦啦啦啦".encode(),dest)#目标地址
    data,addr = s.recvfrom(1024)
    print("Received from %s:%s"%(addr,data.decode()))
s.close()

# while True:
#     data = input('input: ')
#     s.sendto(("@鸿182："+ data).encode(),dest)
# s.close()
# 局域网聊天室，同端口号

* 广播定义 ： 一端发送多点接收
     
* 广播地址 ： 每个网络的最大地址为发送广播的地址，向该地址发送，则网段内所有主机都能接收。

 TCP套接字之HTTP传输
 HTTP协议 （超文本传输协议）
 
1. 用途 ： 网页获取，数据的传输
 
2. 特点

应用层协议，传输层使用tcp传输 

简单，灵活，很多语言都有HTTP专门接口

无状态，协议不记录传输内容

http1.1 支持持久连接，丰富了请求类型
 
3. 网页请求过程
　　1.客户端（浏览器）通过tcp传输，发送http请求给服务端
　　2.服务端接收到http请求后进行解析
　　3.服务端处理请求内容，组织响应内容
　　4.服务端将响应内容以http响应格式发送给浏览器
　　5.浏览器接收到响应内容，解析展示

HTTP请求（request）

"""
httpserver v2.0
env: python3.6
io多路复用 和 http训练
"""

from socket import *
from select import *


# 具体功能实现
class HTTPServer:
    def __init__(self, host='0.0.0.0', port=8000, dir=None):
        self.host = host
        self.port = port
        self.dir = dir
        self.address = (host, port)
        # 多路复用列表
        self.rlist = []
        self.wlist = []
        self.xlist = []
        # 实例化对象时直接创建套接字
        self.create_socket()
        self.bind()

    # 创建套接字
    def create_socket(self):
        self.sockfd = socket()
        self.sockfd.setsockopt(SOL_SOCKET,
                               SO_REUSEADDR, 1)

    # 绑定地址
    def bind(self):
        self.sockfd.bind(self.address)

    # 启动服务
    def serve_forever(self):
        self.sockfd.listen(3)
        print("Listen the port %d" % self.port)
        # IO多路复用接收客户端请求
        self.rlist.append(self.sockfd)
        while True:
            rs, wx, xs = select(self.rlist,
                                self.wlist,
                                self.xlist)
            for r in rs:
                if r is self.sockfd:
                    c, addr = r.accept()
                    self.rlist.append(c)
                else:
                    # 处理请求
                    self.handle(r)

    def handle(self, connfd):
        # 接收HTTP请求
        request = connfd.recv(4096)
        # 客户端断开
        if not request:
            self.rlist.remove(connfd)
            connfd.close()
            return
        # 提取请求内容 (字节串按行分割)
        request_line = request.splitlines()[0]
        info = request_line.decode().split(' ')[1]
        print(connfd.getpeername(), ':', info)

        # 根据请求内容进行数据整理
        # 分为两类 1.请求网页  2.其他
        if info == '/' or info[-5:] == '.html':
            self.get_html(connfd, info)
        else:
            self.get_data(connfd, info)

    # 返回网页
    def get_html(self, connfd, info):
        if info == '/':
            # 请求主页
            filename = self.dir + "/index.html"
        else:
            filename = self.dir + info
        try:
            fd = open(filename)
        except Exception:
            # 网页不存在
            response = "HTTP/1.1 404 Not Found
"
            response += 'Content-Type:text/html
'
            response += '
'
            response += '<h1>Sorry....</h1>'
        else:
            # 网页存在
            response = "HTTP/1.1 200 OK
"
            response += 'Content-Type:text/html
'
            response += '
'
            response += fd.read()
        finally:
            # 将响应发送给浏览器
            connfd.send(response.encode())

    # 其他数据
    def get_data(self, connfd, info):
        response = "HTTP/1.1 200 OK
"
        response += 'Content-Type:text/html
'
        response += '
'
        response += "<h1>Waiting for httpserver 3.0</h1>"
        connfd.send(response.encode())


# 用户使用HTTPServer
if __name__ == "__main__":
    """
    通过 HTTPServer类快速搭建服务，展示自己的网页
    """
    # 用户决定的参数
    HOST = '0.0.0.0'
    PORT = 8000
    DIR = './static'  # 网页存储位置

    httpd = HTTPServer(HOST, PORT, DIR)  # 实例化对象
    httpd.serve_forever()  # 启动服务

#静态网页处理器
#采用循环的模式，无法满足客户端长连接

from socket import *#网络连接端点,导入模块

#处理客户端请求, 交互
def handleClient(connfd):#请求，调用函数
    request = connfd.recv(2048)#请求套接字接受文件
    # print('**************')
    # print(request)
    # print('**************')
    #按照行切割请求， 方便查看
    request_lines = request.splitlines()
    for line in request_lines:
        print(line.decode())#对分割后的文件解码

    try:
        f = open("index.html")
    except IOError:#找不到页面， 文件出错
        response = "HTTP/1.1 303 not Found
"#http响应行
        response += '
'#无响应头， 有空行
        response += '''====sorry ,file not find
                    *******************************
                    Sorry bing i love you miss you.
                    *******************************
                    '''
    else:#正常情况运行
        response = "HTTP/1.1 200 OK
"#成功响应头， 响应体是页面
        response += '
'
        response += f.read()#响应体是页面
        # for i in f:
        #     response += i
    finally:
        connfd.send(response.encode())#发送给浏览器
        connfd.close()

#流程控制
def main():
    sockfd = socket()#创建流式套接字
    sockfd.setsockopt(SOL_SOCKET,SO_REUSEADDR,1)#设置端口重用
    sockfd.bind(('0.0.0.0',8888))#绑定套接字
    sockfd.listen(10)#监听套接字
    while True:#循环监听等待连接
        print("Listen the port 8000..")
        connfd,addr = sockfd.accept()#创建另一个套接字连接请求，便于接收一个后再接收，
        #处理浏览器发来的请求
        handleClient(connfd)#跟客户顿交互
        connfd.close()#关闭套接字
     

if __name__ == "__main__":#调用主函数
    main()


# ---------------------------------------------------------------


# #接收请求
# #查看请求
# #返回客户端请求

# def handleClient():
#     pass


# #创建tcp套接字， 调用handleClient完成功能
# def main():
#     pass

# if __name__=="__main__":
#     main()

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>欢迎进入Alan主页</title>
</head>
<body>
    <h1>Alan songzihong welcome to you </h1>
    <h1>what is you name</h1>
    <h1>How can i do cna help you </h1>
</body>
</html>

<!-- 没保存会只显示文件名 -->
<!-- html:5 + tab -->
<!-- h1 + tab -->

* 请求行 ： 具体的请求类别和请求内容
 
```
    GET         /        HTTP/1.1
    请求类别   请求内容     协议版本
```
 
请求类别：每个请求类别表示要做不同的事情  
 
```        
        GET : 获取网络资源
        POST ：提交一定的信息，得到反馈
        HEAD ： 只获取网络资源的响应头
        PUT ： 更新服务器资源
        DELETE ： 删除服务器资源
        CONNECT
        TRACE ： 测试
        OPTIONS ： 获取服务器性能信息
```
 
* 请求头：对请求的进一步解释和描述
```
Accept-Encoding: gzip
```
* 空行
* 请求体: 请求参数或者提交内容

http响应（response）
 
1. 响应格式：响应行，响应头，空行，响应体
 
* 响应行 ： 反馈基本的响应情况
 
```         
HTTP/1.1     200       OK
版本信息    响应码   附加信息
```
 
响应码 ：  
```
1xx  提示信息，表示请求被接收
2xx  响应成功
3xx  响应需要进一步操作，重定向
4xx  客户端错误
5xx  服务器错误
```
* 响应头：对响应内容的描述
```             
Content-Type: text/html
```
 
* 响应体：响应的主体内容信息