1.  #通过socket 实现简单的ssh#服务端
  2.  
  3.  #服务端
  4.  import os
  5.  import socket
  6.  
  7.  server = socket.socket()
  8.  
  9.  #server.bind(('0.0.0.0',9999))
  10.  server.bind(('localhost',9999))
  11.  server.alisten()
  12.  
  13.  while True:
  14.      conn,addr = server.accept()
  15.      print ('new conn:',addr)
  16.      while True:
  17.          print ('等待新指令')
  18.          data = conn.recv(1024)
  19.          if not data:
  20.              print ('客户端已经断开')
  21.              break
  22.  
  23.          print ('执行指令：',data)
  24.          cmd_res = os.poen(data.decode()).read()#接收字符串，执行结果也是字符串
  25.          print('before send',len(cmd_res))
  26.          if len(cmd_res) == 0 :
  27.              cmd_res = 'cmd has no output...'
  28.  
  29.          conn.send(str(len(cmd_res.encode())).encode('utf-8'))  #先发文件大小给客户端
  30.          conn.send(cmd_res.encode('utf-8'))
  31.          print('send done')
  32.  
  33.  server.close()

#通过socket 实现简单的ssh#服务端

  1.  #通过socket 实现简单的ssh#客户端
  2.  
  3.  #客户端
  4.  
  5.  import socket
  6.  
  7.  client = socket.socket()
  8.  
  9.  #client.connect(('192.168.16.200',9999))
  10.  client.connect(('localhost',9999))
  11.  
  12.  while True:
  13.      cmd =input('>>>>:').strip()
  14.      if len(cmd) == 0:continue
  15.      client.send(cmd.encode('utf-8'))
  16.  
  17.      cmd_rer_size = client.recv(1024)#接收命令结果的长度（文件大小）
  18.      #cmd_res = client.recv(1024)
  19.  
  20.      print ('命令结果大小:',cmd_res._size)
  21.  
  22.      received_size = 0  
  23.  
  24.      received_data = b''
  25.  
  26.      while received_size < int(cmd_res_size.decode()):
  27.          data = client.recv(1024)
  28.          received_size += len(data) #每次收到的有可能小于1024，所以必须用len判断
  29.          #print (data.decode())
  30.          #print (received_size)
  31.          received_data += data
  32.  
  33.      else:
  34.          print (' cmd res receive done...',received_size)
  35.          print (received_data.decode())
  36.  
  37.  client.close()

