Day8 socket

socket网络编程
一、socket介绍
二、socket参数介绍
三、socket实例
四、socket多连接处理
五、socket简单ssh
六、socket文件传送


1、socket介绍
socket通常也称作"套接字"，用于描述IP地址和端口，是一个通信链的句柄，应用程序通常通过"套接字"向网络发出请求或者应答网络请求。
socket起源于Unix，而Unix/Linux基本哲学之一就是“一切皆文件”，对于文件用【打开】【读写】【关闭】模式来操作。socket就是该模式的一个实现，socket即是一种特殊的文件，一些socket函数就是对其进行的操作（读/写IO、打开、关闭）
socket和file的区别：
    file模块是针对某个指定文件进行【打开】【读写】【关闭】
    socket模块是针对 服务器端 和 客户端Socket 进行【打开】【读写】【关闭】

 

###### socket server######
#!/usr/bin/env python
# -*- coding:utf-8 -*-

import socket

ip_port = ('127.0.0.1',9999)

sk = socket.socket()
sk.bind(ip_port)
sk.listen(5)

while True:
    print 'server waiting...'
    conn,addr = sk.accept()

    client_data = conn.recv(1024)
    print client_data
    conn.sendall('------不要回答--------')

    conn.close()


######## socket client #######
#!/usr/bin/env python
# -*- coding:utf-8 -*-
import socket
ip_port = ('127.0.0.1',9999)

sk = socket.socket()
sk.connect(ip_port)

sk.sendall('--->>>请求占领地球')

server_reply = sk.recv(1024)
print server_reply

sk.close()

Socket Families(地址簇)
socket.AF_UNIX unix本机进程间通信
socket.AF_INET　IPV4　
socket.AF_INET6  IPV6

Socket Types
socket.SOCK_STREAM  #for tcp
socket.SOCK_DGRAM   #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 #废弃了

2、socket参数介绍

socket.socket(family=AF_INET, type=SOCK_STREAM, proto=0, fileno=None)  必会
socket.socketpair([family[, type[, proto]]])
socket.create_connection(address[, timeout[, source_address]])
socket.getaddrinfo(host, port, family=0, type=0, proto=0, flags=0) #获取要连接的对端主机地址 必会

sk = socket.socket(socket.AF_INET,socket.SOCK_STREAM,0)
sk.bind(address) 必会
　　s.bind(address) 将套接字绑定到地址。address地址的格式取决于地址族。在AF_INET下，以元组（host,port）的形式表示地址。

sk.listen(backlog) 必会
　　开始监听传入连接。backlog指定在拒绝连接之前，可以挂起的最大连接数量。
      backlog等于5，表示内核已经接到了连接请求，但服务器还没有调用accept进行处理的连接个数最大为5
      这个值不能无限大，因为要在内核中维护连接队列

sk.setblocking(bool) 必会
　　是否阻塞（默认True），如果设置False，那么accept和recv时一旦无数据，则报错。

sk.accept() 必会
　　接受连接并返回（conn,address）,其中conn是新的套接字对象，可以用来接收和发送数据。address是连接客户端的地址。
　　接收TCP 客户的连接（阻塞式）等待连接的到来

sk.connect(address) 必会
　　连接到address处的套接字。一般，address的格式为元组（hostname,port）,如果连接出错，返回socket.error错误。

sk.connect_ex(address)
　　同上，只不过会有返回值，连接成功时返回 0 ，连接失败时候返回编码，例如：10061

sk.close() 必会
　　关闭套接字

sk.recv(bufsize[,flag]) 必会
　　接受套接字的数据。数据以字符串形式返回，bufsize指定最多可以接收的数量。flag提供有关消息的其他信息，通常可以忽略。

sk.recvfrom(bufsize[.flag])
　　与recv()类似，但返回值是（data,address）。其中data是包含接收数据的字符串，address是发送数据的套接字地址。

sk.send(string[,flag]) 必会
　　将string中的数据发送到连接的套接字。返回值是要发送的字节数量，该数量可能小于string的字节大小。即：可能未将指定内容全部发送。

sk.sendall(string[,flag]) 必会
　　将string中的数据发送到连接的套接字，但在返回之前会尝试发送所有数据。成功返回None，失败则抛出异常。
    内部通过递归调用send，将所有内容发送出去。

sk.sendto(string[,flag],address)
　　将数据发送到套接字，address是形式为（ipaddr，port）的元组，指定远程地址。返回值是发送的字节数。该函数主要用于UDP协议。

