server.cpp

#include "server.h"

namespace n2nc {

using namespace n2nc ;

ClientInfo * Server::getClientInfo(net::Socket * sock, ClientInfo::ClientID id){
  m_peers_it_sk pit1 ;
  m_peers_it_id pit2 ;
  if(sock){
//     pit1 = this->m_online_peers_sk.find ( sock );
//     return (pit1 != this->m_online_peers_sk.end()) ? pit1->second : NULL ;
  }else if(id){
    pit2 = this->m_online_peers_id.find ( id );
    return (pit2 != this->m_online_peers_id.end()) ? pit2->second : NULL ;
  }else{
    /* no parameter */
    return NULL ;
  }
}

ClientInfo * Server::newClientInfo(net::Socket * sock, ClientInfo::ClientID id){
  ClientInfo *ci = new ClientInfo(id, sock);
  int isnew ;
//   std::cerr << "inserting new skpeer?:" << sock << this->m_online_peers_sk.insert ( std::pair<net::Socket*,ClientInfo*>(sock,ci)).second << std::endl ;
  isnew = this->m_online_peers_id.insert ( std::pair<ClientInfo::ClientID,ClientInfo*>(id,ci)).second ;
  if(!isnew){
    delete ci ;
    return NULL ;
  }
  return ci ;
}

int Server::delClientInfo(ClientInfo::ClientID id){
  std::cerr << "erased idpeer:" << std::hex << id << this->m_online_peers_id.erase(id) << std::endl ;
}

int Server::delClientInfo(net::Socket * sock){
  /* slow routine, linear on worst case */
  m_peers_it_id pit ;
reinithack:
  for (pit = this->m_online_peers_id.begin(); pit != this->m_online_peers_id.end(); pit++ ){
    if ( pit->second->getCtlSock() == sock ){
      std::cerr << "del client info. removed idpeer from list:" << std::hex << pit->first << std::endl ;
      this->m_online_peers_id.erase(pit);
      goto reinithack;
    }
  }
}



Server::Server() {
  std::cerr << "server starting" << std::endl ;
}


Server::~Server() {
}

int Server::listen ( int port ) {
  this->m_sock = new n2nc::net::TcpSocket ( AF_INET );
  net::SocketAddress *sa = net::Resolver::getSocketAddressByService ( "0.0.0.0", port, SOCK_STREAM, AF_INET, false ) ;
  this->m_sock->bind ( *sa );
  delete sa ;
  this->m_sock->setListen ( 10 );
  this->m_skev = new net::SocketEventsHandler();

  this->m_skev->add ( *this->m_sock, net::SocketEventsHandler::READ, *this );
  this->m_skev->waitForEvents();
  return 0;
}


int Server::shutdown ( std::string message ) {

}

}

