tagging ychat-0.8.0ychat-0.8.0

4 files changed, 480 insertions, 276 deletions

diff --git a/src/sock/sock.cpp b/src/sock/sock.cpp
index 2964160..9d673ef 100755
--- a/src/sock/sock.cpp
+++ b/src/sock/sock.cpp
@@ -5,296 +5,526 @@
 #include <errno.h>
 #include <sys/types.h>
 #include <unistd.h>
+
 #include "sock.h"
-#include "../chat/chat.h"
-#include "../chat/user.h"
 
 using namespace std;
 
 sock::sock()
 {
-    this->b_run      = true;
-    this->i_req      = 0;
-    this->i_threads  = 0;
-    this->req_parser = new reqp();
-    this->thrd_pool  = new pool();
+  this->b_run      = true;
+  this->i_req      = 0;
+  this->req_parser = new reqp();
 #ifdef LOGGING
-    this->log_daemon = new logd( wrap::CONF->get_elem( "httpd.logging.accessfile" ),
 
-                                 wrap::CONF->get_elem( "httpd.logging.accesslines" ) );
+  this->log_daemon = new logd( wrap::CONF->get_elem( "httpd.logging.accessfile" ),
+
+                               wrap::CONF->get_elem( "httpd.logging.access_lines" ) );
 #endif
 }
 
-sock::~sock()
+int
+sock::_send(socketcontainer *p_sock, const char *sz, int len)
+{
+
+  return send( p_sock->i_sock, sz, len, 0 );
+}
+
+int
+sock::_read(socketcontainer *p_sock,  char *sz, int len)
+{
+
+  return read( p_sock->i_sock, sz, len );
+}
+
+int
+sock::_close(socketcontainer *p_sock)
 {
+  shutdown( p_sock->i_sock, 2 );
+  close   ( p_sock->i_sock    );
+  delete p_sock;
 }
 
 //<<*
 void
-sock::chat_stream( int i_sock, user *p_user, hashmap<string> &map_params )
+sock::chat_stream( socketcontainer *p_sock, user *p_user, map<string,string> &map_params )
 {
-    string s_msg( "\n" );
+  string s_msg( "\n" );
 
-    for ( int i = 0; i < PUSHSTR; i++ )
-     send( i_sock, s_msg.c_str(), s_msg.size(), 0 );
+  for ( int i = 0; i < PUSHSTR; i++ )
+    _send(p_sock,s_msg.c_str(), s_msg.size());
 
-    pthread_mutex_t mutex;
-    pthread_mutex_init( &mutex, NULL ); 
-    pthread_mutex_lock( &mutex );
+  pthread_mutex_t mutex;
+  pthread_mutex_init( &mutex, NULL );
+  pthread_mutex_lock( &mutex );
 
-    do
+  do
+  {
+    s_msg = p_user->get_mess( );
+
+    if ( 0 > _send( p_sock, s_msg.c_str(), s_msg.size() ) )
     {
-        s_msg = p_user->get_mess( );
+      p_user->set_online( false );
+      break;
+    }
 
-        if ( 0 > send( i_sock, s_msg.c_str(), s_msg.size(), 0 ) )
-	{
-            p_user->set_online( false );
-	    break;
-	}
+    pthread_cond_wait( &(p_user->cond_message), &mutex );
+  }
+  while( p_user->get_online() );
 
-        pthread_cond_wait( &(p_user->cond_message), &mutex );
-    }
-    while( p_user->get_online() );
+  pthread_mutex_destroy( &mutex );
 
-    pthread_mutex_destroy( &mutex );
- 
-    // if there is still a message to send:
-    s_msg = p_user->get_mess( );
+  // if there is still a message to send:
+  s_msg = p_user->get_mess( );
 
-    if ( ! s_msg.empty() )
-        send( i_sock, s_msg.c_str(), s_msg.size(), 0 );
+  if ( ! s_msg.empty() )
+    _send( p_sock, s_msg.c_str(), s_msg.size());
 
-    // remove the user from its room.
-    string s_user( p_user->get_name() );
-    string s_user_lowercase( p_user->get_lowercase_name() );
+  // remove the user from its room.
+  string s_user( p_user->get_name() );
+  string s_user_lowercase( p_user->get_lowercase_name() );
 
