socket

最新推荐文章于 2024-06-27 20:38:30 发布
最新推荐文章于 2024-06-27 20:38:30 发布
阅读量66 收藏
点赞数
文章标签： 操作系统 shell 网络
原文链接：http://www.cnblogs.com/-777/p/11361614.html
版权
socket

Day30 socket

  1. socket套接字

    ​ socket处于应用层与传输层之间,提供了一些简单的接口. 避免与操作系统之间对接,省去了相当繁琐复杂的操作.

    ​ socket在python中属于一个模块.为我们提供了这些简单的功能.

  2. 单个客户端与服务端通信（low版）

    server

    import socket
phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
phone.bind(('127.0.0.1',8088))
phone.listen(3)

conn,addr = phone.accept()

from_client_data = conn.recv(1024)
print(f"来自客户端的消息：{from_client_data.decode('utf-8')}")

to_client_data = input('>>>')
conn.send(to_client_data.encode('utf-8'))
conn.close()
phone.close()

    client

    import socket
phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
phone.connect(('127.0.0.1',8088))

to_server_data = input('>>>')
phone.send(to_server_data.encode('utf-8'))

from_server_data = phone.recv(1024)
print(f'收到来自服务端的信息：{from_server_data.decode("utf-8")}')
phone.close()

  3. 基于TCP协议的socket单个循环通信

    server：

    import socket
phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
phone.bind(('127.0.0.1',8088))
phone.listen(3)

conn,addr = phone.accept()
while 1:
    try:
        from_client_data = conn.recv(1024)
        print(f"来自客户端的消息：{from_client_data.decode('utf-8')}")

        to_client_data = input('>>>')
        conn.send(to_client_data.encode('utf-8'))
    except ConnectionResetError:
        print('客户端异常断开链接')
        break
conn.close()
phone.close()

    client：

    import socket
phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
phone.connect(('127.0.0.1',8088))

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

        from_server_data = phone.recv(1024)
        print(f'收到来自服务端的信息：{from_server_data.decode("utf-8")}')
phone.close()

  4. 基于TCP协议的socket 链接+循环 通信

    server

    import socket

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

            print(f'来自客户端{addr}消息:{from_client_data.decode("utf-8")}')
            to_client_data = input('>>>').strip().encode('utf-8')
            conn.send(to_client_data)
        except ConnectionResetError:
            print('客户端链接中断了')
            break
    conn.close()
phone.close()

    client

    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("utf-8")}')

phone.close()

  5. 基于TCP协议的socket通信: 实例: 远程执行命令

    server

    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编码。

    client

    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()

  6. 粘包现象

    展示收发的问题

    server

    # 发多次收一次
# import socket
#
# phone = socket.socket()
#
# phone.bind(('127.0.0.1',8848))
#
# phone.listen(5)
#
#
# conn,addr = phone.accept()  # 等待客户端链接我,阻塞状态中
#
# from_client_data = conn.recv(1024)  # 最多接受1024字节
# print(f'来自客户端{addr}消息:{from_client_data.decode("utf-8")}')
#
# from_client_data = conn.recv(1024)  # 最多接受1024字节
# print(f'来自客户端{addr}消息:{from_client_data.decode("utf-8")}')
# conn.close()
# phone.close()



# 发一次收多次

# import socket
#
# phone = socket.socket()
#
# phone.bind(('127.0.0.1',8848))
#
# phone.listen(5)
#
#
# conn,addr = phone.accept()  # 等待客户端链接我,阻塞状态中
#
# from_client_data = conn.recv(3)  # 最多接受1024字节
# print(f'来自客户端{addr}消息:{from_client_data.decode("utf-8")}')
#
# from_client_data = conn.recv(3)  # 最多接受1024字节
# print(f'来自客户端{addr}消息:{from_client_data.decode("utf-8")}')
#
# from_client_data = conn.recv(3)  # 最多接受1024字节
# print(f'来自客户端{addr}消息:{from_client_data.decode("utf-8")}')
#
# from_client_data = conn.recv(3)  # 最多接受1024字节
# print(f'来自客户端{addr}消息:{from_client_data.decode("utf-8")}')
#
# conn.close()
# phone.close()

    client

    # 发多次收一次
