Ea::Network Class Reference

#include <network.h>

Inheritance diagram for Ea::Network:

Public Types
enum	{   IDLE = 0 , CONNECTED , CONNECTING , DATA ,   NET_ERROR }

Public Member Functions
	Network ()
virtual	~Network ()
bool	connect (const ServerInfo &server)
void	disconnect ()
ServerInfo	getServer () const
int	getState () const
const std::string &	getError () const
bool	isConnected () const
int	getInSize () const
void	skip (const int len)
void	flush ()
void	fixSendBuffer ()
void	pauseDispatch ()

Protected Member Functions
void	setError (const std::string &error)
uint16_t	readWord (const int pos) const
bool	realConnect ()
void	receive ()

Protected Attributes
TcpNet::Socket	mSocket
ServerInfo	mServer
PacketInfo *	mPackets
char *	mInBuffer
char *	mOutBuffer
unsigned int	mInSize
unsigned int	mOutSize
unsigned int	mToSkip
int	mState
std::string	mError
SDL_Thread *	mWorkerThread
SDL_mutex *	mMutexIn
SDL_mutex *	mMutexOut
int	mSleep
bool	mPauseDispatch

Friends
int	networkThread (void *data)

Detailed Description

Definition at line 39 of file network.h.

Member Enumeration Documentation

anonymous enum

anonymous enum

Enumerator
IDLE
CONNECTED
CONNECTING
DATA
NET_ERROR

Definition at line 77 of file network.h.

        {
            IDLE = 0,
            CONNECTED,
            CONNECTING,
            DATA,
            NET_ERROR
        };

Constructor & Destructor Documentation

Network()

Ea::Network::Network

(

)

Definition at line 64 of file network.cpp.

                 :
    mSocket(nullptr),
    mServer(),
    mPackets(nullptr),
    mInBuffer(new char[BUFFER_SIZE]),
    mOutBuffer(new char[BUFFER_SIZE]),
    mInSize(0),
    mOutSize(0),
    mToSkip(0),
    mState(IDLE),
    mError(),
    mWorkerThread(nullptr),
    mMutexIn(SDL_CreateMutex()),
    mMutexOut(SDL_CreateMutex()),
    mSleep(config.getIntValue("networksleep")),
    mPauseDispatch(false)
{
    TcpNet::init();
}

References TcpNet::init().

~Network()

Ea::Network::~Network ( )

virtual

Reimplemented in TmwAthena::Network, and EAthena::Network.

Definition at line 84 of file network.cpp.

{
    if (mState != IDLE && mState != NET_ERROR)
        disconnect();
 
    SDL_DestroyMutex(mMutexIn);
    mMutexIn = nullptr;
    SDL_DestroyMutex(mMutexOut);
    mMutexOut = nullptr;
 
    delete2Arr(mInBuffer)
    delete2Arr(mOutBuffer)
    delete2Arr(mPackets)
 
    TcpNet::quit();
}

References delete2Arr, disconnect(), IDLE, mInBuffer, mMutexIn, mMutexOut, mOutBuffer, mPackets, mState, NET_ERROR, and TcpNet::quit().

Member Function Documentation

connect()

bool Ea::Network::connect

(

const ServerInfo &

server

)

Definition at line 101 of file network.cpp.

{
    if (mState != IDLE && mState != NET_ERROR)
    {
        logger->log1("Tried to connect an already connected socket!");
        return false;
    }
 
    if (server.hostname.empty())
    {
        // TRANSLATORS: error message
        setError(_("Empty address given to Network::connect()!"));
        return false;
    }
 
    logger->log("Network::Connecting to %s:%i",
        server.hostname.c_str(), server.port);
 
    mServer.hostname = server.hostname;
    mServer.althostname = server.althostname;
    mServer.port = server.port;
 
    // Reset to sane values
    mOutSize = 0;
    mInSize = 0;
    mToSkip = 0;
 
    mState = CONNECTING;
    mWorkerThread = SDL::createThread(&networkThread, "network", this);
    if (mWorkerThread == nullptr)
    {
        setError("Unable to create network worker thread");
        return false;
    }
 
    return true;
}