#通过socket 实现简单的ssh#客户端

  1.  '''
  2.  
  3.  #通过socket接收大数据2#服务端
  4.  
  5.  #通过socket 实现简单的ssh#服务端
  6.  
  7.  #服务端A
  8.  import time
  9.  import os
  10.  import socket
  11.  
  12.  server = socket.socket()
  13.  
  14.  server.bind(('0.0.0.0',9999))
  15.  #server.bind(('localhost',9999))
  16.  server.listen()
  17.  
  18.  while True:
  19.      conn,addr = server.accept()
  20.      print ('new conn:',addr)
  21.      while True:
  22.          print ('等待新指令')
  23.          data = conn.recv(1024)
  24.          if not data:
  25.              print ('客户端已经断开')
  26.              break
  27.  
  28.          print ('执行指令：',data)
  29.          cmd_res = os.popen(data.decode()).read()#接收字符串，执行结果也是字符串
  30.          print('before send',len(cmd_res))
  31.          if len(cmd_res) == 0 :
  32.              cmd_res = 'cmd has no output...'
  33.  
  34.          conn.send(str(len(cmd_res.encode())).encode('utf-8'))  #先发文件大小给客户端
  35.          #time.sleep(0.5)   #socket 粘包,解决方法不好
  36.  
  37.          client_ack = conn.recv(1024) #等待客户端确认
  38.          print ('ack from client:',client_ack)
  39.  
  40.          conn.send(cmd_res.encode('utf-8'))
  41.          print('send done')
  42.  
  43.  server.close()
  44.  
  45.  '''
  46.  '''
  47.  import hashlib
  48.  m = hashlib.md5
  49.  m.update(b'test')
  50.  m.update(b'abc')
  51.  
  52.  '''
  53.  
  54.  '''
  55.  
  56.  #服务端B
  57.  import hashlib
  58.  import time
  59.  import os
  60.  import socket
  61.  
  62.  server = socket.socket()
  63.  
  64.  server.bind(('0.0.0.0',9999))
  65.  #server.bind(('localhost',9999))
  66.  server.listen()
  67.  
  68.  while True:
  69.      conn,addr = server.accept()
  70.      print ('new conn:',addr)
  71.      while True:
  72.          print ('等待新指令')
  73.          data = conn.recv(1024)
  74.          if not data:
  75.              print ('客户端已经断开')
  76.              break
  77.  
  78.          cmd,filename = data.decode().split()
  79.          print (filename)
  80.  
  81.          if os.path.isfile(filename):
  82.              f =open(filename,'rb')
  83.              m=hashlib.md5()
  84.              file_size =os.stat(filename).st_size
  85.              conn.send(str(file_size).encode())#文件大小
  86.              conn.recv(1024)#等待 ack
  87.              for line in f:
  88.                  #m.update(line)
  89.                  conn.send(line)
  90.              #print ('file md5',m.hexdigest())
  91.              f.close()
  92.          print('send done')
  93.  
  94.  server.close()
  95.  
  96.  '''
  97.  
  98.  #服务端C
  99.  import hashlib
  100.  import time
  101.  import os
  102.  import socket
  103.  
  104.  server = socket.socket()
  105.  
  106.  server.bind(('0.0.0.0',9999))
  107.  #server.bind(('localhost',9999))
  108.  server.listen()
  109.  
  110.  while True:
  111.      conn,addr = server.accept()
  112.      print ('new conn:',addr)
  113.      while True:
  114.          print ('等待新指令')
  115.          data = conn.recv(1024)
  116.          if not data:
  117.              print ('客户端已经断开')
  118.              break
  119.  
  120.          cmd,filename = data.decode().split()
  121.          print (filename)
  122.  
  123.          if os.path.isfile(filename):
  124.              f =open(filename,'rb')
  125.              m=hashlib.md5()
  126.              file_size =os.stat(filename).st_size
  127.              conn.send(str(file_size).encode())#文件大小
  128.              conn.recv(1024)#等待 ack
  129.              for line in f:
  130.                  m.update(line)
  131.                  conn.send(line)
  132.              print ('file md5',m.hexdigest())
  133.              f.close()
  134.              conn.send(m.hexdigest().encode())#mp5
  135.  
  136.          print('send done')
  137.  
  138.  server.close()

