python_网络编程

#python网络套接字模块
from socket import *

HOST = ‘127.0.0.1‘
PORT = 8888
ADDR = (HOST,PORT)
BUFFERSIZE = 1024

#1、创建流式套接字
socketfd = socket(AF_INET,SOCK_STREAM,proto=0)
#2、绑定本机IP和端口号
socketfd.bind(ADDR)
#3、将套接字变为可监听套接字
socketfd.listen(5)

print(‘wait for connect.....‘)
#4、套接字等待客户端请求
conn,addr = socketfd.accept()

print(‘connect from ‘,addr)

#5、消息的收发
while True:
    data = conn.recv(BUFFERSIZE)
    if not data:
        break
    print(‘接收到：‘,data.decode())
    n = conn.send(b‘Recv your message‘)
    print(‘发送了%d字节的数据‘%n)
#6、关闭套接字
conn.close()#表示和客户端断开连接
socketfd.close()#清除套接字，不能再使用

from socket import *

HOST = ‘127.0.0.1‘
PORT = 8888
ADDR = (HOST,PORT)
BUFFERSIZE = 1024

connfd = socket(AF_INET,SOCK_STREAM)
#连接服务器
connfd.connect(ADDR)

#和服务器进行通信
while True:
    data = input(‘发送>>>‘)
    if not data:
        break
    connfd.send(data.encode())
    data = connfd.recv(1024)
    print(‘客户端收到：‘,data.decode())

#关闭套接字
connfd.close()

from socket import *
import sys
from time import ctime

#从命令行传入客户端IP和端口号
HOST = sys.argv[1]
PORT = int(sys.argv[2])
ADDR = (HOST,PORT)
BUFFERSIZE = 1024

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

#2、绑定本地IP和端口
sockdf.bind(ADDR)

#3、收发消息
while True:
    data,addr = sockdf.recvfrom(BUFFERSIZE)
    print(‘recv from‘,addr,‘:‘,data.decode())
    sockdf.sendto((‘在%s接收到消息‘%ctime()).encode(),addr)
#4、关闭套接字
sockdf.close()

from socket import *
import sys

#从命令行传入服务器IP和端口号
HOST = sys.argv[1]
PORT = int(sys.argv[2])
ADDR = (HOST,PORT)
BUFFERSIZE = 1024

#1、创建数据报套接字
socketfd = socket(AF_INET,SOCK_DGRAM)
#2、消息收发
while True:
    data = input(‘消息>>‘)
    if not data:#输入为空时客户端退出
        break
    socketfd.sendto(data.encode(),ADDR)
    data,addr = socketfd.recvfrom(BUFFERSIZE)
    print(‘从服务器接收：‘,data.decode())
    
#3、关闭套接字
socketfd.close()

from socket import *

HOST = ‘127.0.0.1‘
PORT = 8888
ADDR = (HOST,PORT)
BUFFERSIZE = 1024

socketfd = socket(AF_INET,SOCK_STREAM,proto=0)
print(socketfd.fileno())#3,前面三个分别为os.stdin,os.stdout,os.stdnumber
print(socketfd.type)#SocketKind.SOCK_STREAM
print(socketfd.getsockname())#(‘0.0.0.0‘, 0)获取套接字对应的绑定的IP和端口,此时还没有绑定所以为0

#将端口号设置为立即重用
socketfd.setsockopt(SOL_SOCKET,SO_REUSEADDR,1)
print(socketfd.getsockopt(SOL_SOCKET,SO_REUSEADDR))#1,获取上面函数的第三个参数，如果没有设置则返回0

socketfd.bind(ADDR)
print(socketfd.getsockname())#(‘127.0.0.1‘, 9999)

socketfd.listen(5)

print(‘wait for connect.....‘)
conn,addr = socketfd.accept()
print(‘connect from ‘,conn.getpeername())#connect from  (‘127.0.0.1‘, 43236)
print(conn.fileno())

while True:
    data = conn.recv(BUFFERSIZE)
    if not data:
        break
    print(‘接收到：‘,data.decode())
    n = conn.send(b‘Recv your message‘)
    print(‘发送了%d字节的数据‘%n)

conn.close()#表示和客户端断开连接
socketfd.close()#清除套接字，不能再使用

from socket import *
import os
import signal #信号用来处理僵尸进程

def handler(c):
    ‘‘‘子进程处理客户端请求事件的函数‘‘‘
    while True:
        data = conn.recv(BUFFERSIZE)
        if not data:
            break
        print(‘recv %s from %s‘%(data.decode(),addr))
        num = conn.send(b‘hello‘)
        print(‘send %s size to %s:‘%(num,addr))
    conn.close()
    os._exit(0)#子进程结束