References _, ServerInfo::althostname, CONNECTING, SDL::createThread(), ServerInfo::hostname, IDLE, Logger::log(), Logger::log1(), logger, mInSize, mOutSize, mServer, mState, mToSkip, mWorkerThread, NET_ERROR, networkThread, ServerInfo::port, and setError().

Referenced by EAthena::CharServerHandler::connect(), EAthena::GameHandler::connect(), EAthena::LoginHandler::connect(), TmwAthena::CharServerHandler::connect(), TmwAthena::GameHandler::connect(), and TmwAthena::LoginHandler::connect().

disconnect()

void Ea::Network::disconnect

(

)

Definition at line 139 of file network.cpp.

{
    BLOCK_START("Network::disconnect")
    mState = IDLE;
 
    SDL::WaitThread(mWorkerThread);
    mWorkerThread = nullptr;
 
    if (mSocket != nullptr)
    {
        TcpNet::closeSocket(mSocket);
        mSocket = nullptr;
        if (mSleep > 0)
            SDL_Delay(mSleep);
    }
    BLOCK_END("Network::disconnect")
}

References BLOCK_END, BLOCK_START, TcpNet::closeSocket(), IDLE, mSleep, mSocket, mState, mWorkerThread, and SDL::WaitThread().

Referenced by EAthena::CharServerHandler::connect(), TmwAthena::CharServerHandler::connect(), EAthena::GameHandler::disconnect(), EAthena::LoginHandler::disconnect(), TmwAthena::GameHandler::disconnect(), TmwAthena::LoginHandler::disconnect(), EAthena::CharServerRecv::processChangeMapServer(), TmwAthena::CharServerRecv::processChangeMapServer(), EAthena::CharServerRecv::processCharMapInfo(), TmwAthena::CharServerRecv::processCharMapInfo(), EAthena::GeneralHandler::reload(), TmwAthena::GeneralHandler::reload(), and ~Network().

fixSendBuffer()

void Ea::Network::fixSendBuffer

(

)

Definition at line 362 of file network.cpp.

{
    if (mOutSize > BUFFER_LIMIT)
    {
        if (mState != CONNECTED)
            mOutSize = 0;
        else
            flush();
    }
}

References Ea::BUFFER_LIMIT, CONNECTED, flush(), mOutSize, and mState.

Referenced by EAthena::MessageOut::MessageOut(), and TmwAthena::MessageOut::MessageOut().

flush()

void Ea::Network::flush

(

)

Definition at line 157 of file network.cpp.

{
    if ((mOutSize == 0U) || mState != CONNECTED)
        return;
 
    SDL_mutexP(mMutexOut);
    const int ret = TcpNet::send(mSocket, mOutBuffer, mOutSize);
/*
    if (logger)
    {
        logger->dlog(std::string("Send ").append(
            toString(mOutSize)).append(" bytes"));
    }
*/
    if (ret < CAST_S32(mOutSize))
    {
        SDL_mutexV(mMutexOut);
        setError("Error in TcpNet::send(): " +
            std::string(TcpNet::getError()));
    }
    mOutSize = 0;
    SDL_mutexV(mMutexOut);
}

References CAST_S32, CONNECTED, TcpNet::getError(), mMutexOut, mOutBuffer, mOutSize, mSocket, mState, TcpNet::send(), and setError().

Referenced by fixSendBuffer(), EAthena::GeneralHandler::flushNetwork(), TmwAthena::GeneralHandler::flushNetwork(), EAthena::GeneralHandler::flushSend(), and TmwAthena::GeneralHandler::flushSend().

getError()

const std::string& Ea::Network::getError ( ) const

inline

Definition at line 58 of file network.h.

        { return mError; }

References mError.

Referenced by EAthena::GeneralHandler::flushNetwork(), and TmwAthena::GeneralHandler::flushNetwork().

getInSize()

int Ea::Network::getInSize ( ) const