#通过socket接收大数据2#服务端

  1.  '''
  2.  #通过socket接收大数据2#客户端
  3.  
  4.  #通过socket 实现简单的ssh#客户端
  5.  
  6.  #客户端A
  7.  
  8.  import socket
  9.  
  10.  client = socket.socket()
  11.  
  12.  #client.connect(('192.168.80.20',9999))
  13.  client.connect(('localhost',9999))
  14.  
  15.  while True:
  16.      cmd =input('>>>>:').strip()
  17.      if len(cmd) == 0:continue
  18.      client.send(cmd.encode('utf-8'))
  19.  
  20.      cmd_rer_size = client.recv(1024)#接收命令结果的长度（文件大小）
  21.      #cmd_res = client.recv(1024)
  22.  
  23.      print ('命令结果大小:',cmd_res._size)
  24.      client.send('准备好接收了,loser可以发了'.encode('utf-8'))
  25.      received_size = 0  
  26.  
  27.      received_data = b''
  28.  
  29.      while received_size < int(cmd_res_size.decode()):
  30.          data = client.recv(1024)
  31.          received_size += len(data) #每次收到的有可能小于1024，所以必须用len判断
  32.          #print (data.decode())
  33.          #print (received_size)
  34.          received_data += data
  35.  
  36.      else:
  37.          print (' cmd res receive done...',received_size)
  38.          print (received_data.decode())
  39.  
  40.  client.close()
  41.  
  42.  '''
  43.  
  44.  '''
  45.  #客户端B
  46.  
  47.  import socket
  48.  
  49.  client = socket.socket()
  50.  
  51.  #client.connect(('192.168.80.20',9999))
  52.  client.connect(('localhost',9999))
  53.  
  54.  while True:
  55.      cmd =input('>>>>:').strip()
  56.      if len(cmd) == 0:continue
  57.      if cmd.startswith('get'):
  58.          client.send(cmd.encode())
  59.          server_response = client.recv(1024)
  60.          print ('servr response',server_response)
  61.          client.send(b'ready to recv file')
  62.          file_total_size = int (server_response.decode())
  63.          received_size = 0
  64.          filename = cmd.split()[1]
  65.          f =open (filename +'.new','wb')
  66.          while received_size < file_total_size:
  67.              data =client.recv(1024)
  68.              received_size += len(data)
  69.              f.write(data)
  70.              #print (file_total_size,received_size)
  71.          else:
  72.              print('file recv done',received_size,file_total_size)
  73.              f.close()
  74.  client.close()
  75.  
  76.  '''
  77.  
  78.  #客户端C
  79.  
  80.  import socket
  81.  import hashlib
  82.  client = socket.socket()
  83.  
  84.  #client.connect(('192.168.80.20',9999))
  85.  client.connect(('localhost',9999))
  86.  
  87.  while True:
  88.      cmd =input('>>>>:').strip()
  89.      if len(cmd) == 0:continue
  90.      if cmd.startswith('get'):
  91.          client.send(cmd.encode())
  92.          server_response = client.recv(1024)
  93.          print ('servr response',server_response)
  94.          client.send(b'ready to recv file')
  95.          file_total_size = int (server_response.decode())
  96.          received_size = 0
  97.          filename = cmd.split()[1]
  98.          f = open (filename +'.new','wb')
  99.          m = hashlib.md5()
  100.  
  101.          while received_size < file_total_size:
  102.              if file_total_size - received_size > 1024 :#要收不止一次
  103.                  size =1024
  104.              else:  #最后一次了，剩下多少收多少
  105.                  size = file_total_size - received_size
  106.                  print ('lastreceive:',size)
  107.              data =client.recv(size)
  108.              received_size += len(data)
  109.              m.update(data)
  110.              f.write(data)
  111.              #print (file_total_size,received_size)
  112.          else:
  113.              new_file_md5 = m.hexdigest()
  114.              print('file recv done',received_size,file_total_size)
  115.              f.close()
  116.          server_file_md5 = client.recv(1024)
  117.          print ('server file md5:',server_file_md5)
  118.          print ('clientr file md5:',new_file_md5)
  119.  
  120.  client.close()

#通过socket接收大数据2#客户端

  1.  #socketserver基本使用#服务器端
  2.  '''
  3.  1 你必须创建一个请求处理类。并且这个类要继承BaseRequestHandler，
  4.          并且还要重写父亲类的handle()
  5.  
  6.  2 你必须实例化TCPServer,并且传递server ip 和你上面创建的请求处理类
  7.          给这个TCPServer
  8.  
  9.  3 调用  Server.handle_request()#只处理一个请求
  10.          Server.serve_forever()#处理多个请求，并且永远执行
  11.  
  12.  4 关闭服务
  13.  '''
  14.  
  15.  #socketserver基本使用
  16.  
  17.  import socketserver
  18.  
  19.  class MyTCPHandler(socketserver.BaseRequestHandler):
  20.      def handle(self):
  21.          while True:
  22.              try:
  23.                  self.data =self.request.recv(1024).strip()
  24.                  print ('{} wrote:'.format(self.client_address[0]))
  25.                  print (self.data)
  26.                  self.request.send(self.data.upper())
  27.              except ConnectionResetError as e:
  28.                  print ('err,e')
  29.                  break
  30.  
  31.  if __name__ == '__main__':
  32.      HOST,PORT = 'localhost',9999
  33.      server = socketserver.TCPServer((HOST,PORT),MyTCPHandler)
  34.      server.serve_forever()

