python套接字流重定向实例汇总

将套接字流重定向到标准输入或输出流

#!/usr/bin/env python3
"""
测试socket-stream 重定向模式
"""
import sys,os,time
from multiprocessing import Process
from socket import *

def initListenerSocket(port=50008,host=''):
    """
    初始化在服务器模式下调用者用于监听连接的套接字
    """
    sock=socket()
    try:
        sock.bind((host,port))
    except OSError as e:
        print('Address already in use')
        os._exit(1)
    sock.listen(5)
    conn,addr=sock.accept()
    return conn

def redirecOut(port=50008,host='localhost'):
    """
    在接受之前其他连接都失败,连接调用者标准输出流
    到一个套接字,这个套接字用于gui监听,在收听者启动后,启动调用者
    """
    sock=socket()
    try:
        sock.connect((host,port))
    except ConnectionRefusedError as e:
        print('connection refuse')
        os._exit(1)
    file=sock.makefile('w')
    sys.stdout=file
    return sock

def redirecIn(port=50008,host='localhost'):
    """
    连接调用者标准输入流到用于gui来提供的套接字
    """
    sock=socket()
    try:
        sock.connect((host,port))
    except ConnectionRefusedError as e:
        print('conenction refuse')
        os._exit(1)
    file=sock.makefile('r')
    sys.stdin=file
    return sock

def redirecBothAsClient(port=50008,host='localhost'):
    """
    在这种模式下,连接调用者标准输入和输出流到相同的套接字
    调用者对于服务器来说就是客户端:发送消息,接受响应答复
    """
    sock=socket()
    try:
        sock.connect((host,port))
    except ConnectionRefusedError as e:
        print('connection refuse')
        os._exit(1)
    ofile=sock.makefile('w')
    ifile=sock.makefile('r')
    sys.stdout=ofile
    sys.stdin=ifile
    return sock

def redirecBothAsServer(port=50008,host='localhost'):
    """
    在这种模式下,连接调用者标准输入和输出流到相同的套接字,调用者对于
    服务器来说就是服务端:接受消息,发送响应答复
    """
    sock=socket()
    try:
        sock.bind((host,port))
    except OSError as e:
        print('Address already in use')
        os._exit(1)
    sock.listen(5)
    conn,addr=sock.accept()
    ofile=conn.makefile('w')
    ifile=conn.makefile('r')
    sys.stdout=ofile
    sys.stdin=ifile
    return conn

def server1():
    mypid=os.getpid()
    conn=initListenerSocket()
    file=conn.makefile('r')
    for i in range(3):
        data=file.readline().rstrip()
        print('server %s got [%s]' %(mypid,data))

def client1():
    time.sleep(1)
    mypid=os.getpid()
    redirecOut()
    for i in range(3):
        print('client: %s:%s' % (mypid,i))
        sys.stdout.flush()

def server2():
    mypid=os.getpid()
    conn=initListenerSocket()
    for i in range(3):
        conn.send(('server %s got [%s]\n' %(mypid,i)).encode())

def client2():
    time.sleep(1)
    mypid=os.getpid()
    redirecIn()
    for i in range(3):
        data=input()
        print('client %s got [%s]]'%(mypid,data))

def server3():
    mypid=os.getpid()
    conn=initListenerSocket()
    file=conn.makefile('r')
    for i in range(3):
        data=file.readline().rstrip()
        conn.send(('server %s got [%s]\n' % (mypid,data)).encode())

def client3():
    time.sleep(1)
    mypid=os.getpid()
    redirecBothAsClient()
    for i in range(3):
        print('Client %s: %s' %(mypid,data))
        data=input()
        sys.stderr.write('client %s got [%s]\n' %(mypid,data))

def server4(port=50008,host='localhost'):
    mypid=os.getpid()
    sock=socket()
    try:
        sock.connect((host,port))
    ConnectionRefusedError as e:
        print('connection refuse')
        os._exit(1)
    file=sock.makefile('r')
    for i in range(3):
        sock.send(('server %s: %S\n' %(mypid,i)).encode())
        data=file.readline().rstrip()
        print('server %s got [%s]' %(mypid,data))

def client4():
    time.sleep(1)
    mypid=os.getpid()
    redirecBothAsServer()
    for i in range(3):
        data=input()
        print('client %s got [%s]'%(mypid,data))
        sys.stdout.flush()