inline

Definition at line 64 of file network.h.

        { return mInSize; }

References mInSize.

getServer()

ServerInfo Ea::Network::getServer ( ) const

inline

Definition at line 52 of file network.h.

        { return mServer; }

References mServer.

getState()

int Ea::Network::getState ( ) const

inline

Definition at line 55 of file network.h.

        { return mState; }

References mState.

isConnected()

bool Ea::Network::isConnected ( ) const

inline

Definition at line 61 of file network.h.

        { return mState == CONNECTED; }

References CONNECTED, and mState.

Referenced by EAthena::GameHandler::isConnected(), EAthena::LoginHandler::isConnected(), TmwAthena::GameHandler::isConnected(), and TmwAthena::LoginHandler::isConnected().

pauseDispatch()

void Ea::Network::pauseDispatch ( )

inline

Definition at line 73 of file network.h.

        { mPauseDispatch = true; }

References mPauseDispatch.

Referenced by EAthena::GameRecv::processMapLogin(), and TmwAthena::GameRecv::processMapLogin().

readWord()

uint16_t Ea::Network::readWord ( const int  pos ) const

protected

Definition at line 350 of file network.cpp.

{
#if SDL_BYTEORDER == SDL_BIG_ENDIAN
    return SDL_Swap16(*reinterpret_cast<uint16_t*>(
        mInBuffer + CAST_SIZE(pos)));
#else  // SDL_BYTEORDER == SDL_BIG_ENDIAN
 
    return (*reinterpret_cast<uint16_t*>(
        mInBuffer + CAST_SIZE(pos)));
#endif  // SDL_BYTEORDER == SDL_BIG_ENDIAN
}

References CAST_SIZE, and mInBuffer.

Referenced by EAthena::Network::dispatchMessages(), TmwAthena::Network::dispatchMessages(), EAthena::Network::messageReady(), and TmwAthena::Network::messageReady().

realConnect()

bool Ea::Network::realConnect ( )

protected

Definition at line 205 of file network.cpp.

{
    IPaddress ipAddress;
 
    if (TcpNet::resolveHost(&ipAddress, mServer.hostname.c_str(),
        mServer.port) == -1)
    {
        if (mServer.althostname.empty() || TcpNet::resolveHost(&ipAddress,
            mServer.althostname.c_str(), mServer.port) == -1)
        {
            const std::string errorMessage = std::string(
                // TRANSLATORS: error message
                _("Unable to resolve host \"")).append(
                mServer.hostname).append("\".");
            setError(errorMessage);
            logger->log_r("TcpNet::ResolveHost: %s", errorMessage.c_str());
            return false;
        }
        logger->log_r("using alt host name: %s", mServer.althostname.c_str());
    }
 
    mState = CONNECTING;
 
    mSocket = TcpNet::open(&ipAddress);
    if (mSocket == nullptr)
    {
        logger->log_r("Error in TcpNet::open(): %s", TcpNet::getError());
        setError(TcpNet::getError());
        return false;
    }
 
    mLastHost = ipAddress.host;
    logger->log_r("Network::Started session with %s:%i",
        ipToString(ipAddress.host), ipAddress.port);
 
    mState = CONNECTED;
    return true;
}

References _, ServerInfo::althostname, CONNECTED, CONNECTING, errorMessage, TcpNet::getError(), ServerInfo::hostname, ipToString(), Logger::log_r(), logger, mLastHost, mServer, mSocket, mState, TcpNet::open(), ServerInfo::port, TcpNet::resolveHost(), and setError().

receive()

void Ea::Network::receive ( )

protected

Definition at line 244 of file network.cpp.

