tagging tags

4 files changed, 350 insertions, 0 deletions

diff --git a/yhttpd-0.7.1/src/sock/Makefile b/yhttpd-0.7.1/src/sock/Makefile
new file mode 100644
index 0000000..f5895f1
--- /dev/null
+++ b/yhttpd-0.7.1/src/sock/Makefile
@@ -0,0 +1,23 @@
+#CC=gcc33
+CC=g++
+INCLUDE=
+DEBUG=-D_GNU_SOURCE
+#CFLAGS=-Wall -O3 -s $(DEBUG) $(INCLUDE)
+#CFLAGS=-Wall -g -ansi -pedantic $(DEBUG) $(INCLUDE)
+CFLAGS=-Wall -g $(DEBUG) $(INCLUDE)
+LIBS=-lstdc++
+
+OBJECTS=main-test.o tcp-client.o exception.o
+PROGRAM=main-test
+
+all: $(PROGRAM)
+
+$(PROGRAM): $(OBJECTS)
+	$(CC) $(CFLAGS) -o $@ $(OBJECTS) $(LIBS)
+
+.cpp.o:
+	$(CC) $(CFLAGS) -c -o $@ $<
+
+clean:
+	rm -f $(PROGRAM) $(OBJECTS)
+						
diff --git a/yhttpd-0.7.1/src/sock/README b/yhttpd-0.7.1/src/sock/README
new file mode 100644
index 0000000..9d3aac9
--- /dev/null
+++ b/yhttpd-0.7.1/src/sock/README
@@ -0,0 +1 @@
+ossl.h not yet implemented (see header info)
diff --git a/yhttpd-0.7.1/src/sock/sock.cpp b/yhttpd-0.7.1/src/sock/sock.cpp
new file mode 100755
index 0000000..7dba4b7
--- /dev/null
+++ b/yhttpd-0.7.1/src/sock/sock.cpp
@@ -0,0 +1,257 @@
+#ifndef SOCK_CPP
+#define SOCK_CPP
+
+#include <arpa/inet.h>
+#include <errno.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include "sock.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->log_daemon = new logd( wrap::CONF->get_elem( "httpd.logging.accessfile" ),
+                                 wrap::CONF->get_elem( "httpd.logging.accesslines" ) );
+
+    pthread_mutex_init( &mut_threads, NULL );
+}
+
+sock::~sock()
+{
+    pthread_mutex_destroy( &mut_threads );
+}
+
+
+int
+sock::make_server_socket( int i_port )
+{
+    size_t sock;
+    struct sockaddr_in name;
+
+    // create the server socket.
+    sock = socket (PF_INET, SOCK_STREAM, 0);
+    if (sock < 0)
+    {
+        wrap::system_message( SOCKERR );
+
+        if ( ++i_port > MAXPORT )
+            exit(-1);
+
+        wrap::system_message( SOCKERR );
+
+        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 optval=1;
+
+    setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (char*)&optval, sizeof(int));
+
+    if (bind (sock, (struct sockaddr *) &name, sizeof (name)) < 0)
+    {
+
+     wrap::system_message( BINDERR );
+
+        if ( ++i_port > MAXPORT )
+            exit(-1);
+
+        wrap::system_message( string(SOCKERR) + tool::int2string(i_port) );
+
+        return make_server_socket( 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
+
+    return sock;
+}
+
+int
+sock::read_write( thrd* p_thrd, int i_sock )
+{
+    char c_req[READSOCK];
+    int i_bytes = read (i_sock, c_req, READSOCK);
+
+    if (i_bytes <= 0)
+    {
+     wrap::system_message( READERR );
+    }
+    else
+    {
+        // stores the request params.
+        map_string 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);
+
+        map_params["REMOTE_ADDR"] = inet_ntoa(client.sin_addr);
+        //map_params["REMOTE_PORT"] = ntohs(client.sin_port);
+
+        string s_rep = req_parser->parse( p_thrd, string( c_req ), map_params );
+
+        log_daemon->log_access(map_params);
+
+        // send s_rep to the client.
+        send( i_sock, s_rep.c_str(), s_rep.size(), 0 );
+
+        // dont need those vals anymore.
+        map_params.clear();
+
+        return 0;
+    }
+
+    return -1;
+}
+
+int
+sock::start()
+{
+    wrap::system_message( SOCKSRV );
+
+#ifdef NCURSES
+    print_hits();
+    print_threads();
+    thrd_pool->print_pool_size();
+#endif
+
+    auto int i_port = tool::string2int( wrap::CONF->get_elem( "httpd.serverport" ) );
+
+    int sock;
+    fd_set active_fd_set, read_fd_set;
+    int i;
+    struct sockaddr_in clientname;
+    size_t size;
+
+
+    // create the server socket and set it up to accept connections.
+    sock = make_server_socket ( i_port );
+
+    if (listen (sock, 1) < 0)
+    {
+      wrap::system_message( LISTERR );
+      exit( EXIT_FAILURE );
+    }
+
+    wrap::system_message( SOCKRDY );
+
+    // initialize the set of active sockets.
+    FD_ZERO (&active_fd_set);
+    FD_SET  (sock, &active_fd_set);
+
+    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 );
+
+         exit( EXIT_FAILURE );
+        }
+
+        // service all the sockets with input pending.
+        for ( i = 0; i < FD_SETSIZE; i++ )
+            if ( FD_ISSET (i, &read_fd_set) )
+            {
+                if ( i == sock )
+                {
+                    // connection request on original socket.
+                    i_req++;
+#ifdef NCURSES
+                    print_hits();
+#endif
+                    int new_sock;
+                    size = sizeof (clientname);
+                    new_sock = accept (sock, (struct sockaddr *) &clientname, &size);
+
+                    if (new_sock < 0)
+                    {
+	             wrap::system_message( ACCPERR );
+                     close ( 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 ))
+			);
+#endif
+                     FD_SET (new_sock, &active_fd_set);
+                    }
+                }
+
+                else
+                {
+                    thrd_pool->run( (void*) new thrd( i ) );
+                    FD_CLR( i, &active_fd_set );
+                }
+            }
+    }
+}
+
+void
+sock::increase_num_threads()
+{
+    pthread_mutex_lock( &mut_threads );
+    i_threads++;
+    pthread_mutex_unlock( &mut_threads );
+
+#ifdef NCURSES
+    print_threads();
+#endif
+}
+
+void
+sock::decrease_num_threads()
+{
+    pthread_mutex_lock( &mut_threads );
+    i_threads--;
+    pthread_mutex_unlock( &mut_threads );
+
+#ifdef NCURSES
+    print_threads();
+#endif
+}
+
+#ifdef NCURSES
+void
+sock::print_threads()
+{
+    if ( wrap::NCUR->is_ready() )
+    {
+     mvprintw( NCUR_POOL_RUNNING_X,NCUR_POOL_RUNNING_Y, "In use: %d ", i_threads);
+     refresh();
+   }
+}
+
+void
+sock::print_hits()
+{
+    if ( wrap::NCUR->is_ready() )
+    {
+     mvprintw( NCUR_HITS_X,NCUR_HITS_Y, "Hits: %d ", i_req);
+     refresh();
+    }
+}
+#endif
+
+#endif
diff --git a/yhttpd-0.7.1/src/sock/sock.h b/yhttpd-0.7.1/src/sock/sock.h
new file mode 100755
index 0000000..079dfd8
--- /dev/null
+++ b/yhttpd-0.7.1/src/sock/sock.h
@@ -0,0 +1,69 @@
+#include "../incl.h"
+
+#ifndef SOCK_H
+#define SOCK_H
+
+
+#include <queue>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <netdb.h>
+#include "../thrd/pool.h"
+#include "../thrd/thrd.h"
+#include "../reqp.h"
+#include "../logd.h"
+
+using namespace std;
+
+class sock
+{
+private:
+    // total number of server requests.
+    unsigned long long int 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.
+    logd* log_daemon; // the log daemon
+    char* c_buffer;   // char buffer!
+
+    int   i_threads;     // total amount of threads inside the thread pool.
+    pthread_mutex_t mut_threads;
+    pthread_mutex_t mut_hits;
+
+
+public:
+    // creates a server socket.
+    int make_server_socket( int port );
+
+    // small inline methods:
+    bool get_run() const
+    {
+        return b_run;
+    }
+    bool set_run( bool b_run )
+    {
+        this->b_run = b_run;
+    }
+
+    // public methods.
+    explicit sock( ); // simple constructor.
+    ~sock( );
+    virtual int  read_write( thrd* p_thrd, int filedes   );
+    virtual int  start();
+
+    // the chat stream there all the chat messages will sent through.
+
+    void increase_num_threads();
+    void decrease_num_threads();
+#ifdef NCURSES
+
+    void print_threads();
+    void print_hits();
+#endif
+
+};
+
+#endif