247 lines
9.4 KiB
C++
247 lines
9.4 KiB
C++
|
/*
|
||
|
|
* Portable Agile C++ Classes (PACC)
|
||
|
|
* Copyright (C) 2001-2003 by Marc Parizeau and Marc Dubreuil
|
||
|
|
* http://manitou.gel.ulaval.ca/~parizeau/PACC
|
||
|
|
*
|
||
|
|
* This library is free software; you can redistribute it and/or
|
||
|
|
* modify it under the terms of the GNU Lesser General Public
|
||
|
|
* License as published by the Free Software Foundation; either
|
||
|
|
* version 2.1 of the License, or (at your option) any later version.
|
||
|
|
*
|
||
|
|
* This library is distributed in the hope that it will be useful,
|
||
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||
|
|
* Lesser General Public License for more details.
|
||
|
|
*
|
||
|
|
* You should have received a copy of the GNU Lesser General Public
|
||
|
|
* License along with this library; if not, write to the Free Software
|
||
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||
|
|
*
|
||
|
|
* Contact:
|
||
|
|
* Laboratoire de Vision et Systemes Numeriques
|
||
|
|
* Departement de genie electrique et de genie informatique
|
||
|
|
* Universite Laval, Quebec, Canada, G1K 7P4
|
||
|
|
* http://vision.gel.ulaval.ca
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
|
||
|
|
/*!
|
||
|
|
* \file PACC/Socket/Cafe.cpp
|
||
|
|
* \brief Class methods for the cafe protocol.
|
||
|
|
* \author Marc Parizeau and Marc Dubreuil, Laboratoire de vision et systèmes numériques, Université Laval
|
||
|
|
* $Revision: 1.6.2.1 $
|
||
|
|
* $Date: 2007/09/10 18:24:09 $
|
||
|
|
*/
|
||
|
|
|
||
|
|
#include "Socket/Cafe.hpp"
|
||
|
|
#include <iostream>
|
||
|
|
|
||
|
|
#ifdef WIN32
|
||
|
|
///////////// specifics for windows /////////////
|
||
|
|
#include <winsock2.h>
|
||
|
|
namespace PACC {
|
||
|
|
typedef u_long UInt32;
|
||
|
|
}
|
||
|
|
|
||
|
|
#else
|
||
|
|
///////////// specifics for unixes /////////////
|
||
|
|
#include <netinet/in.h>
|
||
|
|
namespace PACC {
|
||
|
|
typedef uint32_t UInt32;
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
|
||
|
|
#ifdef PACC_ZLIB
|
||
|
|
// Set this variable in order to enable message compression
|
||
|
|
#include <zlib.h>
|
||
|
|
#endif
|
||
|
|
|
||
|
|
using namespace std;
|
||
|
|
using namespace PACC;
|
||
|
|
|
||
|
|
/*!
|
||
|
|
WARNING: in order to enable message compression, this class needs to be compiled with variable PACC_ZLIB set.
|
||
|
|
*/
|
||
|
|
#ifdef PACC_ZLIB
|
||
|
|
void Socket::Cafe::compress(const std::string& inMessage, std::string& outMessage, unsigned int inCompressionLevel)
|
||
|
|
{
|
||
|
|
if(inCompressionLevel == 0) outMessage = inMessage;
|
||
|
|
else
|
||
|
|
{
|
||
|
|
// size of buffer must be at least 0.1% + 12 bytes larger than the message size
|
||
|
|
unsigned long lBufLength = (inMessage.size() + inMessage.size()/1000 + 1) + 12;
|
||
|
|
outMessage.resize(lBufLength);
|
||
|
|
// compress message
|
||
|
|
int lReturn = ::compress2((Bytef *)&outMessage[0], (uLongf*)&lBufLength, (const Bytef *)inMessage.data(), inMessage.size(), inCompressionLevel);
|
||
|
|
// check for error
|
||
|
|
if(lReturn != Z_OK)
|
||
|
|
{
|
||
|
|
outMessage.clear();
|
||
|
|
throw Exception(eOtherError, "Cafe::compress() unable to compress message!");
|
||
|
|
}
|
||
|
|
// resize message to size of compressed message
|
||
|
|
outMessage.resize(lBufLength);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
|
||
|
|
/*!
|
||
|
|
This method will wait until the specified amount of bytes in received from the socket. It assumes that buffer \c inBuffer is large enough to accept \c inCount bytes. Any error (e.g. timeouts or broken connection) will throw a Socket::Exception.
|
||
|
|
*/
|
||
|
|
void Socket::Cafe::receive(char* inBuffer, unsigned int inCount)
|
||
|
|
{
|
||
|
|
PACC::UInt32 lTotalReceived = 0;
|
||
|
|
while(lTotalReceived < inCount) {
|
||
|
|
PACC::UInt32 lRecv = Port::receive(inBuffer+lTotalReceived, inCount-lTotalReceived);
|
||
|
|
lTotalReceived += lRecv;;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/*!
|
||
|
|
This function waits for a valid message according to the Cafe protocol, or until
|
||
|
|
time out. It returns the received message through output parameter \c OutMessage.
|
||
|
|
Any error raises a Socket::Exception. For instance, it throws an exception with
|
||
|
|
code Socket::eConnectionClosed if the connection is closed by the other party
|
||
|
|
before message end, with code Socket::eBadMessage if the protocol signature is
|
||
|
|
invalid, or with code Socket::eTimeOut if the timeout period expires before
|
||
|
|
reception of a cmoplete message. The timeout period can be changed using function
|
||
|
|
Port::setSockOpt with parameter Socket::eRecvTimeOut.
|
||
|
|
*/
|
||
|
|
void Socket::Cafe::receiveMessage(std::string& outMessage)
|
||
|
|
{
|
||
|
|
if(mDescriptor < 0) throw Exception(eBadDescriptor, "Cafe::receiveMessage() invalid socket");
|
||
|
|
// check message signature
|
||
|
|
PACC::UInt32 lSignature = 0;
|
||
|
|
receive((char*)&lSignature, sizeof(lSignature));
|
||
|
|
switch(ntohl(lSignature))
|
||
|
|
{
|
||
|
|
case 0xCAFE: // uncompressed Cafe
|
||
|
|
{
|
||
|
|
// read message size
|
||
|
|
PACC::UInt32 lMessageSize = 0;
|
||
|
|
receive((char*)&lMessageSize, sizeof(lMessageSize));
|
||
|
|
lMessageSize = ntohl(lMessageSize);
|
||
|
|
// resize output string
|
||
|
|
outMessage.resize(lMessageSize);
|
||
|
|
// read message body
|
||
|
|
receive(&outMessage[0], lMessageSize);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case 0xCCAFE: // compressed Cafe
|
||
|
|
{
|
||
|
|
#ifdef PACC_ZLIB
|
||
|
|
// read message size
|
||
|
|
PACC::UInt32 lMessageSize = 0;
|
||
|
|
receive((char*)&lMessageSize, sizeof(lMessageSize));
|
||
|
|
lMessageSize = ntohl(lMessageSize);
|
||
|
|
// resize output string
|
||
|
|
outMessage.resize(lMessageSize);
|
||
|
|
//read uncompressed size
|
||
|
|
PACC::UInt32 lUncompressedSize = 0;
|
||
|
|
receive((char*)&lUncompressedSize, sizeof(lUncompressedSize));
|
||
|
|
lUncompressedSize = ntohl(lUncompressedSize);
|
||
|
|
// read message body
|
||
|
|
receive(&outMessage[0], lMessageSize);
|
||
|
|
//decompress message
|
||
|
|
uncompress(outMessage, lUncompressedSize);
|
||
|
|
break;
|
||
|
|
#else
|
||
|
|
throw Exception(eOtherError, "Cafe::receiveMessage() class needs to be compiled with variable PACC_ZLIB set, in order to enable message decompression");
|
||
|
|
#endif
|
||
|
|
}
|
||
|
|
default: // unknown
|
||
|
|
throw Exception(eBadMessage, "Cafe::receiveMessage() invalid signature");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/*!
|
||
|
|
This function sends a message string using either of the two Cafe protocols. The
|
||
|
|
user can specify a compression level using argument \c inCompressionLevel.
|
||
|
|
However, this argument is ignored by default and messages are not compressed in
|
||
|
|
any way. To enable compression, the class must be compiled with variable
|
||
|
|
PACC_ZLIB set, and the executable must be linked with the zlib library
|
||
|
|
<http://www.gzip.org/zlib>.
|
||
|
|
|
||
|
|
Compression level must range from 0 to 9. A nul compression level means no
|
||
|
|
compression, while a level of 9 specifies maximum compression. The message is
|
||
|
|
sent compressed only if smaller than the original.
|
||
|
|
|
||
|
|
Any error raises a Socket::Exception. For instance, it throws an exception with
|
||
|
|
code Socket::eConnectionClosed if the connection is closed by the other party
|
||
|
|
during message transmission, or with code Socket::eTimeOut if the message
|
||
|
|
cannot be sent before the time out period expires. The time out period can be
|
||
|
|
changed using function Port::setSockOpt with parameter Socket::eSendTimeOut.
|
||
|
|
*/
|
||
|
|
void Socket::Cafe::sendMessage(const std::string& inMessage, unsigned int inCompressionLevel)
|
||
|
|
{
|
||
|
|
if(inCompressionLevel > 9)
|
||
|
|
{
|
||
|
|
throw Exception(eOtherError, "Cafe::sendMessage() invalid compression level!");
|
||
|
|
}
|
||
|
|
#ifdef PACC_ZLIB
|
||
|
|
if(inCompressionLevel > 0)
|
||
|
|
{
|
||
|
|
// try to compress message
|
||
|
|
string lCompressedMessage;
|
||
|
|
compress(inMessage, lCompressedMessage, inCompressionLevel);
|
||
|
|
if(lCompressedMessage.size() < inMessage.size())
|
||
|
|
{
|
||
|
|
// send compressed message only if smaller
|
||
|
|
// assume MTU is 1500 bytes - IP headers
|
||
|
|
char lBuffer[1460];
|
||
|
|
PACC::UInt32* lHeader = (PACC::UInt32*) lBuffer;
|
||
|
|
lHeader[0] = htonl(0xCCAFE);
|
||
|
|
lHeader[1] = htonl(lCompressedMessage.size());
|
||
|
|
lHeader[2] = htonl(inMessage.size());
|
||
|
|
// copy start of compressed message to header
|
||
|
|
memcpy(lBuffer+12, lCompressedMessage.data(), (lCompressedMessage.size()<sizeof(lBuffer)-12?lCompressedMessage.size():sizeof(lBuffer)-12));
|
||
|
|
// write header and compressed message
|
||
|
|
send(lBuffer, (lCompressedMessage.size()<sizeof(lBuffer)-12?lCompressedMessage.size()+12:sizeof(lBuffer)));
|
||
|
|
if(lCompressedMessage.size() > sizeof(lBuffer)-12) send(lCompressedMessage.data()+sizeof(lBuffer)-12, lCompressedMessage.size()-sizeof(lBuffer)+12);
|
||
|
|
} else {
|
||
|
|
// send uncompressed message
|
||
|
|
// assume MTU is 1500 bytes - IP headers
|
||
|
|
char lBuffer[1460];
|
||
|
|
PACC::UInt32* lHeader = (PACC::UInt32*) lBuffer;
|
||
|
|
lHeader[0] = htonl(0xCAFE);
|
||
|
|
lHeader[1] = htonl(inMessage.size());
|
||
|
|
// copy start of uncompressed message to header
|
||
|
|
memcpy(lBuffer+8, inMessage.data(), (inMessage.size()<sizeof(lBuffer)-8?inMessage.size():sizeof(lBuffer)-8));
|
||
|
|
// write header and uncompressed message
|
||
|
|
send(lBuffer, (inMessage.size()<sizeof(lBuffer)-8?inMessage.size()+8:sizeof(lBuffer)));
|
||
|
|
if(inMessage.size() > sizeof(lBuffer)-8) send(inMessage.data()+sizeof(lBuffer)-8, inMessage.size()-sizeof(lBuffer)+8);
|
||
|
|
}
|
||
|
|
} else
|
||
|
|
#endif
|
||
|
|
{
|
||
|
|
// send uncompressed message (compression is disabled)
|
||
|
|
// assume MTU is 1500 bytes - IP headers
|
||
|
|
char lBuffer[1460];
|
||
|
|
PACC::UInt32* lHeader = (PACC::UInt32*) lBuffer;
|
||
|
|
lHeader[0] = htonl(0xCAFE);
|
||
|
|
lHeader[1] = htonl(inMessage.size());
|
||
|
|
// copy start of message to header
|
||
|
|
memcpy(lBuffer+8, inMessage.data(), (inMessage.size()<sizeof(lBuffer)-8?inMessage.size():sizeof(lBuffer)-8));
|
||
|
|
// write header and message
|
||
|
|
send(lBuffer, (inMessage.size()<sizeof(lBuffer)-8?inMessage.size()+8:sizeof(lBuffer)));
|
||
|
|
if(inMessage.size() > sizeof(lBuffer)-8) send(inMessage.data()+sizeof(lBuffer)-8, inMessage.size()-sizeof(lBuffer)+8);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/*!
|
||
|
|
WARNING: in order to enable message compression/uncompression, this class needs to be compiled with variable PACC_ZLIB set.
|
||
|
|
*/
|
||
|
|
#ifdef PACC_ZLIB
|
||
|
|
void Socket::Cafe::uncompress(std::string& ioMessage, unsigned long inUncompressedSize)
|
||
|
|
{
|
||
|
|
string lUncompressedMessage;
|
||
|
|
lUncompressedMessage.resize(inUncompressedSize);
|
||
|
|
int lReturn = ::uncompress((Bytef*)&lUncompressedMessage[0], (uLong*)&inUncompressedSize, (const Bytef*)ioMessage.data(), ioMessage.size());
|
||
|
|
if(lReturn != Z_OK) {
|
||
|
|
throw Exception(eOtherError, "Cafe::uncompress() unable to uncompress message!");
|
||
|
|
}
|
||
|
|
ioMessage = lUncompressedMessage;
|
||
|
|
}
|
||
|
|
#endif
|