RealSocket.cpp

Ugrás a fájl dokumentációjához.

/*
    mySocket, RealSocket
    Copyright (C) 2006  Kornel Csernai <csko@csko.hu>

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 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 General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
*/
#include <RealSocket.h>
#include <StringLib.h>
#include <iostream>

using namespace StringLib;
using namespace std;

RealSocket::RealSocket(socket_t _sock) : Socket(_sock) {

  ReadBuf = "";
  ReadLen = 0;
  WriteBuf = "";
  WriteLen = 0;
  if(_sock == -1) connected = false;
    else connected = true;

  }


// Retrun current read buffer
string RealSocket::GetReadBuf(){

  return ReadBuf;

  }


// Return read buffer length
int RealSocket::GetReadLen(){

  return ReadBuf.size();

  }

// Retrun current write buffer
string RealSocket::GetWriteBuf(){

  return WriteBuf;

  }

// Return write buffer length
int RealSocket::GetWriteLen(){

  return WriteBuf.size();

  }


void RealSocket::Write(string str){

  WriteBuf += str;
  WriteLen = WriteBuf.size();

  }


// Physical write to a socket
int RealSocket::WriteBuffer(string writeval){

  return WriteBuffer((void*)writeval.c_str(), writeval.size());

  }


// Physical write to a socket
int RealSocket::WriteBuffer(void* writeval, int writelen){

  if(writeval == NULL or writelen < 0){
//    throw SocketException(SERR_INVALID_PARAMETERS);
    return -1;
    }

  if(!IsConnected()) throw SocketException(SOCKET_CLOSED);

  if(writelen == 0) return 0;


  int ret;


  if(is_SSL){
#ifdef HAVE_SSL

    ret = SSL_write(ssl, writeval, writelen);

#else

    throw SocketException(NO_SSL);

#endif

    }else{

#ifdef _WIN32
    ret = send(GetSock(), (char*)writeval, writelen, 0);
#else
    ret = send(GetSock(), writeval, writelen, 0);
#endif

    }
/*
  if(ret < writelen){
    throw -1;
    }
*/
  if(ret == -1) throw SocketException(SOCKET_DISCONNECTED);

  return ret;

  }

// Physical write to a socket
int RealSocket::WriteBuffer(char* writeval){ // deprecated function

// THAT'S WHY I DONT REALLY LIKE CHAR*'S

  int i = strlen(writeval);
  char* tmp = (char*) malloc(i+2);
  memcpy(tmp, writeval, i);
  tmp[i] = '\r';
  tmp[i+1] = '\n';
  int ret = WriteBuffer((void*)tmp, i+2);
  free(tmp);
  return ret;

  }



// Read from a socket
int RealSocket::Read(string& readval){

  int ret;
  char _readval[bufflen];

  ret = Read(_readval, bufflen);
  readval.append(_readval, ret);

  return ret; // Received ret bytes
  }

// Read from a socket
int RealSocket::Read(void* readval, int readlen){

  if(readval == NULL or readlen < 0){
//    throw SocketException(INVALID_PARAMETERS);
    }

  if(!IsConnected()) throw SocketException(SOCKET_CLOSED);

  if(readlen == 0){

    return 0;

    }

  int ret;

  if(is_SSL){
#ifdef HAVE_SSL

    ret = SSL_read(ssl, readval, readlen);
//    if(ret<0) error(SSL_get_error(ssl, ret));

#else

    throw SocketException(NO_SSL);

#endif

    }else{

#ifdef _WIN32

    ret = recv(GetSock(), (char*) readval, readlen, 0);

#else

    ret = recv(GetSock(), readval, readlen, 0);

#endif

    }

  if(ret <= 0){

    OnConnClosed();

    }

  return ret; // Received ret bytes

  }


/* deprecated
int RealSocket::readfrom( void* buf, int bufLen, struct sockaddr* from, socklen_t* fromLen ) {
  if ( ( buf == NULL ) || ( bufLen < 0 ) || ( from == NULL ) || ( fromLen == NULL ) ) {
//    throw SocketException( SERR_INVALID_PARAMETERS );
  }

  if ( bufLen == 0 ) {
    return 0;
  }
#ifdef _WIN32
  int ans = ::recvfrom( sock, (char*)buf, bufLen, 0, from, fromLen );
#else
  int ans = ::recvfrom( sock, buf, bufLen, 0, from, fromLen );
#endif
  if ( ans <= 0 ) {
//    throw SocketException( SERR_STREAM_CLOSED );
  }

  return ans;
}
*/

// Called on recv()
void RealSocket::OnRead() {

  string readstr;
  int ret = Read(readstr);

  if(ret == -1) throw SocketException(READ_FAILED);

  // store read results for user
  ReadBuf = readstr;
  ReadLen = ret;

  if(ret > 0)  __OnRead();

  }

// Called when it's safe to write
void RealSocket::OnWrite() {

//  if(WriteBufLen == 0) throw SocketException(INVALID_PARAMETERS);

  int ret = WriteBuffer(GetWriteBuf());

  // setting buffer to the remaining part
  WriteBuf = WriteBuf.substr(ret);
  WriteLen = WriteBuf.size();
  }


void RealSocket::OnConnectionError(){

  Close();

  }

bool RealSocket::IsConnected(){

  return connected;

  }

RealSocket* operator<<(RealSocket* _socket, string str){

  _socket -> Write(str);

  }

RealSocket* operator+=(RealSocket* _socket, string str){

  _socket << str;

  }