sco/pokerth
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Merge remote-tracking branch 'origin/master'

Browse Source
This commit is contained in:
doitux
2013-09-16 17:59:41 +02:00
parent 088c17a586 07e0d6d798
commit cc386419d2
33 changed files with 1193 additions and 341 deletions
Download Patch File Download Diff File Expand all files Collapse all files
pokerth_lib.pro
+15 -2
View File
@@ -74,7 +74,9 @@ HEADERS += \
src/net/senderhelper.h \
src/net/sendercallback.h \
src/net/serverexception.h \
src/net/serveracceptinterface.h \
src/net/serveraccepthelper.h \
src/net/serveracceptwebhelper.h \
src/net/servergame.h \
src/net/servergamestate.h \
src/net/serverlobbythread.h \
@@ -127,9 +129,15 @@ HEADERS += \
src/gui/qttoolsinterface.h \
src/gui/generic/serverguiwrapper.h \
src/net/receivebuffer.h \
src/net/asioreceivebuffer.h \
src/net/webreceivebuffer.h \
src/net/sendbuffer.h \
src/net/asiosendbuffer.h \
src/net/websendbuffer.h \
src/net/servermanagerfactory.h \
src/net/uploadcallback.h
src/net/uploadcallback.h \
src/net/websocket_defs.h \
src/net/websocketdata.h
SOURCES += \
src/engine/game.cpp \
@@ -178,7 +186,8 @@ SOURCES += \
src/net/common/senderhelper.cpp \
src/net/common/sendercallback.cpp \
src/net/common/serverexception.cpp \
src/net/common/serveraccepthelper.cpp \
src/net/common/serveracceptinterface.cpp \
src/net/common/serveracceptwebhelper.cpp \
src/net/common/servergame.cpp \
src/net/common/servergamestate.cpp \
src/net/common/serverlobbythread.cpp \
@@ -202,7 +211,11 @@ SOURCES += \
src/gui/generic/serverguiwrapper.cpp \
src/gui/qttoolsinterface.cpp \
src/net/common/sendbuffer.cpp \
src/net/common/asiosendbuffer.cpp \
src/net/common/websendbuffer.cpp \
src/net/common/receivebuffer.cpp \
src/net/common/asioreceivebuffer.cpp \
src/net/common/webreceivebuffer.cpp \
src/net/common/uploadcallback.cpp
!android:!android_test{
src/engine/local_engine/cardsvalue.cpp
-2
View File
@@ -1142,11 +1142,9 @@ std::string CardsValue::determineHandName(int myCardsValueInt, PlayerList active
// 4.there are still same hands
if(equal) {
different = false;
equal = false;
// third kicker?
for(it = sameHandCardsValueInt.begin(); it != sameHandCardsValueInt.end(); ) {
if((*it) == myCardsValueInt) {
equal = true;
++it;
} else {
different = true;
src/net/asioreceivebuffer.h
+62
View File
@@ -0,0 +1,62 @@
/*****************************************************************************
* PokerTH - The open source texas holdem engine *
* Copyright (C) 2006-2013 Felix Hammer, Florian Thauer, Lothar May *
* *
* This program is free software: you can redistribute it and/or modify *
* it under the terms of the GNU Affero General Public License as *
* published by the Free Software Foundation, either version 3 of the *
* License, or (at your option) any later version. *
* *
* This program 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 Affero General Public License for more details. *
* *
* You should have received a copy of the GNU Affero General Public License *
* along with this program. If not, see <http://www.gnu.org/licenses/>. *
* *
* *
* Additional permission under GNU AGPL version 3 section 7 *
* *
* If you modify this program, or any covered work, by linking or *
* combining it with the OpenSSL project's OpenSSL library (or a *
* modified version of that library), containing parts covered by the *
* terms of the OpenSSL or SSLeay licenses, the authors of PokerTH *
* (Felix Hammer, Florian Thauer, Lothar May) grant you additional *
* permission to convey the resulting work. *
* Corresponding Source for a non-source form of such a combination *
* shall include the source code for the parts of OpenSSL used as well *
* as that of the covered work. *
*****************************************************************************/
/* ASIO standard socket receive buffer. */
#ifndef _ASIORECEIVEBUFFER_H_
#define _ASIORECEIVEBUFFER_H_
#include <net/receivebuffer.h>
// MUST be larger than MAX_PACKET_SIZE
#define RECV_BUF_SIZE 5 * MAX_PACKET_SIZE
class AsioReceiveBuffer : public ReceiveBuffer
{
public:
AsioReceiveBuffer();
virtual void StartAsyncRead(boost::shared_ptr<SessionData> session);
virtual void HandleRead(boost::shared_ptr<SessionData> session, const boost::system::error_code &error, size_t bytesRead);
virtual void HandleMessage(boost::shared_ptr<SessionData> session, const std::string &msg);
protected:
void ScanPackets(boost::shared_ptr<SessionData> session);
void ProcessPackets(boost::shared_ptr<SessionData> session);
private:
NetPacketList receivedPackets;
char recvBuf[RECV_BUF_SIZE];
size_t recvBufUsed;
};
#endif
src/net/asiosendbuffer.h
+101
View File
@@ -0,0 +1,101 @@
/*****************************************************************************
* PokerTH - The open source texas holdem engine *
* Copyright (C) 2006-2013 Felix Hammer, Florian Thauer, Lothar May *
* *
* This program is free software: you can redistribute it and/or modify *
* it under the terms of the GNU Affero General Public License as *
* published by the Free Software Foundation, either version 3 of the *
* License, or (at your option) any later version. *
* *
* This program 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 Affero General Public License for more details. *
* *
* You should have received a copy of the GNU Affero General Public License *
* along with this program. If not, see <http://www.gnu.org/licenses/>. *
* *
* *
* Additional permission under GNU AGPL version 3 section 7 *
* *
* If you modify this program, or any covered work, by linking or *
* combining it with the OpenSSL project's OpenSSL library (or a *
* modified version of that library), containing parts covered by the *
* terms of the OpenSSL or SSLeay licenses, the authors of PokerTH *
* (Felix Hammer, Florian Thauer, Lothar May) grant you additional *
* permission to convey the resulting work. *
* Corresponding Source for a non-source form of such a combination *
* shall include the source code for the parts of OpenSSL used as well *
* as that of the covered work. *
*****************************************************************************/
/* Buffer for sending network data. */
#ifndef _ASIOSENDBUFFER_H_
#define _ASIOSENDBUFFER_H_
#include <net/sendbuffer.h>
#include <cstdlib>
#define SEND_BUF_FIRST_ALLOC_CHUNKSIZE 4096
#define MAX_SEND_BUF_SIZE SEND_BUF_FIRST_ALLOC_CHUNKSIZE * 256
class AsioSendBuffer : public SendBuffer
{
public:
AsioSendBuffer();
virtual ~AsioSendBuffer();
inline size_t GetSendBufLeft() const {
int bytesLeft = (int)(sendBufAllocated - sendBufUsed);
return bytesLeft < 0 ? (size_t)0 : (size_t)bytesLeft;
}
inline size_t GetAllocated() const {
return sendBufAllocated;
}
inline bool ReallocSendBuf() {
bool retVal = false;
size_t allocAmount = sendBufAllocated * 2;
if (0 == allocAmount) {
allocAmount = (size_t)SEND_BUF_FIRST_ALLOC_CHUNKSIZE;
}
if (allocAmount <= MAX_SEND_BUF_SIZE) {
char *tempBuf = (char *)std::realloc(sendBuf, allocAmount);
if (tempBuf) {
sendBuf = tempBuf;
sendBufAllocated = allocAmount;
retVal = true;
}
}
return retVal;
}
inline void AppendToSendBufWithoutCheck(const char *data, size_t size) {
std::memcpy(sendBuf + sendBufUsed, data, size);
sendBufUsed += size;
}
virtual void SetCloseAfterSend();
virtual void AsyncSendNextPacket(boost::shared_ptr<SessionData> session);
void AsyncSendNextPacket(boost::shared_ptr<boost::asio::ip::tcp::socket> socket);
virtual void InternalStorePacket(boost::shared_ptr<SessionData> session, boost::shared_ptr<NetPacket> packet);
int EncodeToBuf(const void *data, size_t size);
virtual void HandleWrite(boost::shared_ptr<boost::asio::ip::tcp::socket> socket, const boost::system::error_code &error);
private:
char *sendBuf;
char *curWriteBuf;
size_t sendBufAllocated;
size_t sendBufUsed;
size_t curWriteBufAllocated;
size_t curWriteBufUsed;
bool closeAfterSend;
};
#endif
src/net/chatcleanermanager.h
+2 -2
View File
@@ -42,7 +42,7 @@
#define MAX_CLEANER_PACKET_SIZE 512
#define CLEANER_PROTOCOL_VERSION 2
class SendBuffer;
class AsioSendBuffer;
class ChatCleanerMessage;
class ChatCleanerManager : public boost::enable_shared_from_this<ChatCleanerManager>
@@ -73,7 +73,7 @@ private:
boost::shared_ptr<boost::asio::io_service> m_ioService;
boost::shared_ptr<boost::asio::ip::tcp::resolver> m_resolver;
boost::shared_ptr<boost::asio::ip::tcp::socket> m_socket;
boost::shared_ptr<SendBuffer> m_sendManager;
boost::shared_ptr<AsioSendBuffer> m_sendManager;
bool m_connected;
unsigned m_curRequestId;
src/net/clientcontext.h
-6
View File
@@ -35,7 +35,6 @@
#include <boost/shared_ptr.hpp>
#include <net/receivebuffer.h>
#include <net/sessiondata.h>
#include <playerdata.h>
@@ -135,10 +134,6 @@ public:
m_hasSubscribedLobbyMsg = setSubscribe;
}
ReceiveBuffer &GetReceiveBuffer() {
return m_receiveBuffer;
}
const std::string &GetSessionGuid() const {
return m_sessionGuid;
}
@@ -164,7 +159,6 @@ private:
std::string m_avatarFile;
std::string m_cacheDir;
bool m_hasSubscribedLobbyMsg;
ReceiveBuffer m_receiveBuffer;
std::string m_sessionGuid;
};
src/net/common/asioreceivebuffer.cpp
+150
View File
@@ -0,0 +1,150 @@
/*****************************************************************************
* PokerTH - The open source texas holdem engine *
* Copyright (C) 2006-2012 Felix Hammer, Florian Thauer, Lothar May *
* *
* This program is free software: you can redistribute it and/or modify *
* it under the terms of the GNU Affero General Public License as *
* published by the Free Software Foundation, either version 3 of the *
* License, or (at your option) any later version. *
* *
* This program 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 Affero General Public License for more details. *
* *
* You should have received a copy of the GNU Affero General Public License *
* along with this program. If not, see <http://www.gnu.org/licenses/>. *
* *
* *
* Additional permission under GNU AGPL version 3 section 7 *
* *
* If you modify this program, or any covered work, by linking or *
* combining it with the OpenSSL project's OpenSSL library (or a *
* modified version of that library), containing parts covered by the *
* terms of the OpenSSL or SSLeay licenses, the authors of PokerTH *
* (Felix Hammer, Florian Thauer, Lothar May) grant you additional *
* permission to convey the resulting work. *
* Corresponding Source for a non-source form of such a combination *
* shall include the source code for the parts of OpenSSL used as well *
* as that of the covered work. *
*****************************************************************************/
#include <boost/asio.hpp>
#include <boost/bind.hpp>
#include <net/asioreceivebuffer.h>
#include <net/sessiondata.h>
#include <core/loghelper.h>
#include <boost/swap.hpp>
using namespace std;
AsioReceiveBuffer::AsioReceiveBuffer()
: recvBufUsed(0)
{
recvBuf[0] = 0;
}
void
AsioReceiveBuffer::StartAsyncRead(boost::shared_ptr<SessionData> session)
{
session->GetAsioSocket()->async_read_some(
boost::asio::buffer(recvBuf + recvBufUsed, RECV_BUF_SIZE - recvBufUsed),
boost::bind(
&ReceiveBuffer::HandleRead,
shared_from_this(),
session,
boost::asio::placeholders::error,
boost::asio::placeholders::bytes_transferred));
}
void
AsioReceiveBuffer::HandleRead(boost::shared_ptr<SessionData> session, const boost::system::error_code &error, size_t bytesRead)
{
if (error != boost::asio::error::operation_aborted) {
try {
if (!error) {
recvBufUsed += bytesRead;
ScanPackets(session);
ProcessPackets(session);
StartAsyncRead(session);
} else if (error == boost::asio::error::interrupted || error == boost::asio::error::try_again) {
LOG_ERROR("Session " << session->GetId() << " - recv interrupted: " << error);
StartAsyncRead(session);
} else {
LOG_ERROR("Session " << session->GetId() << " - Connection closed: " << error);
// On error: Close this session.
session->Close();
}
} catch (const exception &e) {
LOG_ERROR("Session " << session->GetId() << " - unhandled exception in HandleRead: " << e.what());
throw;
}
}
}
void
AsioReceiveBuffer::HandleMessage(boost::shared_ptr<SessionData> /*session*/, const string &/*msg*/)
{
LOG_ERROR("AsioReceiveBuffer::HandleMessage should never be called because TCP I/O is not message based.");
}
void
AsioReceiveBuffer::ScanPackets(boost::shared_ptr<SessionData> session)
{
bool dataAvailable = true;
do {
boost::shared_ptr<NetPacket> tmpPacket;
// This is necessary, because we use TCP.
// Packets may be received in multiple chunks or
// several packets may be received at once.
if (recvBufUsed >= NET_HEADER_SIZE) {
// Read the size of the packet (first 4 bytes in network byte order).
uint32_t nativeVal;
memcpy(&nativeVal, &recvBuf[0], sizeof(uint32_t));
size_t packetSize = ntohl(nativeVal);
if (packetSize > MAX_PACKET_SIZE) {
recvBufUsed = 0;
LOG_ERROR("Session " << session->GetId() << " - Invalid packet size: " << packetSize);
} else if (recvBufUsed >= packetSize + NET_HEADER_SIZE) {
try {
tmpPacket = NetPacket::Create(&recvBuf[NET_HEADER_SIZE], packetSize);
if (tmpPacket) {
recvBufUsed -= (packetSize + NET_HEADER_SIZE);
if (recvBufUsed) {
memmove(recvBuf, recvBuf + packetSize + NET_HEADER_SIZE, recvBufUsed);
}
}
} catch (const exception &e) {
// Reset buffer on error.
recvBufUsed = 0;
LOG_ERROR("Session " << session->GetId() << " - " << e.what());
}
}
}
if (tmpPacket) {
if (validator.IsValidPacket(*tmpPacket)) {
receivedPackets.push_back(tmpPacket);
} else {
LOG_ERROR("Session " << session->GetId() << " - Invalid packet: " << tmpPacket->GetMsg()->messagetype());
}
} else {
dataAvailable = false;
}
} while(dataAvailable);
}
void
AsioReceiveBuffer::ProcessPackets(boost::shared_ptr<SessionData> session)
{
while (!receivedPackets.empty()) {
boost::shared_ptr<NetPacket> p = receivedPackets.front();
receivedPackets.pop_front();
session->HandlePacket(p);
}
if (recvBufUsed >= RECV_BUF_SIZE) {
LOG_ERROR("Session " << session->GetId() << " - Receive buf full: " << recvBufUsed);
recvBufUsed = 0;
}
}
src/net/common/asiosendbuffer.cpp
+126
View File
@@ -0,0 +1,126 @@
/*****************************************************************************
* PokerTH - The open source texas holdem engine *
* Copyright (C) 2006-2013 Felix Hammer, Florian Thauer, Lothar May *
* *
* This program is free software: you can redistribute it and/or modify *
* it under the terms of the GNU Affero General Public License as *
* published by the Free Software Foundation, either version 3 of the *
* License, or (at your option) any later version. *
* *
* This program 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 Affero General Public License for more details. *
* *
* You should have received a copy of the GNU Affero General Public License *
* along with this program. If not, see <http://www.gnu.org/licenses/>. *
* *
* *
* Additional permission under GNU AGPL version 3 section 7 *
* *
* If you modify this program, or any covered work, by linking or *
* combining it with the OpenSSL project's OpenSSL library (or a *
* modified version of that library), containing parts covered by the *
* terms of the OpenSSL or SSLeay licenses, the authors of PokerTH *
* (Felix Hammer, Florian Thauer, Lothar May) grant you additional *
* permission to convey the resulting work. *
* Corresponding Source for a non-source form of such a combination *
* shall include the source code for the parts of OpenSSL used as well *
* as that of the covered work. *
*****************************************************************************/
#include <boost/asio.hpp>
#include <boost/bind.hpp>
#include <net/asiosendbuffer.h>
#include <net/sessiondata.h>
#include <net/netpacket.h>
#include <boost/swap.hpp>
using namespace std;
AsioSendBuffer::AsioSendBuffer()
: sendBuf(NULL), curWriteBuf(NULL), sendBufAllocated(0), sendBufUsed(0),
curWriteBufAllocated(0), curWriteBufUsed(0), closeAfterSend(false)
{
}
AsioSendBuffer::~AsioSendBuffer()
{
free(sendBuf);
free(curWriteBuf);
}
void
AsioSendBuffer::SetCloseAfterSend()
{
closeAfterSend = true;
}
void
AsioSendBuffer::HandleWrite(boost::shared_ptr<boost::asio::ip::tcp::socket> socket, const boost::system::error_code &error)
{
if (!error) {
// Successfully sent the data.
boost::mutex::scoped_lock lock(dataMutex);
curWriteBufUsed = 0;
// Send more data, if available.
AsyncSendNextPacket(socket);
}
}
void
AsioSendBuffer::AsyncSendNextPacket(boost::shared_ptr<SessionData> session)
{
AsyncSendNextPacket(session->GetAsioSocket());
}
void
AsioSendBuffer::AsyncSendNextPacket(boost::shared_ptr<boost::asio::ip::tcp::socket> socket)
{
if (!curWriteBufUsed) {
// Swap buffers and send data.
boost::swap(curWriteBuf, sendBuf);
boost::swap(curWriteBufAllocated, sendBufAllocated);
boost::swap(curWriteBufUsed, sendBufUsed);
if (curWriteBufUsed) {
boost::asio::async_write(
*socket,
boost::asio::buffer(curWriteBuf, curWriteBufUsed),
boost::bind(&SendBuffer::HandleWrite,
shared_from_this(),
socket,
boost::asio::placeholders::error));
} else if (closeAfterSend) {
socket->close();
}
}
}
void
AsioSendBuffer::InternalStorePacket(boost::shared_ptr<SessionData> session, boost::shared_ptr<NetPacket> packet)
{
uint32_t packetSize = packet->GetMsg()->ByteSize();
google::protobuf::uint8 *buf = new google::protobuf::uint8[packetSize + NET_HEADER_SIZE];
*((uint32_t *)buf) = htonl(packetSize);
packet->GetMsg()->SerializeWithCachedSizesToArray(&buf[NET_HEADER_SIZE]);
EncodeToBuf(buf, packetSize + NET_HEADER_SIZE);
delete[] buf;
}
int
AsioSendBuffer::EncodeToBuf(const void *data, size_t size)
{
// Realloc buffer if necessary.
while (GetSendBufLeft() < size) {
if (!ReallocSendBuf()) {
return -1;
}
}
AppendToSendBufWithoutCheck((const char*)data, size);
return 0;
}
src/net/common/chatcleanermanager.cpp
+4 -4
View File
@@ -1,6 +1,6 @@
/*****************************************************************************
* PokerTH - The open source texas holdem engine *
* Copyright (C) 2006-2012 Felix Hammer, Florian Thauer, Lothar May *
* Copyright (C) 2006-2013 Felix Hammer, Florian Thauer, Lothar May *
* *
* This program is free software: you can redistribute it and/or modify *
* it under the terms of the GNU Affero General Public License as *
@@ -30,7 +30,7 @@
*****************************************************************************/
#include <net/chatcleanermanager.h>
#include <net/sendbuffer.h>
#include <net/asiosendbuffer.h>
#include <boost/bind.hpp>
#include <core/loghelper.h>
#include <third_party/protobuf/chatcleaner.pb.h>
@@ -49,7 +49,7 @@ ChatCleanerManager::ChatCleanerManager(ChatCleanerCallback &cb, boost::shared_pt
m_resolver.reset(
new boost::asio::ip::tcp::resolver(*m_ioService));
m_sendManager.reset(
new SendBuffer);
new AsioSendBuffer);
}
ChatCleanerManager::~ChatCleanerManager()
@@ -273,7 +273,7 @@ ChatCleanerManager::SendMessageToServer(ChatCleanerMessage &msg)
google::protobuf::uint8 *buf = new google::protobuf::uint8[packetSize + CLEANER_NET_HEADER_SIZE];
*((uint32_t *)buf) = htonl(packetSize);
msg.SerializeWithCachedSizesToArray(&buf[CLEANER_NET_HEADER_SIZE]);
SendBuffer::EncodeToBuf(buf, packetSize + CLEANER_NET_HEADER_SIZE, m_sendManager.get());
m_sendManager->EncodeToBuf(buf, packetSize + CLEANER_NET_HEADER_SIZE);
delete[] buf;
m_sendManager->AsyncSendNextPacket(m_socket);
src/net/common/clientthread.cpp
+1
View File
@@ -39,6 +39,7 @@
#include <net/clientexception.h>
#include <net/socket_msg.h>
#include <net/net_helper.h>
#include <net/asioreceivebuffer.h>
#include <core/avatarmanager.h>
#include <core/loghelper.h>
#include <clientenginefactory.h>
src/net/common/receivebuffer.cpp
+2 -109
View File
@@ -1,6 +1,6 @@
/*****************************************************************************
* PokerTH - The open source texas holdem engine *
* Copyright (C) 2006-2012 Felix Hammer, Florian Thauer, Lothar May *
* Copyright (C) 2006-2013 Felix Hammer, Florian Thauer, Lothar May *
* *
* This program is free software: you can redistribute it and/or modify *
* it under the terms of the GNU Affero General Public License as *
@@ -29,118 +29,11 @@
* as that of the covered work. *
*****************************************************************************/
#include <boost/asio.hpp>
#include <boost/bind.hpp>
#include <net/receivebuffer.h>
#include <net/sessiondata.h>
#include <core/loghelper.h>
#include <boost/swap.hpp>
using namespace std;
NetPacketValidator ReceiveBuffer::validator;
ReceiveBuffer::ReceiveBuffer()
: recvBufUsed(0)
ReceiveBuffer::~ReceiveBuffer()
{
recvBuf[0] = 0;
}
void
ReceiveBuffer::StartAsyncRead(boost::shared_ptr<SessionData> session)
{
session->GetAsioSocket()->async_read_some(
boost::asio::buffer(recvBuf + recvBufUsed, RECV_BUF_SIZE - recvBufUsed),
boost::bind(
&ReceiveBuffer::HandleRead,
shared_from_this(),
session,
boost::asio::placeholders::error,
boost::asio::placeholders::bytes_transferred));
}
void
ReceiveBuffer::HandleRead(boost::shared_ptr<SessionData> session, const boost::system::error_code &error, size_t bytesRead)
{
if (error != boost::asio::error::operation_aborted) {
try {
if (!error) {
recvBufUsed += bytesRead;
ScanPackets(session);
ProcessPackets(session);
StartAsyncRead(session);
} else if (error == boost::asio::error::interrupted || error == boost::asio::error::try_again) {
LOG_ERROR("Session " << session->GetId() << " - recv interrupted: " << error);
StartAsyncRead(session);
} else {
LOG_ERROR("Session " << session->GetId() << " - Connection closed: " << error);
// On error: Close this session.
session->Close();
}
} catch (const exception &e) {
LOG_ERROR("Session " << session->GetId() << " - unhandled exception in HandleRead: " << e.what());
throw;
}
}
}
void
ReceiveBuffer::ScanPackets(boost::shared_ptr<SessionData> session)
{
bool dataAvailable = true;
do {
boost::shared_ptr<NetPacket> tmpPacket;
// This is necessary, because we use TCP.
// Packets may be received in multiple chunks or
// several packets may be received at once.
if (recvBufUsed >= NET_HEADER_SIZE) {
// Read the size of the packet (first 4 bytes in network byte order).
uint32_t nativeVal;
memcpy(&nativeVal, &recvBuf[0], sizeof(uint32_t));
size_t packetSize = ntohl(nativeVal);
if (packetSize > MAX_PACKET_SIZE) {
recvBufUsed = 0;
LOG_ERROR("Session " << session->GetId() << " - Invalid packet size: " << packetSize);
} else if (recvBufUsed >= packetSize + NET_HEADER_SIZE) {
try {
tmpPacket = NetPacket::Create(&recvBuf[NET_HEADER_SIZE], packetSize);
if (tmpPacket) {
recvBufUsed -= (packetSize + NET_HEADER_SIZE);
if (recvBufUsed) {
memmove(recvBuf, recvBuf + packetSize + NET_HEADER_SIZE, recvBufUsed);
}
}
} catch (const exception &e) {
// Reset buffer on error.
recvBufUsed = 0;
LOG_ERROR("Session " << session->GetId() << " - " << e.what());
}
}
}
if (tmpPacket) {
if (validator.IsValidPacket(*tmpPacket)) {
receivedPackets.push_back(tmpPacket);
} else {
LOG_ERROR("Session " << session->GetId() << " - Invalid packet: " << tmpPacket->GetMsg()->messagetype());
}
} else {
dataAvailable = false;
}
} while(dataAvailable);
}
void
ReceiveBuffer::ProcessPackets(boost::shared_ptr<SessionData> session)
{
while (!receivedPackets.empty()) {
boost::shared_ptr<NetPacket> p = receivedPackets.front();
receivedPackets.pop_front();
session->HandlePacket(p);
}
if (recvBufUsed >= RECV_BUF_SIZE) {
LOG_ERROR("Session " << session->GetId() << " - Receive buf full: " << recvBufUsed);
recvBufUsed = 0;
}
}
src/net/common/sendbuffer.cpp
+1 -64
View File
@@ -1,6 +1,6 @@
/*****************************************************************************
* PokerTH - The open source texas holdem engine *
* Copyright (C) 2006-2012 Felix Hammer, Florian Thauer, Lothar May *
* Copyright (C) 2006-2013 Felix Hammer, Florian Thauer, Lothar May *
* *
* This program is free software: you can redistribute it and/or modify *
* it under the terms of the GNU Affero General Public License as *
@@ -29,75 +29,12 @@
* as that of the covered work. *
*****************************************************************************/
#include <boost/asio.hpp>
#include <boost/bind.hpp>
#include <net/sendbuffer.h>
#include <boost/swap.hpp>
using namespace std;
SendBuffer::SendBuffer()
: sendBuf(NULL), curWriteBuf(NULL), sendBufAllocated(0), sendBufUsed(0),
curWriteBufAllocated(0), curWriteBufUsed(0), closeAfterSend(false)
{
}
SendBuffer::~SendBuffer()
{
free(sendBuf);
free(curWriteBuf);
}
void
SendBuffer::HandleWrite(boost::shared_ptr<boost::asio::ip::tcp::socket> socket, const boost::system::error_code &error)
{
if (!error) {
// Successfully sent the data.
boost::mutex::scoped_lock lock(dataMutex);
curWriteBufUsed = 0;
// Send more data, if available.
AsyncSendNextPacket(socket);
}
}
void
SendBuffer::AsyncSendNextPacket(boost::shared_ptr<boost::asio::ip::tcp::socket> socket)
{
if (!curWriteBufUsed) {
// Swap buffers and send data.
boost::swap(curWriteBuf, sendBuf);
boost::swap(curWriteBufAllocated, sendBufAllocated);
boost::swap(curWriteBufUsed, sendBufUsed);
if (curWriteBufUsed) {
boost::asio::async_write(
*socket,
boost::asio::buffer(curWriteBuf, curWriteBufUsed),
boost::bind(&SendBuffer::HandleWrite,
shared_from_this(),
socket,
boost::asio::placeholders::error));
} else if (closeAfterSend) {
socket->close();
}
}
}
int
SendBuffer::EncodeToBuf(const void *data, size_t size, void *arg)
{
SendBuffer *m = static_cast<SendBuffer *>(arg);
// Realloc buffer if necessary.
while (m->GetSendBufLeft() < size) {
if (!m->ReallocSendBuf()) {
return -1;
}
}
m->AppendToSendBufWithoutCheck((const char*)data, size);
return 0;
}
src/net/common/senderhelper.cpp
+6 -17
View File
@@ -1,6 +1,6 @@
/*****************************************************************************
* PokerTH - The open source texas holdem engine *
* Copyright (C) 2006-2012 Felix Hammer, Florian Thauer, Lothar May *
* Copyright (C) 2006-2013 Felix Hammer, Florian Thauer, Lothar May *
* *
* This program is free software: you can redistribute it and/or modify *
* it under the terms of the GNU Affero General Public License as *
@@ -56,9 +56,9 @@ SenderHelper::Send(boost::shared_ptr<SessionData> session, boost::shared_ptr<Net
SendBuffer &tmpBuffer = session->GetSendBuffer();
// Add packet to specific queue.
boost::mutex::scoped_lock lock(tmpBuffer.dataMutex);
InternalStorePacket(tmpBuffer, packet);
tmpBuffer.InternalStorePacket(session, packet);
// Activate async send, if needed.
tmpBuffer.AsyncSendNextPacket(session->GetAsioSocket());
tmpBuffer.AsyncSendNextPacket(session);
}
}
@@ -73,11 +73,11 @@ SenderHelper::Send(boost::shared_ptr<SessionData> session, const NetPacketList &
NetPacketList::const_iterator end = packetList.end();
while (i != end) {
if (*i)
InternalStorePacket(tmpBuffer, *i);
tmpBuffer.InternalStorePacket(session, *i);
++i;
}
// Activate async send, if needed.
tmpBuffer.AsyncSendNextPacket(session->GetAsioSocket());
tmpBuffer.AsyncSendNextPacket(session);
}
}
@@ -90,17 +90,6 @@ SenderHelper::SetCloseAfterSend(boost::shared_ptr<SessionData> session)
// Mark that the socket should be closed after the send operation.
tmpBuffer.SetCloseAfterSend();
// Activate async send, if needed.
tmpBuffer.AsyncSendNextPacket(session->GetAsioSocket());
}
void
SenderHelper::InternalStorePacket(SendBuffer &tmpBuffer, boost::shared_ptr<NetPacket> packet)
{
uint32_t packetSize = packet->GetMsg()->ByteSize();
google::protobuf::uint8 *buf = new google::protobuf::uint8[packetSize + NET_HEADER_SIZE];
*((uint32_t *)buf) = htonl(packetSize);
packet->GetMsg()->SerializeWithCachedSizesToArray(&buf[NET_HEADER_SIZE]);
SendBuffer::EncodeToBuf(buf, packetSize + NET_HEADER_SIZE, &tmpBuffer);
delete[] buf;
tmpBuffer.AsyncSendNextPacket(session);
}
src/net/common/serveraccepthelper.cpp → src/net/common/serveracceptinterface.cpp
+2 -2
View File
@@ -1,6 +1,6 @@
/*****************************************************************************
* PokerTH - The open source texas holdem engine *
* Copyright (C) 2006-2012 Felix Hammer, Florian Thauer, Lothar May *
* Copyright (C) 2006-2013 Felix Hammer, Florian Thauer, Lothar May *
* *
* This program is free software: you can redistribute it and/or modify *
* it under the terms of the GNU Affero General Public License as *
@@ -29,7 +29,7 @@
* as that of the covered work. *
*****************************************************************************/
#include <net/serveraccepthelper.h>
#include <net/serveracceptinterface.h>
ServerAcceptInterface::~ServerAcceptInterface()
src/net/common/serveracceptwebhelper.cpp
+116
View File
@@ -0,0 +1,116 @@
/*****************************************************************************
* PokerTH - The open source texas holdem engine *
* Copyright (C) 2006-2013 Felix Hammer, Florian Thauer, Lothar May *
* *
* This program is free software: you can redistribute it and/or modify *
* it under the terms of the GNU Affero General Public License as *
* published by the Free Software Foundation, either version 3 of the *
* License, or (at your option) any later version. *
* *
* This program 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 Affero General Public License for more details. *
* *
* You should have received a copy of the GNU Affero General Public License *
* along with this program. If not, see <http://www.gnu.org/licenses/>. *
* *
* *
* Additional permission under GNU AGPL version 3 section 7 *
* *
* If you modify this program, or any covered work, by linking or *
* combining it with the OpenSSL project's OpenSSL library (or a *
* modified version of that library), containing parts covered by the *
* terms of the OpenSSL or SSLeay licenses, the authors of PokerTH *
* (Felix Hammer, Florian Thauer, Lothar May) grant you additional *
* permission to convey the resulting work. *
* Corresponding Source for a non-source form of such a combination *
* shall include the source code for the parts of OpenSSL used as well *
* as that of the covered work. *
*****************************************************************************/
#include <net/serveracceptwebhelper.h>
#include <net/sessiondata.h>
#include <net/webreceivebuffer.h>
#include <net/websocketdata.h>
using namespace std;
ServerAcceptWebHelper::ServerAcceptWebHelper(ServerCallback &serverCallback, boost::shared_ptr<boost::asio::io_service> ioService)
: m_serverCallback(serverCallback), m_ioService(ioService)
{
m_webSocketServer.reset(new server);
}
void
ServerAcceptWebHelper::Listen(unsigned serverPort, bool /*ipv6*/, const std::string &/*logDir*/, boost::shared_ptr<ServerLobbyThread> lobbyThread)
{
m_lobbyThread = lobbyThread;
// Set logging settings
#ifdef QT_NO_DEBUG
m_webSocketServer->clear_access_channels(websocketpp::log::alevel::all);
#else
m_webSocketServer->set_access_channels(websocketpp::log::alevel::all);
#endif
m_webSocketServer->init_asio(m_ioService.get());
m_webSocketServer->set_validate_handler(boost::bind(boost::mem_fn(&ServerAcceptWebHelper::validate), this, _1));
m_webSocketServer->set_open_handler(boost::bind(boost::mem_fn(&ServerAcceptWebHelper::on_open), this, _1));
m_webSocketServer->set_close_handler(boost::bind(boost::mem_fn(&ServerAcceptWebHelper::on_close), this, _1));
m_webSocketServer->set_message_handler(boost::bind(boost::mem_fn(&ServerAcceptWebHelper::on_message), this, _1, _2));
m_webSocketServer->listen(serverPort);
m_webSocketServer->start_accept();
}
void
ServerAcceptWebHelper::Close()
{
}
bool
ServerAcceptWebHelper::validate(websocketpp::connection_hdl hdl)
{
return true;
}
void
ServerAcceptWebHelper::on_open(websocketpp::connection_hdl hdl)
{
boost::shared_ptr<WebSocketData> webData(new WebSocketData);
webData->webSocketServer = m_webSocketServer;
webData->webHandle = hdl;
boost::shared_ptr<SessionData> sessionData(new SessionData(webData, m_lobbyThread->GetNextSessionId(), m_lobbyThread->GetSessionDataCallback(), *m_ioService, 0));
m_sessionMap.insert(make_pair(hdl, sessionData));
m_lobbyThread->AddConnection(sessionData);
}
void
ServerAcceptWebHelper::on_close(websocketpp::connection_hdl hdl)
{
SessionMap::iterator pos = m_sessionMap.find(hdl);
if (pos != m_sessionMap.end()) {
boost::shared_ptr<SessionData> tmpSession = pos->second.lock();
if (tmpSession) {
tmpSession->Close();
}
m_sessionMap.erase(pos);
}
}
void
ServerAcceptWebHelper::on_message(websocketpp::connection_hdl hdl, server::message_ptr msg)
{
if (msg->get_opcode() == websocketpp::frame::opcode::BINARY) {
SessionMap::iterator pos = m_sessionMap.find(hdl);
if (pos != m_sessionMap.end()) {
boost::shared_ptr<SessionData> tmpSession = pos->second.lock();
if (tmpSession) {
tmpSession->GetReceiveBuffer().HandleMessage(tmpSession, msg->get_payload());
}
}
}
}
src/net/common/serverlobbythread.cpp
+47 -38
View File
@@ -267,10 +267,9 @@ ServerLobbyThread::SignalTermination()
}
void
ServerLobbyThread::AddConnection(boost::shared_ptr<tcp::socket> sock)
ServerLobbyThread::AddConnection(boost::shared_ptr<SessionData> sessionData)
{
// Create a new session.
boost::shared_ptr<SessionData> sessionData(new SessionData(sock, m_curSessionId++, *m_internalServerCallback, GetIOService()));
m_sessionManager.AddSession(sessionData);
LOG_VERBOSE("Accepted connection - session #" << sessionData->GetId() << ".");
@@ -284,42 +283,37 @@ ServerLobbyThread::AddConnection(boost::shared_ptr<tcp::socket> sock)
if (numLobbySessions <= SERVER_MAX_NUM_LOBBY_SESSIONS
&& numLobbySessions + numGameSessions <= SERVER_MAX_NUM_TOTAL_SESSIONS) {
bool hasClientIp = false;
boost::system::error_code errCode;
tcp::endpoint clientEndpoint = sock->remote_endpoint(errCode);
if (!errCode) {
string ipAddress = clientEndpoint.address().to_string(errCode);
if (!errCode && !ipAddress.empty()) {
sessionData->SetClientAddr(ipAddress);
hasClientIp = true;
string ipAddress = sessionData->GetRemoteIPAddressFromSocket();
if (!ipAddress.empty()) {
sessionData->SetClientAddr(ipAddress);
hasClientIp = true;
boost::shared_ptr<NetPacket> packet(new NetPacket);
packet->GetMsg()->set_messagetype(PokerTHMessage::Type_AnnounceMessage);
AnnounceMessage *netAnnounce = packet->GetMsg()->mutable_announcemessage();
netAnnounce->mutable_protocolversion()->set_majorversion(NET_VERSION_MAJOR);
netAnnounce->mutable_protocolversion()->set_minorversion(NET_VERSION_MINOR);
netAnnounce->mutable_latestgameversion()->set_majorversion(POKERTH_VERSION_MAJOR);
netAnnounce->mutable_latestgameversion()->set_minorversion(POKERTH_VERSION_MINOR);
netAnnounce->set_latestbetarevision(POKERTH_BETA_REVISION);
switch (GetServerMode()) {
case SERVER_MODE_LAN:
netAnnounce->set_servertype(AnnounceMessage::serverTypeLAN);
break;
case SERVER_MODE_INTERNET_NOAUTH:
netAnnounce->set_servertype(AnnounceMessage::serverTypeInternetNoAuth);
break;
case SERVER_MODE_INTERNET_AUTH:
netAnnounce->set_servertype(AnnounceMessage::serverTypeInternetAuth);
break;
}
{
boost::mutex::scoped_lock lock(m_statMutex);
netAnnounce->set_numplayersonserver(m_statData.numberOfPlayersOnServer);
}
GetSender().Send(sessionData, packet);
sessionData->GetReceiveBuffer().StartAsyncRead(sessionData);
boost::shared_ptr<NetPacket> packet(new NetPacket);
packet->GetMsg()->set_messagetype(PokerTHMessage::Type_AnnounceMessage);
AnnounceMessage *netAnnounce = packet->GetMsg()->mutable_announcemessage();
netAnnounce->mutable_protocolversion()->set_majorversion(NET_VERSION_MAJOR);
netAnnounce->mutable_protocolversion()->set_minorversion(NET_VERSION_MINOR);
netAnnounce->mutable_latestgameversion()->set_majorversion(POKERTH_VERSION_MAJOR);
netAnnounce->mutable_latestgameversion()->set_minorversion(POKERTH_VERSION_MINOR);
netAnnounce->set_latestbetarevision(POKERTH_BETA_REVISION);
switch (GetServerMode()) {
case SERVER_MODE_LAN:
netAnnounce->set_servertype(AnnounceMessage::serverTypeLAN);
break;
case SERVER_MODE_INTERNET_NOAUTH:
netAnnounce->set_servertype(AnnounceMessage::serverTypeInternetNoAuth);
break;
case SERVER_MODE_INTERNET_AUTH:
netAnnounce->set_servertype(AnnounceMessage::serverTypeInternetAuth);
break;
}
}
if (!hasClientIp) {
{
boost::mutex::scoped_lock lock(m_statMutex);
netAnnounce->set_numplayersonserver(m_statData.numberOfPlayersOnServer);
}
GetSender().Send(sessionData, packet);
sessionData->GetReceiveBuffer().StartAsyncRead(sessionData);
} else {
// We do not accept sessions if we cannot
// retrieve the client address.
SessionError(sessionData, ERR_NET_INVALID_SESSION);
@@ -406,8 +400,11 @@ ServerLobbyThread::CloseSession(boost::shared_ptr<SessionData> session)
UpdateStatisticsNumberOfPlayers();
// Ignore error when shutting down the socket.
boost::system::error_code ec;
session->GetAsioSocket()->shutdown(boost::asio::ip::tcp::socket::shutdown_receive, ec);
boost::shared_ptr<boost::asio::ip::tcp::socket> sock = session->GetAsioSocket();
if (sock) {
boost::system::error_code ec;
session->GetAsioSocket()->shutdown(boost::asio::ip::tcp::socket::shutdown_receive, ec);
}
// Close this session after send.
GetSender().SetCloseAfterSend(session);
// Cancel all timers of the session.
@@ -789,6 +786,18 @@ ServerLobbyThread::GetBanManager()
return *m_banManager;
}
SessionDataCallback &
ServerLobbyThread::GetSessionDataCallback()
{
return *m_internalServerCallback;
}
u_int32_t
ServerLobbyThread::GetNextSessionId()
{
return m_curSessionId++;
}
u_int32_t
ServerLobbyThread::GetNextUniquePlayerId()
{
src/net/common/servermanager.cpp
+6
View File
@@ -34,6 +34,7 @@
#include <net/socket_helper.h>
#include <net/serverlobbythread.h>
#include <net/serveraccepthelper.h>
#include <net/serveracceptwebhelper.h>
#include <net/serverexception.h>
#include <net/socket_msg.h>
#include <net/socket_startup.h>
@@ -92,6 +93,11 @@ ServerManager::Init(unsigned serverPort, bool ipv6, ServerTransportProtocol prot
sctpAcceptHelper->Listen(serverPort, ipv6, logDir, m_lobbyThread);
m_acceptHelperPool.push_back(sctpAcceptHelper);
}*/
{
boost::shared_ptr<ServerAcceptInterface> webAcceptHelper(new ServerAcceptWebHelper(GetGui(), m_ioService));
webAcceptHelper->Listen(7233, true, logDir, m_lobbyThread);
m_acceptHelperPool.push_back(webAcceptHelper);
}
}
void
src/net/common/sessiondata.cpp
+54 -4
View File
@@ -30,25 +30,40 @@
*****************************************************************************/
#include <net/sessiondata.h>
#include <net/receivebuffer.h>
#include <net/sendbuffer.h>
#include <net/asioreceivebuffer.h>
#include <net/webreceivebuffer.h>
#include <net/asiosendbuffer.h>
#include <net/websendbuffer.h>
#include <net/socket_msg.h>
#include <net/websocketdata.h>
#include <gsasl.h>
using namespace std;
using boost::asio::ip::tcp;
SessionData::SessionData(boost::shared_ptr<boost::asio::ip::tcp::socket> sock, SessionId id, SessionDataCallback &cb, boost::asio::io_service &ioService)
: m_socket(sock), m_id(id), m_state(SessionData::Init), m_readyFlag(false), m_wantsLobbyMsg(true),
m_activityTimeoutSec(0), m_activityWarningRemainingSec(0), m_initTimeoutTimer(ioService), m_globalTimeoutTimer(ioService),
m_activityTimeoutTimer(ioService), m_callback(cb), m_authSession(NULL), m_curAuthStep(0)
{
m_receiveBuffer.reset(new ReceiveBuffer);
m_sendBuffer.reset(new SendBuffer);
m_receiveBuffer.reset(new AsioReceiveBuffer);
m_sendBuffer.reset(new AsioSendBuffer);
}
SessionData::SessionData(boost::shared_ptr<WebSocketData> webData, SessionId id, SessionDataCallback &cb, boost::asio::io_service &ioService, int filler)
: m_webData(webData), m_id(id), m_state(SessionData::Init), m_readyFlag(false), m_wantsLobbyMsg(true),
m_activityTimeoutSec(0), m_activityWarningRemainingSec(0), m_initTimeoutTimer(ioService), m_globalTimeoutTimer(ioService),
m_activityTimeoutTimer(ioService), m_callback(cb), m_authSession(NULL), m_curAuthStep(0)
{
m_receiveBuffer.reset(new WebReceiveBuffer);
m_sendBuffer.reset(new WebSendBuffer(webData));
}
SessionData::~SessionData()
{
InternalClearAuthSession();
// Web Socket handle needs to be manually closed, asio socket is closed automatically.
CloseWebSocketHandle();
}
SessionId
@@ -278,6 +293,24 @@ SessionData::SetClientAddr(const std::string &addr)
m_clientAddr = addr;
}
void
SessionData::CloseSocketHandle()
{
if (m_socket) {
boost::system::error_code ec;
m_socket->close(ec);
}
}
void
SessionData::CloseWebSocketHandle()
{
if (m_webData) {
boost::system::error_code ec;
m_webData->webSocketServer->close(m_webData->webHandle, websocketpp::close::status::normal, "PokerTH server closed the connection.", ec);
}
}
void
SessionData::ResetActivityTimer()
{
@@ -348,3 +381,20 @@ SessionData::GetPlayerData()
return m_playerData;
}
string
SessionData::GetRemoteIPAddressFromSocket() const
{
string ipAddress;
if (m_socket) {
boost::system::error_code errCode;
tcp::endpoint clientEndpoint = m_socket->remote_endpoint(errCode);
if (!errCode) {
ipAddress = clientEndpoint.address().to_string(errCode);
}
} else {
server::connection_ptr con = m_webData->webSocketServer->get_con_from_hdl(m_webData->webHandle);
ipAddress = con->get_remote_endpoint();
}
return ipAddress;
}
src/net/common/sessionmanager.cpp
+3 -1
View File
@@ -281,7 +281,9 @@ SessionManager::Clear()
boost::system::error_code ec;
while (i != end) {
i->second->GetAsioSocket()->close(ec);
// Close all raw handles.
i->second->CloseSocketHandle();
i->second->CloseWebSocketHandle();
++i;
}
m_sessionMap.clear();
src/net/common/webreceivebuffer.cpp
+72
View File
@@ -0,0 +1,72 @@
/*****************************************************************************
* PokerTH - The open source texas holdem engine *
* Copyright (C) 2006-2013 Felix Hammer, Florian Thauer, Lothar May *
* *
* This program is free software: you can redistribute it and/or modify *
* it under the terms of the GNU Affero General Public License as *
* published by the Free Software Foundation, either version 3 of the *
* License, or (at your option) any later version. *
* *
* This program 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 Affero General Public License for more details. *
* *
* You should have received a copy of the GNU Affero General Public License *
* along with this program. If not, see <http://www.gnu.org/licenses/>. *
* *
* *
* Additional permission under GNU AGPL version 3 section 7 *
* *
* If you modify this program, or any covered work, by linking or *
* combining it with the OpenSSL project's OpenSSL library (or a *
* modified version of that library), containing parts covered by the *
* terms of the OpenSSL or SSLeay licenses, the authors of PokerTH *
* (Felix Hammer, Florian Thauer, Lothar May) grant you additional *
* permission to convey the resulting work. *
* Corresponding Source for a non-source form of such a combination *
* shall include the source code for the parts of OpenSSL used as well *
* as that of the covered work. *
*****************************************************************************/
#include <net/sessiondata.h>
#include <net/webreceivebuffer.h>
#include <core/loghelper.h>
using namespace std;
WebReceiveBuffer::WebReceiveBuffer()
{
}
void
WebReceiveBuffer::StartAsyncRead(boost::shared_ptr<SessionData> session)
{
// Nothing to do. This is handled internally by websocketpp.
}
void
WebReceiveBuffer::HandleRead(boost::shared_ptr<SessionData> /*session*/, const boost::system::error_code &/*error*/, size_t /*bytesRead*/)
{
LOG_ERROR("WebReceiveBuffer::HandleRead should never be called because Websocket I/O is message based.");
}
void
WebReceiveBuffer::HandleMessage(boost::shared_ptr<SessionData> session, const string &msg)
{
boost::shared_ptr<NetPacket> tmpPacket;
try {
tmpPacket = NetPacket::Create(msg.c_str(), msg.size());
if (!validator.IsValidPacket(*tmpPacket)) {
LOG_ERROR("Session " << session->GetId() << " - Invalid packet: " << tmpPacket->GetMsg()->messagetype());
tmpPacket.reset();
}
} catch (const exception &e) {
LOG_ERROR("Session " << session->GetId() << " - " << e.what());
}
if (tmpPacket) {
session->HandlePacket(tmpPacket);
}
}
src/net/common/websendbuffer.cpp
+75
View File
@@ -0,0 +1,75 @@
/*****************************************************************************
* PokerTH - The open source texas holdem engine *
* Copyright (C) 2006-2012 Felix Hammer, Florian Thauer, Lothar May *
* *
* This program is free software: you can redistribute it and/or modify *
* it under the terms of the GNU Affero General Public License as *
* published by the Free Software Foundation, either version 3 of the *
* License, or (at your option) any later version. *
* *
* This program 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 Affero General Public License for more details. *
* *
* You should have received a copy of the GNU Affero General Public License *
* along with this program. If not, see <http://www.gnu.org/licenses/>. *
* *
* *
* Additional permission under GNU AGPL version 3 section 7 *
* *
* If you modify this program, or any covered work, by linking or *
* combining it with the OpenSSL project's OpenSSL library (or a *
* modified version of that library), containing parts covered by the *
* terms of the OpenSSL or SSLeay licenses, the authors of PokerTH *
* (Felix Hammer, Florian Thauer, Lothar May) grant you additional *
* permission to convey the resulting work. *
* Corresponding Source for a non-source form of such a combination *
* shall include the source code for the parts of OpenSSL used as well *
* as that of the covered work. *
*****************************************************************************/
#include <net/websendbuffer.h>
#include <net/websocketdata.h>
#include <net/netpacket.h>
using namespace std;
WebSendBuffer::WebSendBuffer(boost::shared_ptr<WebSocketData> webData)
: closeAfterSend(false), m_webData(webData)
{
}
void
WebSendBuffer::SetCloseAfterSend()
{
closeAfterSend = true;
}
void
WebSendBuffer::HandleWrite(boost::shared_ptr<boost::asio::ip::tcp::socket> /*socket*/, const boost::system::error_code &/*error*/)
{
}
void
WebSendBuffer::AsyncSendNextPacket(boost::shared_ptr<SessionData> session)
{
if (closeAfterSend) {
boost::system::error_code ec;
m_webData->webSocketServer->close(m_webData->webHandle, websocketpp::close::status::normal, "PokerTH server closed the connection.", ec);
}
}
void
WebSendBuffer::InternalStorePacket(boost::shared_ptr<SessionData> session, boost::shared_ptr<NetPacket> packet)
{
uint32_t packetSize = packet->GetMsg()->ByteSize();
google::protobuf::uint8 *buf = new google::protobuf::uint8[packetSize];
packet->GetMsg()->SerializeWithCachedSizesToArray(buf);
m_webData->webSocketServer->send(m_webData->webHandle, string((const char *)buf, packetSize), websocketpp::frame::opcode::BINARY);
delete[] buf;
}
src/net/receivebuffer.h
+8 -16
View File
@@ -1,6 +1,6 @@
/*****************************************************************************
* PokerTH - The open source texas holdem engine *
* Copyright (C) 2006-2012 Felix Hammer, Florian Thauer, Lothar May *
* Copyright (C) 2006-2013 Felix Hammer, Florian Thauer, Lothar May *
* *
* This program is free software: you can redistribute it and/or modify *
* it under the terms of the GNU Affero General Public License as *
@@ -28,39 +28,31 @@
* shall include the source code for the parts of OpenSSL used as well *
* as that of the covered work. *
*****************************************************************************/
/* Buffer for ReceiveHelper. */
/* Interface for receive buffers. */
#ifndef _RECEIVEBUFFER_H_
#define _RECEIVEBUFFER_H_
#include <boost/enable_shared_from_this.hpp>
#include <boost/system/error_code.hpp>
#include <net/netpacket.h>
#include <net/netpacketvalidator.h>
// MUST be larger than MAX_PACKET_SIZE
#define RECV_BUF_SIZE 5 * MAX_PACKET_SIZE
class SessionData;
class ReceiveBuffer : public boost::enable_shared_from_this<ReceiveBuffer>
{
public:
ReceiveBuffer();
virtual ~ReceiveBuffer();
void StartAsyncRead(boost::shared_ptr<SessionData> session);
virtual void StartAsyncRead(boost::shared_ptr<SessionData> session) = 0;
virtual void HandleRead(boost::shared_ptr<SessionData> session, const boost::system::error_code &error, size_t bytesRead) = 0;
virtual void HandleMessage(boost::shared_ptr<SessionData> session, const std::string &msg) = 0;
protected:
void HandleRead(boost::shared_ptr<SessionData> session, const boost::system::error_code &error, size_t bytesRead);
void ScanPackets(boost::shared_ptr<SessionData> session);
void ProcessPackets(boost::shared_ptr<SessionData> session);
private:
NetPacketList receivedPackets;
char recvBuf[RECV_BUF_SIZE];
size_t recvBufUsed;
static NetPacketValidator validator;
};
#endif
src/net/sendbuffer.h
+11 -57
View File
@@ -1,6 +1,6 @@
/*****************************************************************************
* PokerTH - The open source texas holdem engine *
* Copyright (C) 2006-2012 Felix Hammer, Florian Thauer, Lothar May *
* Copyright (C) 2006-2013 Felix Hammer, Florian Thauer, Lothar May *
* *
* This program is free software: you can redistribute it and/or modify *
* it under the terms of the GNU Affero General Public License as *
@@ -28,77 +28,31 @@
* shall include the source code for the parts of OpenSSL used as well *
* as that of the covered work. *
*****************************************************************************/
/* Buffer for sending network data. */
/* Buffer interface for sending network data. */
#ifndef _SENDBUFFER_H_
#define _SENDBUFFER_H_
#include <boost/asio.hpp>
#include <boost/thread.hpp>
#include <net/websocket_defs.h>
#include <boost/enable_shared_from_this.hpp>
#include <cstdlib>
#define SEND_BUF_FIRST_ALLOC_CHUNKSIZE 4096
#define MAX_SEND_BUF_SIZE SEND_BUF_FIRST_ALLOC_CHUNKSIZE * 256
#include <boost/thread.hpp>
class SessionData;
class NetPacket;
class SendBuffer : public boost::enable_shared_from_this<SendBuffer>
{
public:
SendBuffer();
~SendBuffer();
virtual ~SendBuffer();
inline size_t GetSendBufLeft() const {
int bytesLeft = (int)(sendBufAllocated - sendBufUsed);
return bytesLeft < 0 ? (size_t)0 : (size_t)bytesLeft;
}
virtual void SetCloseAfterSend() = 0;
inline size_t GetAllocated() const {
return sendBufAllocated;
}
virtual void AsyncSendNextPacket(boost::shared_ptr<SessionData> session) = 0;
virtual void InternalStorePacket(boost::shared_ptr<SessionData> session, boost::shared_ptr<NetPacket> packet) = 0;
inline bool ReallocSendBuf() {
bool retVal = false;
size_t allocAmount = sendBufAllocated * 2;
if (0 == allocAmount) {
allocAmount = (size_t)SEND_BUF_FIRST_ALLOC_CHUNKSIZE;
}
if (allocAmount <= MAX_SEND_BUF_SIZE) {
char *tempBuf = (char *)std::realloc(sendBuf, allocAmount);
if (tempBuf) {
sendBuf = tempBuf;
sendBufAllocated = allocAmount;
retVal = true;
}
}
return retVal;
}
inline void AppendToSendBufWithoutCheck(const char *data, size_t size) {
std::memcpy(sendBuf + sendBufUsed, data, size);
sendBufUsed += size;
}
inline void SetCloseAfterSend() {
closeAfterSend = true;
}
void HandleWrite(boost::shared_ptr<boost::asio::ip::tcp::socket> socket, const boost::system::error_code &error);
void AsyncSendNextPacket(boost::shared_ptr<boost::asio::ip::tcp::socket> socket);
static int EncodeToBuf(const void *data, size_t size, void *arg);
virtual void HandleWrite(boost::shared_ptr<boost::asio::ip::tcp::socket> socket, const boost::system::error_code &error) = 0;
mutable boost::mutex dataMutex;
private:
char *sendBuf;
char *curWriteBuf;
size_t sendBufAllocated;
size_t sendBufUsed;
size_t curWriteBufAllocated;
size_t curWriteBufUsed;
bool closeAfterSend;
};
#endif
src/net/senderhelper.h
-3
View File
@@ -50,9 +50,6 @@ public:
void SetCloseAfterSend(boost::shared_ptr<SessionData> session);
protected:
void InternalStorePacket(SendBuffer &tmpManager, boost::shared_ptr<NetPacket> packet);
private:
boost::shared_ptr<boost::asio::io_service> m_ioService;
src/net/serveraccepthelper.h
+3 -12
View File
@@ -36,6 +36,7 @@
#include <boost/asio.hpp>
#include <string>
#include <net/serveracceptinterface.h>
#include <net/serverlobbythread.h>
#include <net/serverexception.h>
#include <net/socket_msg.h>
@@ -43,17 +44,6 @@
#include <game_defs.h>
#include <gui/guiinterface.h>
class ServerAcceptInterface
{
public:
virtual ~ServerAcceptInterface();
virtual void Listen(unsigned serverPort, bool ipv6, const std::string &logDir,
boost::shared_ptr<ServerLobbyThread> lobbyThread) = 0;
virtual void Close() = 0;
};
template <typename P>
class ServerAcceptHelper : public ServerAcceptInterface
{
@@ -130,7 +120,8 @@ protected:
acceptedSocket->io_control(command);
acceptedSocket->set_option(typename P::no_delay(true));
acceptedSocket->set_option(boost::asio::socket_base::keep_alive(true));
GetLobbyThread().AddConnection(acceptedSocket);
boost::shared_ptr<SessionData> sessionData(new SessionData(acceptedSocket, m_lobbyThread->GetNextSessionId(), m_lobbyThread->GetSessionDataCallback(), *m_ioService));
GetLobbyThread().AddConnection(sessionData);
boost::shared_ptr<typename P::socket> newSocket(new typename P::socket(*m_ioService));
m_acceptor->async_accept(
src/net/serveracceptinterface.h
+53
View File
@@ -0,0 +1,53 @@
/*****************************************************************************
* PokerTH - The open source texas holdem engine *
* Copyright (C) 2006-2013 Felix Hammer, Florian Thauer, Lothar May *
* *
* This program is free software: you can redistribute it and/or modify *
* it under the terms of the GNU Affero General Public License as *
* published by the Free Software Foundation, either version 3 of the *
* License, or (at your option) any later version. *
* *
* This program 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 Affero General Public License for more details. *
* *
* You should have received a copy of the GNU Affero General Public License *
* along with this program. If not, see <http://www.gnu.org/licenses/>. *
* *
* *
* Additional permission under GNU AGPL version 3 section 7 *
* *
* If you modify this program, or any covered work, by linking or *
* combining it with the OpenSSL project's OpenSSL library (or a *
* modified version of that library), containing parts covered by the *
* terms of the OpenSSL or SSLeay licenses, the authors of PokerTH *
* (Felix Hammer, Florian Thauer, Lothar May) grant you additional *
* permission to convey the resulting work. *
* Corresponding Source for a non-source form of such a combination *
* shall include the source code for the parts of OpenSSL used as well *
* as that of the covered work. *
*****************************************************************************/
/* Network server helper interface to accept connections. */
#ifndef _SERVERACCEPINTERFACE_H_
#define _SERVERACCEPINTERFACE_H_
#include <string>
#include <boost/shared_ptr.hpp>
class ServerLobbyThread;
class ServerAcceptInterface
{
public:
virtual ~ServerAcceptInterface();
virtual void Listen(unsigned serverPort, bool ipv6, const std::string &logDir,
boost::shared_ptr<ServerLobbyThread> lobbyThread) = 0;
virtual void Close() = 0;
};
#endif
src/net/serveracceptwebhelper.h
+68
View File
@@ -0,0 +1,68 @@
/*****************************************************************************
* PokerTH - The open source texas holdem engine *
* Copyright (C) 2006-2013 Felix Hammer, Florian Thauer, Lothar May *
* *
* This program is free software: you can redistribute it and/or modify *
* it under the terms of the GNU Affero General Public License as *
* published by the Free Software Foundation, either version 3 of the *
* License, or (at your option) any later version. *
* *
* This program 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 Affero General Public License for more details. *
* *
* You should have received a copy of the GNU Affero General Public License *
* along with this program. If not, see <http://www.gnu.org/licenses/>. *
* *
* *
* Additional permission under GNU AGPL version 3 section 7 *
* *
* If you modify this program, or any covered work, by linking or *
* combining it with the OpenSSL project's OpenSSL library (or a *
* modified version of that library), containing parts covered by the *
* terms of the OpenSSL or SSLeay licenses, the authors of PokerTH *
* (Felix Hammer, Florian Thauer, Lothar May) grant you additional *
* permission to convey the resulting work. *
* Corresponding Source for a non-source form of such a combination *
* shall include the source code for the parts of OpenSSL used as well *
* as that of the covered work. *
*****************************************************************************/
/* Network server helper to accept websocket connections. */
#ifndef _SERVERACCEPTWEBHELPER_H_
#define _SERVERACCEPTWEBHELPER_H_
#include <net/websocket_defs.h>
#include <net/serveracceptinterface.h>
#include <net/serverlobbythread.h>
class ServerAcceptWebHelper : public ServerAcceptInterface
{
public:
ServerAcceptWebHelper(ServerCallback &serverCallback, boost::shared_ptr<boost::asio::io_service> ioService);
virtual void Listen(unsigned serverPort, bool ipv6, const std::string &logDir,
boost::shared_ptr<ServerLobbyThread> lobbyThread);
virtual void Close();
protected:
typedef std::map<websocketpp::connection_hdl, boost::weak_ptr<SessionData> > SessionMap;
bool validate(websocketpp::connection_hdl hdl);
void on_open(websocketpp::connection_hdl hdl);
void on_close(websocketpp::connection_hdl hdl);
void on_message(websocketpp::connection_hdl hdl, server::message_ptr msg);
private:
boost::shared_ptr<boost::asio::io_service> m_ioService;
ServerCallback &m_serverCallback;
boost::shared_ptr<server> m_webSocketServer;
SessionMap m_sessionMap;
boost::shared_ptr<ServerLobbyThread> m_lobbyThread;
};
#endif
src/net/serverlobbythread.h
+4 -1
View File
@@ -70,7 +70,7 @@ public:
void Init(const std::string &logDir);
virtual void SignalTermination();
void AddConnection(boost::shared_ptr<boost::asio::ip::tcp::socket> sock);
void AddConnection(boost::shared_ptr<SessionData> sessionData);
void ReAddSession(boost::shared_ptr<SessionData> session, int reason, unsigned gameId);
void MoveSessionToGame(boost::shared_ptr<ServerGame> game, boost::shared_ptr<SessionData> session, bool autoLeave, bool spectateOnly);
void SessionError(boost::shared_ptr<SessionData> session, int errorCode);
@@ -111,6 +111,7 @@ public:
bool SendToLobbyPlayer(unsigned playerId, boost::shared_ptr<NetPacket> packet);
u_int32_t GetNextSessionId();
u_int32_t GetNextUniquePlayerId();
u_int32_t GetNextGameId();
ServerCallback &GetCallback();
@@ -127,6 +128,8 @@ public:
boost::shared_ptr<ServerDBInterface> GetDatabase();
ServerBanManager &GetBanManager();
SessionDataCallback &GetSessionDataCallback();
protected:
typedef std::deque<boost::shared_ptr<boost::asio::ip::tcp::socket> > ConnectQueue;
src/net/sessiondata.h
+8 -1
View File
@@ -49,6 +49,7 @@ typedef unsigned SessionId;
struct Gsasl;
struct Gsasl_session;
struct WebSocketData;
class ReceiveBuffer;
class SendBuffer;
class NetPacket;
@@ -61,6 +62,7 @@ public:
enum State { Init = 1, ReceivingAvatar = 2, Established = 4, Game = 8, Spectating = 16, SpectatorWaiting = 32, Closed = 128 };
SessionData(boost::shared_ptr<boost::asio::ip::tcp::socket> sock, SessionId id, SessionDataCallback &cb, boost::asio::io_service &ioService);
SessionData(boost::shared_ptr<WebSocketData> webData, SessionId id, SessionDataCallback &cb, boost::asio::io_service &ioService, int filler);
~SessionData();
SessionId GetId() const;
@@ -102,6 +104,8 @@ public:
void Close() {
m_callback.CloseSession(shared_from_this());
}
void CloseSocketHandle();
void CloseWebSocketHandle();
void HandlePacket(boost::shared_ptr<NetPacket> packet) {
m_callback.HandlePacket(shared_from_this(), packet);
}
@@ -116,6 +120,8 @@ public:
void SetPlayerData(boost::shared_ptr<PlayerData> player);
boost::shared_ptr<PlayerData> GetPlayerData();
std::string GetRemoteIPAddressFromSocket() const;
protected:
SessionData(const SessionData &other);
SessionData &operator=(const SessionData &other);
@@ -125,7 +131,8 @@ protected:
void TimerActivityWarning(const boost::system::error_code &ec);
private:
boost::shared_ptr<boost::asio::ip::tcp::socket> m_socket;
boost::shared_ptr<boost::asio::ip::tcp::socket> m_socket;
boost::shared_ptr<WebSocketData> m_webData;
const SessionId m_id;
boost::weak_ptr<ServerGame> m_game;
State m_state;
src/net/webreceivebuffer.h
+48
View File
@@ -0,0 +1,48 @@
/*****************************************************************************
* PokerTH - The open source texas holdem engine *
* Copyright (C) 2006-2013 Felix Hammer, Florian Thauer, Lothar May *
* *
* This program is free software: you can redistribute it and/or modify *
* it under the terms of the GNU Affero General Public License as *
* published by the Free Software Foundation, either version 3 of the *
* License, or (at your option) any later version. *
* *
* This program 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 Affero General Public License for more details. *
* *
* You should have received a copy of the GNU Affero General Public License *
* along with this program. If not, see <http://www.gnu.org/licenses/>. *
* *
* *
* Additional permission under GNU AGPL version 3 section 7 *
* *
* If you modify this program, or any covered work, by linking or *
* combining it with the OpenSSL project's OpenSSL library (or a *
* modified version of that library), containing parts covered by the *
* terms of the OpenSSL or SSLeay licenses, the authors of PokerTH *
* (Felix Hammer, Florian Thauer, Lothar May) grant you additional *
* permission to convey the resulting work. *
* Corresponding Source for a non-source form of such a combination *
* shall include the source code for the parts of OpenSSL used as well *
* as that of the covered work. *
*****************************************************************************/
/* Websocket receive buffer. */
#ifndef _WEBRECEIVEBUFFER_H_
#define _WEBRECEIVEBUFFER_H_
#include <net/receivebuffer.h>
class WebReceiveBuffer : public ReceiveBuffer
{
public:
WebReceiveBuffer();
virtual void StartAsyncRead(boost::shared_ptr<SessionData> session);
virtual void HandleRead(boost::shared_ptr<SessionData> session, const boost::system::error_code &error, size_t bytesRead);
virtual void HandleMessage(boost::shared_ptr<SessionData> session, const std::string &msg);
};
#endif
src/net/websendbuffer.h
+59
View File
@@ -0,0 +1,59 @@
/*****************************************************************************
* PokerTH - The open source texas holdem engine *
* Copyright (C) 2006-2013 Felix Hammer, Florian Thauer, Lothar May *
* *
* This program is free software: you can redistribute it and/or modify *
* it under the terms of the GNU Affero General Public License as *
* published by the Free Software Foundation, either version 3 of the *
* License, or (at your option) any later version. *
* *
* This program 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 Affero General Public License for more details. *
* *
* You should have received a copy of the GNU Affero General Public License *
* along with this program. If not, see <http://www.gnu.org/licenses/>. *
* *
* *
* Additional permission under GNU AGPL version 3 section 7 *
* *
* If you modify this program, or any covered work, by linking or *
* combining it with the OpenSSL project's OpenSSL library (or a *
* modified version of that library), containing parts covered by the *
* terms of the OpenSSL or SSLeay licenses, the authors of PokerTH *
* (Felix Hammer, Florian Thauer, Lothar May) grant you additional *
* permission to convey the resulting work. *
* Corresponding Source for a non-source form of such a combination *
* shall include the source code for the parts of OpenSSL used as well *
* as that of the covered work. *
*****************************************************************************/
/* Buffer for sending network data through a websocket. */
#ifndef _WEBSENDBUFFER_H_
#define _WEBSENDBUFFER_H_
#include <net/sendbuffer.h>
#include <cstdlib>
struct WebSocketData;
class WebSendBuffer : public SendBuffer
{
public:
WebSendBuffer(boost::shared_ptr<WebSocketData> webData);
virtual void SetCloseAfterSend();
virtual void AsyncSendNextPacket(boost::shared_ptr<SessionData> session);
virtual void InternalStorePacket(boost::shared_ptr<SessionData> session, boost::shared_ptr<NetPacket> packet);
virtual void HandleWrite(boost::shared_ptr<boost::asio::ip::tcp::socket> socket, const boost::system::error_code &error);
private:
bool closeAfterSend;
boost::shared_ptr<WebSocketData> m_webData;
};
#endif
src/net/websocket_defs.h
+41
View File
@@ -0,0 +1,41 @@
/*****************************************************************************
* PokerTH - The open source texas holdem engine *
* Copyright (C) 2006-2013 Felix Hammer, Florian Thauer, Lothar May *
* *
* This program is free software: you can redistribute it and/or modify *
* it under the terms of the GNU Affero General Public License as *
* published by the Free Software Foundation, either version 3 of the *
* License, or (at your option) any later version. *
* *
* This program 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 Affero General Public License for more details. *
* *
* You should have received a copy of the GNU Affero General Public License *
* along with this program. If not, see <http://www.gnu.org/licenses/>. *
* *
* *
* Additional permission under GNU AGPL version 3 section 7 *
* *
* If you modify this program, or any covered work, by linking or *
* combining it with the OpenSSL project's OpenSSL library (or a *
* modified version of that library), containing parts covered by the *
* terms of the OpenSSL or SSLeay licenses, the authors of PokerTH *
* (Felix Hammer, Florian Thauer, Lothar May) grant you additional *
* permission to convey the resulting work. *
* Corresponding Source for a non-source form of such a combination *
* shall include the source code for the parts of OpenSSL used as well *
* as that of the covered work. *
*****************************************************************************/
/* Definitions and includes for websocketpp. */
#ifndef _WEBSOCKET_DEFS_H_
#define _WEBSOCKET_DEFS_H_
#include <websocketpp/config/asio_no_tls.hpp>
#include <websocketpp/server.hpp>
typedef websocketpp::server<websocketpp::config::asio> server;
#endif
src/net/websocketdata.h
+45
View File
@@ -0,0 +1,45 @@
/*****************************************************************************
* PokerTH - The open source texas holdem engine *
* Copyright (C) 2006-2013 Felix Hammer, Florian Thauer, Lothar May *
* *
* This program is free software: you can redistribute it and/or modify *
* it under the terms of the GNU Affero General Public License as *
* published by the Free Software Foundation, either version 3 of the *
* License, or (at your option) any later version. *
* *
* This program 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 Affero General Public License for more details. *
* *
* You should have received a copy of the GNU Affero General Public License *
* along with this program. If not, see <http://www.gnu.org/licenses/>. *
* *
* *
* Additional permission under GNU AGPL version 3 section 7 *
* *
* If you modify this program, or any covered work, by linking or *
* combining it with the OpenSSL project's OpenSSL library (or a *
* modified version of that library), containing parts covered by the *
* terms of the OpenSSL or SSLeay licenses, the authors of PokerTH *
* (Felix Hammer, Florian Thauer, Lothar May) grant you additional *
* permission to convey the resulting work. *
* Corresponding Source for a non-source form of such a combination *
* shall include the source code for the parts of OpenSSL used as well *
* as that of the covered work. *
*****************************************************************************/
/* Structure for web socket data for a session. */
#ifndef _WEBSOCKETDATA_H_
#define _WEBSOCKETDATA_H_
#include <net/websocket_defs.h>
struct WebSocketData
{
boost::shared_ptr<server> webSocketServer;
websocketpp::connection_hdl webHandle;
};
#endif