socket补充：通信循环、链接循环、远程操作及黏包现象

最新推荐文章于 2024-07-19 11:27:44 发布
最新推荐文章于 2024-07-19 11:27:44 发布
阅读量146 收藏
点赞数
文章标签： shell 网络 操作系统
原文链接：http://www.cnblogs.com/lifangzheng/p/11364213.html
版权

socket补充：通信循环、链接循环、远程操作及黏包现象

socket通信循环

server端：

import socket

phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)

phone.bind(('127.0.0.1',8080))

phone.listen(5)


conn, client_addr = phone.accept()
print(conn, client_addr, sep='\n')

while 1:  # 循环收发消息
    try:
        from_client_data = conn.recv(1024)
        print(from_client_data.decode('utf-8'))
    
        conn.send(from_client_data + b'SB')
    
    except ConnectionResetError:
        break

conn.close()
phone.close()

client端：

import socket

phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)  # 买电话

phone.connect(('127.0.0.1',8080))  # 与客户端建立连接， 拨号


while 1:  # 循环收发消息
    client_data = input('>>>')
    phone.send(client_data.encode('utf-8'))
    
    from_server_data = phone.recv(1024)
    
    print(from_server_data.decode('utf-8'))

phone.close()  # 挂电话

socket通信链接循环

server端：

import socket

phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)

phone.bind(('127.0.0.1',8080))

phone.listen(5)

while 1 : # 循环连接客户端
    conn, client_addr = phone.accept()
    print(client_addr)
    
    while 1:
        try:
            from_client_data = conn.recv(1024)
            print(from_client_data.decode('utf-8'))
        
            conn.send(from_client_data + b'SB')
        
        except ConnectionResetError:
            break

conn.close()
phone.close()

服务端：

import socket

phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)  # 买电话

phone.connect(('127.0.0.1',8080))  # 与客户端建立连接， 拨号


while 1:
    client_data = input('>>>')
    phone.send(client_data.encode('utf-8'))
    
    from_server_data = phone.recv(1024)
    
    print(from_server_data.decode('utf-8'))

phone.close()  # 挂电话

socket远程操作

import subprocess

obj = subprocess.Popen('dir1',
                       shell=True,
                       stdout=subprocess.PIPE,
                       stderr=subprocess.PIPE,
                       )

print(obj.stdout.read().decode('gbk'))  # 正确命令
print(obj.stderr.read().decode('gbk'))  # 错误命令

服务端：

import socket
import subprocess
phone = socket.socket()

phone.bind(('127.0.0.1',8848))

phone.listen(2)
# listen: 2 允许有两个客户端加到半链接池，超过两个则会报错

while 1:
    conn,addr = phone.accept()  # 等待客户端链接我,阻塞状态中
    print(f'链接来了: {conn,addr}')

    while 1:
        try:

            from_client_data = conn.recv(1024)  # 最多接受1024字节


            if from_client_data.upper() == b'Q':
                print('客户端正常退出聊天了')
                break

            obj = subprocess.Popen(from_client_data.decode('utf-8'),
                                   shell=True,
                                   stdout=subprocess.PIPE,
                                   stderr=subprocess.PIPE,

                                   )
            result = obj.stdout.read() + obj.stderr.read()

            conn.send(result)
        except ConnectionResetError:
            print('客户端链接中断了')
            break
    conn.close()
phone.close()


# shell: 命令解释器，相当于调用cmd 执行指定的命令。
# stdout:正确结果丢到管道中。
# stderr:错了丢到另一个管道中。
# windows操作系统的默认编码是gbk编码。

客户端：

import socket

phone = socket.socket()

phone.connect(('127.0.0.1',8848))
while 1:
    to_server_data = input('>>>输入q或者Q退出').strip().encode('utf-8')
    if not to_server_data:
        # 服务端如果接受到了空的内容，服务端就会一直阻塞中，所以无论哪一端发送内容时，都不能为空发送
        print('发送内容不能为空')
        continue
    phone.send(to_server_data)
    if to_server_data.upper() == b'Q':
        break
    from_server_data = phone.recv(1024)  # 最多接受1024字节
    print(f'{from_server_data.decode("gbk")}')

phone.close()

什么叫做黏包现象？为什么会出现黏包现象？

socket收发消息的原理

1729998-20190816152859172-18357743.png

应用程序所看到的数据是一个整体，或说是一个流（stream），一条消息有多少字节对应用程序是不可见的，因此TCP协议是面向流的协议，这也是容易出现粘包问题的原因。