-    p_user->get_room()->del_elem( s_user_lowercase );
+  p_user->get_room()->del_elem( s_user_lowercase );
 
-    // post the room that the user has left the chat.
-    s_msg = wrap::TIMR->get_time() + " " 
+  // post the room that the user has left the chat.
+  s_msg = wrap::TIMR->get_time() + " "
           + p_user->get_colored_bold_name()
           + wrap::CONF->get_elem( "chat.msgs.userleaveschat" )
           + "<br>\n";
 
-    p_user->get_room()->msg_post( &s_msg );
-    p_user->get_room()->reload_onlineframe();
+  p_user->get_room()->msg_post( &s_msg );
+  p_user->get_room()->reload_onlineframe();
 
 #ifdef VERBOSE
-    cout << REMUSER << s_user << endl;
+
+  cout << REMUSER << s_user << endl;
 #endif
 
-    wrap::GCOL->add_user_to_garbage( p_user );
+  wrap::GCOL->add_user_to_garbage( p_user );
 }
 //*>>
 
 int
-sock::make_server_socket( int i_port )
+sock::_make_server_socket( int i_port )
 {
-    size_t i_sock;
-    struct sockaddr_in name;
+  size_t i_sock;
+  struct sockaddr_in name;
 
-    // create the server socket.
-    i_sock = socket (PF_INET, SOCK_STREAM, 0);
-    if (i_sock < 0)
-    {
-        wrap::system_message( SOCKERR );
+  // create the server socket.
+  i_sock = socket (PF_INET, SOCK_STREAM, 0);
+  if (i_sock < 0)
+  {
+    wrap::system_message( SOCKERR );
 
-        if ( ++i_port > MAXPORT )
-            exit(1);
+    if ( ++i_port > MAXPORT )
+      exit(1);
 
-        wrap::system_message( SOCKERR );
+    wrap::system_message( SOCKERR );
 
-        return make_server_socket( i_port );
-    }
+    return _make_server_socket( i_port );
+  }
 
-    // give the server socket a name.
-    name.sin_family = AF_INET;
-    name.sin_port = htons(i_port);
-    name.sin_addr.s_addr = htonl(INADDR_ANY);
-    int i_optval = 1;
+  // give the server socket a name.
+  name.sin_family = AF_INET;
+  name.sin_port = htons(i_port);
+  name.sin_addr.s_addr = htonl(INADDR_ANY);
+  int i_optval = 1;
 
-    setsockopt( i_sock, SOL_SOCKET, SO_REUSEADDR, (char*)&i_optval, sizeof(int) );
+  setsockopt( i_sock, SOL_SOCKET, SO_REUSEADDR, (char*)&i_optval, sizeof(int) );
 
-    if ( bind(i_sock, (struct sockaddr *) &name, sizeof (name)) < 0 )
-    {
+  if ( bind(i_sock, (struct sockaddr *) &name, sizeof (name)) < 0 )
+  {
 
-     wrap::system_message( BINDERR );
+    wrap::system_message( BINDERR );
 
-        if ( ++i_port > MAXPORT )
-            exit(1);
+    if ( ++i_port > MAXPORT )
+      exit(1);
 
-        wrap::system_message( string(SOCKERR) + tool::int2string(i_port) );
+    wrap::system_message( string(SOCKERR) + tool::int2string(i_port) );
 
-        // Rerun recursive.
-        return make_server_socket( i_port );
-    }
+    // Rerun recursive.
+    return _make_server_socket( i_port );
+  }
 
-    wrap::system_message( SOCKCRT + string("localhost:") + tool::int2string(i_port) );
+  wrap::system_message( SOCKCRT + string("localhost:") + tool::int2string(i_port) );
 
-#ifdef NCURSES
-    mvprintw( NCUR_PORT_X,NCUR_PORT_Y, "Port: %d ", i_port);
-    refresh();
-#endif
+  i_server_port = i_port;
+  i_server_sock = i_sock;
 
-    return i_sock;
+  return i_sock;
 }
 
