socket是什么

什么是socket所谓socket通常也称作"套接字",用于描述IP地址和端口,是一个通信链的句柄。应用程序通常通过"套接字"向网络发出请求或者应答网络请求。说白了就是一种通信机制。它类似于银行,电信啊这些部分的电话客服部门。你打电话的时候,那边会分配置一个人回答你的问题,客服部门就相当于socket的服务器端了,你这边呢就相当于客户端了,在和你通话结束前,如果有人在想找和你通话的那个说话,是不可能的,因为你在和他通信,当然客服部门的电话交换机也不会重复分配。我们天天用的http\smtp\ftp等网络协议都是基于socket的上层实现,无论使用何种网络协议,最本质上都是在进行数据的接收和发送,只不过发送的数据类型和内容不同罢了,“发送”和“接收”这两个动作就是socket处理数据的主要方式。

socket起源于Unix,而Unix/Linux基本哲学之一就是“一切皆文件”,都可以用“打开open–> 读写write/read–> 关闭close”模式来操作。Socket就是该模式的一个实现,socket即是一种特殊的文件,一些socket函数就是对其进行的操作(读/IO、打开、关闭),pythonsocket模块是直接调用的unixsocket库,接下来我们一起来看下,如何在python下实现socket

 

使用socket时需要指定Socket Family(地址簇),包括以下几种:

socket.AF_UNIX       只能够用于单一的Unix系统进程间通信

socket.AF_INET      用于主机之间的网络通信

socket.AF_INET6    IPv6通信

若想实现主机之间的通信,我们就得使用socket.AF_INET

 

确认地址簇后,还需要指定socket 数据类型

socket.SOCK_STREAM     流式socket, for TCP

socket.SOCK_DGRAM       数据报式socket, for UDP

socket.SOCK_RAW    原始套接字,普通的套接字无法处理ICMPIGMP等网络报文,而SOCK_RAW可以;其次,SOCK_RAW也可以处理特殊的IPv4报文;此外,利用原始套接字,可以通过IP_HDRINCL套接字选项由用户构造IP头。

socket.SOCK_RDM   是一种可靠的UDP形式,即保证交付数据报但不保证顺序。SOCK_RAM用来提供对原始协议的低级访问,在需要执行某些特殊操作时使用,如发送ICMP报文。SOCK_RAM通常仅限于高级用户或管理员运行的程序使用。

socket.SOCK_SEQPACKET      可靠的连续数据包服务

 

我们主要用的一般是SOCK_STREAM (for TCP)SOCK_DGRAMfor UDP.

 

 

进行socket调用时可能会用到的函数:

s = socket(family,type[,protocal])       使用给定的地址族、套接字类型、协议编号(默认为0)来创建套接字。

 