HOST = ‘127.0.0.1‘
PORT = 8888
ADDR = (HOST,PORT)
BUFFERSIZE = 1024

# 1、创建套接字，绑定，监听
socketfd = socket(AF_INET,SOCK_STREAM)
socketfd.setsockopt(SOL_SOCKET,SO_REUSEADDR,1)#将端口号设置为立即重用
socketfd.bind(ADDR)
socketfd.listen(5)
#处理僵尸进程
signal.signal(signal.SIGCHLD,signal.SIG_IGN)

# 2、接收客户端连接请求，创建新的进程
while True:
    try:
        conn,addr = socketfd.accept()
    except KeyboardInterrupt:
        print(‘服务器结束‘)
        socketfd.close()#如果按ctrl+c则关闭套接字
        os._exit(0)
    except Exception:
        continue#如果是其他异常则继续监听
    print(‘接收到客户端连接>‘,conn.getpeername())

    #创建子进程,子进程处理客户端事件
    pid = os.fork()
    if pid < 0:
        print(‘create process failed‘)
        continue
    elif pid ==0:
        socketfd.close()#把子进程中的流式套接字关闭
        print(‘接收客户端请求事件‘)
        handler(conn)
    else:
        conn.close()#把主进程中的连接客户端的套接字关闭
        continue# 主进程继续接收下一个客户端连接请求，

from socket import *
import threading
import os

def handler(c):
    ‘‘‘子线程处理客户端请求事件的函数‘‘‘
    while True:
        data = conn.recv(BUFFERSIZE)
        if not data:
            break
        print(‘recv %s from %s‘%(data.decode(),addr))
        num = conn.send(b‘hello‘)
        print(‘send %s size to %s:‘%(num,addr))
    conn.close()

HOST = ‘127.0.0.1‘
PORT = 8888
ADDR = (HOST,PORT)
BUFFERSIZE = 1024

# 1、创建套接字，绑定，监听
socketfd = socket(AF_INET,SOCK_STREAM)
socketfd.setsockopt(SOL_SOCKET,SO_REUSEADDR,1)#将端口号设置为立即重用
socketfd.bind(ADDR)
socketfd.listen(5)

# 2、接收客户端连接请求，创建新的线程
while True:
    try:
        conn,addr = socketfd.accept()
    except KeyboardInterrupt:
        print(‘服务器结束‘)
        socketfd.close()#如果按ctrl+c则关闭套接字
        os._exit(0)
    except Exception:
        continue#如果是其他异常则继续监听
    print(‘接收到客户端连接>‘,conn.getpeername())

    #创建子进程,子进程处理客户端事件
    t  = threading.Thread(target = handler,args=(conn,))
    t.setDaemon(True)#主线程结束，所有的子线程都结束
    t.start()
    #conn.close()#把主线程中的连接客户端的套接字关闭

#fork +tcp 并发
from socketserver import *

#创建服务器类
class Server(ForkingMixIn,TCPServer):#等价于Server(ForkingTCPServer)
    pass
#创建处理类
class Handler(StreamRequestHandler):
    def handle(self):
        ‘‘‘当客户端连接进来时候会自动调用该函数处理客户端请求时间‘‘‘
        addr = self.client_address
        print(‘connect from ‘,addr)
        while True:
            #self.requset为tcp中为我们自动生成的和客户端交互的套接字

            data = self.request.recv(1024)
            if not data:
                break
            print(‘recv %s from %s‘%(data.decode(),addr))
            num = self.request.send(b‘hello‘)
            print(‘send %s size to %s:‘%(num,addr))
    
#使用创建的服务器类来生产服务器
server = Server((‘127.0.0.1‘,8888),Handler)
#运行服务器
server.serve_forever()

#fork + udp
from socketserver import *

class Server(ForkingUDPServer):
    pass

class Handler(DatagramRequestHandler):
    #udp无连接所以request的含义不同
    def handle(self):
        data = self.rfile.readline()
        print(‘接收到了：‘,data.decode())
        self.wfile.write(b‘recevie message‘)
        
server = Server((‘127.0.0.1‘,8888),Handler)
server.serve_forever()

from socket import *
import os
import sys
import signal
import time

