socket 的ssh以及ftp，socketServer的ssh和ftp

简单的socket的ssh：

　　这里需要注意几点：

　　　　　　1.发送数据是先放到缓存区，如何让客户端全部数据。

　　　　　　　　发数据之前，先把数据大小发给客户端，让客户端接受这么多数据

　　　　　　2.如何处理粘包问题

　　　　　　　　客户端接收到需要接受多少数据后，再给服务器发一个开始接受数据　　　　　

 socket_server:

# Author:zylong
#创建通道
import socket,os

server = socket.socket()

server.bind(("0.0.0.0",8888))

server.listen()

while True:
    coon,addr = server.accept()#接受客户端的连接

    while True:
        data = coon.recv(1024)
        if not data:
            break
        #执行客户端发送过来的命令
        cmd_res = os.popen(data.decode()).read()
        #这里需要注意的是，这个发送，系统会有一个缓冲区，再发给客户端
        print(cmd_res)
        aa = len(cmd_res.encode())
        print(aa)
        coon.send(str(aa).encode())
        res_client = coon.recv(1023)
        coon.sendall(cmd_res.encode())

 

socket_client:

# Author:zylong
import socket

client = socket.socket()

client.connect(("localhost",8888))

while True:
    cmd = input(">>:")
    client.send(cmd.encode())
    #接受的命令长度
    server_len = client.recv(1024)
    print(server_len)
    server_len = int(server_len.decode())
    client.send("ok".encode())
    has_recv = 0
    rece_size = 1024
    recv_data = ""
    while True:
        if server_len - has_recv < 1024:
            rece_size = server_len - has_recv
        data = client.recv(rece_size)
        if not data:
            break
        has_recv += len(data)
        recv_data += data.decode()
    print(recv_data)

 

========================================================================

简单的socket ftp

 server:

# Author:zylong

#下载
import socket,os,sys,hashlib

server = socket.socket()

server.bind(("0.0.0.0",8888))

server.listen()
#并且加密认证
while True:
    coon,addr = server.accept()
    while True:
        fileMethod = coon.recv(1024).decode()
        print(fileMethod)
        if not fileMethod:
            break
        md5 = hashlib.md5()
        #这个是文件路径和文件名 例如 get D:\data\cfgtoollogs\oui\oraInstall2017-04-18_04-47-25PM.out
        #将这个路径进行分割
        fileName = fileMethod.split()[1]
        #判断文件是否存在
        if os.path.isfile(fileName):
            #获取文件大小
            size = os.stat(fileName).st_size
            print("size:",size)
            coon.send(str(size).encode())
            with open(fileName,"rb") as f:
                for line in f:
                    print(line.decode("gbk"))
                    coon.send(line)
                    md5.update(line)
                #最后再将加密的秘法发送过去
            coon.send(md5.hexdigest().encode())
            print(md5.hexdigest())
        else:
            coon.send("文件不存在".encode())

 

client:

# Author:zylong
import socket,os,hashlib

client = socket.socket()

client.connect(("localhost",8888))

while True:
    md5 = hashlib.md5()
    getFile = input("please get begin:")

    fileName = os.path.split(getFile.split()[1])[1]
    client.send(getFile.encode())
    fileSize = int(client.recv(1024).decode())
    print("fileSize",fileSize)
    has_recv = 0
    recv_size = 8192
    f = open(fileName, "wb")
    while True:
        if fileSize - has_recv < 8192:
            recv_size = fileSize - has_recv
        line = client.recv(recv_size)
        if not line:
            print("not data")
            break
        print(line.decode("gbk"))
        has_recv += len(line)
        f.write(line)
        md5.update(line)
    #在接受服务端的md5
    print("本地",md5.hexdigest())
    server_md5 = client.recv(1024)
    print("服务器",server_md5)
    f.close()

 

socketserver:

socketserver_ssh的实例：

import socketserver,os

class MyRequestHandler(socketserver.BaseRequestHandler):

    def handle(self):
        # super().handle()
        #这里处理所有的请求
        #获取链接(这里会有一个问题就是，客户端断开连接的时候，这里是会报错的)
        coon = self.request
        print(self.client_address)
        try:
            while True:
                cmd = coon.recv(1024)

                if not cmd:
                    break
                cmd_res = os.popen(cmd.decode()).read()
                #防止粘包(这里注意，长度一定要encode())要不客户端报错
                res_len = len(cmd_res.encode())
                print(res_len)
                coon.send(str(res_len).encode())
                client_answer = coon.recv(1024)
                print(client_answer)
                coon.sendall(cmd_res.encode())
                print(cmd_res)
        except ConnectionResetError as e:
            #这里就取不到客户端的信息了
            # print(self.client_address)
            print(e)