{
    TcpNet::SocketSet set;
 
    if ((set = TcpNet::allocSocketSet(1)) == nullptr)
    {
        setError("Error in TcpNet::allocSocketSet(): " +
            std::string(TcpNet::getError()));
        return;
    }
 
    if (TcpNet::addSocket(set, mSocket) == -1)
    {
        setError("Error in TcpNet::addSocket(): " +
            std::string(TcpNet::getError()));
    }
 
    while (mState == CONNECTED)
    {
        const int numReady = TcpNet::checkSockets(
            set, (CAST_U32(500)));
        switch (numReady)
        {
            case -1:
                logger->log_r("Error: TcpNet::checkSockets");
                break;
                // FALLTHROUGH
            case 0:
                break;
 
            case 1:
            {
                // Receive data from the socket
                SDL_mutexP(mMutexIn);
                if (mInSize > BUFFER_LIMIT)
                {
                    SDL_mutexV(mMutexIn);
                    SDL_Delay(100);
                    continue;
                }
 
                const int ret = TcpNet::recv(mSocket,
                    mInBuffer + CAST_SIZE(mInSize),
                    BUFFER_SIZE - mInSize);
 
                if (ret == 0)
                {
                    // We got disconnected
                    mState = IDLE;
                    logger->log_r("Disconnected.");
                }
                else if (ret < 0)
                {
                    // TRANSLATORS: error message
                    setError(_("Connection to server terminated. ") +
                             std::string(TcpNet::getError()));
                }
                else
                {
//                    DEBUGLOG("Receive " + toString(ret) + " bytes");
                    mInSize += ret;
                    if (mToSkip != 0U)
                    {
                        if (mInSize >= mToSkip)
                        {
                            mInSize -= mToSkip;
                            memmove(mInBuffer,
                                mInBuffer + CAST_SIZE(mToSkip),
                                mInSize);
                            mToSkip = 0;
                        }
                        else
                        {
                            mToSkip -= mInSize;
                            mInSize = 0;
                        }
                    }
                }
                SDL_mutexV(mMutexIn);
                break;
            }
 
            default:
                // more than one socket is ready..
                // this should not happen since we only listen once socket.
                std::stringstream errorStream;
                errorStream << "Error in TcpNet::recv(), " << numReady
                            << " sockets are ready: " << TcpNet::getError();
                setError(errorStream.str());
                break;
        }
    }
 
    if (TcpNet::delSocket(set, mSocket) == -1)
        logger->log_r("Error in TcpNet::delSocket(): %s", TcpNet::getError());
 
    TcpNet::freeSocketSet(set);
}

References _, TcpNet::addSocket(), TcpNet::allocSocketSet(), Ea::BUFFER_LIMIT, Ea::BUFFER_SIZE, CAST_SIZE, CAST_U32, TcpNet::checkSockets(), CONNECTED, TcpNet::delSocket(), TcpNet::freeSocketSet(), TcpNet::getError(), IDLE, Logger::log_r(), logger, mInBuffer, mInSize, mMutexIn, mSocket, mState, mToSkip, TcpNet::recv(), and setError().

setError()

void Ea::Network::setError ( const std::string &  error )

protected

Definition at line 343 of file network.cpp.

{
    logger->log_r("Network error: %s", error.c_str());
    mError = error;
    mState = NET_ERROR;
}

References Actions::error(), Logger::log_r(), logger, mError, mState, and NET_ERROR.

Referenced by connect(), flush(), realConnect(), and receive().

skip()

void Ea::Network::skip

(

const int

len

)

Definition at line 181 of file network.cpp.

{
    SDL_mutexP(mMutexIn);
    mToSkip += len;
    if (mInSize == 0U)
    {
        SDL_mutexV(mMutexIn);
        return;
    }
 
    if (mInSize >= mToSkip)
    {
        mInSize -= mToSkip;
        memmove(mInBuffer, mInBuffer + CAST_SIZE(mToSkip), mInSize);
        mToSkip = 0;
    }
    else
    {
        mToSkip -= mInSize;
        mInSize = 0;
    }
    SDL_mutexV(mMutexIn);
}

References CAST_SIZE, mInBuffer, mInSize, mMutexIn, and mToSkip.

Referenced by EAthena::CharServerHandler::connect(), TmwAthena::CharServerHandler::connect(), TmwAthena::GameHandler::connect(), EAthena::Network::dispatchMessages(), and TmwAthena::Network::dispatchMessages().