FILE_PATH = ‘/home/xdl/python/ftp/file_path/‘
class FtpServer(object):
    def __init__(self,conn):
        self.conn = conn

    def do_list(self):
        ‘‘‘服务器端确认请求是否可以执行‘‘‘
        filelist = os.listdir(FILE_PATH)
        if not filelist or filelist == None:
            self.conn.send(b‘FAIL‘)
        else:
            self.conn.send(b‘OK‘)
            time.sleep(0.1)
        for file in filelist:
            #print(file)
            if file[0] != ‘.‘ and os.path.isfile(FILE_PATH+file):
                self.conn.send(file.encode())
                time.sleep(0.1)
        self.conn.send(b‘##‘)#告诉客户端我已经发送完毕
        print(‘文件列表发送完毕‘)
        return
    def do_get(self,filename):
        try:
            with open(FILE_PATH+filename,‘rb‘) as fd:
                self.conn.send(b‘OK‘)
                time.sleep(0.1)
                for line in fd:
                    self.conn.send(line)
        except:
            print(‘文件打开失败‘)
            self.conn.send(b‘FAIL‘)
        time.sleep(0.1)
        self.conn.send(b‘##‘)
        print(‘文件发送成功‘)
        return
    def do_put(self,filename):
        try:
            with open(FILE_PATH+filename,‘w‘) as fd:
                print(filename)
                self.conn.send(b‘ok‘)
                time.sleep(0.1)
                while True:
                    data = self.conn.recv(1024).decode()
                    if data == ‘##‘:
                        break
                    fd.write(data)
                print(‘文件接收成功‘)
                return
        except OSError:
            print(‘文件打开失败‘)#可能权限不够导致文件打开失败
            self.conn.send(b‘FAIL‘)

def main():
    if len(sys.argv) != 3:#保证输入的命令是三个部分
        print(‘argv is error‘)
        sys.exit(1)
    HOST = sys.argv[1]
    PORT = int(sys.argv[2])
    ADDR = (HOST,PORT)
    BUFFERSIZE = 1024

    socketfd = socket(AF_INET,SOCK_STREAM)#创建流式套接字
    socketfd.setsockopt(SOL_SOCKET,SO_REUSEADDR,1)#将端口设置为立即可用
    socketfd.bind(ADDR)
    socketfd.listen(5)
    signal.signal(signal.SIGCHLD,signal.SIG_IGN)#处理僵尸进程

    while True:
        try:
            conn,addr = socketfd.accept()
        except KeyboardInterrupt:
            print(‘服务器结束‘)#如果按ctrl+c则关闭套接字
            socketfd.close()
            os._exit(0)
        except Exception:
            continue #如果是其他异常则继续监听
        print(‘connect from :‘,addr)

        pid = os.fork()#创建子进程
        if pid < 0:
            print(‘create process failed‘)
            continue
        elif pid ==0:
            socketfd.close()#把子进程中的流式套接字关闭
            ftp = FtpServer(conn)

            while True:#接收客户请求
                data = conn.recv(1024).decode()
                if data[0] ==‘L‘:
                    ftp.do_list()
                elif data[0] ==‘G‘:
                    filename = data.split()[-1]
                    #print(filename)
                    ftp.do_get(filename)
                elif data[0] ==‘P‘:
                    filename = data.split()[-1]
                    print(filename)
                    ftp.do_put(filename)
                elif data[0] == ‘Q‘:
                    print(‘客户端退出‘)
                    sys.exit(0)
        else:
            conn.close()#把主进程中的连接客户端的套接字关闭
            continue# 主进程继续接收下一个客户端连接请求

if __name__ == ‘__main__‘:
    main()

from socket import *
import sys
import time

FILE_PATH = ‘/home/xdl/python/ftp/down_file_path/‘
class FtpClient(object):
    def __init__(self,connfd):
        self.connfd = connfd

    def do_list(self):
        self.connfd.send(b‘L‘)#发送请求类型
        #接收服务器端的确认消息
        data = self.connfd.recv(1024).decode()
        if data == ‘OK‘:
            while True:
                data = self.connfd.recv(1024).decode()
                if data == ‘##‘:
                    break
                print(data)
            print(‘文件列表展示完毕‘)
            return
        else:
            print(‘文件列表请求失败‘)
            return

    def do_get(self,filename):
        self.connfd.send((‘G ‘+filename).encode())
        data = self.connfd.recv(1024).decode()
        if data == ‘OK‘:
            with open(FILE_PATH+filename,‘w‘) as fd:
                while True:
                    data = self.connfd.recv(1024).decode()
                    if data == ‘##‘:
                        break
                    fd.write(data)
                print(‘%s下载完成‘%filename)
                return
        else:
            print(‘下载文件失败‘)
            return

    def do_put(self,filename):
        try:#如果文件打开失败，就不要向服务器发送数据了
            with open(FILE_PATH+filename,‘rb‘) as fd:
                self.connfd.send((‘P ‘+filename).encode())
                data = self.connfd.recv(1024).decode()

                if data == ‘ok‘:
                    for line in fd:
                        self.connfd.send(line)
                    time.sleep(0.1)
                    self.connfd.send(b‘##‘)
                    print("%s文件上传成功"%filename)
                else:
                    print(‘文件上传失败‘)
                    return                        
        except OSError:
            print(‘文件打开失败‘)
            return        

    def do_quit(self):
        self.connfd.send(b‘Q‘)

def main():
    if len(sys.argv) != 3:#保证输入的命令是三个部分
        print(‘argv is error‘)
        sys.exit(1)
    HOST = sys.argv[1]
    PORT = int(sys.argv[2])
    ADDR = (HOST,PORT)
    BUFFERSIZE = 1024

    connfd = socket()
    connfd.connect(ADDR)

    ftp = FtpClient(connfd)
    while True:
        print(‘***********命令选项***********‘)
        print(‘***********L(展示列表)***********‘)
        print(‘***********G(下载)***********‘)
        print(‘***********P(上传)***********‘)
        print(‘***********Q(退出)***********‘)
        data = input(‘输入命令>>‘)
        if data == ‘L‘:
            ftp.do_list()
        elif data[0] == ‘G‘:
            filename = data.split()[-1]
            ftp.do_get(filename)
        elif data[0] == ‘P‘:
            filename = data.split()[-1]
            ftp.do_put(filename)
        elif data == ‘Q‘:
            ftp.do_quit()
            connfd.close()
            sys.exit(0)
        else:
            print(‘请输入正确的命令!!!‘)
            continue

    #关闭套接字
    connfd.close()
if __name__ == ‘__main__‘:
    main()

#基于select的IO多路复用监听服务器
from socket import *
import select

#s套接字作为一个IO事件
s = socket()
s.bind((‘127.0.0.1‘,8889))
s.listen(5)

rlist = [s]
wlist = []
xlist = [s]

while True:
    #监听三个关注的列表中的IO事件
    rs,ws,es = select.select(rlist,wlist,xlist)
    print(‘有IO事件发生了‘)
    #通过for循环遍历每个返回列表，去处理IO
    for r in rs:
        if r is s:
            c,addr = s.accept()
            print("connect from ",addr)
            #将新的IO事件加入到监控列表
            rlist.append(c)
        else:
            data = r.recv(1024).decode()
            if not data:
                print(‘客户端退出‘)
                rlist.remove(r)
                r.close()
            print(‘收到客户端信息‘,data)
            r.send(‘收到了你的消息‘.encode())    
    for w in ws:
        pass
    for e in es:
        pass
s.close()

#基于select的IO多路复用监听服务器
from socket import *
import select
import sys

#s套接字作为一个IO事件
s = socket()
s.bind((‘127.0.0.1‘,8889))
s.listen(5)

rlist = [s]
wlist = []
xlist = [s]

while True:
    #监听三个关注的列表中的IO事件
    rs,ws,es = select.select(rlist,wlist,xlist)
    print(‘有IO事件发生了‘)
    #通过for循环遍历每个返回列表，去处理IO
    for r in rs:
        if r is s:
            c,addr = s.accept()
            print("connect from ",addr)
            #将新的IO事件加入到监控列表
            rlist.append(c)
            xlist.append(c)#将与客户端交互的套接字加入到异常列表中
        else:
            data = r.recv(1024).decode()
            if not data:
                print(‘客户端退出‘)
                rlist.remove(r)
                xlist.remove(r)
                r.close()
            else:
                wlist.append(r)
            print(‘收到客户端信息‘,data)

    for w in ws:
        r.send(‘收到了你的消息‘.encode())
        wlist.remove(w)    
    for e in es:
        if e is s:
            s.close()
            sys.exit(0)#如果发生异常则退出
        else:
            e.close()
            rlist.remove(e)
            xlist.remove(e)

#基于poll的IO多路复用监听服务器
from socket import *
import select

#s套接字作为一个IO事件
s = socket()
s.setsockopt(SOL_SOCKET,SO_REUSEADDR,1)
s.bind((‘127.0.0.1‘,8888))
s.listen(5)
#以每个IO对象的fileno为键，IO对象为值
fdmap = {s.fileno():s}

#创建poll对象
p = select.poll()
#添加关注的IO
p.register(s)#此处添加IO对象的fileno也可以:等价于p.register(s.fileno)

while True:
    #监控关注的IO
    events = p.poll()
    #print(events)
    for fd,event in events:
        if fd == s.fileno():
            c,addr = fdmap[fd].accept()
            print(‘Connect from ‘,addr)
            #将客户端套接字添加关注并添加到字典中
            p.register(c)
            fdmap[c.fileno()] = c
        elif event & select.POLLIN :#得到True表示是当前事件类型
            data = fdmap[fd].recv(1024).decode()
            #如果客户端退出则不再关注，并从字典中移除
            if not data:
                p.unregister(fd)
                del fdmap[fd]
            else:
                print(data)
                fdmap[fd].send(‘收到你的消息‘.encode())