int n2nc::Server::onReceive ( n2nc::net::Socket & sock, int dtlen ) {
//   char buf[dtlen+1];
  packet pk_tmp, pk_tmp_reply ; /*temporary packet */
  m_peers_it pit; /* peers iterator */
  int retval ;
  ClientInfo *ci_tmp,*ci;
  net::SocketAddress *peer_sa ;
  net::Address *peer_a ;
  
  ::bzero ( &pk_tmp, sizeof ( pk_tmp ) );
  if ( dtlen < sizeof ( packet ) ) {
    std::cerr << "malformed packet, do nothing:" << dtlen << std::endl ;
    ::sleep ( 1 );
    this->m_skev->enableSocket ( sock );
    return -1 ;
  }
  sock.recv ( ( void* ) &pk_tmp, sizeof ( packet ) );
  std::cerr << "onReceive. bytes:" << dtlen << std::endl ;

  /* dispatch command */
  switch(pk_tmp.cmd){
    case CMD_REGISTER :
      std::cerr << "lock in register cmd" << std::endl ;
      this->m_lock.lock();
        ci = this->newClientInfo(&sock,pk_tmp.src);
        ::bzero(&pk_tmp_reply,sizeof(pk_tmp_reply));
        pk_tmp_reply.cmd = CMD_REGISTER_ACK ;
        if (!ci){
          /* already resistered id */
          std::cerr << "onReceive:Already registered id" << std::hex << pk_tmp.src << std::endl ;
          pk_tmp_reply.msg = MSG_ALREADY_REGISTERED ;
        }else{
          /* the peer need to be registered */
          std::cerr << "onReceive:REGISTER rsa ID:" << std::hex << pk_tmp.src << "port:" << pk_tmp.src_port << std::endl ;
          ci->setServicePort(pk_tmp.src_port);
          ci->setAckTime();
          pk_tmp_reply.msg = MSG_OK ;
        }
      /* ack the client */
      sock.send(&pk_tmp_reply,sizeof(pk_tmp_reply));
      this->m_lock.unlock();
      break ;
    
    case CMD_PING :
      ci_tmp = this->getClientInfo(&sock);
      
      if (!ci_tmp){std::cerr << "ClientInfo not set. Exit" << std::endl ; exit(255);}
      ci_tmp->setAckTime();
      break ;
    
    /* TODO */
    case CMD_LEAVE :
      break ;
    
    case CMD_GET_CLIENT_INFO :
        std::cerr << "CMD_GET_CLIENT_INFO: requested id" << std::hex << pk_tmp.dst << std::endl ;
        ci_tmp = this->getClientInfo(NULL,pk_tmp.dst);
        bzero (&pk_tmp_reply,sizeof(pk_tmp_reply));
        pk_tmp_reply.cmd = CMD_GET_CLIENT_INFO_REPLY ;
        if (!ci_tmp){
          std::cerr << "Client not registered." << std::endl ; 
          pk_tmp_reply.msg = MSG_NOT_FOUND ;
        }else{
          pk_tmp_reply.msg = MSG_OK ;
          pk_tmp_reply.dst = pk_tmp.dst ;
          peer_sa = ci_tmp->getSrvSocketAddr();
          memcpy(&pk_tmp_reply.srv_addr,peer_sa->getRawSockAddr(),sizeof(net::SocketAddress::Storage));
          
//           delete peer_sa ;
        }
        
        sock.send(&pk_tmp_reply,sizeof(pk_tmp_reply));
      break ;
    
    case CMD_CONNECT :
        ci_tmp = this->getClientInfo(NULL,pk_tmp.dst);
        if(!ci_tmp){
          std::cerr << "CMD_CONNECT from ID: " << std::hex << pk_tmp.src << " to: " << pk_tmp.dst << " FAILED" << std::endl ;
          break ;
        }
        std::cerr << "CMD_CONNECT from ID: " << std::hex << pk_tmp.src << " to: " << pk_tmp.dst << std::endl ;
        /* relay the packet to dts peer */
        ci_tmp->getCtlSock()->send(&pk_tmp,sizeof(pk_tmp));
      break ;
    
    case CMD_CONNECT_ACK :
        ci_tmp = this->getClientInfo(NULL,pk_tmp.dst);
        if(!ci_tmp){
          std::cerr << "CMD_CONNECT_ACK from ID: " << std::hex << pk_tmp.src << " to: " << pk_tmp.dst << " FAILED" << std::endl ;
          break ;
        }
        std::cerr << "CMD_CONNECT_ACK from ID: " << std::hex << pk_tmp.src << " to: " << pk_tmp.dst << std::endl ;
        /* relay the packet to dts peer */
        ci_tmp->getCtlSock()->send(&pk_tmp,sizeof(pk_tmp));
      break ;
    case CMD_CONNECT_OK :
        ci_tmp = this->getClientInfo(NULL,pk_tmp.dst);
        if(!ci_tmp){
          std::cerr << "CMD_CONNECT_OK from ID: " << std::hex << pk_tmp.src << " to: " << pk_tmp.dst << " FAILED" << std::endl ;
          break ;
        }
        std::cerr << "CMD_CONNECT_OK from ID: " << std::hex << pk_tmp.src << " to: " << pk_tmp.dst << std::endl ;
        /* relay the packet to dts peer */
        ci_tmp->getCtlSock()->send(&pk_tmp,sizeof(pk_tmp));
      break ;
    
    case CMD_CONNECT_OK_ACK :
        ci_tmp = this->getClientInfo(NULL,pk_tmp.dst);
        if(!ci_tmp){
          std::cerr << "CMD_CONNECT_OK_ACK from ID: " << std::hex << pk_tmp.src << " to: " << pk_tmp.dst << " FAILED" << std::endl ;
          break ;
        }
        std::cerr << "CMD_CONNECT_OK_ACK from ID: " << std::hex << pk_tmp.src << " to: " << pk_tmp.dst << std::endl ;
        /* relay the packet to dts peer */
        ci_tmp->getCtlSock()->send(&pk_tmp,sizeof(pk_tmp));
      break ;
    
    case CMD_SMSG :
        ci_tmp = this->getClientInfo(NULL,pk_tmp.dst);
        if(!ci_tmp){
          std::cerr << "CMD_SMSG from ID: " << std::hex << pk_tmp.src << " to: " << pk_tmp.dst << " FAILED" << std::endl ;
          break ;
        }
        std::cerr << "CMD_SMSG from ID: " << std::hex << pk_tmp.src << " to: " << pk_tmp.dst << std::endl ;
        /* relay the packet to dts peer */
        ci_tmp->getCtlSock()->send(&pk_tmp,sizeof(pk_tmp));
      break ;
    case CMD_SMSG_ACK :
        ci_tmp = this->getClientInfo(NULL,pk_tmp.dst);
        if(!ci_tmp){
          std::cerr << "CMD_SMSG_ACK from ID: " << std::hex << pk_tmp.src << " to: " << pk_tmp.dst << " FAILED" << std::endl ;
          break ;
        }
        std::cerr << "CMD_SMSG_ACK from ID: " << std::hex << pk_tmp.src << " to: " << pk_tmp.dst << std::endl ;
        /* relay the packet to dts peer */
        ci_tmp->getCtlSock()->send(&pk_tmp,sizeof(pk_tmp));
      break ;
    
    case CMD_DISCONNECT :
      break ;
    
  }
  
  /* anyway, re-enable the socket to be watched */
  this->m_skev->enableSocket ( sock );

  return retval ;
}

