我必须要说的第一件事是，这篇文章在[Remy Lebeau] [1] https://stackoverflow.com/users/65863/remy-lebeau的回答中受到强烈启发：
Send binary file over TCP/IP connection。
我正在使用poco库和C ++。
目标是通过互联网发送一些大的二进制文件。所以为了实现这一点，我使用以下消息头：
class FileDesc
{
size_t file_size = 0;
size_t chunk_size = 0;
size_t file_name_len = 0;
char file_name[0];
public:
FileDesc(size_t file_sz, size_t buf_sz)
: file_size(ByteOrder::toNetwork(file_sz)),
chunk_size(ByteOrder::toNetwork(buf_sz)) {}
size_t get_file_size() const { return ByteOrder::fromNetwork(file_size); }
size_t get_chunk_size() const { return ByteOrder::fromNetwork(chunk_size); }
string get_file_name() const
{
const auto len = get_file_name_len();
string ret; ret.reserve(len + 1);
for (size_t i = 0; i < len; ++i)
ret.push_back(file_name[i]);
return ret;
}
size_t get_file_name_len() const
{
return ByteOrder::fromNetwork(file_name_len);
}
size_t size() const
{
return sizeof(*this) + ByteOrder::fromNetwork(file_name_len);
}
static shared_ptr<FileDesc> allocate(size_t file_sz, size_t buf_sz,
const string & name)
{
const auto n = name.size();
const size_t sz = sizeof(FileDesc) + n;
shared_ptr<FileDesc> ret((FileDesc*) malloc(sz), free);
new (ret.get()) FileDesc(file_sz, buf_sz);
memcpy(ret->file_name, name.data(), n);
ret->file_name_len = ByteOrder::toNetwork(n);
return ret;
}
};
文件将由固定长度的块发送，除了最后一个。该标头在传输开始时发送。发送方部分通过大小为file_size的块并且文件名具有chunk_size个字符，通知接收方部分将发送file_name_len个字节的文件。在此消息的末尾通过char数组file_name填充文件名，其长度是可变的并且取决于文件名长度。静态方法allocate负责分配此标头，其大小足以存储完整的文件名。
以下是发件人部分的代码：
bool send_file(StreamSocket & sock, const string & file_name, long buf_size)
{
stringstream s;
ifstream file(file_name, ios::binary | ios::ate);
if (not file.is_open() or not file.good()) // verify file reading
{
s << "cannot open file " << file_name;
throw domain_error(s.str());
}
long file_size = file.tellg();
if (file_size == 0)
{
s << "file " << file_name << " has zero bytes";
throw domain_error(s.str());
}
file.seekg(0);
unique_ptr<char[]> chunk(new char[buf_size]);
auto desc_ptr = FileDesc::allocate(file_size, buf_size, file_name);
// send the file description
int status = sock.sendBytes(desc_ptr.get(), desc_ptr->size());
if (status != desc_ptr->size())
return false;
do // now send the file
{
long num_bytes = min(file_size, buf_size);
file.read(chunk.get(), num_bytes);
char * pbuf = chunk.get();
auto n = num_bytes;
while (n > 0)
{
status = sock.sendBytes(pbuf, n);
pbuf += status;
n -= status;
}
file_size -= num_bytes;
}
while (file_size > 0);
char ok; // now I wait for receiving part notifies reception
status = sock.receiveBytes(&ok, sizeof(ok));
return ok == 0;
}
send_file(sock, file_name, buf_size)打开文件file_name，并通过大小为sock的块通过poco套接字buf_len发送其内容。因此它将执行file_size/buf_len传输以及文件描述符的初始传输。
接收方实例化poco ServerSocket，如下所示：
ServerSocket server_socket(addr);
auto sock = server_socket.acceptConnection();
auto p = receive_file(sock, 256);
receive_file(sock, 256)表示在套接字sock会收到一个文件，其最大文件长度为256字节（足够我的应用程序）。此例程是send_file()的对应部分，保存文件，其实现方式如下：
pair<bool, string>
receive_file(StreamSocket & sock, size_t max_file_name_len)
{
stringstream s;
size_t buf_sz = sizeof(FileDesc) + max_file_name_len;
unique_ptr<char[]> buffer(new char[buf_sz]);
int num = sock.receiveBytes(buffer.get(), buf_sz);
FileDesc * msg = reinterpret_cast<FileDesc*>(buffer.get());
if (msg->size() > num)
return make_pair(false, "");
long chunk_size = msg->get_chunk_size();
if (chunk_size == 0)
throw domain_error("chunk size is zero");
const string file_name = msg->get_file_name();
ofstream file(file_name, ios::binary);
if (not file.is_open() or not file.good())
{
s << "cannot create file" << file_name;
throw domain_error(s.str());
}
long file_size = msg->get_file_size();
unique_ptr<char[]> chunk(new char[chunk_size]);
do
{ // num_bytes is the quantity that I must receive for this chunk
auto num_bytes = min(file_size, chunk_size);
char * pbuf = chunk.get();
long n = num_bytes;
while (n > 0)
{
num = sock.receiveBytes(pbuf, n, 0); // <-- here is potentially the problem
if (num == 0) // connection closed?
return make_pair(file_size == 0, file_name);
pbuf += num;
n -= num;
}
file.write(chunk.get(), num_bytes);
file_size -= num_bytes;
}
while (file_size > 0);
char ok;
num = sock.sendBytes(&ok, sizeof(ok)); // notify reception to sender
return make_pair(true, file_name);
}
receive_file()返回pair<bool,string>，其中first表示接收已正确完成且second为文件名。
由于我无法理解的原因，有时，当num = sock.receiveBytes(pbuf, n, 0)收到的字节少于预期的n并且循环完成读取余数时，只有最后一个接收对应于最后一个发送块。
奇怪的是，到目前为止，我的问题只发生在我使用环回（127.0.0.1）时，这对于测试非常实用，因为我在我的机器上测试了所有内容。相反，当传输在两个不同的对等体之间时，一切正常，当然并不表示一切都是正确的。
所以，如果有人可以帮助我批评我的实施并最终表明问题出在哪里，我将非常感激
答案 0 :(得分：4)
如果您不想阻止I / O，则应将套接字设置为non-blocking mode。
但是，看起来简单的事情过于复杂;这是一个简单的例子：
$ fallocate -l 1G test.in
$ ls -al test.in
-rw-r--r-- 1 alex alex 1073741824 Oct 15 23:31 test.in
$ ls -al test.out
ls: cannot access test.out: No such file or directory
$./download
$ ls -al test.out
-rw-rw-r-- 1 alex alex 1073741824 Oct 15 23:32 test.out
$ diff test.out test.in
$
所以，我们很好 - 文件是1G且相同（尽管很无聊）。
客户代码：
#include "Poco/StreamCopier.h"
#include "Poco/FileStream.h"
#include "Poco/Net/SocketAddress.h"
#include "Poco/Net/ServerSocket.h"
#include "Poco/Net/StreamSocket.h"
#include "Poco/Net/SocketStream.h"
using namespace Poco;
using namespace Poco::Net;
int main()
{
StreamSocket ss;
ss.connect(SocketAddress("localhost", 9999));
SocketStream istr(ss);
std::string file("test.out");
Poco::FileOutputStream ostr(file, std::ios::binary);
StreamCopier::copyStream(istr, ostr);
return 0;
}
这是服务器：
#include "Poco/Net/SocketAddress.h"
#include "Poco/Net/Socket.h"
#include "Poco/Net/StreamSocket.h"
#include "Poco/Net/ServerSocket.h"
#include "Poco/Net/SocketStream.h"
#include "Poco/StreamCopier.h"
#include "Poco/Timespan.h"
#include "Poco/FileStream.h"
using namespace Poco;
using namespace Poco::Net;
int main()
{
ServerSocket srvs(SocketAddress("localhost", 9999));
Timespan span(250000);
while (true)
{
if (srvs.poll(span, Socket::SELECT_READ))
{
StreamSocket strs = srvs.acceptConnection();
SocketStream ostr(strs);
std::string file("test.in");
Poco::FileInputStream istr(file, std::ios::binary);
StreamCopier::copyStream(istr, ostr);
}
}
return 0;
}
享受POCO！