#socketserver基本使用#服务器端

  1.  #socketserver基本使用#客户端
  2.  '''
  3.  1 你必须创建一个请求处理类。并且这个类要继承BaseRequestHandler，
  4.          并且还要重写父亲类的handle()
  5.  
  6.  2 你必须实例化TCPServer,并且传递server ip 和你上面创建的请求处理类
  7.          给这个TCPServer
  8.  
  9.  3 调用  Server.handle_request()#只处理一个请求
  10.          Server.serve_forever()#处理多个请求，并且永远执行
  11.  
  12.  4 关闭服务
  13.  '''
  14.  
  15.  #socketserver基本使用#客户端
  16.  
  17.  import socket
  18.  
  19.  client = socket.socket()#声明socket类型，同时生成socket连接对象
  20.  
  21.  client.connect(('localhost',9999))
  22.  
  23.  while True:
  24.      msg =input('>>:').strip()
  25.      if len(msg) == 0:continue
  26.      client.send(msg.encode('utf-8'))
  27.      data = client.recv(10240)
  28.      print ('recv:',data.decode())
  29.  
  30.  client.close()

#socketserver基本使用#客户端

  1.  #socketserver 多线程（多并发）使用#服务端
  2.  '''
  3.  1 你必须创建一个请求处理类。并且这个类要继承BaseRequestHandler，
  4.          并且还要重写父亲类的handle()
  5.  
  6.  2 你必须实例化TCPServer,并且传递server ip 和你上面创建的请求处理类
  7.          给这个TCPServer
  8.  
  9.  3 调用  Server.handle_request()#只处理一个请求
  10.          Server.serve_forever()#处理多个请求，并且永远执行
  11.  
  12.  4 关闭服务
  13.  '''
  14.  #普通socket地址重用
  15.  #server = socket.socket() #获得socket实例
  16.  #server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
  17.  
  18.  #socketserver 地址重用
  19.  #self.allow_reuse_address
  20.  
  21.  import socketserver
  22.  
  23.  class MyTCPHandler(socketserver.BaseRequestHandler):
  24.      def handle(self):
  25.          while True:
  26.              try:
  27.                  self.data =self.request.recv(1024).strip()
  28.                  print ('{} wrote:'.format(self.client_address[0]))
  29.                  print (self.data)
  30.                  self.request.send(self.data.upper())
  31.              except ConnectionResetError as e:
  32.                  print ('err,e')
  33.                  break
  34.  
  35.  if __name__ == '__main__':
  36.      HOST,PORT = 'localhost',9999
  37.  
  38.      server = socketserver.ThreadingTCPServer((HOST,PORT),MyTCPHandler)
  39.      server.serve_forever()

#socketserver 多线程（多并发）使用#服务端

  1.  #socketserver 多进程使用#服务端 WIN不能使用
  2.  '''
  3.  1 你必须创建一个请求处理类。并且这个类要继承BaseRequestHandler，
  4.          并且还要重写父亲类的handle()
  5.  
  6.  2 你必须实例化TCPServer,并且传递server ip 和你上面创建的请求处理类
  7.          给这个TCPServer
  8.  
  9.  3 调用  Server.handle_request()#只处理一个请求
  10.          Server.serve_forever()#处理多个请求，并且永远执行
  11.  
  12.  4 关闭服务
  13.  '''
  14.  
  15.  import socketserver
  16.  
  17.  class MyTCPHandler(socketserver.BaseRequestHandler):
  18.      def handle(self):
  19.          while True:
  20.              try:
  21.                  self.data =self.request.recv(1024).strip()
  22.                  print ('{} wrote:'.format(self.client_address[0]))
  23.                  print (self.data)
  24.                  self.request.send(self.data.upper())
  25.              except ConnectionResetError as e:
  26.                  print ('err,e')
  27.                  break
  28.  
  29.  if __name__ == '__main__':
  30.      HOST,PORT = 'localhost',9999
  31.      server = socketserver.ForkingTCPServer((HOST,PORT),MyTCPHandler)
  32.      server.serve_forever()

#socketserver 多进程使用#服务端 WIN不能使用

