n2nc.cpp

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include "n2nc.h"
#include "filter.h"
#include "packetmanager.h"
#include "filteradapter.h"
#include "filters/filterblowfish.h"
#include "utils.h"
#include "libvdeplug_dyn.h"

#include <fstream>

using namespace n2nc;
using namespace std;

namespace n2nc{

struct myconf_t myconf;

int stdinoutAttach(net::Socket *srv_sock, FilterAdapter &fa);
int vdeAttach(net::Socket *srv_sock, FilterAdapter &fa);
int loadArgsHelper(int argc,char **argv);
int passivemode(net::Socket *ctl_sock, net::Socket &srv_sock, FilterAdapter &fa);
int activemode(net::Socket *ctl_sock, net::Socket &srv_sock, FilterAdapter &fa);
int punching(net::Socket &srv_sock);

Server::packet *sendMSG(net::Socket *ctl_sock,Server::server_command cmd) ;
Server::packet *awaitMSG(net::Socket *ctl_sock,Server::server_command cmd, Server::packet *recvpk) ;

Server::packet *sendMSG(net::Socket *ctl_sock,Server::server_command cmd){
  Server::packet pk;
  bzero(&pk,sizeof(pk));
  pk.cmd=cmd ;
  pk.src = myconf.myid ;
  pk.dst = myconf.otherid ;
  ctl_sock->send((void*)&pk,sizeof(pk));
}

Server::packet *awaitMSG(net::Socket *ctl_sock,Server::server_command cmd, Server::packet *recvpk){
  ctl_sock->recv(recvpk,sizeof(Server::packet));
  if (recvpk->cmd == cmd )
    return recvpk;
  else
    return NULL ;
}

int punching(net::Socket &srv_sock){
  bool imreceiving = false;
  bool imsending = false;
  int timeoutcicles = 1000 ;
  struct timespec ts ;
  ts.tv_sec = 0;
  ts.tv_nsec = 10000000L ;  /*10 ms sleep */
  PacketManager::srv_packet_header srv_pk ;
  PacketManager::srv_packet_header srv_pk_recv ;
  
  
  while( (!(imsending && imreceiving)) && --timeoutcicles){
    bzero(&srv_pk,sizeof(srv_pk));
    srv_pk.h_type = PacketManager::SRV_PK_GARBAGE ;
//     sendto(srv_sock.getFD() , &srv_pk, sizeof(srv_pk) , 0, srv_sock.getRemoteSocketAddress()->getRawSockAddr(),srv_sock.getRemoteSocketAddress()->getRawSockAddrLen() ) ;
    srv_sock.send(&srv_pk,sizeof(srv_pk));
    
    if (srv_sock.recvCheck() >= sizeof(srv_pk_recv)){
      /* i've received something */
      srv_sock.recv(&srv_pk_recv,sizeof(srv_pk_recv));
      switch(srv_pk_recv.h_type){
        case PacketManager::SRV_PK_GARBAGE :
          bzero(&srv_pk,sizeof(srv_pk));
          srv_pk.h_type = PacketManager::SRV_PK_GARBAGE_ACK ;
//           sendto(srv_sock.getFD() , &srv_pk, sizeof(srv_pk) , 0, srv_sock.getRemoteSocketAddress()->getRawSockAddr(),srv_sock.getRemoteSocketAddress()->getRawSockAddrLen() ) ;
          srv_sock.send(&srv_pk,sizeof(srv_pk));
          imreceiving = true ;
          std::cerr << "RECEIVED GARBAGE" << std::endl ;
          break ;
        
        case PacketManager::SRV_PK_GARBAGE_ACK :
          imsending = true ;
          std::cerr << "RECEIVED GARBAGE_ACK" << std::endl ;
          break ;
      }
    }
    ::nanosleep(&ts,NULL);
  }
  
  if (!timeoutcicles){
    std::cerr << "timeoutcicles expires"<< std::endl ;
    return 0 ;
  }
  /* flushing garbage data */
  while (srv_sock.recvCheck() > 0 && srv_sock.recv(&srv_pk_recv,sizeof(srv_pk_recv)))
    ;
  return 1 ;
}

int loadArgsHelper(int argc,char **argv){
  utils::args::ArgumentsHelper args(argv, argc) ;
  utils::args::ValidArgument* t_val ;
  string filterdir ;
  string homedir = getenv ("HOME");
  
  t_val = args.addValid("-sport");
  t_val->comment = "server port" ;
  t_val->paramlist_pattern.push_back("d") ; /* integer expected */
  
  t_val = args.addValid("-saddr");
  t_val->comment = "server address" ;
  t_val->paramlist_pattern.push_back("s") ; /* string expected */
  t_val->paramrequired = true ;
  
  t_val = args.addValid("-bindip");
  t_val->comment = "bind service port to ip" ;
  t_val->paramlist_pattern.push_back("s") ; /* string expected */
  t_val->paramrequired = true ;
  
  t_val = args.addValid("-keydir");
  t_val->comment = "rsa key directory" ;
  t_val->paramlist_pattern.push_back("s") ; /* string expected */
  
  t_val = args.addValid("-filterdir");
  t_val->comment = "filter modules directory" ;
  t_val->paramlist_pattern.push_back("s") ; /* string expected */
  t_val->paramrequired = true ;
  
  t_val = args.addValid("-myid");
  t_val->paramlist_pattern.push_back("s") ; /* integer expected */
  t_val->comment = "my id" ;
  
  t_val = args.addValid("-otherid");
  t_val->paramlist_pattern.push_back("s") ; /* integer expected */
  t_val->comment = "endpoint id" ;
  
  t_val = args.addValid("-vdesock");
  t_val->paramlist_pattern.push_back("s") ; /* integer expected */
  t_val->comment = "vde socket control dir" ;
  t_val->defaultparam = "/tmp/vde.ctl/" ;
  
  t_val = args.addValid("-mysrvport");
  t_val->paramlist_pattern.push_back("d") ; /* integer expected */
  t_val->comment = "my service port" ;
  
  t_val = args.addValid("-mtu");
  t_val->paramlist_pattern.push_back("d") ; /* integer expected */
  t_val->comment = "max transfer unit to send" ;
  
  t_val = args.addValid("-mss");
  t_val->paramlist_pattern.push_back("d") ; /* integer expected */
  t_val->comment = "maximum segment size to read" ;
  
  t_val = args.addValid("-p");
  t_val->comment = "passive mode" ;
  
  
  cerr << args.dumpAllValid() ;
  cerr << args.toString() << endl ;
//   cerr << "free arg " << args.getFreeArg(0) << endl ;
  cerr << "valid?: " << args.validate() << endl ;
  
  if (args["-p"]){
    cerr << "passive mode" << endl ;
    myconf.mode_isactive = false ;
  }else{
    cerr << "active mode" << endl ;
    myconf.mode_isactive = true ;
  }

  if (args["-myid"]){
    cerr << args["-myid"]->param() << endl ;
    myconf.myid = utils::stringToHex(args["-myid"]->param() );
  }else{
    /* load default */
    if(myconf.mode_isactive)
      myconf.myid = 1234 ;
    else
      myconf.myid = 4321 ;
  }
  
  if (args["-otherid"]){
    cerr << args["-otherid"]->param() << endl ;
    myconf.otherid = utils::stringToHex(args["-otherid"]->param() );
  }else{
    /* load default */
    if(!myconf.mode_isactive)
      myconf.otherid = 1234 ;
    else
      myconf.otherid = 4321 ;
  }
  
  if (args["-mysrvport"]){
    cerr << args["-mysrvport"]->param() << endl ;
    myconf.mysrvport = atoi (args["-mysrvport"]->param().c_str());
  }else{
    /* load default */
    if(myconf.mode_isactive)
      myconf.mysrvport = 2345 ;
    else
      myconf.mysrvport = 5432 ;
  }
  
  if (args["-sport"]){
    myconf.sport = atoi (args["-sport"]->param().c_str());
  }else{
    myconf.sport = 5555 ;
  }
  
  if (args["-vdesock"]){
    myconf.vdepath = args["-vdesock"]->param();
  }
 
  if (args["-keydir"]){
    myconf.keydir = args["-keydir"]->param();
  }else{
//     myconf.keydir = "keyring" ;
    myconf.keydir = homedir + "/.n2nc/keyring";
  }
  
  if (args["-saddr"]){
    myconf.saddr = args["-saddr"]->param();
  }else{
//     myconf.saddr = "130.136.4.226" ;
    myconf.saddr = "127.0.0.1" ;
  }
  
  if (args["-bindip"]){
    myconf.bind_ip = args["-bindip"]->param();
  }else{
    myconf.bind_ip = "127.0.0.1" ;
//    myconf.bind_ip = "192.168.0.55" ;
  }
  
  if (args["-mtu"]){
    myconf.mss = atoi( args["-mtu"]->param().c_str() );
  }else{
    myconf.mss = 0 ;
  }

  if (args["-filterdir"]){
    filterdir = args["-filterdir"]->param() ;
  }else{
    /* FIXME */
    filterdir = "/home/fab/myproject/n2nc-wc/n2nc/trunk/debug/src/filters/.libs/" ;
//     filterdir = "" ;
  }
  /* read the loadfilters conf file */
  string loadfilterfname = homedir + "/.n2nc/loadfilters" ;
  fstream filestr (loadfilterfname.c_str(), fstream::in);
  if (!filestr.is_open()){
    std::cerr << "WARNING: NO ~/.n2nc/loadfilters file found." << loadfilterfname << std::endl ;
  }
  char plugin_fname[255];
  while(filestr.is_open() && !filestr.eof()){
    filestr.getline(plugin_fname,255);
    if (plugin_fname[0] == '#' || (strlen(plugin_fname) < 1))  continue ;
    myconf.plugins.push_back(filterdir + "/" + plugin_fname);
  }
  
//   myconf.bind_ip = "192.168.0.55" ;
  
  std::cerr << "CONFIGURATION. ID:" << std::hex << myconf.myid << "\tSERVICEPORT: " << myconf.mysrvport << std::endl ;
  std::cerr << "CONFIGURATION. OTHERID:" << std::hex << myconf.otherid << "\tOTHERSERVICEPORT: " << myconf.othersrvport << std::endl ;
}

int passivemode(net::Socket *ctl_sock, net::Socket &srv_sock, FilterAdapter &fa){
  Server::packet pk , recvpk ;
  net::SocketAddress *peer_srv_sa ;
  PacketManager::srv_packet_header srv_pk_recv ;
//   security::BlowFish::key_t skey ;
  
  char ciphertext[128];
  security::Rsa rsa;
  std::ostringstream os ;
  os << myconf.keydir << "/" << std::hex << myconf.myid << ".pri" ;
//   key_fname = myconf.keydir + "/" + myconf.myid ;
  std::cerr << "loading rsa private key: " << os.str() << std::endl ;
  if (rsa.loadPriFromFile(os.str()) == -1){
    cerr << "fatal error on loading private key: " << os.str() << std::endl ;
    exit(1);
  }
//   rsa.loadPriFromFile("keypri");
  
reawait:
  /* await commands from server */
  if (awaitMSG(ctl_sock,Server::CMD_CONNECT,&recvpk))
    std::cerr << "CMD_CONNECT RECEIVED from ID: " << hex << recvpk.src << std::endl ;
  else{
    std::cerr << "SOME COMMAND RECEIVED but not expected. Restart" << std::endl ;
    goto reawait;
  }

  myconf.otherid = recvpk.src ;

  /* handle the connection request, now ask the server the peer's information (endpoint) */
  sendMSG(ctl_sock,Server::CMD_GET_CLIENT_INFO);

  /* await client info reply */
  if (awaitMSG(ctl_sock,Server::CMD_GET_CLIENT_INFO_REPLY,&recvpk))
    std::cerr << "CMD_GET_CLIENT_INFO_REPLY RECEIVED" << std::endl ;
  else{
    std::cerr << "CMD_GET_CLIENT_INFO_REPLY NOT RECEIVED" << std::endl ;
    exit (255);
  }

  if (recvpk.msg == Server::MSG_NOT_FOUND){
    std::cerr << "PEER NOT FOUND: " << hex << myconf.otherid << std::endl ;
    exit (255);
  }else if (recvpk.msg == Server::MSG_OK){
    /* peer not found */
    std::cerr << "PEER FOUND: " << hex << myconf.otherid << std::endl ;
  }

  peer_srv_sa = new net::SocketAddress((struct sockaddr*) &recvpk.srv_addr);
  std::cerr << "other peer has:" << peer_srv_sa->toString()<< std::endl ;

  /* okay, ack the connection request */
  sendMSG(ctl_sock,Server::CMD_CONNECT_ACK);
  std::cerr << "SENDING CMD_CONNECT_ACK to:" << hex << myconf.otherid << std::endl ;
  
  srv_sock.open(*peer_srv_sa);

  if (punching(srv_sock)){
    std::cerr << "connection established successflully" << std::endl ;
  }else{
    std::cerr << "there was a problem to connect" << std::endl ;
    exit (255);
  }

  /* connection established. informing other peer */
  sendMSG(ctl_sock,Server::CMD_CONNECT_OK);
  std::cerr << "SENDING CMD_CONNECT_OK to:" << hex << myconf.otherid << std::endl ;
  
  
  
  /* await CONNECT_OK_ACK reply */
  if (awaitMSG(ctl_sock,Server::CMD_CONNECT_OK_ACK,&recvpk))
    std::cerr << "CMD_CONNECT_OK_ACK RECEIVED" << std::endl ;
  else{
    std::cerr << "CMD_CONNECT_OK_ACK NOT RECEIVED" << std::endl ;
    exit (255);
  }
  
  /* flushing udp incoming garbage message */
  while (srv_sock.recvCheck() > 0 && srv_sock.recv(&srv_pk_recv,sizeof(srv_pk_recv))) ;
  
  
  if (awaitMSG(ctl_sock,Server::CMD_SMSG,&recvpk)){
    rsa.decrypt(recvpk.smsg,ciphertext,128);
    ::memcpy(&myconf.skey,ciphertext,sizeof(myconf.skey));
    std::cerr << "CMD_SMSG RECEIVED. session key: " << ciphertext << std::endl ;
  }
  else{
    std::cerr << "CMD_SMSG NOT RECEIVED" << std::endl ;
    exit (255);
  }

  sendMSG(ctl_sock,Server::CMD_SMSG_ACK);
  std::cerr << "SENDING CMD_SMSG_ACK to:" << hex << myconf.otherid << std::endl ;
  
  if (myconf.vdepath != "")
    vdeAttach(&srv_sock,fa);
  else
    stdinoutAttach(&srv_sock,fa);

  
  
  return 0 ;
}

int activemode(net::Socket *ctl_sock, net::Socket &srv_sock, FilterAdapter &fa){
  bool imreceiving = false;
  bool imsending = false;
  Server::packet pk , recvpk ;
  net::SocketAddress *peer_srv_sa ;
  PacketManager::srv_packet_header srv_pk ;  /* service packet header */
  PacketManager::srv_packet_header srv_pk_recv ;
//   security::BlowFish::key_t skey ;
  
  char ciphertext[128];
  security::Rsa rsa;
  std::ostringstream os ;
  os << myconf.keydir << "/" << hex << myconf.otherid << ".pub" ;
  std::cerr << "loading rsa public key of other peer: " << os.str() << std::endl ;
  if (rsa.loadPubFromFile(os.str()) == -1){
    exit(1);
  }
//   rsa.loadPubFromFile("keypub");


  sendMSG(ctl_sock,Server::CMD_GET_CLIENT_INFO);
  
  /* await client info reply */
  if (awaitMSG(ctl_sock,Server::CMD_GET_CLIENT_INFO_REPLY,&recvpk))
    std::cerr << "CMD_GET_CLIENT_INFO_REPLY RECEIVED" << std::endl ;
  else{
    std::cerr << "CMD_GET_CLIENT_INFO_REPLY NOT RECEIVED" << std::endl ;
    exit(1);
  }
  
  if (recvpk.msg == Server::MSG_NOT_FOUND){
    /* peer not found */
    std::cerr << "PEER NOT FOUND: " << hex << myconf.otherid << std::endl ;
    exit (255);
  }
  peer_srv_sa = new net::SocketAddress((struct sockaddr*) &recvpk.srv_addr);
  std::cerr << "loading sa. other peer has:" << peer_srv_sa->toString()<< std::endl ;


  /* connect my service port (UDP) to external endpoint */
  srv_sock.open(*peer_srv_sa);
  
  /* tell the server that i wanna connect to peer */
  sendMSG(ctl_sock,Server::CMD_CONNECT);

  if (awaitMSG(ctl_sock,Server::CMD_CONNECT_ACK,&recvpk))
    std::cerr << "CMD_CONNECT_ACK RECEIVED, starting garbaging data" << std::endl ;
  else{
    std::cerr << "CMD_CONNECT_ACK NOT RECEIVED" << std::endl ;
    exit (255);
  }

  if (punching(srv_sock)){
    std::cerr << "connection established successflully" << std::endl ;
  }else{
    std::cerr << "connection failure" << std::endl ;
    exit (255);
  }

  /* connection established. attach std in/out */
  
  /* await CONNECT_OK reply */
  if (awaitMSG(ctl_sock,Server::CMD_CONNECT_OK,&recvpk))
    std::cerr << "CMD_CONNECT_OK RECEIVED" << std::endl ;
  else{
    std::cerr << "CMD_CONNECT_OK NOT RECEIVED" << std::endl ;
    exit (255);
  }
  
  sendMSG(ctl_sock,Server::CMD_CONNECT_OK_ACK);
  /* flushing udp incoming garbage message */
  while (srv_sock.recvCheck() > 0 && srv_sock.recv(&srv_pk_recv,sizeof(srv_pk_recv))) ;
  /* create a session key */
  security::BlowFish::keyRand(&myconf.skey);
  std::cerr << "creating random session key: " << myconf.skey.key << std::endl ;
  std::cerr << "encrypt smsg len: " << rsa.encrypt((void*)&myconf.skey,ciphertext,sizeof(myconf.skey)) << std::endl ;
  
  bzero(&pk,sizeof(pk));
  pk.cmd=Server::CMD_SMSG ;
  pk.src = myconf.myid ;
  pk.dst = myconf.otherid ;
  memcpy(pk.smsg,ciphertext,128);
//   strcpy(pk.smsg,ciphertext);
  ctl_sock->send((void*)&pk,sizeof(pk));
  
  if (awaitMSG(ctl_sock,Server::CMD_SMSG_ACK,&recvpk))
    std::cerr << "CMD_SMSG_ACK RECEIVED" << std::endl ;
  else{
    std::cerr << "CMD_SMSG_ACK NOT RECEIVED" << std::endl ;
    exit (255);
  }
  
  if (myconf.vdepath != "")
    vdeAttach(&srv_sock,fa);
  else
    stdinoutAttach(&srv_sock,fa);

}

int stdinoutAttach(net::Socket *srv_sock, FilterAdapter &fa){
  void *stdinbuf = malloc(65535);
  void *buf = malloc(65535);
//   void *buf2 = malloc(65535);
  int inlen =0 ;
  fd_set readfds ;
  int maxfd , sent, mss;
  PacketManager::srv_packet_header pk ,recvpk;
//   n2nc::security::BlowFish::key_t key /*{0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15}*/ ;
//   strncpy((char*)key.key,"0123456789012345",16) ;
  
  /* *************************** loading filters ************************* */
//   std::vector<std::string>::iterator fit;
//   DIR *filterdir ;
//   Filter *f;
//   struct dirent *direntry ;
//   PacketManager pkm(srv_sock) ;
//   FilterAdapter fa(pkm);
//   /* load filters */
//   for (fit = myconf.plugins.begin() ; fit != myconf.plugins.end(); fit++){
//     f = Filter::load_filter(*fit);
//     if (!f) continue ;
//     f->setPKM(&pkm);
//     f->setSessionKey(&myconf.skey);
//     fa.addFilter(f);
//   }
//   
//   /* computing the maximun packet size to read */
  mss = MAX_MSS - sizeof(PacketManager::srv_packet_header_t) - fa.getMaxOverHead() ;
  mss = (myconf.mss ? myconf.mss : mss) ;
//   std::cerr << dec << "MSS, MPS: " << MAX_MSS << ", " << mss << std::endl ; 
  
  /* await readability from stdin and from srv_sock */
  FD_ZERO(&readfds);
  FD_SET(0,&readfds);
  FD_SET(srv_sock->getFD(),&readfds);
  maxfd = srv_sock->getFD() ;  /* obviously */
  long long tread = 0;
  struct timeval tv,tv2;
  

  while (true){
    FD_ZERO(&readfds);
    FD_SET(0,&readfds);
    FD_SET(srv_sock->getFD(),&readfds);
    if ( ::select(maxfd+1,&readfds, NULL, NULL, NULL) < 0) {
      std::cerr << "problem with select" << ::strerror(errno) << std::endl ;
    }
    if (FD_ISSET(0,&readfds)){
      inlen = ::read(0,stdinbuf,mss );  /* MSS */
      std::cerr << "**STD <<<<<<<<< STDIN LEN: " << dec << inlen << std::endl ;
      if (inlen < 0){
        std::cerr << "** >>>>>>>>>> STD_READ.MAIN::STDIN.INLEN -1 " << std::endl ;
        continue ;
      }
      if(inlen > MAX_MPS){
        std::cerr << "** >>>>>>>>>> STD_READ.MAIN::STDIN. len exceed mps: " << dec<< inlen << std::endl ;
      }
      
      tread += inlen ;
      sent = fa.send(stdinbuf,inlen);
      std::cerr << "**STD >>>>>>>>>> NETWRITE LEN: " << dec << sent << std::endl ;
      std::cerr << std::endl ;

      if (!inlen){std::cerr << "reading from stdin 0 byte, sent EOF" << std::endl; }
    }
    if (FD_ISSET(srv_sock->getFD(),&readfds)){
      inlen = fa.recv(buf,MAX_MSS);
      std::cerr << "** <<<<<<<<< SOCK READ LEN: " << dec<< inlen << std::endl ;
      std::cerr << std::endl ;
      if (inlen < 0)  continue ;
      ::write(1,buf,inlen);

      if(!inlen){std::cerr << "MAIN::new_read EOF" << std::endl ; exit(0);}
    }
    ::fflush(NULL);
  }
  ::free(stdinbuf);

}

int vdeAttach(net::Socket *srv_sock, FilterAdapter &fa){
  void *stdinbuf = malloc(65535);
  void *buf = malloc(65535);
//   void *buf2 = malloc(65535);
  int inlen =0 ;
  fd_set readfds ;
  int maxfd , sent,mss;
  PacketManager::srv_packet_header pk ,recvpk;
  void *vh;
  struct vdepluglib vdeplug ;
  libvdeplug_dynopen(vdeplug);
  std::cerr << "loading vdeplug library: " << (vdeplug.dl_handle == NULL ? "problem" : "OK") << std::endl ;
  vde_open_args vdearg;  vdearg.group=NULL ; vdearg.mode=0700, vdearg.port=0 ;
  VDECONN *vdec ;
  vdec = vdeplug.vde_open(myconf.vdepath.c_str(),"n2nc",&vdearg);
  int fdplug = vdeplug.vde_datafd(vdec);
//   /* computing the maximun packet size to read */
  mss = MAX_MSS - sizeof(PacketManager::srv_packet_header_t) - fa.getMaxOverHead() ;
  mss = (myconf.mss ? myconf.mss : mss) ;
  /* await readability from vdefd and from srv_sock */
  maxfd = srv_sock->getFD() > fdplug ? srv_sock->getFD() : fdplug ;
  long long tread = 0;
  struct timeval tv,tv2;

  while (true){
    FD_ZERO(&readfds);
    FD_SET(fdplug,&readfds);
    FD_SET(srv_sock->getFD(),&readfds);
    if ( ::select(maxfd+1,&readfds, NULL, NULL, NULL) < 0) {
      std::cerr << "problem with select" << ::strerror(errno) << std::endl ;
    }
    if (FD_ISSET(fdplug,&readfds)){
      inlen = vdeplug.vde_recv(vdec,stdinbuf,mss,0);
//       inlen = vdeplug.vde_recv(vdec,stdinbuf,2000,0);

      if (inlen < 0){
        std::cerr << "** >>>>>>>>>> STD_READ.MAIN::STDIN.INLEN -1 " << std::endl ;
        continue ;
      }
      if(inlen > MAX_MPS){
        std::cerr << "** >>>>>>>>>> STD_READ.MAIN::STDIN. len exceed mps: " << dec << inlen << std::endl ;
      }
      
      sent = fa.send(stdinbuf,inlen);
      std::cerr << "PLUG >> NET . read: " << dec <<inlen << " written: " << sent << std::endl ;

      if (!inlen){std::cerr << "reading from stdin 0 byte, sent EOF" << std::endl; }
    }
    if (FD_ISSET(srv_sock->getFD(),&readfds)){
      inlen = fa.recv(buf,MAX_MSS);
      if (inlen < 0){
        std::cerr << "MAIN RECV ERROR" << std::endl ;
        continue ;
      }
      sent = vdeplug.vde_send(vdec,buf,inlen,0);
      std::cerr << "NET >>> PLUG . read: " << dec  << inlen << " written: " << sent << std::endl ;

      if(!inlen){std::cerr << "MAIN::read EOF" << std::endl ; exit(0);}
    }
//     ::fflush(NULL);
  }
  ::free(stdinbuf);

}

}