int n2nc::Server::onNewConnection ( n2nc::net::Socket & sock ) {
  std::cerr << "new connection" << std::endl ;
  n2nc::net::TcpSocket *cast_sock = ( n2nc::net::TcpSocket* ) & sock ;
  std::cerr << "pre accepted"  <<  std::endl ;
  n2nc::net::Socket *new_sock = cast_sock->accept();

//   this->m_online_peers.insert( std::pair<n2nc::net::Socket*,n2nc::ClientInfo*>(new_sock,NULL) ) ;
  std::cerr << "accepted with new fd:" << new_sock->getFD() <<  std::endl ;
  net::SocketEventsHandler::check_for_t tmp_checkfor  = ( net::SocketEventsHandler::check_for_t ) ( net::SocketEventsHandler::READ | net::SocketEventsHandler::EXCEPT );
  this->m_skev->add ( *new_sock , tmp_checkfor, *this );
  this->m_skev->enableSocket ( sock );
}

int n2nc::Server::onWriteComplete ( n2nc::net::Socket & sock ) {
  std::cerr << "w complete" << std::endl ;
}

int n2nc::Server::onClose ( n2nc::net::Socket & sock ) {
  std::cerr << "onClose" << errno << " from thread: " << sync::Thread::getCurrent().toString() << std::endl ;
  this->m_lock.lock();
  this->delClientInfo(&sock);
  this->m_skev->del ( sock );
  delete &sock ;
  this->m_lock.unlock();
}

int n2nc::Server::onError ( n2nc::net::Socket & sock ) {
  std::cerr << "onError" << errno << std::endl ;
  std::cerr << "onClose" <<  EAGAIN << std::endl ;
}

int n2nc::Server::onRawReceive ( n2nc::net::Socket & sock ) {
  std::cerr << "OnRawReceive" << std::endl ;
}

int n2nc::Server::check_clients_status() {
  m_peers_it_id pit ;
  this->m_lock.lock();
reinithack:
  for (pit = this->m_online_peers_id.begin(); pit != this->m_online_peers_id.end(); pit++ ){
    std::cerr << "check_client_status id: " << std::hex << pit->first << "service address: " << pit->second->getSrvSocketAddr()->toString() << std::endl ;
      if (! pit->second->checkStatus()){
        /* went offline */
        std::cerr << "too idle detected.closing connection " << std::endl ;
        this->onClose(*(pit->second->getCtlSock()));  /* FIXME onClose remove from the list ;)*/
        goto reinithack ;
      }
  }
  this->m_lock.unlock();
}

int n2nc::Server::show_clients(){
  m_peers_it_id pit ;
  this->m_lock.lock();
  for(pit = this->m_online_peers_id.begin(); pit != this->m_online_peers_id.end() ; pit++){
    std::cerr << "peerID: " << std::hex << pit->second->getKeyID() << " service address: " << pit->second->getSrvSocketAddr()->toString() << std::endl ;
  }
  this->m_lock.unlock();

}

int n2nc::Server::sendCommand(enum server_command cmd, net::Socket & sock){
  packet pk ;
  ::bzero(&pk,sizeof(pk));
  pk.cmd = cmd ;
  sock.send(&pk,sizeof(pk));
}

---