+string
+sock::read_http_line(socketcontainer *p_sock)
+{
+  string s_line;
+  int i_total = 0;
+  int i_read = 0;
+  char ch;
+
+  do
+  {
+    i_read = _read(p_sock, &ch, sizeof(ch));
+
+    if(i_read <= 0)
+      return "";
+
+    s_line += ch;
+    i_total++;
+  }
+  while((ch != '\n') && i_total < MAXLENGTH);
+
+  if(ch != '\n')
+    /*
+    **  the games people play
+    */
+    return "";
+
+  return s_line;
+}
 int
-sock::read_write( int* p_sock )
+sock::read_http(socketcontainer *p_sock, char *c_zbuf, int i_buflen, int &i_postpayloadoffset)
 {
-    int i_sock = *p_sock; 	
-    char c_req[READSOCK];
-    int i_bytes = read(i_sock, c_req, READSOCK);
+  /*
+  **  1)  Read the first line
+  **  2)  If GET, handle as such
+  **  3)  If POST, handle as such
+  */
+  char ch;
+  int i_read;
+  int i_ret = -1;
+  int x,z;
+
+  string s_content_length;
+  string s_cl;
+  string s_post_return;
+  string s_line = read_http_line(p_sock);
+
+  i_postpayloadoffset = 0;
+  if(s_line.length() <= 0)
+    return -1;
+
+  /*
+  **  GET yada\r\n Followed by stuff we don't care about :) heh.
+  **  01234
+  */
+  /*
+  **  POST yada\r\n
+  **  xxxxx
+  **  Content-Length: NNN\n
+  **  \n
+  */
+  if(s_line.substr(0,3) == "GET")
+  {
+    if(s_line.length() > i_buflen)
+    {
+      /*
+      **  Buffer overflow
+      */
+      return -1;
+    }
+    else
+    {
+      memcpy(c_zbuf,s_line.c_str(),s_line.length());
+      return s_line.length();
+    }
+  }
+
+  else
+  {
+    /*
+    **  POST yada
+    **  01234
+    */
+    if(s_line.substr(0,4) != "POST")
+      return -1;
+
+    /*
+    **  Get us to the Content-Length:
+    */
+    s_post_return += s_line;
+    i_postpayloadoffset += s_line.length();
+
+    for(x=0 ;x < MAXLINES; x++)
+    {
+      s_line = read_http_line(p_sock);
+      s_post_return += s_line;
+      i_postpayloadoffset += s_line.length();
+
+      if (s_line.compare(0, 15, "Content-Length:"))
+        continue;
+
+      // Match found on Content-Length:...  process, and then break out and get us to the promised land
+      s_content_length = s_line.substr( 16 /*strlen("Content-Length: ")*/, 
+		s_line.length() - 16 /*strlen("Content-Length: ")*/);
+
+      /*
+      **  Content-Length: 333\n
+      **  0123456789abcdefghijklmnopqrstuvwxyzAB
+      */
+
+      z = 0;
+
+      do
+      {
+        ch = s_content_length[z];
+        if(isdigit(ch))
+          s_cl += ch;
 
-    if (i_bytes <= 0)
+        z++;
+        
+      }
+      while(ch != '\n');
+
+      break;
+    }
+
+    if(s_cl.length() <= 0)
+      return -1;
+
+    z = atoi(s_cl.c_str());
+
+    /*
+    **  If we are going to overflow the buffer just by the payload, leave
+    **  of, if z did not convert correctly. (should have been ok by isdigit)
+    */
+    if(z > i_buflen || z < 0)
+      return -1;
+
+    /*
+    **  We have MAXLINES to get to the blank line separating POST data.
+    */
+    for(x=0 ;x < MAXLINES; x++)
     {
-     wrap::system_message( READERR );
+      s_line = read_http_line(p_sock);
+      s_post_return += s_line;
+
+      i_postpayloadoffset += s_line.length();
+      if(s_line == "\r\n")
+        break;
     }
 
-    else
+    /*
+    **  funny business
+    */
+    if(x == MAXLINES)
+      return -1;
+
+    for(x=0; x < z; x++)
     {
-        // stores the request params.
-        hashmap<string> map_params;
+      if(_read(p_sock,&ch,sizeof(ch)) != 1)
+        return -1;
+
+      s_post_return += ch;
+    }
 
-        // get the s_rep ( s_html response which will be send imediatly to the client
-        struct sockaddr_in client;
-        size_t size = sizeof(client);
+    if(s_post_return.length() > i_buflen)
+      return -1;
 
-#ifdef CYGWIN
-        getpeername( i_sock, (struct sockaddr *)&client, (int*)&size);
-#else
-        getpeername( i_sock, (struct sockaddr *)&client, &size);
-#endif
+    memcpy(c_zbuf,s_post_return.c_str(),s_post_return.length());
+    return s_post_return.length();
+  }
+}
 
