void thread_client()
{
try
{
printf("[Client] Started\n");
CClientTCPSocket sock;
printf("[Client] Connecting\n");
sock.connect( "127.0.0.1", 15000 );
printf("[Client] Connected. Waiting for a message...\n");
// cout << "pending: " << sock.getReadPendingBytes() << endl;
// mrpt::system::sleep(4000);
// cout << "pending: " << sock.getReadPendingBytes() << endl;
CMessage msg;
bool ok = sock.receiveMessage( msg, 2000,2000);
if (!ok)
{
printf("[Client] Error receiving message!!\n");
}
else
{
printf("[Client] Message received OK!:\n");
printf(" MSG Type: %i\n", msg.type );
printf(" MSG Length: %u bytes\n", (unsigned int)msg.content.size() );
printf("[Client] Parsing image...\n");
CImage img;
msg.deserializeIntoExistingObject( &img );
printf("[Client] Saving image...\n");
img.saveToFile("received_frame.jpg");
printf("[Client] Done!!\n");
}
printf("[Client] Finish\n");
}
catch(std::exception &e)
{
cerr << e.what() << endl;
}
catch(...)
{
cerr << "[thread_client] Runtime error!" << endl;;
}
}
void thread_server()
{
try
{
printf("[Server] Started\n");
CServerTCPSocket server( 15000, "127.0.0.1" , 10, true );
CClientTCPSocket *client;
client = server.accept( 2000 );
if (client)
{
printf("[Server] Conection accepted\n");
// Load test image:
CImage img;
img.loadFromFile(myDataDir+string("frame_color.jpg"));
// Send a message with the image:
CMessage msg;
msg.type = 0x10;
msg.serializeObject( &img );
printf("[Server] Sending message...\n");
client->sendMessage( msg );
printf("[Server] Message sent!!\n");
mrpt::system::sleep(50);
delete client;
}
printf("[Server] Finish\n");
}
catch(std::exception &e)
{
cerr << e.what() << endl;
}
catch(...)
{
printf("[thread_server] Runtime error!\n");
}
}
void CListenSocket::OnAccept(int nErrorCode)
{
// 0.42e
if (!nErrorCode) {
m_nPendingConnections++;
if (m_nPendingConnections < 1) {
wxFAIL;
m_nPendingConnections = 1;
}
if (TooManySockets(true) && !theApp->serverconnect->IsConnecting()) {
StopListening();
return;
} else if (bListening == false) {
// If the client is still at maxconnections,
// this will allow it to go above it ...
// But if you don't, you will get a lowID on all servers.
ReStartListening();
}
// Deal with the pending connections, there might be more than one, due to
// the StopListening() call above.
while (m_nPendingConnections) {
m_nPendingConnections--;
// Create a new socket to deal with the connection
CClientTCPSocket* newclient = new CClientTCPSocket();
// Accept the connection and give it to the newly created socket
if (!AcceptWith(*newclient, false)) {
newclient->Safe_Delete();
} else {
wxASSERT(theApp->IsRunning());
if (!newclient->InitNetworkData()) {
// IP or port were not returned correctly
// from the accepted address, or filtered.
newclient->Safe_Delete();
}
}
}
}
}
/*---------------------------------------------------------------
http_get
---------------------------------------------------------------*/
ERRORCODE_HTTP BASE_IMPEXP
mrpt::utils::net::http_get(
const string &url,
vector_byte &out_content,
string &out_errormsg,
int port,
const string &auth_user,
const string &auth_pass,
int *out_http_responsecode,
mrpt::utils::TParameters<string> *extra_headers,
mrpt::utils::TParameters<string> *out_headers,
int timeout_ms
)
{
// Reset output data:
out_content.clear();
if (out_http_responsecode) *out_http_responsecode=0;
if (out_headers) out_headers->clear();
// URL must be:
// http://<SERVER>/<LOCAL_ADDR>
if (0!=::strncmp(url.c_str(),"http://",7))
{
out_errormsg="URL must start with 'http://'";
return net::erBadURL;
}
string server_addr = url.substr(7);
string get_object = "/";
// Remove from the first "/" on:
size_t pos = server_addr.find("/");
if (pos==0)
{
out_errormsg="Server name not found in URL";
return net::erBadURL;
}
if (pos!=string::npos)
{
get_object = server_addr.substr(pos);
server_addr.resize(pos);
}
CClientTCPSocket sock;
try {
// Connect:
sock.connect(server_addr,port, timeout_ms);
}
catch (std::exception &e) {
out_errormsg = e.what();
return net::erCouldntConnect;
}
try {
// Set the user-defined headers (we may overwrite them if needed)
TParameters<string> headers_to_send;
if (extra_headers)
headers_to_send=*extra_headers;
headers_to_send["Connection"]="close"; // Don't keep alive
if (!headers_to_send.has("User-Agent"))
headers_to_send["User-Agent"]="MRPT Library";
// Implement HTTP Basic authentication:
// See: http://en.wikipedia.org/wiki/Basic_access_authentication
if (!auth_user.empty())
{
string auth_str = auth_user+string(":")+auth_pass;
vector_byte v(auth_str.size());
::memcpy(&v[0],&auth_str [0],auth_str .size());
string encoded_str;
mrpt::system::encodeBase64(v,encoded_str);
headers_to_send["Authorization"]=string("Basic ")+encoded_str;
}
// Prepare the request string
// ---------------------------------
string req = format(
"GET %s HTTP/1.1\r\n"
"Host: %s\r\n",
get_object.c_str(),server_addr.c_str());
// Other headers:
for (TParameters<string>::const_iterator i=headers_to_send.begin();i!=headers_to_send.end();++i)
{
req+=i->first;
req+=": ";
req+=i->second;
req+="\r\n";
}
// End:
req+="\r\n";
// Send:
sock.sendString(req);
// Read answer:
vector_byte buf;
buf.reserve(1<<14);
size_t total_read = 0;
bool content_length_read = false;
bool all_headers_read = false;
size_t content_length = 0;
size_t content_offset = 0;
int http_code = 0;
mrpt::utils::TParameters<string> rx_headers;
CTicTac watchdog;
watchdog.Tic();
while (!content_length_read || total_read<(content_offset+content_length))
{
// Read until "Content-Length: XXX \r\n" is read or the whole message is read,
// or an error code is read.
size_t to_read_now;
if (!content_length_read)
{
to_read_now = 1500;
}
else
{
to_read_now = (content_length+content_offset) -total_read;
}
// make room for the data to come:
buf.resize(total_read+to_read_now+1);
// Read:
size_t len = sock.readAsync(&buf[total_read],to_read_now, timeout_ms,100);
if (!len)
{
//
if (!sock.isConnected())
{
if (all_headers_read) // It seems we're done...
break;
else
{
out_errormsg = "Connection to server was lost";
return net::erCouldntConnect;
}
}
if ( watchdog.Tac()>1e-3*timeout_ms)
{
out_errormsg = "Timeout waiting answer from server";
return net::erCouldntConnect;
}
mrpt::system::sleep(10);
continue;
}
total_read+=len;
watchdog.Tic();
buf[total_read]='\0';
// do we have a \r\n\r\n ??
if (!all_headers_read)
{
const char *ptr = ::strstr(reinterpret_cast<const char*>(&buf[0]),"\r\n\r\n");
if (ptr)
{
all_headers_read = true;
const size_t pos_dblret = ((char*)ptr)-(char*)(&buf[0]);
// Process the headers:
// ------------------------------
if (!::strncmp("HTTP/",(const char*)&buf[0], 5))
{
http_code = ::atoi( (const char*)&buf[9] );
}
else
{
// May it be a "SOURCETABLE " answer for NTRIP protocol??
if (!::strncmp("SOURCETABLE ",(const char*)&buf[0], 12))
{
http_code = ::atoi( (const char*)&buf[12] );
}
else
{
out_errormsg = "Server didn't send an HTTP/1.1 answer.";
return net::erOtherHTTPError;
}
}
// Check the HTTP code and the content-length:
content_offset = pos_dblret + 4;
// Do we have a "Content-Length:"??
const char *ptr_len = ::strstr(reinterpret_cast<const char*>(&buf[0]),"Content-Length:");
if (ptr_len)
{
content_length = ::atol( ptr_len+15 );
content_length_read = true;
}
// Parse the rest of HTTP headers:
{
string aux_all_headers;
deque<string> lstLines;
aux_all_headers.resize(content_offset);
::memcpy( &aux_all_headers[0],&buf[0],content_offset);
mrpt::system::tokenize(aux_all_headers,"\r\n",lstLines);
for (deque<string>::const_iterator i=lstLines.begin();i!=lstLines.end();++i)
{
const size_t p = i->find(":");
if (p==string::npos) continue;
const string key = i->substr(0,p);
const string val = i->substr(p+2);
rx_headers[key] = val;
}
}
}
}
} // end while
if (out_http_responsecode) *out_http_responsecode=http_code;
if (out_headers) *out_headers = rx_headers;
// Remove the headers from the content:
buf.erase(buf.begin(),buf.begin()+content_offset);
// Process: "Transfer-Encoding: chunked"
if (rx_headers.has("Transfer-Encoding") && rx_headers["Transfer-Encoding"]=="chunked" )
{
// See: http://en.wikipedia.org/wiki/Chunked_transfer_encoding
size_t index = 0;
while (index<buf.size())
{
if (buf[index]=='\r' && buf[index+1]=='\n')
{
buf.erase(buf.begin()+index,buf.begin()+index+2);
continue;
}
const char *pCRLF = ::strstr((const char*)&buf[index],"\r\n");
if (!pCRLF) break;
const size_t len_substr = ((char*)pCRLF)-(char*)(&buf[index]);
string sLen((const char*)&buf[index], len_substr);
sLen=string("0x")+sLen;
unsigned int lenChunk;
int fields = ::sscanf(sLen.c_str(),"%x",&lenChunk);
if (!fields) break;
// Remove the len of this chunk header from the data:
buf.erase(buf.begin()+index,buf.begin()+index+len_substr+2);
index+=lenChunk;
if (!lenChunk)
{
buf.resize(index);
break;
}
}
}
// Set the content output:
out_content.swap(buf);
if (http_code==200)
{
return net::erOk;
}
else
{
out_errormsg = format("HTTP error %i",http_code);
return net::erOtherHTTPError;
}
}
catch (std::exception &e) {
out_errormsg = e.what();
return net::erCouldntConnect;
}
return net::erOk;
}