if __name__ == '__main__':
    #这样就监听一个客户端的链接了
    # tcpServer = socketserver.TCPServer(("0.0.0.0",8888),MyRequestHandler)
    # tcpServer.serve_forever()
    #如果想启动多线程，多客户端同时监听
    threadTcpserver = socketserver.ThreadingTCPServer(("0.0.0.0",8888),MyRequestHandler)
    threadTcpserver.serve_forever()

 

socket_client_ssh:

import socket

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

while True:
    cmd= input(">>:")
    if not cmd:
        continue
    client.send(cmd.encode())
    dataSize = int(client.recv(1024).decode())
    print(dataSize)
    has_recv = 0
    recv_size = 1024
    client.send("ok".encode())
    while True:
        if dataSize - has_recv< 1024:
            recv_size = dataSize - has_recv
        data = client.recv(recv_size)
        if not data:
            break
        has_recv += len(data)
        print(data.decode())

 

=================================================================================

socketserver_ftp:

# Author:zylong
import  socketserver,os

class MyFtpRequestHandler(socketserver.BaseRequestHandler):
    def handle(self):
        # super().handle()
        coon = self.request
        #获取是上传文件还是下载文件  以get 或者 upload 开头，其他情况视为非法操作
        cmd_filename = coon.recv(1024).decode()
        print(cmd_filename)

        method = cmd_filename.split()[0]
        fileName = cmd_filename.split()[1]
        #根据反射回去方法
        if hasattr(MyFtpRequestHandler,method):
            fun = getattr(self,method)
            fun(fileName)
        else:
            coon.send("你输入的命令不存在".encode())
            print("输入命令有误")

    def saveFile(self, filename, size, recv_size=1024):
        coon = self.request
        has_recv = 0
        # 直接保存
        with open(filename, "wb") as f:
            while True:
                if size - has_recv < 1024:
                    recv_size = size - has_recv
                data = coon.recv(recv_size)
                if not data:
                    break
                has_recv += len(data)
                f.write(data)

    def get(self,*args):
        #判断文件是否存在
        coon = self.request
        filename = args[0]
        if os.path.isfile(filename):
            #获取文件大小
            size = os.stat(filename).st_size
            coon.send(str(size).encode())
            client_answer = coon.recv(1024)
            print(client_answer)
            with open(filename,"rb") as f:
                for line in f:
                    coon.send(line)
        else:
            coon.send("文件不存在".encode())

    def upload(self,*args):
        coon = self.request
        filepathname = args[0]
        #保存在当前文件夹下
        filename = os.path.split(filepathname)[1]
        #文件大小
        size = int(coon.recv(1024).decode())
        print(size)
        #判断当前文件夹下文件是否存在，提示用户，是覆盖还是创建新的
        # path = os.getcwd()
        # file = os.path.join(path,filename)
        # if os.path.isfile(file):
        #     coon.send("文件已存在是否覆盖".encode())
        #     client_answer = coon.recv(1024).decode()
        #     if client_answer == 'yes':
        #         self.saveFile(filename, size)
        #
        # else:
        #     self.saveFile(filename,size)
        coon.send("ok".encode())
        f = open(filename,"wb")
        has_recv = 0
        recv_size = 1024
        while True:
            if size - has_recv < 1024:
                recv_size = size - has_recv
            data = coon.recv(recv_size)
            if not data:
                break
            has_recv += len(data)
            #把已接受的发送给客户端
            coon.send(str(has_recv).encode())
            f.write(data)
        f.close()







if __name__ == '__main__':
    tcpserver = socketserver.ThreadingTCPServer(("0.0.0.0",9999),MyFtpRequestHandler)
    tcpserver.serve_forever()

 

 

 

socket_client；

# Author:zylong
import socket,os

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

#E:\pythonworkspace\oldboylearn\day06\schoole\core\admin.py
# 上传 upload D:\data\cfgtoollogs\oui\oraInstall2017-04-18_04-47-25PM.out

while True:
    cmd = input(">>>:")
    if not cmd:
        continue
    client.send(cmd.encode())
    if cmd.startswith("get"):
        size = int(client.recv(1024).decode())
        print("data",size)
        client.send("ok".encode())
        has_resv = 0
        recv_size = 1024
        f = open("aa.txt","wb")
        while True:
            if size - has_resv < 1024:
                recv_size = size - has_resv
            data = client.recv(recv_size)
            if not data:
                break
            print(data)
            has_resv += len(data)
            f.write(data)
        f.close()
    else:
        filename = cmd.split()[1]
        size = os.stat(filename).st_size
        client.send(str(size).encode())
        data = client.recv(1024).decode()
        # if not data:
        #     pass
        # else:
        #     yes_no = input("|||:")
        #     client.send(yes_no.encode())
        print("data",data)
        f = open(filename,"rb")
        for line in f:
            client.send(line)
        f.close()