int main(int argc, char *argv[]){
  net::TcpSocket *ctl_sock ;  /* control socket */
  Server::packet pk , recvpk ;
  n2nc::sync::Thread::init();
  loadArgsHelper(argc,argv);
  net::SocketAddress  *srv_sa ; /* local service sockaddr */
  net::UdpSocket      srv_sock(AF_INET) ;  /*local service socket */
  net::SocketAddress  *server_sa ; /* server sockaddr */
  int retval, mss ;
  std::vector<std::string>::iterator fit;
  Filter *f;
  
//   server_sa = net::Resolver::getSocketAddressByService ( myconf.saddr, myconf.sport, SOCK_STREAM, AF_INET, true ) ;
  server_sa = net::Resolver::getSocketAddressByService ( myconf.saddr, myconf.sport, SOCK_STREAM, 0, true ) ;
  srv_sa = net::Resolver::getSocketAddressByService ( myconf.bind_ip, myconf.mysrvport, SOCK_DGRAM, AF_INET, false ) ;
//   srv_sa = net::Resolver::getSocketAddressByService ( "any", myconf.mysrvport, SOCK_DGRAM, AF_INET, false ) ;
  
  /* bind the service port */
  retval = srv_sock.bind(*srv_sa);
  
  /* loading plugins */
  PacketManager pkm(&srv_sock) ;
  FilterAdapter fa(pkm);
  /* load filters */
  for (fit = myconf.plugins.begin() ; fit != myconf.plugins.end(); fit++){
    f = Filter::load_filter(*fit);
    if (!f) continue ;
    f->setPKM(&pkm);
    f->setSessionKey(&myconf.skey);
    fa.addFilter(f);
  }
  
  /* computing the maximun packet size to read */
  mss = MAX_MSS - sizeof(PacketManager::srv_packet_header_t) - fa.getMaxOverHead() ;
  mss = (myconf.mss ? myconf.mss : mss) ;
  std::cerr << dec << "MSS, MPS: " << MAX_MSS << ", " << mss << std::endl ;   
  
  
  /* open a connection to server */
  ctl_sock = new net::TcpSocket(server_sa->getAddressFamily());
  retval = ctl_sock->open(*server_sa);
  if (retval < 0){
    std::cerr << "Problem connecting to server" << std::endl ;
    exit(1);
  }
  
  /* register within the server */
  pk.cmd = Server::CMD_REGISTER ;
  pk.src = myconf.myid ; /* id */
  pk.src_port = myconf.mysrvport ;  /* transport port */
  ctl_sock->send((void*)&pk,sizeof(pk));
  /* await ack */
  awaitMSG(ctl_sock,Server::CMD_REGISTER_ACK,&recvpk);
//   ctl_sock->recv(&recvpk,sizeof(recvpk));
  if (recvpk.cmd == Server::CMD_REGISTER_ACK && recvpk.msg == Server::MSG_OK){
    std::cerr << "REGISTERED SUCCESFULLY" << std::endl ;
  }else if(recvpk.msg == Server::MSG_ALREADY_REGISTERED){
    std::cerr << "ALREADY REGISTERED" << std::endl ;
    exit(1);
  }

  /* okay peer is registered */
  if (myconf.mode_isactive)
    activemode(ctl_sock,srv_sock,fa);
  else
    passivemode(ctl_sock,srv_sock,fa);

  return EXIT_SUCCESS;
}

---