而UDP是面向消息的协议，每个UDP段都是一条消息，应用程序必须以消息为单位提取数据，不能一次提取任意字节的数据，这一点和TCP是很不同的。怎样定义消息呢？

可以认为对方一次性write/send的数据为一个消息，需要明白的是当对方send一条信息的时候，无论底层怎样分段分片，TCP协议层会把构成整条消息的数据段排序完成后才呈现在内核缓冲区。

设置缓冲区的两个好处：

  1. 暂时存储一些数据.
  2. 缓冲区存在如果你的网络波动,保证数据的收发稳定,匀速.

所谓粘包问题主要还是因为接收方不知道消息之间的界限，不知道一次性提取多少字节的数据所造成的。

只有TCP有粘包现象，UDP永远不会粘包

黏包的两种情况：

1，接收方没有及时接收缓冲区的包，造成多个包接收（客户端发送了一段数据，服务端只收了一小部分，服务端下次再收的时候还是从缓冲区拿上次遗留的数据，产生粘包）

server端：

import socket
import subprocess

phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

phone.bind(('127.0.0.1', 8080))

phone.listen(5)

while 1:  # 循环连接客户端
    conn, client_addr = phone.accept()
    print(client_addr)

    while 1:
        try:
            cmd = conn.recv(1024)
            ret = subprocess.Popen(cmd.decode('utf-8'), shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
            correct_msg = ret.stdout.read()
            error_msg = ret.stderr.read()
            conn.send(correct_msg + error_msg)
        except ConnectionResetError:
            break

conn.close()
phone.close()

client端：

import socket

phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)  # 买电话

phone.connect(('127.0.0.1',8080))  # 与客户端建立连接， 拨号


while 1:
    cmd = input('>>>')
    phone.send(cmd.encode('utf-8'))

    from_server_data = phone.recv(1024)

    print(from_server_data.decode('gbk'))

phone.close()

2、发送端需要等缓冲区满才发送出去，造成粘包（发送数据时间间隔很短，数据也很小，会合到一起，产生粘包）

server端：

import socket


phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

phone.bind(('127.0.0.1', 8080))

phone.listen(5)

conn, client_addr = phone.accept()

frist_data = conn.recv(1024)
print('1:',frist_data.decode('utf-8'))  # 1: helloworld
second_data = conn.recv(1024)
print('2:',second_data.decode('utf-8'))


conn.close()
phone.close()

客户端：

import socket

phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM)  

phone.connect(('127.0.0.1', 8080)) 

phone.send(b'hello')
phone.send(b'world')

phone.close()  

# 两次返送信息时间间隔太短，数据小，造成服务端一次收取

如何解决黏包现象？

struct模块

该模块可以把一个类型，如数字，转成固定长度的bytes

1729998-20190816152911745-450888539.jpg

import struct
# 将一个数字转化成等长度的bytes类型。
ret = struct.pack('i', 183346)
print(ret, type(ret), len(ret))

# 通过unpack反解回来
ret1 = struct.unpack('i',ret)[0]
print(ret1, type(ret1), len(ret1))


# 但是通过struct 处理不能处理太大

ret = struct.pack('l', 4323241232132324)
print(ret, type(ret), len(ret))  # 报错

方案一：low版。

　　问题的根源在于，接收端不知道发送端将要传送的字节流的长度，所以解决粘包的方法就是围绕，如何让发送端在发送数据前，把自己将要发送的字节流总数按照固定字节发送给接收端后面跟上总数据，然后接收端先接收固定字节的总字节流，再来一个死循环接收完所有数据。

server端：

import socket
import subprocess
import struct
phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

phone.bind(('127.0.0.1', 8080))

phone.listen(5)

while 1:
    conn, client_addr = phone.accept()
    print(client_addr)
    
    while 1:
        try:
            cmd = conn.recv(1024)
            ret = subprocess.Popen(cmd.decode('utf-8'), shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
            correct_msg = ret.stdout.read()
            error_msg = ret.stderr.read()
            
            # 1 制作固定报头
            total_size = len(correct_msg) + len(error_msg)
            header = struct.pack('i', total_size)
            
            # 2 发送报头
            conn.send(header)
            
            # 发送真实数据：
            conn.send(correct_msg)
            conn.send(error_msg)
        except ConnectionResetError:
            break

conn.close()
phone.close()

client端：

import socket
import struct
phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)

phone.connect(('127.0.0.1',8080))