sk.settimeout(timeout) 必会
　　设置套接字操作的超时期，timeout是一个浮点数，单位是秒。值为None表示没有超时期。一般，超时期应该在刚创建套接字时设置，因为它们可能用于连接的操作（如 client 连接最多等待5s ）

sk.getpeername()  必会
　　返回连接套接字的远程地址。返回值通常是元组（ipaddr,port）。

sk.getsockname()
　　返回套接字自己的地址。通常是一个元组(ipaddr,port)

sk.fileno()
　　套接字的文件描述符

socket.sendfile(file, offset=0, count=None)
    发送文件 ，但目前多数情况下并无什么卵用。

3、socket实例
4、socket多连接处理
5、socket简单ssh

#author:xiefugui
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import socket
import os
server = socket.socket()
server.bind(('localhost',9999))
server.listen(5)
print("已经开始等")

while True:
    conn,addr = server.accept()
    print("已经接通")
    print(conn,addr)
    while True:
            data =conn.recv(1024)
            print("recv:",data)
            if not data:
                print("client has lost.")
                break
            #res = os.popen(data.decode()).read()
            conn.send(data.upper())
            #conn.send(res.encode("utf-8"))
server.close()

#author:xiefugui
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import  socket
client = socket.socket()  #声明socket类型, 同时一成socket连接对象
client.connect(('localhost',9999))

while True:
    msg = input(">:").strip()
    print(msg)
    if len(msg) == 0:continue
    if msg == 'exit':
        break
    client.send(msg.encode("utf-8"))
    data = client.recv(1024)
    #print("recv:",data.decode())
    print(data.decode())
client.close()

 以上程序注释行打开后为一个简单的ssh,但会有以问题:
a、无法执行top类实时持续输出结果的命令,因为服务端拿到命令是用os.popen一次性执行拿结果返回,top类永远都不会结束(后面会学习select异步模块)
b、无法执cd类没有返回的命令,客户端无法接收到返回卡死,可在服务端加个执行返回结果长度判断,如为空自己加一个结果返回给客户端
c、如执行命令返回结果较大时,会发现返回不全,客户端再执一条命令发现返回的还是上一条命令执行结果的后半段结果,1024以旧换新限制,可在服务器发送前另一个结果大小判断,把结果大小发送给客户端.

如提前发送命令结果大小给客户端, 发现会出现发送大小和发送命令结果重叠发送,造成粘包情况
有粘包的问题, 为了提高io的效率, 两次或多次发送的数据粘在一起发送了, 以下为解决粘包发送大数据 :

import socket
import os,subprocess,time

server = socket.socket() #获得socket实例
#server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
server.bind(("localhost",9999)) #绑定ip port
server.listen(8)  #开始监听

while True: #第一层loop
    print("等待客户端的连接...")
    conn,addr = server.accept() #接受并建立与客户端的连接,程序在此处开始阻塞,只到有客户端连接进来...
    print("新连接:",addr )
    while True:
        data = conn.recv(1024)
        if not data:
            print("客户端断开了...")
            break #这里断开就会再次回到第一次外层的loop
        print("收到命令:",data)
        res = os.popen(data.decode('utf-8')).read() #py3 里socket发送的只有bytes,os.popen又只能接受str,所以要decode一下
        #res = subprocess.Popen(data,shell=True,stdout=subprocess.PIPE).stdout.read() #跟上面那条命令的效果是一样的
        if len(res) == 0:
            res = "cmd exec success,has not output!".encode("utf-8")
        conn.send(str(len(res.encode())).encode("utf-8")) #发送数据之前,先告诉客户端要发多少数据给它
        print("等待客户ack应答...")
        client_final_ack = conn.recv(1024) #等待客户端响应
        print("客户应答:",client_final_ack.decode())
        print(type(res))
        conn.sendall(res.encode("utf-8")) #发送端也有最大数据量限制,所以这里用sendall,相当于重复循环调用conn.send,直至数据发送完毕
        continue
server.close()

import socket
import sys

client = socket.socket()
client.connect(("localhost",9999))