-        map_params["REMOTE_ADDR"] = inet_ntoa(client.sin_addr);
-        //map_params["REMOTE_PORT"] = ntohs(client.sin_port);
+int
+sock::read_write(socketcontainer* p_sock)
+{
+  int i_postpayloadoffset;
+  int i_sock = p_sock->i_sock;
+
+  char c_req[READSOCK];
+
+  memset(c_req,0,sizeof(c_req));
+
+  int i_bytes = read_http(p_sock, c_req, READSOCK-1,i_postpayloadoffset);
+
+  if (i_bytes <= 0)
+  {
+    wrap::system_message( READERR );
+  }
+
+  else
+  {
+    // stores the request params.
+    map<string,string> map_params;
 
-        string s_rep = req_parser->parse( i_sock, string( c_req ), map_params );
+    // get the s_rep ( s_html response which will be send imediatly to the client
+    struct sockaddr_in client;
+    size_t size = sizeof(client);
+
+    getpeername(i_sock, (struct sockaddr *)&client, &size);
+
+    uint32_t &s_addr = client.sin_addr.s_addr;
+    if ( (map_params["REMOTE_ADDR"] = get_elem(s_addr)) == "" )
+    {
+      map_params["REMOTE_ADDR"] = string(inet_ntoa(client.sin_addr));
+      set_elem(map_params["REMOTE_ADDR"], s_addr);
+      wrap::system_message(SOCKCAC+map_params["REMOTE_ADDR"]);
+    }
+
+    string s_rep = req_parser->parse(p_sock, string(c_req), map_params, i_postpayloadoffset);
 
 #ifdef LOGGING
-        log_daemon->log_access(map_params);
+
+    log_daemon->log_access(map_params);
 #endif
 
-        // send s_rep to the client.
-        send(i_sock, s_rep.c_str(), s_rep.size(), 0);
+    // send s_rep to the client.
+    _send(p_sock, s_rep.c_str(), s_rep.size());
 
-        // dont need those vals anymore.
-        map_params.clear();
+    // dont need those vals anymore.
+    map_params.clear();
 
-	shutdown( i_sock, 2 );
-	close   ( i_sock    );
+    _close(p_sock);
+    return 0;
+  }
 
-        return 0;
-    }
+  _close(p_sock);
+  return 1;
+}
 
-    shutdown( i_sock, 2 );
-    close   ( i_sock    );
+void
+sock::_main_loop_init()
+{
+  wrap::system_message(SOCKUNS);
+}
 
