server.h

#ifndef N2NC_SERVER_H
#define N2NC_SERVER_H

#include "nixsys.h"
#include "socket.h"
#include "tcpsocket.h"
#include "resolver.h"
#include "socketevents.h"
#include "socketeventshandler.h"
#include "clientinfo.h"
#include "mutex.h"
#include "socketaddress.h"

using namespace n2nc ;
namespace n2nc {

class Server : n2nc::net::SocketEvents{
  public:
    Server();
    ~Server();
    int listen(int port);
    int shutdown(std::string message);
    
    int check_clients_status();
  
    int show_clients();

    enum server_command{
      CMD_REGISTER,
      CMD_REGISTER_ACK,
      CMD_PING ,
      CMD_LEAVE,
      CMD_GET_CLIENT_INFO,
      CMD_GET_CLIENT_INFO_REPLY,
      CMD_CONNECT,
      CMD_CONNECT_ACK,
      CMD_CONNECT_OK,
      CMD_CONNECT_OK_ACK,
      CMD_SMSG, /* secured message (rsa encrypted) */
      CMD_SMSG_ACK, /* secured message (rsa encrypted) */
      CMD_DISCONNECT
    };
    
    enum server_messages{
      MSG_OK = 0,
      MSG_ALREADY_REGISTERED ,
      MSG_NOT_FOUND,
    };
//     typedef 
    
    int sendCommand(enum server_command cmd, net::Socket& sock);

/* packet structure */
    
    struct packet{
      enum server_command               cmd ;
      n2nc::ClientInfo::ClientID        src ;
      n2nc::ClientInfo::ClientID        dst ;
      uint16_t                          src_port ;
      uint16_t                          dst_port ;
      n2nc::net::SocketAddress::Storage srv_addr ;
      n2nc::net::SocketAddress::Storage dst_addr ;
      uint16_t                          msg ;
      char                              smsg[128] ;
    };
//typedef struct packet packet ;
    
  private:
//     std::map<n2nc::security::RSAKey::ID,n2nc::ClientInfo> m_online_peers;
    
/*    int deliver()*/
//     std::map<n2nc::net::Socket*,n2nc::ClientInfo*> m_online_peers;
    /* map iterator */
    typedef std::map<n2nc::net::Socket*,n2nc::ClientInfo*>::iterator m_peers_it ;
    n2nc::net::TcpSocket *m_sock ;
    n2nc::net::SocketEventsHandler* m_skev ;
    n2nc::sync::Mutex m_lock ;
    
    /* new associative storage. i need to retrieve clientinfo from its own id, 
    and from ots own socket, this way i need to guarantee data reilability
    socket --> ClientInfo
    id --> ClientInfo
    */
    ClientInfo *getClientInfo(net::Socket* sock=NULL, ClientInfo::ClientID id=0);
    ClientInfo *newClientInfo(net::Socket* sock, ClientInfo::ClientID);
    int         delClientInfo(ClientInfo::ClientID id);
    int         delClientInfo(net::Socket* sock);
    
//     std::map<net::Socket*,ClientInfo*>          m_online_peers_sk;
    std::map<ClientInfo::ClientID,ClientInfo*>  m_online_peers_id;
    /* map iterator */
    typedef std::map<net::Socket*,ClientInfo*>::iterator          m_peers_it_sk ;
    typedef std::map<ClientInfo::ClientID,ClientInfo*>::iterator  m_peers_it_id ;
    
    virtual int onReceive(n2nc::net::Socket& sock,int dtlen);
    virtual int onNewConnection(n2nc::net::Socket& sock);
    virtual int onWriteComplete(n2nc::net::Socket& sock);
    virtual int onClose(n2nc::net::Socket& sock);
    virtual int onError(n2nc::net::Socket& sock);
    virtual int onRawReceive(n2nc::net::Socket& sock);

//     std::map<n2nc::security::RSAKey,>




};

/*

  ** CMD_REGISTER (client only) **
    src is filled to own RSA key ID.
    src_port need to be the service port.
    returns CMD_REGISTER_ACK on success.

  ** CMD_PING (server only) **
    returns nothing.

  ** CMD_GET_CLIENT_INFO (client only) **
    dst needs to be the RSA key ID of the peer to be contacted.
    returns CMD_GET_CLIENT_INFO_REPLY

  ** CMD_GET_CLIENT_INFO_REPLY (server only) **
    dst needs to be the RSA key ID of the peer to be contacted.
    srv_addr, the service address requested

    returns dst_addr or 0 filled if the client doesn't match

  ** CMD_CONNECT  (client) **
    src, the my RSA key ID
    dst, the RSA key ID of peer to be contacted
    return CMD_CONNECT_REPLY

  ** CMD_CONNECT  (server to client) **
    src, the my RSA key ID
    dst, the RSA key ID of peer to be contacted
    return CMD_CONNECT_ACK

  ** CMD_CONNECT_ACK  (server to client) **
    src, the my RSA key ID
    dst, the RSA key ID of peer to be contacted
    return CMD_CONNECT_REPLY

*/
}
#endif

---