def server5():
    mypid=os.getpid()
    conn=initListenerSocket()
    file=conn.makefile('r')
    for i in range(3):
        conn.send(('server %s:%s\n' %(mypid,i)).encode())
        data=file.readline().rstrip()
        print('server %s got [%s]' % (mypid,data))

def client5():
    mypid=os.getpid()
    s=redirecBothAsClient()
    for i in range(3):
        data=input()
        print('client %s got [%s]'%(mypid,data))
        sys.stdout.flush()

def main():
    server=eval('server'+sys.argv[1])
    client=eval('client'+sys.argv[1])
    Process(target=server).start()
    client()

if __name__=='__main__':
    main()
(0)

相关推荐

  • python socket网络编程步骤详解(socket套接字使用)

    一.套接字套接字是为特定网络协议(例如TCP/IP,ICMP/IP,UDP/IP等)套件对上的网络应用程序提供者提供当前可移植标准的对象.它们允许程序接受并进行连接,如发送和接受数据.为了建立通信通道,网络通信的每个端点拥有一个套接字对象极为重要.套接字为BSD UNIX系统核心的一部分,而且他们也被许多其他类似UNIX的操作系统包括Linux所采纳.许多非BSD UNIX系统(如ms-dos,windows,os/2,mac os及大部分主机环境)都以库形式提供对套接字的支持.三种最流行的套接

  • 详解python3中socket套接字的编码问题解决

    一.TCP 1.tcp服务器创建 #创建服务器 from socket import * from time import ctime #导入ctime HOST = '' #任意主机 PORT = 21567 #随机提供个端口号 BUFSIZ = 1024 # 缓冲区大小设置为1KB,可以根据网络性能和程序需要改变这个容量 ADDR = (HOST, PORT) tcpSerSock = socket(AF_INET, SOCK_STREAM) #分配了 TCP 服务器套接字 tcpSerSo

  • python原始套接字编程示例分享

    下面开始构造HTTP数据包, IP层和TCP层使用python的Impacket库,http内容自行填写. 复制代码 代码如下: #!/usr/bin/env python #-------------------------------------------------------------------------------# Name:     raw_http.py# Purpose:       construct a raw http get packet## Author:  

  • Python中利用原始套接字进行网络编程的示例

    在实验中需要自己构造单独的HTTP数据报文,而使用SOCK_STREAM进行发送数据包,需要进行完整的TCP交互. 因此想使用原始套接字进行编程,直接构造数据包,并在IP层进行发送,即采用SOCK_RAW进行数据发送. 使用SOCK_RAW的优势是,可以对数据包进行完整的修改,可以处理IP层上的所有数据包,对各字段进行修改,而不受UDP和TCP的限制. 下面开始构造HTTP数据包, IP层和TCP层使用python的Impacket库,http内容自行填写. #!/usr/bin/env pyt

  • Python网络编程 Python套接字编程

    Python 提供了两个级别访问的网络服务. 低级别的网络服务支持基本的 Socket,它提供了标准的 BSD Sockets API,可以访问底层操作系统Socket接口的全部方法. 高级别的网络服务模块 SocketServer, 它提供了服务器中心类,可以简化网络服务器的开发. 什么是 Socket? Socket又称"套接字",应用程序通常通过"套接字"向网络发出请求或者应答网络请求,使主机间或者一台计算机上的进程间可以通讯. socket()函数 Pyth

  • Python里disconnect UDP套接字的方法

    UDP 套接字是可以使用 connect 系统调用连接到指定的地址的.从此以后,这个套接字只会接收来自这个地址的数据,而且可以使用 send 系统调用直接发数据而不用指定地址.可以再次调用 connect 来连接到别的地方.但是在 Python 里,一旦调用 connect 之后,就再也回不到最初的能够接收从任意地址来的数据的状态了! 这是 Python 的 API 限制,没办法给 connect 方法传递到 AF_UNSPEC 地址簇(在 C 代码里写死了的).C 里边就可以做到的(代码来自这

  • python套接字流重定向实例汇总

    将套接字流重定向到标准输入或输出流 #!/usr/bin/env python3 """ 测试socket-stream 重定向模式 """ import sys,os,time from multiprocessing import Process from socket import * def initListenerSocket(port=50008,host=''): """ 初始化在服务器模式下调用者用于

  • python套接字socket通信

    目录 一.初步认识 二.socket对象 一.初步认识 socket被翻译成套接字,尽管有些人诟病,但我觉得还挺贴切的.其功能是提供低级别的网络服务,最常用的就是根据IP来传输数据. 所谓传输,就要有两个“端”,首先做一个服务端 import socket s = socket.socket() host = socket.gethostname() #本机地址    port = 12345                #端口 s.bind((host,port))         #绑定端

  • Python图像处理二值化方法实例汇总

    在用python进行图像处理时,二值化是非常重要的一步,现总结了自己遇到过的6种 图像二值化的方法(当然这个绝对不是全部的二值化方法,若发现新的方法会继续新增). 1. opencv 简单阈值 cv2.threshold 2. opencv 自适应阈值 cv2.adaptiveThreshold (自适应阈值中计算阈值的方法有两种:mean_c 和 guassian_c ,可以尝试用下哪种效果好) 3. Otsu's 二值化 例子: import cv2 import numpy as np f

  • Python中的套接字编程是什么?

    Why use Sockets? 套接字是网络的基础.它们使在两个不同程序或设备之间的信息传输成为可能.例如,当您打开浏览器时,您作为客户端正在与服务器建立连接以进行信息传输. 在深入探讨这种通信之前,让我们首先弄清楚这些插座的确切含义. What are Sockets? 一般而言,套接字是为发送和接收数据而构建的内部端点.单个网络将具有两个套接字,每个通信设备或程序一个.这些套接字是IP地址和端口的组合.根据所使用的端口号,单个设备可以具有n个插槽.不同的端口可用于不同类型的协议.请看以下图

  • 浅析Python中的套接字编程

    目录 一.为什么使用套接字 二.什么是套接字 三.如何在Python中实现Socket编程 四.什么是服务器 五.什么是客户端 5.1.Echo Client-Server 5.2.Multiple Communications 六.传输Python对象 6.1.Python pickle模块 6.2.如何使用pickle模块传递python对象结构 一.为什么使用套接字 套接字是网络的基础.它们使在两个不同程序或设备之间的信息传输成为可能.例如,当您打开浏览器时,您作为客户端正在与服务器建立连

  • python实现套接字创建

    目录 1.网络协议 2.地址族 3.通过域名获取IP地址 4.socket 1.网络协议 TCP / IP 是设备用于在 Internet 和大多数本地网络上进行通信的一组协议. TCP 更可靠,具有大量错误检查并需要更多资源. HTTP,SMTP 或 FTP 等服务使用它. UDP 的可靠性要差得多,错误检查的能力也有限,所需资源也更少. VoIP 等服务使用它. socket.SOCK_STREAM用于为 TCP 创建套接字,而socket.SOCK_DGRAM为 UDP 创建套接字. 2.

  • Python编程scoketServer实现多线程同步实例代码

    本文研究的主要是Python编程scoketServer实现多线程同步的相关内容,具体介绍如下. 开发过程中,为了实现不同的客户端同一时刻只能有一个使用共同数据. 虽说用Python编写简单的网络程序很方便,但复杂一点的网络程序还是用现成的框架比较好.这样就可以专心事务逻辑,而不是套接字的各种细节.SocketServer模块简化了编写网络服务程序的任务.同时SocketServer模块也是Python标准库中很多服务器框架的基础. 网络服务类: SocketServer提供了4个基本的服务类:

  • Python原始套接字编程实例解析

    这篇文章主要介绍了Python原始套接字编程实例解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 在实验中需要自己构造单独的HTTP数据报文,而使用SOCK_STREAM进行发送数据包,需要进行完整的TCP交互. 因此想使用原始套接字进行编程,直接构造数据包,并在IP层进行发送,即采用SOCK_RAW进行数据发送. 使用SOCK_RAW的优势是,可以对数据包进行完整的修改,可以处理IP层上的所有数据包,对各字段进行修改,而不受UDP和TCP的

  • Python网络编程之TCP套接字简单用法示例

    本文实例讲述了Python网络编程之TCP套接字简单用法.分享给大家供大家参考,具体如下: 上学期学的计算机网络,因为之前还未学习python,而java则一知半解,C写起来又麻烦,所以一直都没有真正实现过TCP套接字编程. 最近学习了python,而用它来写套接字又十分方便简单,所以当然要试一试咯. 下面根据代码来介绍一下最简单的tcp程序,由客户端输入数据,发送给服务器,服务器加上时间后返回给客户端 #!/usr/bin/python 'test TCP server' from socke

随机推荐