-    return 1;
+#ifdef OPENSSL
+// This method is virtual, and is overloaded by sslsock!
+bool
+sock::_main_loop_do_ssl_stuff(int &i_new_sock)
+{
+  return 0;
+}
+#endif
+
+socketcontainer*
+sock::_create_container(int &i_sock)
+{
+  socketcontainer* p_sock = new socketcontainer;
+  p_sock->i_sock = i_sock;
+  return p_sock;
 }
 
 int
 sock::start()
 {
-    wrap::system_message( SOCKSRV );
+  wrap::system_message( SOCKSRV );
+  pool* p_pool = wrap::POOL;
+  int i_sock = i_server_sock;
 
 #ifdef NCURSES
-    print_hits();
-    thrd_pool->print_pool_size();
+
+  print_hits();
+  p_pool->print_pool_size();
 #endif
 
-    int i_port = tool::string2int( wrap::CONF->get_elem( "httpd.serverport" ) );
-    int i_sock, i;
-    fd_set active_fd_set, read_fd_set;
-    struct sockaddr_in clientname;
-    size_t size;
+  int i_port = tool::string2int( wrap::CONF->get_elem( "httpd.serverport" ) );
+  _main_loop_init();
+
+  int i;
+  fd_set active_fd_set, read_fd_set;
+  struct sockaddr_in clientname;
+  size_t size;
+
+  if (listen (i_sock, 1) < 0)
+  {
+    wrap::system_message( LISTERR );
+    exit( EXIT_FAILURE );
+  }
 
+  wrap::system_message( SOCKRDY );
 
-    // create the server socket and set it up to accept connections.
-    i_sock = make_server_socket ( i_port );
+  // initialize the set of active sockets.
+  FD_ZERO (&active_fd_set);
+  FD_SET  (i_sock, &active_fd_set);
 
-    if (listen (i_sock, 1) < 0)
+  while( b_run )
+  {
+    // block until input arrives on one or more active sockets.
+    read_fd_set = active_fd_set;
+    if (select (FD_SETSIZE, &read_fd_set, NULL, NULL, NULL) < 0)
     {
-      wrap::system_message( LISTERR );
+      wrap::system_message( SELCERR );
+
       exit( EXIT_FAILURE );
     }
 
-    wrap::system_message( SOCKRDY );
+    // service all the sockets with input pending.
+    for ( i = 0; i < FD_SETSIZE; i++ )
+      if ( FD_ISSET (i, &read_fd_set) )
+      {
+        if ( i == i_sock )
+        {
+          // connection request on original socket.
+          ++i_req;
 
-    // initialize the set of active sockets.
-    FD_ZERO (&active_fd_set);
-    FD_SET  (i_sock, &active_fd_set);
+#ifdef NCURSES
 
-    while( b_run )
-    {
-        // block until input arrives on one or more active sockets.
-        read_fd_set = active_fd_set;
-        if (select (FD_SETSIZE, &read_fd_set, NULL, NULL, NULL) < 0)
-        {
-         wrap::system_message( SELCERR );
+          print_hits();
+#endif
 
-         exit( EXIT_FAILURE );
-        }
+          int i_new_sock;
+          size = sizeof(clientname);
+          i_new_sock = accept (i_sock, (struct sockaddr *) &clientname, &size);
 
-        // service all the sockets with input pending.
-        for ( i = 0; i < FD_SETSIZE; i++ )
-            if ( FD_ISSET (i, &read_fd_set) )
-            {
-                if ( i == i_sock )
-                {
-                    // connection request on original socket.
-                    ++i_req;
+#ifdef OPENSSL
 
-#ifdef NCURSES
-                    print_hits();
-#endif
-                    int i_new_sock;
-                    size = sizeof(clientname);
-#ifdef CYGWIN
-                    i_new_sock = accept (i_sock, (struct sockaddr *) &clientname, (int*)&size);
-#else
-                    i_new_sock = accept (i_sock, (struct sockaddr *) &clientname, &size);
+          if (_main_loop_do_ssl_stuff(i_new_sock))
+            continue;
 #endif
 
-                    if (i_new_sock < 0)
-                    {
-	             wrap::system_message( ACCPERR );
-                     close(i_new_sock);
-                    }
-		
-                    else	
-		    {
 #ifdef VERBOSE
-                     wrap::system_message(NEWREQU 
-			+ tool::int2string(i_req) +  " "
-                     	+ string(inet_ntoa( clientname.sin_addr )) + ":"
-                     	+ tool::int2string(ntohs ( clientname.sin_port ))
-			);
+
+          wrap::system_message(NEWREQU
+                               + tool::int2string(i_req) +  " "
+                               + string(inet_ntoa( clientname.sin_addr )) + ":"
+                               + tool::int2string(ntohs ( clientname.sin_port ))
+                              );
 #endif
-                     FD_SET (i_new_sock, &active_fd_set);
-                    }
-                }
-
-                else
-                {
-		    int *p_sock = new int;
-		    *p_sock = i;
-                    thrd_pool->run( (void*) p_sock );
-                    FD_CLR( i, &active_fd_set );
-                }
-            }
-    }
+
+          FD_SET (i_new_sock, &active_fd_set);
+
+        }
+        else
+        {
+          socketcontainer *p_sock = _create_container(i);
+          p_pool->run( (void*) p_sock );
+          FD_CLR( i, &active_fd_set );
+        }
+      }
+  }
+}
+
+void
+sock::clean_ipcache()
+{
+  int i_ipcachesize = wrap::CONF->get_int("httpd.ipcachesize");
+  int i_currentsize = size();
+
+  if ( i_currentsize > 0 && (i_ipcachesize == 0 || i_ipcachesize <= i_currentsize) )
+  {
+    wrap::system_message(
+      SOCKCA2+tool::int2string(i_currentsize)+","+tool::int2string(i_ipcachesize)+")");
+    clear();
+  }
 }
 
 #ifdef NCURSES
 void
