---

connection.cpp

Go to the documentation of this file.

#include "sysconfig.h"
#include "connection.h"
#include "socket.h"
#include "server.h"
#include "log.h"

Connection::Connection(SOCKET sock, Server* server)
  : mServer(server), mDisconnectable(false) {
  mSock = new Socket(sock);
}

Connection::~Connection() {
  delete mSock;
}

Connection::Connection(const Connection& r_conn)
  : mServer(r_conn.mServer), mDisconnectable(r_conn.mDisconnectable),
    mInBuffer(r_conn.mInBuffer), mOutBuffer(r_conn.mOutBuffer),
    mPendingInput(r_conn.mPendingInput) {
  mSock = new Socket(*r_conn.mSock);
}

Connection & Connection::operator=(const Connection& r_conn) {
  if (this == &r_conn)
    return *this;
  mServer = r_conn.mServer;
  mInBuffer = r_conn.mInBuffer;
  mOutBuffer = r_conn.mOutBuffer;
  mPendingInput = r_conn.mPendingInput;
  delete mSock;
  mSock = new Socket(*r_conn.mSock);
  return *this;
}

bool Connection::operator==(const Connection& r_conn) const {
  return (GetSocket() == r_conn.GetSocket());
}

void Connection::HandleInput() {
  // Loop to gather all socket input.
  while(true) {
    char c;
    try {
      c = mSock->Read();
    }
    catch (BlockingException &ex) {
      // Indicates no more input can be squeezed from this socket.
      // Let's bust this loop
      mServer->ServerLog().Write("INFO-Connection(recv): Blocking %d on %d",
        ex.mErrCode, GetSocket());
      break;
    }
    catch (ShutdownException &ex) {
      mDisconnectable = true;
      // Connection is scheduled for disconnection, and we'll exit
      mServer->ServerLog().Write("WARNING-Connection(recv): Shutdown %d on %d",
        ex.mErrCode, GetSocket());
      return;
    }
    catch (IOErrorException &ex) {
      // We have a serious error
      // Connection is scheduled for disconnection, and we'll exit
      mServer->ServerLog().Write("ERROR-Connection(recv): IOError %d on %d",
        ex.mErrCode, GetSocket());
      mDisconnectable = true;
      return;
    }
    // Append everything read to our string.
    mPendingInput += c;
    // Let's yield every 4K of input
    if (mPendingInput.size() > 4096)
      break;
  } // while

  // Loop to parse all the input into lines for our buffer
  while(true) {
    int pos = mPendingInput.find("\r\n");
    if (pos != (int)mPendingInput.npos) {
      // A line was found; save it to buffer and remove from input string
      mInBuffer.push_back(mPendingInput.substr(0,pos));
      mPendingInput.erase(0,pos + 2);
    } else {
      // No     more complete lines found
      break;
    }
  }
}

void Connection::HandleOutput() {
  // If there is any output waiting in line buffer write it out
  while (!mOutBuffer.empty()) {
    try {
      mSock->Write(mOutBuffer.front());
      mOutBuffer.pop_front();
      mSock->Flush();
    }
    catch (BlockingException &ex) {
      // :bug: we don't save where we last were in the output.
      mServer->ServerLog().Write("INFO-Connection(send): Blocking %d on %d",
        ex.mErrCode, GetSocket());
      return;
    }
    catch (IOErrorException &ex) {
      // severe error set socket as disconnectable and leave
      mServer->ServerLog().Write("ERROR-Connection(send): IOError %d on %d",
        ex.mErrCode, GetSocket());
      mDisconnectable = true;
      return;
    }
  } // while
}

void Connection::Disconnect() {
  mServer->ServerLog().Write(
    "INFO-Connection(disconnect): Connection %d disconnected", GetSocket());
  mSock->Close();
}

void Connection::SendMsg(const string& r_msg) {
  mOutBuffer.push_back(r_msg);
}

string* Connection::ReadMsg() {
  if (!mInBuffer.empty()) {
          string * msg = new string(mInBuffer.front());
          mInBuffer.pop_front();
          return msg;
  }
  return NULL;
}

bool Connection::CanBeDisconnected() {
  return mDisconnectable;
}

SOCKET Connection::GetSocket() const {
  return mSock->GetSocket();
}

bool Connection::HasOutput() {
  return !mOutBuffer.empty();
}

---