Friends And Related Function Documentation

networkThread

int networkThread ( void *  data )

friend

Definition at line 52 of file network.cpp.

{
    Network *const network = static_cast<Network *>(data);
 
    if ((network == nullptr) || !network->realConnect())
        return -1;
 
    network->receive();
 
    return 0;
}

Referenced by connect().

Field Documentation

mError

std::string Ea::Network::mError

protected

Definition at line 111 of file network.h.

Referenced by getError(), and setError().

mInBuffer

char* Ea::Network::mInBuffer

protected

Definition at line 103 of file network.h.

Referenced by EAthena::Network::dispatchMessages(), TmwAthena::Network::dispatchMessages(), readWord(), receive(), skip(), and ~Network().

mInSize

unsigned int Ea::Network::mInSize

protected

Definition at line 105 of file network.h.

Referenced by connect(), getInSize(), EAthena::Network::messageReady(), TmwAthena::Network::messageReady(), receive(), and skip().

mMutexIn

SDL_mutex* Ea::Network::mMutexIn

protected

Definition at line 114 of file network.h.

Referenced by EAthena::Network::dispatchMessages(), TmwAthena::Network::dispatchMessages(), EAthena::Network::messageReady(), TmwAthena::Network::messageReady(), receive(), skip(), and ~Network().

mMutexOut

SDL_mutex* Ea::Network::mMutexOut

protected

Definition at line 115 of file network.h.

Referenced by flush(), and ~Network().

mOutBuffer

char* Ea::Network::mOutBuffer

protected

Definition at line 104 of file network.h.

Referenced by flush(), EAthena::MessageOut::MessageOut(), TmwAthena::MessageOut::MessageOut(), and ~Network().

mOutSize

unsigned int Ea::Network::mOutSize

protected

Definition at line 106 of file network.h.

Referenced by connect(), EAthena::MessageOut::expand(), TmwAthena::MessageOut::expand(), fixSendBuffer(), flush(), EAthena::MessageOut::MessageOut(), and TmwAthena::MessageOut::MessageOut().

mPackets

PacketInfo* Ea::Network::mPackets

protected

Definition at line 101 of file network.h.

Referenced by EAthena::Network::clearHandlers(), TmwAthena::Network::clearHandlers(), EAthena::Network::dispatchMessages(), TmwAthena::Network::dispatchMessages(), EAthena::Network::messageReady(), TmwAthena::Network::messageReady(), EAthena::Network::Network(), TmwAthena::Network::Network(), EAthena::Network::registerFakeHandlers(), and ~Network().

mPauseDispatch

bool Ea::Network::mPauseDispatch

protected

Definition at line 117 of file network.h.

Referenced by EAthena::Network::dispatchMessages(), TmwAthena::Network::dispatchMessages(), and pauseDispatch().

mServer

ServerInfo Ea::Network::mServer

protected

Definition at line 99 of file network.h.

Referenced by connect(), getServer(), and realConnect().

mSleep

int Ea::Network::mSleep

protected

Definition at line 116 of file network.h.

Referenced by disconnect().

mSocket

TcpNet::Socket Ea::Network::mSocket

protected

Definition at line 97 of file network.h.

Referenced by disconnect(), flush(), realConnect(), and receive().

mState

int Ea::Network::mState

protected

Definition at line 110 of file network.h.

Referenced by connect(), disconnect(), fixSendBuffer(), flush(), getState(), isConnected(), realConnect(), receive(), setError(), and ~Network().

mToSkip

unsigned int Ea::Network::mToSkip

protected

Definition at line 108 of file network.h.

Referenced by connect(), receive(), and skip().

mWorkerThread

SDL_Thread* Ea::Network::mWorkerThread

protected

Definition at line 113 of file network.h.

Referenced by connect(), and disconnect().

---

The documentation for this class was generated from the following files:

• src/net/ea/network.h (986a3bf)
• src/net/ea/network.cpp (986a3bf)