#socket #socketserver的更多相关文章

  1. socket - socketserver - start TCP server

    前面提到如何使用socket模块启动tcpserver: 创建socket:sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 绑定ip: ...

  2. python网络编程socket /socketserver

    提起网络编程,不同于web编程,它主要是C/S架构,也就是服务器.客户端结构的.对于初学者而言,最需要理解的不是网络的概念,而是python对于网络编程都提供了些什么模块和功能.不同于计算机发展的初级 ...

  3. python3之socket&socketserver网络编程

    1.套接字与套接模块 套接字是为特定网络协议(例如TCP/IP,ICMP/IP,UDP/IP等)套件对上的网络应用程序提供者提供当前可移植标准的对象.它们允许程序接受并进行连接,如发送和接受数据.为了 ...

  4. python Socket socketserver

    Socket 套接字 socket的 类型 实现socket对象时传入 到socket 类中 socket.AF_INET 服务器间的通讯 IPv4 socket.AF_INET6 IPv6 sock ...

  5. 进度条 --- socket ---socketserver

    TCP:可靠的面向连接的协议,传输效率低,全双工通信,流数据传输.运用:web浏览器,电子邮件,文件传输程序 UDP:不可靠的,无连接的服务,传输效率高,面向数据包的传输,只能发短消息.运用:dns ...

  6. socket&socketserver网络编程

    1.套接字与套接模块 套接字是为特定网络协议(例如TCP/IP,ICMP/IP,UDP/IP等)套件对上的网络应用程序提供者提供当前可移植标准的对象.它们允许程序接受并进行连接,如发送和接受数据.为了 ...

  7. Python学习之UDP版socket&SocketServer

    7.6 基于UDP的socket 无连接的,不必与对方建立连接,而是直接把数据发送给对方: 适用于一次传输销量数据结构,可靠性不高的应用环境,因为其传输速率快 # 服务端 import socket ...

  8. 小菜学习Winform（三）Socket点对点通信

    前言 Socket的英文原义是“孔”或“插座”,其实在网络编程中Socket就是这个意思,就像我们打电话,要首先知道对方的手机号一样,这个手机号就相当于一个Socket号.一个插座,在网络编程中就是i ...

  9. socketserver 分块记录

    网络编程 Socket(TCP,IP)套接字 服务端 运行起来, 客户端 客户端 客户端 客户端 服务端: import socket sk = socket.socket() #绑定端口号 sk.b ...

随机推荐

  1. java_IO流(输出流)

    ** * io流: * 输入流:硬盘输入到内存 字节/字符输入流 * 输出流:内存输出到硬盘 字节/字符输入流 * 字节流:一切数据都是字节存储(二进制) * 字节输出流(OutputStream): ...

  2. 2019-8-31-dotnet-通过-WMI-获取系统启动的服务

    title author date CreateTime categories dotnet 通过 WMI 获取系统启动的服务 lindexi 2019-08-31 16:55:59 +0800 20 ...

  3. MapReduce各个执行阶段

  4. LoadRunner函数的介绍

    LoadRunner函数的介绍 LoadRunner函数 一:通用函数 LoadRunner的通用函数以lr为前缀,可以在任何协议中使用.可以如下分类: 信息相关的函数: lr_error_messa ...

  5. HDU - 6128

    题意略: 题解:二次剩余板子题 //#pragma GCC optimize(2) //#pragma GCC optimize(3) //#pragma GCC optimize(4) //#pra ...

  6. 0908NOIP模拟测试赛后总结

    %%%skyh rank1- 奶风神.kx.有钱人 rank2-210 NC锅.RNB.B哥 rank5-200 我 rank32- 9-13upd:无意中点进了某个博客发现我竟然考场上yy出了树上莫 ...

  7. Jeecg-Boot前后端分离，针对敏感数据，加密传递方案

    # 针对敏感数据,加密传递方案 第一步: 在vue页面引入aesEncrypt.js encryption方法.示例代码: import { encryption } from '@/utils/en ...

  8. C语言实现 计算个人所得税务2种方法

    #include <stdio.h> #include <stdlib.h> /* 基于C语言的个人所得税计税系统 问题描述: 我国现行的个人所得税计算方法如下: 级数 全月应 ...

  9. 01-python 学习第一天

    今天是学习python语言的第一天,通过中国大学MOOC网的相关课程和其他在线教程,对python 语言有了初步的认识.今天我记住了<人生苦短,Python是岸>这句话.如果有人学习,建议 ...

  10. Python爬取b站任意up主所有视频弹幕

    爬取b站弹幕并不困难.要得到up主所有视频弹幕,我们首先进入up主视频页面,即https://space.bilibili.com/id号/video这个页面.按F12打开开发者菜单,刷新一下,在ne ...