+sock::print_server_port() {
+  mvprintw( NCUR_PORT_X,NCUR_PORT_Y, "Port: %d ", i_server_port);
+  refresh();
+}
+
+void
 sock::print_hits()
 {
-    if ( wrap::NCUR->is_ready() )
-    {
-     mvprintw( NCUR_HITS_X,NCUR_HITS_Y, "Hits: %d ", i_req);
-     refresh();
-    }
+  if ( wrap::NCUR->is_ready() )
+  {
+    mvprintw( NCUR_HITS_X,NCUR_HITS_Y, "Hits: %d ", i_req);
+    refresh();
+  }
 }
 #endif
 
diff --git a/src/sock/sock.h b/src/sock/sock.h
index db01a49..264d9d1 100755
--- a/src/sock/sock.h
+++ b/src/sock/sock.h
@@ -10,62 +10,84 @@
 #include <netinet/in.h>
 #include <netdb.h>
 
-#include "../thrd/pool.h"
 #include "../reqp.h"
 #include "../chat/user.h"
 
+#include "../thrd/pool.h"
+#include "../maps/shashmap.h"
+
 #ifdef LOGGING
 #include "../logd.h"
 #endif
 
-#include "../maps/hashmap.h"
-
 using namespace std;
 
-class sock
+class sock : public shashmap
+      < string, uint32_t, self_hash<uint32_t>, equals_allocator<uint32_t> >
 {
-private:
-    // total number of server requests.
-    unsigned long long i_req;
-
-    bool  b_run;      // true while socket manager is running.
-    reqp *req_parser; // parses the http requests from clients.
-    pool *thrd_pool;  // the thread pool.
+protected:
 #ifdef LOGGING
-    logd *log_daemon; // the log daemon
-#endif
-    char *c_buffer;   // char buffer!
-    int   i_threads;  // total amount of threads inside the thread pool.
-
-    pthread_mutex_t mut_hits;
 
-public:
-    // creates a server socket.
-    int make_server_socket( int i_port );
+  logd *log_daemon; // the log daemon
+#endif
 
-    // small inline methods:
-    bool get_run() const
-    {
-        return b_run;
-    }
+  int i_server_sock;
+  int i_server_port;
 
-    bool set_run( bool b_run )
-    {
-        this->b_run = b_run;
-    }
+  // total number of server requests.
+  unsigned long long i_req;
+  bool  b_run;      // true while socket manager is running.
+  reqp *req_parser; // parses the http requests from clients.
+  char *c_buffer;   // char buffer!
+  pthread_mutex_t mut_hits;
 
-    sock( ); 
-    ~sock( );
+  static string inet_ntoa_callback(void* p_void);
 
-    int read_write( int* p_sock );
-    int start();
+public:
+  // creates a server socket.
+  int read_http(socketcontainer *p_sock, char *c_zbuf, int i_buflen, int  &i_payloadoffset);
+  string read_http_line(socketcontainer *p_sock);
+
+  // small inline methods:
+  bool get_server_() const
+  {
+    return b_run;
+  }
+  // small inline methods:
+  bool get_run() const
+  {
+    return b_run;
+  }
+  bool set_run( bool b_run )
+  {
+    this->b_run = b_run;
+  }
+
+  sock();
+
+  int read_write( socketcontainer* p_sock );
+
+  int start();
+  void clean_ipcache();
+
+  // the chat stream there all the chat messages will sent through.
+  void chat_stream( socketcontainer* p_sock, user* p_user, map<string,string> &map_params ); //<<
+  virtual int _send(socketcontainer *p_sock, const char *sz, int len);
+  virtual int _read(socketcontainer *p_sock, char *sz, int len);
+  virtual int _close(socketcontainer *p_sock);
+  virtual void _main_loop_init();
+#ifdef OPENSSL
+
+  virtual bool _main_loop_do_ssl_stuff(int& i_new_sock);
+#endif
 
-    // the chat stream there all the chat messages will sent through.
-    static void chat_stream( int i_sock, user* p_user, hashmap<string> &map_params ); //<<
+  virtual socketcontainer* _create_container(int& i_sock);
+  virtual int _make_server_socket(int i_port);
 
 #ifdef NCURSES
-    void print_hits();
+  void print_server_port();
+  void print_hits();
 #endif
-};
 