# import socket
#
# phone = socket.socket()
#
# phone.connect(('127.0.0.1',8848))
#
#
# phone.send(b'he')
# phone.send(b'llo')
#
#
# phone.close()
# Nigle算法


# 发一次收多次
# import socket
#
# phone = socket.socket()
#
# phone.connect(('127.0.0.1',8848))
#
#
# phone.send(b'hello world')
#
#
# phone.close()

    现象

    server

    # 1. 粘包第一种： send的数据过大，大于对方recv的上限时，对方第二次recv时，会接收上一次没有recv完的剩余的数据。
# 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()
#             print(f'总字节数：{len(result)}')
#             conn.send(result)
#         except ConnectionResetError:
#             print('客户端链接中断了')
#             break
#     conn.close()
# phone.close()



# s1 = '太白jx'
# # print(len(s1))
# b1 = s1.encode('utf-8')
# # print(b1)
# print(len(b1))


'''
         客户端                          服务端

第一次：  ipconfig                       317字节
         300个字节                       17个字节


         客户端                          服务端

第二次：   dir                           376字节
          17字节                        376字节


'''


# 2. 连续短暂的send多次(数据量很小),你的数据会统一发送出去.

# import socket
#
# phone = socket.socket()
#
# phone.bind(('127.0.0.1',8848))
#
# phone.listen(5)
#
#
# conn,addr = phone.accept()  # 等待客户端链接我,阻塞状态中
#
# from_client_data = conn.recv(1024)  # 最多接受1024字节
# print(f'来自客户端{addr}消息:{from_client_data.decode("utf-8")}')
# conn.close()
# phone.close()


# 展示一些收发的问题。

    client

    # 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(300)  # 最多接受1024字节
#     # print(f'{from_server_data.decode("gbk")}')
#     print(len(from_server_data))
#
# phone.close()



# 2. 连续短暂的send多次(数据量很小),你的数据会统一发送出去.

# import socket
#
# phone = socket.socket()
#
# phone.connect(('127.0.0.1',8848))
#
#
# phone.send(b'he')
# phone.send(b'll')
# phone.send(b'o')
#
#
# phone.close()
# Nigle算法

  7. 操作系统的缓存区

    1. 为什么存在缓冲区??

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

      缺点: 造成了粘包现象之一.

  8. 什么情况下出现粘包

    1. 出现粘包的情况

      连续短暂的send多次(数据量很小),你的数据会统一发送出去.

    2. 深入研究收发

  9. 如何解决粘包现象

    解决粘包现象的思路:

    服务端发一次数据 10000字节,

    客户端接收数据时,循环接收,每次(至多)接收1024个字节,直至将所有的字节全部接收完毕.将接收的数据拼接在一起,最后解码.

    1. 遇到的问题: recv的次数无法确定.

      你发送总具体数据之前,先给我发一个总数据的长度:5000个字节。然后在发送总数据。

      客户端： 先接收一个长度。 5000个字节。

      然后我再循环recv 控制循环的条件就是只要你接受的数据< 5000 一直接收。

    2. 遇到的问题： 总数据的长度转化成的字节数不固定

      服务端：
conn.send(total_size) 

conn.send(result)
total_size int类型


客户端：
total_size_bytes = phone.recv(4)
total_size
data = b''
while len(data) < total_size:
  data = data + phone.recv(1024)

      你要将total_size int类型转化成bytes类型才可以发送

      387 ---- > str(387) '387' ---->bytes b'387' 长度 3bytes

      4185 ----> str(4185) '4185' ---->bytes b'4185' 长度 4bytes

      18000------------------------------------------------------> 长度 5bytes

      我们要解决：

      将不固定长度的int类型转化成固定长度的bytes并且还可以翻转回来。

      struct模块

  10. low版解决粘包现象

    server

    # 1. 粘包第一种： send的数据过大，大于对方recv的上限时，对方第二次recv时，会接收上一次没有recv完的剩余的数据。