while 1:
    cmd = input('>>>').strip()
    if not cmd: continue
    phone.send(cmd.encode('utf-8'))
    
    # 1，接收固定报头
    header = phone.recv(4)
    
    # 2，解析报头
    total_size = struct.unpack('i', header)[0]
    
    # 3，根据报头信息，接收真实数据
    recv_size = 0
    res = b''
    
    while recv_size < total_size:
        
        recv_data = phone.recv(1024)
        res += recv_data
        recv_size += len(recv_data)

    print(res.decode('gbk'))

phone.close()

转载于:https://www.cnblogs.com/lifangzheng/p/11364213.html

weixin_30493401
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Python攻城师的成长————网络编程（socket套接字、通信循环、链接循环、黏包问题）
fonnt的博客
04-15 873
今日学习目标 学习什么是socket套接字，并依靠它去处理TCP协议等网络编程问题 文章目录今日学习目标学习内容一、 socket套接字1.什么是socket2.套接字发展史及分类3.套接字工作流程二、通信循环三、链接循环四、黏包问题问题方法一方法二思路与总结 学习内容 socket套接字 通信循环 链接循环 黏包问题 一、 socket套接字 1.什么是socket Socket是应用层与TCP/IP协议族通信的中间软件抽象层，它是一组接口。在设计模式中，Socket其实
Socket 通信原理
AD_plus的博客
07-30 5903
整理和总结了一下大家常遇到的问题： 1. 客户端socket发送消息后，为什么服务端socket没有收到？ 2. 使用while 循环实现连续输入，是不是就是多线程模式？ 3. 对多线程处理机制不是很明白，希望详细讲解？ 4. 希望详细讲解ServerSocketChannel和SocketChannel与ServerSoket和Socket的区别？ 5. 希望有详细的例子，可以...
套接字接上链接循环
09-06 117
套接字接上链接循环 #加上连接循环的server端 import socket #生成一个socket对象 soc=socket.socket(socket.AF_INET,socket.SOCK_STREAM) #绑定地址跟端口号 soc.bind(('127.0.0.1',8001)) #监听(半连接池的大小),不是连接数 soc.listen(3) #等着客户端来连接,conn相当...
(重)python：Socket编程（四）：发消息原理简介、服务器循环链接请求来收发消息、重启服务器时端口重复问题解决
白骨梦儿
01-27 577
发消息原理简介: from socket import * tcp_service=socket(AF_INET,SOCK_STREAM) ip_port=("127.0.0.1", 8000) brak_log=5 buffer_size=1024 tcp_service.bind(ip_port) tcp_service.listen(brak_log) conn,addr=tcp_...
14.2 Socket 反向远程命令行
CSDN
10-12 1万+
在本节，我们将继续深入探讨套接字通信技术，并介绍一种常见的用法，实现反向远程命令执行功能。对于安全从业者而言，经常需要在远程主机上执行命令并获取执行结果。本节将介绍如何利用_popen()函数来启动命令行进程，并将输出通过套接字发送回服务端，从而实现远程命令执行的功能。在实现反向远程命令执行时，我们可以使用函数来执行特定的命令，并将其输出重定向到一个可读的缓冲区中。这个缓冲区将保存命令的输出内容，我们可以将其发送回控制程序，也就是服务端，从而实现远程命令执行的目标。首先我们来看一下_popen()
C/C++ 使用Socket模拟远程CMD
CSDN
06-09 1万+
函数初始化 Winsock 库，这是在 Windows 系统上进行网络编程的必要步骤。函数初始化 Winsock 库，这是在 Windows 系统上进行网络编程的必要步骤。函数接收客户端的连接请求，并返回一个新的套接字用于与客户端通信。函数将本地地址绑定到所创建的套接字上，以在网络上标识该套接字。函数创建一个套接字，该套接字用于监听客户端连接请求。函数创建一个套接字，该套接字用于与服务器端进行通信。函数创建一个套接字，该套接字用于与服务器端进行通信。关闭套接字：连接建立后，即刻关闭套接字。
某科学的超 Java网络编程：Socket通信原理及实例学习
lemonGuo的大脑皮层、小脑、海马体、杏仁核.....
06-20 4373
首先来思考几个问题： 如何把互联网上的网页抓下来？如何与互联网上的网络资源通信？如何在两个Java程序之间建立网络？面向连接与非面向连接的通信方式有什么区别？ 接下来以此篇文章来学习： 理解计算机网络编程的概念，掌握如何使用Java在一台或多台计算机之间进行基于TCP/IP协议的网络通讯。通过理解TCP/IP协议的通讯模型，以JDK提供的java.net包为工具，掌握各种基
Python Socket编程指南：从入门到实战
热门推荐
qq_35716085的博客
02-21 1万+
本文将详细介绍Python中Socket的用法，包括Socket的概念、基本原理以及如何在Python中使用Socket进行网络编程。通过讲解Socket的基本知识和实际代码示例，读者将学习如何编写客户端和服务端代码，并实现网络通信。最后，通过结果展示，读者将全面掌握Python中Socket的应用场景和实战技巧。
C/C++ 创建Socket实现双工通信
CSDN
06-09 8587
Socket通信是一种用于在计算机网络中进行进程间通信的方法。它提供了一种简单而强大的通信机制，使得运行在不同计算机上的进程可以相互传递数据。
C#中Socket通信用法实例详解
09-03
在C#编程语言中，Socket通信是一种常用的技术，用于实现应用程序间的网络通信。Socket接口提供了低级别的、面向连接或无连接的网络通信服务，支持TCP（Transmission Control Protocol）和UDP（User Datagram ...
NET_Source_C#Socket通信_socket_高性能异步通讯_
10-02
在.NET框架中，C#语言提供了强大的网络编程能力，Socket通信是其中的核心部分。本教程主要探讨如何使用C#实现高性能、异步的Socket服务器，以及如何通过UserToken进行链接关系管理。 首先，Socket通信是基于TCP/IP...
matlab环境下socket通信
10-28
MATLAB提供了丰富的工具和函数来支持Socket通信，使得用户可以在MATLAB环境中创建客户端或服务器应用，与远程设备或应用程序进行数据交互。 首先，要理解Socket通信的基本概念。Socket可以视为通信的两端，一个作为...
Java Socket实现多线程通信功能示例
08-30
Java Socket 实现多线程通信功能示例 Java Socket 是 Java 语言中实现网络通信的基本组件之一，多线程通信是指在服务器端和客户端之间实现在多个线程中进行通信的过程。在 Java 中，使用 Socket 来实现多线程通信...
C#上位机基础学习-基于SOCKET实现与PLC服务器的TCP通信（一）.docx
01-12
总结来说，这个过程涉及了C#编程、TCP/IP通信协议、PLC编程（S7-1500系列）、SOCKET通信以及TIA PORTAL和Visual Studio的使用。理解并掌握这些知识点对于开发能够与PLC进行数据交换的上位机应用至关重要。在实际应用...
第二节 shell脚本基础(5)(6)(7)
weixin_73298423的博客
07-15 407
shell的执行方式,调试和退出值
Linux热键，shell含义及权限介绍
2301_79194984的博客
07-16 807
为了方便能够快速的输入指令，通常利用[Tab]来帮助我们。[Tab]键的作用是具有命令补全和档案补齐的功能。通常为了输入一个指令，我能快要输完的时候按下[Tab]，能够快速补齐，能够减少一点时间吧，起始也能够利用[Tab]来帮助我们查看符合那几个开头的指令能有哪些。生活中的例子可以帮助我们理解。VIP才能看最新出来的电影。进学校的宿舍需要刷脸这也是权限。权限就是通过一定的条件拦住一部分，给另一部分人权利，来访问某种资源。来决定有无或者是能不能的问题。
shell处理用户输入——传递参数
2401_82591819的博客
07-17 385
向shell脚本传递数据的最基本方法是使用命令行参数。命令行参数允许运行脚本时在命令行中添加数据：本例向脚本addem传递了两个命令行参数（10和30）。脚本会通过特殊的变量来处理命令行参数。接下来将介绍如何在bash shell脚本中使用命令行参数。
WSL2- 使用Shell工具连接的一些配置
最新发布
qq_47910339的博客
07-19 323
WSL2-使用Shell工具连接的一些配置
shell脚本
2201_75549363的博客
07-15 794
Shell是一个命令解释器，它在操作系统的最外层，负责直接与用户进行对话，把用户的输入解释给操作系统，并处理各种各样的操作系统的输出结果，输出到屏幕反馈给用户。这种对话方式可是交互也可以是非交互式的,我们所输入的命令计算机是不识别的，这时就需要一种程序来帮助我们进行翻译，变成计算机能识别的二进制程序，同时又把计算机生成的结果返回给我们。重定向的意思就是 ，不输出到默认设备上，输出到你指定的位置（文件 其他输出设备）类型 操作符 用途重定向输入。
UEC++socket通信
03-18
UE4中可以使用C++和socket实现UDP通信。首先，你需要包含UE4的Networking模块，可以通过以下方式引入： ```cpp #include "Runtime/Networking/Public/Networking.h" ``` 然后，你可以创建一个socket对象来进行通信。...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值