Python套接字客户端recv (缓冲区大小)
Python套接字客户端的recv()方法用于从服务器接收数据。它接受一个参数，即缓冲区大小，用于指定每次接收数据的最大字节数。
在Python中，套接字是一种用于网络通信的编程接口，它允许不同计算机之间的进程进行数据交换。套接字客户端是一个使用套接字接口与服务器进行通信的程序。
recv()方法的作用是从服务器接收数据，并将其存储在缓冲区中。缓冲区大小参数指定了每次接收数据的最大字节数。如果接收到的数据超过缓冲区大小，那么recv()方法将会截断数据。
使用套接字客户端的recv()方法，可以实现以下功能：
- 接收服务器发送的数据，例如文本、文件等。
- 实现基于套接字的网络通信协议，如HTTP、FTP等。
推荐的腾讯云相关产品：腾讯云云服务器（CVM）
- 产品介绍链接地址：https://cloud.tencent.com/product/cvm
腾讯云云服务器（CVM）是一种灵活可扩展的云计算服务，提供了高性能、高可靠性的虚拟服务器。您可以使用腾讯云云服务器搭建自己的网络应用程序，并通过Python套接字客户端的recv()方法与服务器进行通信。
腾讯云云服务器的优势：
- 灵活可扩展：您可以根据实际需求选择不同配置的云服务器，满足不同规模和性能要求的应用。
- 高性能：腾讯云云服务器提供了高性能的计算、存储和网络资源，可以满足各种计算密集型和存储密集型应用的需求。
- 高可靠性：腾讯云云服务器采用了分布式架构和冗余设计，保证了服务的高可用性和可靠性。
Python套接字客户端的recv()方法在以下场景中有广泛应用：
- 网络通信：通过套接字客户端的recv()方法，可以实现与服务器之间的数据交换，例如实时聊天、文件传输等。
- 网络编程：套接字客户端的recv()方法是实现网络编程的重要组成部分，可以用于开发各种网络应用程序，如Web服务器、邮件客户端等。
总结：Python套接字客户端的recv()方法用于从服务器接收数据，缓冲区大小参数指定了每次接收数据的最大字节数。腾讯云云服务器（CVM）是一种推荐的云计算产品，可用于搭建网络应用程序并与套接字客户端进行通信。
相关·内容
我总是注意到netstat中RECV_Q的大小总是比RECV_BUF小。例如:我使用getsockopt方法获取我的服务器套接字的RECV_BUF值，该值为20000。我用这种方式阻塞了服务器:只接受来自客户端的连接，但在客户端一直在发送数据时，不接收来自客户端的任何数据。
我使用命令'sudo netstat -talunp | grep 14455'(14455是服务器pid。)结果是：“tcp 15299 0 127.0.0.1:50005 127.0.0.1:44055 ESTABLISHED 14455/python”
这意味着RECV_Q为15299，小于RECV_
浏览 1提问于2012-09-05得票数 0
1回答
首先，我有以下代码...很管用。很明显。
while not self.socket_connected:
try:
client_socket.connect((self.hostname, self.port))
self.socket_connected = True
except:
sleep(0.5)
pass
while self.socket_connected:
message = client_socket.recv(4096)
if(message == b''
浏览 14提问于2018-06-11得票数 0
我有一个C++程序，它从高速摄像机读取帧，并将每个帧写入套接字(unix )。每次写入的字节数为4096字节。每个帧大约是5MB。(不能保证帧大小是恒定的，但它总是4096字节的倍数。)
有一个python脚本，它从套接字读取:每次调用recv时10 * 4096字节。我经常会得到意想不到的行为，我认为这些行为可以归结为理解以下有关套接字的内容。我相信我的两个程序都是阻塞模式下的write/recv。
我可以一次写整个帧(用5MB的数据写调用)吗？是推荐的吗？速度是这里最关心的问题。
如果python客户端无法读取或读取慢于写，是否意味着经过一段时间后，套接字上的写操作不会添加到缓冲区
浏览 4提问于2016-12-05得票数 0
回答已采纳
2回答
是我，还是我找不到关于python中非阻塞套接字的好教程？
我不确定如何在其中确切地使用.recv和.send。根据python文档(至少是我的理解)，recv'ed或send'ed的数据可能只是部分数据。所以这是不是意味着我必须以某种方式在recv的同时连接数据，并确保所有数据都以send的形式发送。如果是这样的话，怎么做?如果是这样的话，我会非常感激。
浏览 0提问于2011-07-16得票数 8
回答已采纳
我想读取缓冲区中的所有可用字节，下面的代码按100字节的块读取。
1)是否可以读取缓冲区中的所有字节？
2) sock.recv()的默认值是什么? //无参数
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server_address = ('localhost', 1489)
sock.connect(server_address)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_SNDBUF, 8192) # Buffer size 81
浏览 1提问于2018-04-11得票数 1
回答已采纳
1回答
我使用的是C++ TCP/IP套接字。根据我的要求，我的客户端必须连接到服务器并读取它发送的消息(这是非常新的东西，不是吗)，但是……在我的应用程序中，我必须等待一段时间(通常是1-2小时)，然后才能真正开始读取消息(通过recv()或read())，而服务器仍然继续发送消息。
我想知道保存这些消息的缓冲区的容量是否有限制，以防它们未被读取，以及使用谁的物理内存来缓冲这些消息？发送者还是接收者？
浏览 2提问于2012-10-17得票数 4
回答已采纳
我正在尝试使用Python套接字向我的远程服务器发送命令。我的远程服务器正在侦听端口50000 (服务器套接字没有配置python)。当我登录服务器并回显我想要的命令时，我得到了正确的结果，如下所示：
echo mycommand | nc 127.0.0.1 50000
我返回到stdout的三行代码：
>ServerOn=
>Command_received
>Cmd=mycommand
我想用python3在客户端实现同样的效果。我知道我能够连接到服务器，但是，我不能像上面那样得到完整的响应。我尝试了以下几种方法：
s = socket.socket(socket.AF
浏览 0提问于2018-10-16得票数 1
3回答
我正在编写一个要发送的程序，另一个通过套接字接收图像流。概括地说：
在客户端:我得到图像并在客户端进行预可视化。然后我用插座把它送过去了。
在服务器端:我等待图像，然后预可视化。
下面是与套接字相关的代码片段：
编辑：
客户端
unsigned int bytes = 0;
for (int i = 0; i < imgSize; i += bytes) {
if ((bytes = send(clientSocket->getSocketDescriptor(), (char*)inputImage.data + i, imgSize - i, 0)) =
浏览 2提问于2014-09-07得票数 1
回答已采纳
我想使用recv的非阻塞API，但是它在64 of的数据之后不能工作，并给出错误:资源暂时不可用。因此，我使用if(error == EAGAIN)，但是由于没有可用的数据，所以它在接收上停留了下来。
while(true) {
ret = recv(csd, buf, size, MSG_DONTWAIT);
if(errno == EAGAIN) {
continue;
}
if (ret < 0) {
perror("Error in receive\n
浏览 0提问于2018-06-21得票数 0
回答已采纳
2回答
我目前正在创建一个基于TCP的反向shell (客户端在远程计算机上，连接到本地服务器)，它既可以发送和接收文件，也可以通过TCP发送shell命令。这些程序在所有其他方面(例如，接收和发送命令，服务器接收文件)都能正常工作，直到我尝试从服务器向客户端发送大文件(大于1kb)为止。当我试图发送大文件时，在服务器发送完之后，客户端会因为某种原因崩溃。我甚至看不到错误信息。我试图通过在客户端显示接收到的内容来调试它，但它似乎收到了很好的结果，但会立即崩溃。我将附加客户端代码和服务器代码给那些想要帮助的人。代码有点奇怪，因为我在第一次调试时添加了一些“标志”。谢谢。
服务器代码：
import so
浏览 0提问于2018-06-17得票数 3
回答已采纳
关于C中的套接字库，我有几个问题。下面是我将在问题中引用的代码片段。
char recv_buffer[3000];
recv(socket, recv_buffer, 3000, 0);
我如何决定recv_buffer的规模有多大？我使用的是3000，但这是任意的。如果recv()收到的数据包比我的缓冲区大会发生什么？我怎么知道我已经收到了整个消息，而不需要再次调用recv，并让它在没有接收到任何东西的情况下一直等待？有没有一种方法可以让一个缓冲区没有固定的空间，这样我就可以继续添加它，而不用担心空间耗尽？也许可以使用strcat将最新的recv()响应连接到缓冲区？
我知道这其中有很多问
浏览 52提问于2010-05-19得票数 145
回答已采纳
我使用python SocketServer下载/上载多个图像文件。
服务器代码
class ThreadedTCPRequestHandler(SocketServer.BaseRequestHandler):
def handle(self):
'''
Here is other codes......
'''
#start sending files to client...
for img_name, img_size in dict_image_
浏览 0提问于2013-10-29得票数 1
回答已采纳
2回答
简而言之，我的问题是:我不知道选择器如何知道哪个套接字应该先读或写。
它是一个能够处理多个连接的服务器，其流程应该是：
服务器创建侦听套接字
客户端创建两个套接字并将它们连接到服务器。
客户端2套接字发送消息
服务器2套接字回显这些消息，客户机和服务器关闭连接。
这就是所发生的情况，但是如果创建的服务器套接字首先写入，则连接将立即关闭或抛出异常(？)，因为它甚至不调用send，客户端套接字将不记录任何内容。那么，选择器如何知道哪个套接字应该准备好先写/读呢？我错过了哪些信息才能理解这一点？
服务器：
import socket
import selectors
impo
浏览 2提问于2018-10-29得票数 4
回答已采纳
# addition_server.py
import socket
buf_size = 4
host = ''
port = 8000
server_addr = (host, port)
def get_msg(soc):
msg = ''
while True:
temp = soc.recv(buf_size)
if not temp:
break
msg += temp
return msg
if __name__ == '__main_
浏览 1提问于2014-12-14得票数 1
回答已采纳
3回答
是否从已关闭的套接字接收数据？
、、、、
假设我有一个服务器应用程序--连接是通过TCP，使用UNIX套接字。
连接是异步的-换句话说，客户端和服务器的套接字是非阻塞的。
假设以下情况:在某些情况下，服务器可能决定向连接的客户端发送一些数据，并立即关闭连接:在SHUT_RDWR中使用shutdown。
所以，我的问题是，当客户端调用recv时，它能保证接收(由服务器发送的)数据吗？
或者，为了接收数据，必须在服务器的shutdown之前调用recv？如果是这样，我应该做什么(或者，更准确地说，我应该如何做)，以确保客户端接收到数据？
浏览 2提问于2012-08-10得票数 6
回答已采纳
我正在阅读boost asio教程中的。它使用recv_buffer_并使用async_receive_from()运行接收循环。
socket_.async_receive_from(
boost::asio::buffer(recv_buffer_), remote_endpoint_,
boost::bind(&udp_server::handle_receive, this,
boost::asio::placeholders::error,
boost::asio::placeholders::bytes_transferred));
浏览 6提问于2013-09-02得票数 0
当我创建一个try to socket.recv()从NETLINK_ROUTE套接字，如果我没有检索所有可用的数据，似乎没有检索到的数据丢失了。
例如：
>>> import socket
>>> sock = socket.socket(socket.AF_NETLINK, socket.SOCK_DGRAM, socket.NETLINK_ROUTE)
>>> sock.bind((0,0))
>>> sock.send('\24\0\0\0\22\0\1\3\23\0364O\0\0\0\0\21\0\0\
浏览 0提问于2012-02-10得票数 1
回答已采纳
1回答
我的服务器发送对象的速度比客户端接收的快得多。这就是客户端接收10秒前发送的对象的原因，因为客户端必须接收队列中的每个对象。所以我的问题是:我如何放慢服务器的速度，或者让我的客户端接收更快？ 编辑:我在服务器上添加了time.sleep(0.1)，但是有没有更有效的方法？ 这是我的Network类： import socket
import pickle
class Network:
def __init__(self):
self.client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
浏览 56提问于2021-01-23得票数 1
我使用Python的select库异步读取两个套接字的数据。由于接收到的数据包大小可能有所不同，而且我也不知道正在读取的数据是否有最大可能大小，因此我实现了一个名为recvAll(sock)的函数，用于从套接字中获取所有数据：
def recvAll(sock):
buffer = ''
data = []
try:
while True:
buffer = sock.recv(8192)
if not buffer:
break
d
浏览 0提问于2018-04-04得票数 0
回答已采纳
2回答
使用非阻塞udp读取时缺少消息。
、、、、
在两个主机之间使用udp中的非阻塞读取时，我遇到了丢失消息的问题。发送者在linux上，阅读器在winxp上。python中的这个例子显示了这个问题。
下面是三个用来显示问题的脚本。
send.py
import socket, sys
s = socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
host = sys.argv[1]
s.sendto('A'*10, (host,8888))
s.sendto('B'*9000, (host,8888))
s.sendto('C'*9000, (ho
浏览 0提问于2010-10-18得票数 8
回答已采纳
我知道这个错误：
Traceback (most recent call last):
File "./server.py", line 12, in <module>
data = connexion.recv(1024)
socket.error: [Errno 57] Socket is not connected
server.py：
#!/usr/bin/python2.7
import socket
connexion = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
connexion
浏览 1提问于2015-02-08得票数 2
回答已采纳
到目前为止，我发现所有关于用套接字(recv)接收数据的方法都是用普通的C语言。
即使是C++，它也是在std::vector<char> (eww!)上逐字节接收，或者是 (例如vec.resize(BIG_NUMBER))，然后接收。
然而，所有这些看起来都非常低效和/或丑陋，所以我想知道，在中使用最有效、最正确和最优雅的方法是什么？(非C)
web浏览器是一个很好的例子，说明某人需要在哪里接收未知数量的数据。(为示例起见，忽略Content-length头)
浏览 10提问于2015-02-16得票数 1
回答已采纳
1回答
我发现了一个类似的问题，，但它不能解决我的问题。
我想控制推送套接字队列中的消息数量，但是它不能工作，并且仍然排队1000条消息。
所以我想知道如何设置推插座的hwm。提前谢谢。
我的环境是: libzmq 4.0.4，pyzmq 14.1.0，python 3.3
这是我的密码：
server.py
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import random
import zmq
class TestPush(object):
def __init__(self):
self.ctx = zmq.
浏览 0提问于2014-03-24得票数 4
2回答
我正试着写一个简单的游戏，但是每次我启动它，Pygame都会崩溃。
以下是客户端代码：
import socket, pygame, sys
port = 5000
host_server = "localhost"
client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
client_socket.connect((host_server, port))
pygame.init()
FPS = 30
fpsClock = pygame.time.Clock()
DISPLAYSURF = pygame
浏览 1提问于2014-04-24得票数 0
我正在阅读<<黑帽Python >>，并尝试了第一个bhnet.py程序。
在一个终端上，我运行脚本
./bhnet.py -l -p 9999 -c
在另一个终端上运行脚本
./bhnet.py -t localhost -p 9999
然后键入
<ctrl-D>
或
ls -alt
<ctrl-D>
第一个航站楼将返回
File "bhnet.py", line 186, in client_handler
cmd_buffer += client_socket.recv(1024).decode('utf-8'
浏览 1提问于2018-07-13得票数 0
假设我有一个发送方应用程序和一个通过UDP进行通信的接收方应用程序。
首先，在发送者应用程序中，我通过两个单独的呼叫发送一些数据。首先，我发送以下15个字节：
[MYHEADER]hello
...then，紧接着，我又发送了15个字节：
[MYHEADER]world
现在，在接收程序中，我使用绑定到相同地址的UDP套接字侦听同一个端口。假设从上次检查接收方套接字以来，这两条消息都已到达(并且顺序相同)。
下面是一些伪代码，它显示了我如何轮询传入数据的套接字，每个帧：
uint32 PendingSize;
while (Socket->HasPendingData(PendingSi
浏览 8提问于2014-10-03得票数 1
回答已采纳
3回答
下面的代码允许我从服务器到客户端下载三个名为tmp.bsp、tmp.seq和tmp.dms的文件。但是，只下载了第一个文件tmp.dms。另一个tmp.seq被tmp.bsp和tmp.bsp驻留0KB的信息填充。
客户端：
import socket
import socket
skClient = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
skClient.connect(("127.0.0.1",2525))
sData = "Temp"
sData2 = "Temp"
sD
浏览 0提问于2018-06-21得票数 3
回答已采纳
我正在尝试编写一个用于文件传输的服务器-客户端应用程序。客户机是用Java编写的，服务器是用C++编写的。
不幸的是，我有以下错误：
java.net.SocketException:由对等方重置连接:套接字写入错误“
以下是我的客户端代码：
import java.io.*;
import java.net.Socket;
public class Proba_binar
{
public static void main(String[] args)
{
byte[] buffer = null;
byte
浏览 2提问于2013-04-17得票数 0
回答已采纳
我的假设是，当TCP连接处于已建立状态时，服务器可以从套接字中读写。但是我看到，当TCP连接处于CLOSE_WAIT状态时，服务器实际上可以从套接字中读取和写入套接字。当客户端关闭连接时会发生这种情况，但是服务器还没有检测到/处理流结束的情况。
例如。同步、阻塞的单线程服务器：
#include <unistd.h>
#include <netdb.h>
#include <signal.h>
int main (void)
{
signal(SIGPIPE, SIG_IGN); // ignore SIGPIPE from last send()
浏览 1提问于2020-03-02得票数 1
我有简单的python服务器和客户端。
服务器：
import SocketServer
import threading
class MyTCPHandler(SocketServer.BaseRequestHandler):
def handle(self):
self.data = self.request.recv(1024).strip()
print str(self.client_address[0]) + " wrote: "
print self.data
self.request.s
浏览 1提问于2011-12-25得票数 16
回答已采纳
相对简单的问题:当使用Linux非阻塞套接字执行recv()时，有没有一种方法可以预先确定有多少数据可供接收？
似乎我总是要做一个额外的recv()调用来确定我已经排空了所有的数据。
浏览 0提问于2016-10-12得票数 0
我很想知道当进行下面的调用时会发生什么。
recv(<socket no>, NULL , <lenght> , 0) ;
还有一个问题是，在调用recv函数后，套接字上的数据会被刷新，或者到底会发生什么？
你好，基兰
浏览 0提问于2013-05-08得票数 0
回答已采纳
我试着在网上查找了大量的页面，没有找到适合windows的，而且总是有效的，我尝试了TCP协议上的这个(逐字节流，直到你碰到3-我尝试了没有3的文件:PPPP和3，我指的是ASCII值3而不是数字'3')。
服务器端：
int sendFile(SOCKET s, const char* file_path)
{
FILE* fp = fopen(file_path, "rb");
int i, err = 0, bytesSent, isOk = 1;
char ch = 0;
if(!fp)
{
fcl
浏览 4提问于2014-08-07得票数 0
2回答
我正在实现从java到C++程序的TCP套接字连接。目前这是单向的，但总有一天会变成双向的。我的留言相当长(~100.000字)。不知何故，我的应用程序一次只发送8192个字符/字节。这怎么可能呢？是否有任何工具可以帮助调试？客户端和服务器都运行在本地windows机器上。我不熟悉网络编程，所以非常感谢你的帮助！提前谢谢你！
到目前为止，我的代码如下：
JAVA:
连接：
try {
serverSocket = new ServerSocket(socketPort);
System.out.println("waiting for c
浏览 1提问于2015-03-02得票数 0
正如所述的，最小以太网数据包大小为64字节：
小于以太网数据包最小64字节(报头+用户数据+ FCS)的以太网数据包被填充到64个字节。
我是否可以假设recv将读取小于最小以太网帧大小的一次性数据？假设连接的另一端一次发送10字节的数据，我是否可以在结束时调用recv一次，并假定读取了所有10个字节？
浏览 3提问于2016-03-16得票数 0
回答已采纳
1回答
我有一个p2p网络，我的套接字发送要么发送不完整的数据，要么在发送完整数据之前中断。我不是很确定发生了什么，或者这里是否有什么地方出了问题。下面是我的发送代码，我循环发送，直到发送完整个msg。我注意到在下面的侦听器代码中，我的json_loads抛出了异常，当我打印出缓冲区时，由于即时消息发送的字典不完整，发送中似乎缺少了一些字节。不知道我到底做错了什么。有谁知道吗？
def unicast(self, msg, recipient_node):
#print('UNICAST HERE')
msg = json.dumps(msg)
浏览 6提问于2021-03-09得票数 0
4回答
我对C语言和编写TCP服务器是相当陌生的，我想知道如何处理来自客户端的recv()，客户端将发送服务器将响应的命令。对于这个问题，假设头部是第一个字节，命令标识符是第二个字节，有效负载长度是第三个字节，后面是有效负载(如果有的话)。
recv()此数据的最佳方法是什么？我在考虑调用recv()将前3个字节读入缓冲区，检查以确保头和命令标识符有效，然后检查有效载荷长度，并再次调用recv()，将有效载荷长度作为长度，并将其添加到前面提到的缓冲区的后面。然而，在阅读Beej的网络文章(特别是部分)时，他建议使用“一个足够大的数组来容纳两个最大长度的数据包”来处理一些情况，比如获取下一个数据包。
处
浏览 0提问于2010-12-02得票数 5
回答已采纳
短问题
在服务器端处理通过Telnet发送的Ctrl事件的正确方法是什么？
长问题
在对套接字调用recv()之后，我想适当地处理一些情况。其中之一是在接收到Ctrl时返回特定的错误代码.有什么正确的方法能探测到这个吗？下面的方法很有效，但似乎不太正确：
size_t recv_count;
static char ctrl_c[5] = {0xff, 0xf4, 0xff, 0xfd, 0x06};
recv_count = recv(socket, buffer, buffer_size, 0);
if (recv_count == sizeof(ctrl_c) &&
浏览 8提问于2010-06-10得票数 5
1回答
当我将套接字连接到服务器套接字，并且在给定时间内服务器套接字关闭时，我会在客户端得到一个BrokenPipeError。但不是下一次我试着发送什么，而是在那之后的时间。
这里是一个SSCCE：
服务器：
#! /usr/bin/python3
import socket
s = socket.socket (socket.AF_INET, socket.SOCK_STREAM)
s.setsockopt (socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
s.bind ( ('', 10100) )
s.listen (1)
print
浏览 1提问于2014-01-07得票数 0
回答已采纳
我目前正在编写一个小型客户端服务器应用程序，用于通过套接字将任意文件从服务器传输到客户端。
服务器一次只能处理一个客户端，但是当客户端被服务时，它应该准备好处理一个新的客户端连接。
客户端将请求一个文件，如果文件存在，客户端将接收该文件，将其写入磁盘并关闭连接。
服务器代码：
PORT = 9000
BUFSIZE = 1000
def main(argv):
print('The server is ready to receive')
server_socket = socket(AF_INET, SOCK_STREAM)
server_socke
浏览 0提问于2019-03-14得票数 3
回答已采纳
看看这个小的基本python程序：
import socket
tcpsock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
tcpsock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
tcpsock.bind(("", 10000))
tcpsock.listen(10)
(sock, (ip, port)) = tcpsock.accept()
s = sock.recv(1024)
print(s)
第二个程序：
import socket
im
浏览 0提问于2019-10-06得票数 0
我正在阅读上的python socketserver文档示例。
为什么在self.request.recv(1024) inside handle方法行中将大小指定为1024。如果客户端发送的数据超过1024个字节，会发生什么情况？让一个循环读取1024个字节直到套接字为空是不是更好？我在这里复制了这个例子：
import SocketServer
class MyTCPHandler(SocketServer.BaseRequestHandler):
"""
The RequestHandler class for our server.
浏览 1提问于2015-04-23得票数 3
我只是在学习C语言的套接字/网络编程，遇到了recv()函数导致一些意想不到的行为(至少对我来说是意外的)的情况。
我有一个设置了套接字的服务器程序，并调用了recv()，如下所示：
bytes_received = recv(connected, recv_data, 5, 0);
recv_data是一个5字节的缓冲区。
我的客户端程序使用send()发送数据，它的发送缓冲区是1024字节，但是由于它是从标准输入读取的，所以在这个实验期间我只给它1-10字节(字符)。
我看到，即使我的recv()调用使用了一个5字节的缓冲区，并且施加了5字节的限制，我仍然可以发送超过5个字节，而且它似乎
浏览 2提问于2013-03-04得票数 3
回答已采纳
1回答
我想用ros旋律包中的子流程进行沟通。
由于ros使用python2作为默认值，所以python3库出现了一些python版本问题。这就是我决定使用子进程的原因。
下面是我的两个代码:第一个是ros节点(作为客户端)，第二个是作为服务器的python3文件。
Client(image_bus.py)
#!/usr/bin/env python
import rospy
import cv2
import numpy as np
import os
import subprocess
from cv_bridge import CvBridge, CvBridgeError
from std_m
浏览 1提问于2020-03-24得票数 0
回答已采纳
1回答
我试图通过TCP套接字发送一个数据包。我通过套接字发送的结构如下：
struct requestPacket {
uint32_t INDEX;
uint32_t KEYSIZE;
uint8_t *KEY;
};
我将数据包(在将它放在缓冲区中后)一次发送到一个带有send的TCP套接字中。
send(sockfd, buff, size, 0);
在不事先知道大小的情况下，服务器如何处理此消息？在recv函数中，您必须定义一个设置大小的缓冲区，但只有在处理数据包开始后才知道这个大小。有小费吗？可以解析两次数据包吗？我知道前8个字节将包含消息的索引和大小。
浏览 9提问于2022-10-16得票数 1
1回答
这个套接字服务器中有一些错误，很可能是与线程相关的。如果这继续接受客户端连接，过一段时间它就会开始挂起。这似乎不是内存泄漏，因为程序占用的内存保持不变，但当我与telnet客户端连接时，它只会挂起，什么也不做。
它仍然会到达but (“Handler分配的”)，但是它什么也不做。有什么原因吗？
/*
C socket server example, handles multiple clients using threads
*/
#include<stdio.h>
#include<string.h> //strlen
#include<stdl
浏览 1提问于2014-03-09得票数 2
4回答
另一个插座问题。
在我的客户端代码中，我发送了一些数据包，并期待服务器端的一些响应：
发送()
recv() <--它阻塞了
send()之后，服务器立即崩溃并重新启动。与此同时，recv()正在等待。但是，即使在服务器运行完毕后，接收呼叫也会挂起。我已经添加了SIGPIPE信号处理，但它仍然无法识别套接字是坏的。
当我取消操作时，我从recv()那里得到了错误，中断已经发出。
谁能帮我纠正这个错误？
这是在Solaris机器上运行的共享库中。
浏览 7提问于2010-02-11得票数 6
回答已采纳
2回答
我有一个简单的问题，我无法解决自己搜索谷歌，希望你能帮助我。
我正在编写一个网络应用服务器，并使用epoll/kqueue来处理连接。
当我收到请求并处理它时，应该立即向客户端套接字发送响应，还是应该将客户端套接字添加到epoll/kqueue监视中，并在它告诉我可以编写操作时发送响应？
例如。(伪码)。我应该这么做吗：
while(true) {
epoll/kqueue check for events
if(triggered event is server listening socket) {
accept() new socket
浏览 1提问于2015-12-07得票数 0
回答已采纳
据我所知，套接字连接的客户端和服务器脚本不能在同一个程序(线程)中运行。但是下面的示例允许在套接字之间建立连接，甚至可以在同一个程序(线程)中交换它们之间的消息。
有人能解释一下这里出了什么问题吗？
from socket import socket, AF_INET, SOCK_STREAM, SOL_SOCKET, SO_REUSEADDR
import time
SERV_SOCK = socket(AF_INET, SOCK_STREAM)
SERV_SOCK.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
SERV_SOCK.bind(('l
浏览 3提问于2021-11-29得票数 0
回答已采纳
Socket编程新手。我在做一个HTTP服务器。在持久连接中，在服务器为来自客户端的第一个HTTP请求发送了第一个文件(1MB文本文件)之后，我保持套接字打开。在此之后，服务器和客户端程序就会处于闲置状态。我搜索了很多次，发现recv()一直在套接字上查找数据，直到套接字连接从服务器端关闭。
如果是长连接，该怎么做？我正在客户端读取一个文件(文件包含很多行。在每一行上只有一个文件名，它将通过持久连接从服务器获取)
发送所请求文件的服务器代码的一部分：
while((bytesread = fread(filecontent,sizeof(char), 1024, fp))>0)
{
浏览 1提问于2015-09-27得票数 0
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
实时音视频
即时通信 IM
对象存储活动推荐
腾讯云开发者