套接字的实例具有以下方法:

  1. s.bind(address) 将套接字绑定到地址。address地址的格式取决于地址族。在AF_INET下,以元组(host,port)的形式表示地址。

  2. s.listen(backlog)   开始监听传入连接。backlog指定在拒绝连接之前,操作系统可以挂起的最大连接数量。该值至少为1,大部分应用程序设为5就可以了。

  3. s.connect(address)  连接到address处的套接字。一般,address的格式为元组(hostname,port),如果连接同一台机器上的服务器,可以将hostname设为‘localhost’。如果连接出错,返回socket.error错误。

  4. s.connect_ex(adddress)  功能与connect(address)相同,但是成功返回0,失败返回errno的值。

  5. s.accept() 接受连接并返回(conn,address,其中conn是新的套接字对象,可以用来接收和发送数据。address是连接客户端的地址。

  6. s.close()  关闭套接字。

  7. s.fileno()  返回套接字的文件描述符。

  8. s.getpeername() 返回连接套接字的远程地址。返回值通常是元组(ipaddr,port)。

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

  10. s.getsockopt(level,optname[.buflen]) 返回套接字选项的值。

  11. s.gettimeout() 返回当前超时期的值,单位是秒,如果没有设置超时期,则返回None

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

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

  14. s.send(string[,flag])  string中的数据发送到连接的套接字。返回值是要发送的字节数量,该数量可能小于string的字节大小。

  15. s.sendall(string[,flag])  string中的数据发送到连接的套接字,但在返回之前会尝试发送所有数据。成功返回None,失败则抛出异常。

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

  17. s.setblocking(flag)  如果flag0,则将套接字设为非阻塞模式,否则将套接字设为阻塞模式(默认值)。非阻塞模式下,如果调用recv()没有发现任何数据,或send()调用无法立即发送数据,那么将引起socket.error异常。

  18. s.setsockopt(level,optname,value)   设置给定套接字选项的值。

  19. s.settimeout(timeout)   设置套接字操作的超时期,timeout是一个浮点数,单位是秒。值为None表示没有超时期。一般,超时期应该在刚创建套接字时设置,因为它们可能用于连接的操作(如connect())普通的非套接字实例的函数

  20. getdefaulttimeout()返回默认的套接字超时时间(以秒为单位)。None表示不设置任何超时时间。

  21. gethostbyname(hostname)   将主机名(如“www.baidu.com”)转换为IPv4地址,IP地址将以字符串的形式返回,如“8.8.8.8”。不支持IPv6

  22. gethostname() 返回本地机器的主机名。

 


正式写代码了噢!!!


下面实现一下最简单的socket 通信:

 

Server.py 服务端

#Echo server program
import
socket

HOST=‘’  #空代表0.0.0.0
PORT= 50007  #监听端口
s= socket.socket(socket.AF_INET,socket.SOCK_STREAM) # 生成socket tcp通信实例,
s.bind((HOST,PORT)) #绑定ip和端口,注意bind只接受一个参数,(HOST,PORT) 做成一个元祖传进去
s.listen(1)  #开始监听,里面的数字是代表服务端在拒绝新连接之前可以最多挂起多少连接,不过实验过了没啥用,所以写个1就好了

conn,addr= s.accept()  #接受连接,并返回两个变量,conn代表每个新连接进入后服务端都会为其生成一个新实例,后面可以用这个实例进行发送和接收,addr是连接进来的客户端的地址,accept()方法在有新连接进入时就会返回conn,addr这两个变量,但如果没有连接时,此方法就会阻塞直至有新连接过来。

print'Connected by', addr

while  True:
    data = conn.recv(1024) #接收1024字节数据
    if not data: break     #如果收不到客户端数据了(代表客户端断开了),就断开
    conn.sendall(data.upper())    #将收到的数据全变成大写再发给客户端
    
conn.close() #关闭连接


Client.py 客户端

import
socket

HOST= '192.168.3.1' # 远程socket服务器ip
PORT= 50007         # 远程socket服务器端口

s = socket.socket(socket.AF_INET,socket.SOCK_STREAM) #实例化socket
s.connect((HOST,PORT)) #连接socket服务器

while True:
    msg = raw_input("Your msg::").strip() #让用户输入消息,去除回车和空格
    if len(msg) == 0:continue 
    
    s.sendall(msg) #向服务器发送消息
    data= s.recv(1024)       #接收服务器的消息
    
    print 'Received:', data
s.close()


这样我们就能实现服务端和客户端1对1来通信了,但是你会发现,只要客户端一中断,服务器也跟着中断了,这样显然是不合理的,一个客户端断开了,服务端应该能持续为其它客户端提供服务才对。 那服务端为啥会跟着客户端一起关闭呢,因为服务端代码中

if not data: break

如果收不到客户端的数据,就跳出循环,我们可以把代表调整成如下:

#Echo server program
import socket

HOST=''  #空代表0.0.0.0
PORT= 50007  #监听端口
s= socket.socket(socket.AF_INET,socket.SOCK_STREAM) 
s.bind((HOST,PORT)) 
s.listen(1)


while True:
    conn,addr= s.accept()  

    print'Connected by', addr

    while  True:
        data = conn.recv(1024) #接收1024字节数据
        if not data: break     #如果收不到客户端数据了(代表客户端断开了),就断开
        conn.sendall(data.upper())    #将收到的数据全变成大写再发给客户端

    conn.close() #关闭此客户端的连接实例

这样如果一个客户端连接断开了,最里面的那个循环会跳出,就又回到第一层的while循环,

conn,addr= s.accept()

上面的accept()方法会继续等待一个新的连接进来,这样,服务端就可以持续不断的为客户端提供服务了。


解决了不能持续提供服务的问题后,新问题又来了,当你启动服务端后,同时再启动2个客户端,你会发现,只能有一个客户端跟服务端不断的通信,另一个客户端会一直处在挂起状态,当你把可以通信的客户端断开后,你会发现第2个客户端就可以跟服务端进行通信了。 这是为什么呢?哈哈,因为你的服务端同时只能为一个客户提供服务呀。就像你跟一个人在说话的同时,是不能同时跟其它人说话的,对么?

一小时学会用Python Socket 开发可并发的FTP服务器!!_Socket


其实想让你的服务端口可以同时为与多个客户端进行通信也很简单,直接用多线程并发就好了,什么?你不会写多线程?没关系,Python已经帮你实现了,你只需要调用一个叫SocketServer的模块就好了。下面咱们就把刚才的单线程socket服务端变成多线程的:


import SocketServer

class MyTCPHandler(SocketServer.BaseRequestHandler):
    #继承BaseRequestHandler基类,然后必须重写handle方法,并且在handle方法里实现与客户端的所有交互
    
    def handle(self):

        while  True:
            data = self.request.recv(1024) #接收1024字节数据
            if not data: break     
            self.request.sendall(data.upper())

if __name__ == "__main__":
    HOST, PORT = "localhost", 50007

    # 把刚才写的类当作一个参数传给ThreadingTCPServer这个类,下面的代码就创建了一个多线程socket server
    server = SocketServer.ThreadingTCPServer((HOST, PORT), MyTCPHandler)

    # 启动这个server,这个server会一直运行,除非按ctrl-C停止
    server.serve_forever()


好了,此时再多启动几个客户端,看看是不是所有的客户端都能同时跟服务器端通信啦。


接下来我们看看怎么通过socket模拟实现一个ftp server,允许客户端上传和下载文件。 


FTP客户端

#_*_coding:utf-8_*_
__author__ = 'jieli'


import socket
import os
class FtpClient(object):
    def __init__(self,host,port ):
        self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self.sock.connect((host, port)) #连接服务器
    def start(self): #实例化客户端类后,需要调用此方法启动客户端
        self.interactive()  #跟用户的交互都在这个方法里
        
        
    def interactive(self):
        while True:
            user_input = raw_input(">>:").strip()
            if len(user_input) == 0:continue
            user_input = user_input.split() #用户输入的指令进行拆分,第一个参数是指要进行什么动作,比如get remote_filename

            if hasattr(self,user_input[0]):#判断类中是否有get或其它输入的方法
                func = getattr(self,user_input[0]) #通过字符串获取类中对应方法的内存对象
                func(user_input) #调用此内存对象

            else: 
                print "\033[31;1mWrong cmd usage\033[0m"

    def get(self,msg): #从服务器端下载文件
        print '--get func---',msg
        if len(msg) ==2 :
            file_name = msg[1]
            instruction = "FileTransfer|get|%s" % file_name #告诉服务器端要下载什么文件
            self.sock.send(instruction)
            feedback = self.sock.recv(100) #等待服务器端的消息确认
            print '-->',feedback
            if feedback.startswith("FileTransfer|get|ready"): #代表服务器上文件存在,并且服务器已经准备好了发送此文件到客户端
                file_size = int(feedback.split("|")[-1]) # 服务器端发回来的确认消息中,最后面一个值是文件大小,必须知道文件大小才知道一共要收多少内容
                self.sock.send("FileTransfer|get|recv_ready") #告诉服务器端已经准备好了接收
                recv_size = 0 # 因为文件可能会比较大,一次收不完,所以要循环收,每收到一次,就计个数
                f = file('client_recv/%s' % os.path.basename(file_name),'wb') #在本地创建一个新文件来存这个要下载的文件内容
                print '--->',file_name
                while not file_size == recv_size:#只要文件总大小和已收到的大小不想等,就代表还没收完
                    if file_size - recv_size>1024:#文件总大下减已收到的大小等于还剩下没收到的大小,如果这个数大于1024,代表一次肯定收不完,那就还得多循环几次
                        data = self.sock.recv(1024) #这次收1024字节,但实际上收到的可能比1024小,所以需要以实际收到的数为准
                        recv_size += len(data) # 已收到的大小加上这一次循环收到的实际大小
                    else:# 如果最后剩下的少于1024,那就一次性把剩下的都收过来
                        data = self.sock.recv(file_size - recv_size) 
                        #recv_size = file_size #不能这么写,因为这一次依然不一定能一次性收完,因为实际收到的数据可能比你规定的数据要少, 所以需要按下面这行的方式写
                        recv_size += (file_size - recv_size) 
                    f.write(data) #收到的内容写入文件
                    print file_size,recv_size
                else:
                    print '---recv file:%s---' % file_name
                    f.close() 
            else:
                print feedback
        else:
            print "\033[31;1mWrong cmd usage\033[0m"

    def put(self): 
        pass
    def ls(self):
        pass
    def cd(self):
        pass
    def delete(self):
        pass


if __name__ == "__main__":
    f = FtpClient('localhost',9002)
    f.start()



服务器端

#_*_coding:utf-8_*_

import SocketServer

import os
class MyTCPHandler(SocketServer.BaseRequestHandler):
    def handle(self):
        while True:
            instruction = self.request.recv(1024).strip() #接收客户端命令
            if not instruction :break
            instruction = instruction.split('|') #将客户端发过来的消息按|来拆分,消息类似这种格式 “FileTransfer|get|file_name”
            if hasattr(self,instruction[0]): #判断类中是否有这个方法
                func = getattr(self, instruction[0]) #获取这个方法的内存对象
                func(instruction) #调用此方法
    def FileTransfer(self,msg): #负责文件的发送和接收
        print '---filetransfer---',msg
        if msg[1] == 'get': #如果客户端发来的指令是get,那就是下载文件
            print "client wants to download file:", msg[2]
            if os.path.isfile(msg[2]): #判断客户端发的文件名是否存在并是个文件
                file_size = os.path.getsize(msg[2]) # 获取文件大小
                res = "ready|%s" % file_size # 把文件大小告诉客户端
            else:
                res = "file doesn't exist" #文件也有可能不存在
            send_confirmation = "FileTransfer|get|%s" %res 
            self.request.send(send_confirmation) # 发送确认消息给客户端
            feedback = self.request.recv(100) #等待客户端确认, 如果这时不等客户端确认就立刻给客户端发文件内容,因为为了减少IO操作,socket发送和接收是有缓冲区的,缓冲区满了才会发送,那上一条消息很有可能会和文件内容的一部分被合并成一条消息发给客户端,这就行成了粘包,所以这里等待客户端的一个确认消息,就把两次发送分开了,不会再有粘包
            if feedback == 'FileTransfer|get|recv_ready': #如果客户端说准备好接收了
                f = file(msg[2],'rb')
                send_size = 0 #发送的逻辑跟客户端循环接收的逻辑是一样的
                while not file_size == send_size :
                    if file_size - send_size > 1024:
                        data = f.read(1024)
                        send_size += 1024
                    else: #left data less than 1024
                        data = f.read(file_size - send_size)
                        send_size +=(file_size - send_size)
                    self.request.send(data)
                    print file_size,send_size
                else:
                    print '---send file:%s done----' % msg[2]
                    f.close()
        elif msg[1] == 'put':
            pass


if __name__ == '__main__':

    HOST, PORT = "", 9002

    server = SocketServer.ThreadingTCPServer((HOST, PORT), MyTCPHandler)

    server.serve_forever()


好了, 这样客户端就能从服务器端上下载文件啦! 当然现在只要下载的功能,不过上传、查看文件列表的业务逻辑基本是跟这个差不多的,大家可以自己进行扩展,当然,如果要真想模拟ftp的功能更全面些,还得加上用户认证,权限认证,可切换目录,可对用户进行上传空间配额,可允许传目录,可实现多用户并发等更多细节功能,我的git里有一个例子,包含了用户认证,限制用户只能在自己的家目录活动,允许用户自主切换目录等,大家可以自己先写,没思路的话再参考我的代码。 


完整代码 :https://github.com/triaquae/py_training/tree/master/sample_code/ftp_sample 


* 注:有的同学问,这个多线程可支持多少用户并发呢?回答是支持不了多少,当然我也没实际测试过具体多少个,估计不会超过几百个,因为Python 的多线程是不能利用多核优势的,所以我们看到的并发其实本质上还是串行的,只不是cpu不断的在不同线程之间进行切换运行而已,但由于GIL要保证线程安全的原因,无论你生成多少个线程,Python的GIL只允许同一时间只有一个线程真正运行。如果真要实际多并发,采用异步的方式会是一个好方法,有机会我在跟大家分享下如何利用异步Select\Epoll来实际Socket的并发吧!


有兴趣的同学可以加入我的Python自动化讨论群(29215534),共同学习呵呵。。。。