import socket
import subprocess
import struct
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)  # 接收命令


            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()
            total_size = len(result)
            print(f'总字节数：{total_size}')

            # 1. 制作固定长度的报头
            head_bytes = struct.pack('i',total_size)

            # 2. 发送固定长度的报头
            conn.send(head_bytes)

            # 3. 发送总数据
            conn.send(result)
        except ConnectionResetError:
            print('客户端链接中断了')
            break
    conn.close()
phone.close()




# import struct

    client

    import socket
import struct
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

    # 1. 接收报头
    head_bytes = phone.recv(4) 
    # 2. 反解报头
    total_size = struct.unpack('i',head_bytes)[0]

    total_data = b''

    while len(total_data) < total_size:
        total_data += phone.recv(1024)

    print(len(total_data))
    print(total_data.decode('gbk'))

phone.close()
posted on 2019-08-16 08:16  七橼77 阅读( ...) 评论( ...) 编辑 收藏

转载于:https://www.cnblogs.com/-777/p/11361614.html

aobai5662
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Socket android
06-02
socket通讯 连接 服务端和客户端 Android与服务器的通信方式主要有两种，一是Http通信，一是Socket通信。两者的最大差异在于，http连接使用的是“请求—响应方式”，即在请求时建立连接通道，当客户端向服务器发送...
C#高性能大容量SOCKET并发完成端口例子（有C#客户端）完整实例源码
06-08
例子主要包括SocketAsyncEventArgs通讯封装、服务端实现日志查看、SCOKET列表、上传、下载、远程文件流、吞吐量协议，用于测试SocketAsyncEventArgs的性能和压力，最大连接数支持65535个长连接，最高命令交互速度...
用大白话解释什么是Socket
Robod的博客
05-20 6万+
我在去年就学习过Java中Socket的使用，但对于Socket的理解一直都是迷迷糊糊的。看了网上很多关于Socket的介绍，看完还是不太理解到底什么是Socket，还是很迷。直到最近在学习计算机网络，我才对Socket有了一个更深地理解。之前一直不理解Socket就是因为没学过计算机网络，所以对于很多概念都很模糊，那么今天我就争取用最简单的话来解释清楚到底Socket是一个什么东西，希望能够帮助到那些正在学习Socket的同学。废话不多说，开始进入正题。...
socket接口详解
L607_607的博客
07-28 8055
socket接口详解socket概述接口详解socket()   socket概述 socket是在应用层和传输层之间的一个抽象层，它把TCP/IP层负责复杂的操作抽象为几个简单的接口供应用层调用已以实现进程在网络中的通信。 socket起源于UNIX，在Unix一切皆文件哲学的思想下，socket是一种“打开——读/写——关闭”模式的实现，服务器和客户端各自维护一个“文件”，在建立连接打开后，可以向自己文件写入内容供对方读取或者读取对方内容，通信结束时关闭文件。   接口详解 sock
Socket的学习（一）什么是Socket?
Fishfishfishfishcat
06-27 10万+
本文参考的是《Socket通信原理》https://www.cnblogs.com/wangcq/p/3520400.html TCP/IP UDP是什么？ TCP/IP（Transmission Control Protocol/Internet Protocol）即传输控制协议/网间协议，是一个工业标准的协议集，它是为广域网（WANs）设计的。UDP（User Data Protocol，...
python之socket编程
mxh的博客
06-06 7万+
Socket是什么呢？ socket起源于Unix，而Unix/Linux基本哲学之一就是“一切皆文件”，对于文件用【打开】【读写】【关闭】模式来操作。socket就是该模式的一个实现，socket即是一种特殊的文件，一些socket函数就是对其进行的操作（读/写IO、打开、关闭） 基本上，Socket 是任何一种计算机网络通讯中最基础的内容。例如当你在浏览器地址栏中输入 http://...
Java网络编程Socket
u014644574的博客
02-05 6303
Java网络编程Socket
Socket通信bind错误
Sky_nnn的博客
08-18 7656
Socket非正常退出导致的bind错误 在Vx下进行Socket无连接通信时，由于在发送消息进程中使用ctrl+c强制中止，导致下一次再进行发送时会出现bind（）出现错误。原因在于非正常退出时，没有进行close，导致端口和地址被占用。解决方法是利用setsockopt()函数将Socket设置为复用。 在bind函数之前使用setsockopt函数，如下即可解决bind错误的情况。 BOOL bReuseaddr = TRUE; setsockopt( s, SOL_SOCKET, SO_REUSEA
socket通讯原理及例程（一看就懂）
热门推荐
jiushimanya的博客
09-13 15万+
对TCP/IP、UDP、Socket编程这些词你不会很陌生吧？随着网络技术的发展，这些词充斥着我们的耳朵。那么我想问： 什么是TCP/IP、UDP？ Socket在哪里呢？ Socket是什么呢？ 你会使用它们吗？ 什么是TCP/IP、UDP？ TCP/IP（Transmission Control Protocol/Internet Protocol）即传输控制协议/网间协议...
socket编程：socket()函数详解
超级大洋葱的博客
04-18 2万+
文章目录1. 什么是socket？1.1 意义1.2 本质1.3 应用1.4 结论2. socket() 函数参数介绍2.1 参数1：int af2.2 参数2：int type2.3 参数3：int protocol3. socket()函数返回值介绍 1. 什么是socket？ 套接字函数创建一个绑定到特定传输服务提供者的套接字。 将底层复杂的协议体系，执行流程，进行了封装，封装完的结果，就是一个SOCKET了，也就是说，SOCKET是我们调用协议进行通信的操作接口。 1.1 意义 将复杂的协议过程与我
Socket
dgdisme
05-31 3756
Socket Socket Socket Socket Socket Socket Socket
Socket通信详细介绍
是阿超
12-11 7177
Socket通信详细介绍
socket调试工具 socketTool
08-13
sokit socket调试 tcp udp for mac
【socket调试工具】
04-09
sokit是一款非常简单易用的tcp、udp调试工具，主要适用于专业的网络管理使用，它可以轻松查看网内的数据情况，能够有效地接收、发送、转发TCP或UDP数据包。sokit工具，可做服务端，可做客户，
Socket实战
01-22
Socket实战系列： Socket实战——UDP连接：https://blog.csdn.net/haoranhaoshi/article/details/86601468 Socket实战——TCP连接：https://blog.csdn.net/haoranhaoshi/article/details/86601522 Socket实战——...
文件进行周期性备份后权限更改的解决方案--使用脚本和定时任务
最新发布
李赛男
06-27 535
使用 rsync 从一台 Linux 服务器备份文件到 NAS时，备份过来的文件的所有者和组都变成了 ，而且权限也改了，怎么解决呢
不出网上线CS的各种姿势（内网横向）
qq_64395221的博客
06-21 961
在内网环境中可以使用ipc $生成的SMB Beacon上传到目标主机执行，但是目标主机并不会直接上线的，需要我们自己用链接命令(link <ip>)去连接它。经常是拿下一台边缘机器，其有多块网卡，用于连接内外网，内网机器都不出网。因为连接的Beacons使用Windows命名管道进行通信，此流量封装在SMB协议中，所以SMB Beacon相对隐蔽，绕防火墙时可能发挥奇效。一样，建立pystinger连接之后，直接生成payload在业务主机执行，业务内网主机192.168.111.236即可成功上线。
网络编程1
bonfirelit的博客
06-21 315
服务器接收到 FIN 包后，会向客户端发送一个 ACK（Acknowledgment）包，确认已经接收到 FIN。客户端接收到服务器的 FIN 包后，向服务器发送一个 ACK 包，确认已经接收到 FIN。网络编程中，客户端调用close或者shutdown后，操作系统会给服务器发送一个FIN。操作系统会发送一个 FIN 包给服务器，表示客户端不会再发送数据。服务器进入半关闭状态，可以继续向客户端发送数据，但不能再接收数据。当双方都发送并接收到 FIN 和 ACK 包后，连接才完全关闭。
【嵌入式Linux】i.MX6ULL IRQ中断服务函数的编写
Beihai_Van的博客
06-25 875
IRQ中断服务函数流程解释，以及手册查询
Socket socket
06-01
Socket是一种抽象层，用于在网络中传输数据。它提供了一种通用的接口，使得不同的应用程序可以通过网络互相通信。在计算机网络中，Socket是一组用于实现网络通信的API，它定义了网络通信的标准接口。通过Socket，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值