+};
 #endif
diff --git a/src/sock/sslsock.cpp b/src/sock/sslsock.cpp
index 494d572..32efc0f 100644
--- a/src/sock/sslsock.cpp
+++ b/src/sock/sslsock.cpp
@@ -1,27 +1,3 @@
-/*:*
- *: File: ./src/sock/sslsock.cpp
- *: 
- *: yChat; Homepage: www.yChat.org; Version 0.8.3-CURRENT
- *: 
- *: Copyright (C) 2003 Paul C. Buetow, Volker Richter
- *: Copyright (C) 2004 Paul C. Buetow
- *: Copyright (C) 2005 EXA Digital Solutions GbR
- *: 
- *: 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
- *:*/
-
 #include "../incl.h"
 
 #ifdef OPENSSL
@@ -40,19 +16,19 @@ sslsock::sslsock() : sock()
 }
 
 int
-sslsock::_send(_socket *p_sock, const char *sz, int len)
+sslsock::_send(socketcontainer *p_sock, const char *sz, int len)
 {
   return SSL_write((SSL*)p_sock->p_ssl_context,sz, len);
 }
 
 int
-sslsock::_read(_socket *p_sock,  char *sz, int len)
+sslsock::_read(socketcontainer *p_sock,  char *sz, int len)
 {
   return SSL_read((SSL*)p_sock->p_ssl_context,sz,len);
 }
 
 int
-sslsock::_close(_socket *p_sock)
+sslsock::_close(socketcontainer *p_sock)
 {
   SSL_free((SSL*)p_sock->p_ssl_context);
   sock::_close(p_sock);
@@ -153,10 +129,10 @@ sslsock::_main_loop_do_ssl_stuff(int& i_new_sock)
   return 0;
 }
 
-_socket*
+socketcontainer*
 sslsock::_create_container(int &i_sock)
 {
-  _socket* p_sock = sock::_create_container(i_sock);
+  socketcontainer* p_sock = sock::_create_container(i_sock);
   p_sock->p_ssl_context = map_certs[i_sock];
   return p_sock;
 }
diff --git a/src/sock/sslsock.h b/src/sock/sslsock.h
index 8be232a..f5358cc 100644
--- a/src/sock/sslsock.h
+++ b/src/sock/sslsock.h
@@ -1,27 +1,3 @@
-/*:*
- *: File: ./src/sock/sslsock.h
- *: 
- *: yChat; Homepage: www.yChat.org; Version 0.8.3-CURRENT
- *: 
- *: Copyright (C) 2003 Paul C. Buetow, Volker Richter
- *: Copyright (C) 2004 Paul C. Buetow
- *: Copyright (C) 2005 EXA Digital Solutions GbR
- *: 
- *: 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
- *:*/
-
 #include "../incl.h"
 
 #ifdef OPENSSL
@@ -52,12 +28,12 @@ public:
   sslsock( );
   ~sslsock( );
 
-  int _send(_socket *p_sock, const char *sz, int len);
-  int _read(_socket *p_sock, char *sz, int len);
-  int _close(_socket *p_sock);
+  int _send(socketcontainer *p_sock, const char *sz, int len);
+  int _read(socketcontainer *p_sock, char *sz, int len);
+  int _close(socketcontainer *p_sock);
   void _main_loop_init();
   bool _main_loop_do_ssl_stuff(int &i_new_sock);
-  _socket* _create_container(int& i_sock);
+  socketcontainer* _create_container(int& i_sock);
   int _make_server_socket(int i_port);
 };