while True:
    msg = input(">>:").strip()
    if len(msg) == 0:continue
    client.send( msg.encode("utf-8") )

    res_return_size  = client.recv(1024) #接收这条命令执行结果的大小
    print("getting cmd result , ", res_return_size.decode('utf-8'))
    total_rece_size = int(res_return_size.decode('utf-8'))
    print("total size:",res_return_size)
    client.send("准备好接收了,发吧".encode("utf-8"))
    received_size = 0 #已接收到的数据
    cmd_res = b''
    f = open("test_copy.html","wb")#把接收到的结果存下来,一会看看收到的数据 对不对
    while received_size < total_rece_size: #代表还没收完
        data = client.recv(1024)
        received_size += len(data) #为什么不是直接1024,还判断len干嘛,注意,实际收到的data有可能比1024少
        cmd_res += data
    else:
        print("数据收完了",received_size)
        #print(cmd_res.decode())
        f.write(cmd_res) #把接收到的结果存下来,一会看看收到的数据 对不对
        f.close()
    #print(data.decode()) #命令执行结果

client.close()

 

6、socket 文件传送

import socket,hashlib
import os,subprocess,time

server = socket.socket() #获得socket实例
server.bind(("localhost",9999)) #绑定ip port
server.listen(8)  #开始监听

while True: #第一层loop
    print("等待客户端的连接...")
    conn,addr = server.accept() #接受并建立与客户端的连接,程序在此处开始阻塞,只到有客户端连接进来...
    print("新连接:",addr )
    while True:
        data = conn.recv(1024)
        if not data:
            print("客户端断开了...")
            break #这里断开就会再次回到第一次外层的loop
        print("收到命令:",data)
        if __name__ == '__main__':
            cmd,filename = data.decode().split()
            print(filename)
            if os.path.isfile(filename):
                f = open(filename,"rb")
                m = hashlib.md5()
                file_size = os.stat(filename).st_size
                conn.send(str(file_size).encode())
                print("send file_size done")
                conn.recv(1024) #wait for ack
                for line in f:
                    m.update(line)
                    conn.send(line)
                print("md5:",m.hexdigest())
                f.close()
                conn.send(m.hexdigest().encode())

server.close()

import socket
import sys,hashlib

client = socket.socket()
client.connect(("localhost",9999))

while True:
    msg = input(">>:").strip()
    if len(msg) == 0:continue
    if msg.startswith("get"):
        client.send( msg.encode())
        res_return_size  = client.recv(1024) #接收这条命令执行结果的大小
        print("getting file size", res_return_size.decode())
        client.send("准备好接收了,发吧".encode())
        total_rece_size = int(res_return_size.decode())
        print("total size:",res_return_size)
        received_size = 0 #已接收到的数据
        filename = msg.split()[1]
        f = open(filename+".new","wb")#把接收到的结果存下来,一会看看收到的数据 对不对
        m = hashlib.md5()
        while received_size < total_rece_size:  # 代表还没收完
            if total_rece_size - received_size > 1024:
                size = 1024
            else:
                size = total_rece_size - received_size
                print("最后一次:",size)
            data = client.recv(size)
            received_size += len(data)  # 为什么不是直接1024,还判断len干嘛,注意,实际收到的data有可能比1024少
            f.write(data)
            m.update(data)
            print(total_rece_size,received_size)
        else:
            print("file recv done")
            f.close()
            new_md5 = m.hexdigest()

        server_md5 = client.recv(1024)
        print("new md5:",new_md5)
        print("server md5:",server_md5)

client.close()

7、socket server

import socketserver

class TCPHandler(socketserver.BaseRequestHandler):
    def handle(self):
        while True:
            try:
                self.data = self.request.recv(1024).strip()
                print("{} wrote:".format(self.client_address[0]))
                print(self.data)
                self.request.send(self.data.upper())
            except ConnectionResetError as e:
                print("error:",e)
                break

if __name__ == "__main__":
    HOST,PORT = "localhost",9999
    #server =socketserver.TCPServer((HOST,PORT),TCPHandler)    #不能多并发
    server =socketserver.ThreadingTCPServer((HOST,PORT),TCPHandler)
    server.serve_forever()

多并发的类

class socketserver.ForkingTCPServer    #多进程tcp server
class socketserver.ForkingUDPServer    #多进程udp server
class socketserver.ThreadingTCPServer    #多线程tcp server
class socketserver.ThreadingUDPServer    #多线程udp server

作业：开发一个支持多用户在线的FTP程序

要求：

    用户加密认证
    允许同时多用户登录
    每个用户有自己的家目录 ，且只能访问自己的家目录
    对用户进行磁盘配额，每个用户的可用空间不同
    允许用户在ftp server上随意切换目录
    允许用户查看当前目录下文件
    允许上传和下载文件，保证文件一致性
    文件传输过程中显示进度条
    附加功能：支持文件的断点续传