path: root/src/sock.cpp

/*:*
 *: File: ./src/sock.cpp
 *: 
 *: yChat; Homepage: www.yChat.org; Version 0.5.6-BASIC
 *: 
 *: Copyright (C) 2003, 2004 Paul C. Buetow, Volker Richter
 *: 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.
 *:*/

// class sock implementation. the multiplex socket implementation has been token from the
// GNU C Library Examples and modified in order to fit in here ( POSIX threads etc. ).

#ifndef s_sock_CXX
#define s_sock_CXX

#include <unistd.h>

#include "sock.h"
#include "s_chat.h"
#include "s_conf.h"
#include "s_mutx.h"
#include "s_tool.h"
#include "s_lang.h"
#include "s_sman.h"
#include "chat.h"
#include "user.h"

using namespace std;

sock::sock()
{
    this->b_run      = true;
    this->i_req      = 0;
    this->req_parser = new reqp();
    this->thrd_pool  = new pool();
}

void
sock::chat_stream( int i_sock, user* p_user, map_string &map_params )
{
    string s_msg( "\n" );

    pthread_mutex_lock  ( &(p_user->mut_message) );

    for ( int i = 0; i < PUSHSTR; i++ )
        send( i_sock, s_msg.c_str(), s_msg.size(), 0 );

    do
    {
        s_msg = p_user->get_mess( );
        if ( 0 > send( i_sock, s_msg.c_str(), s_msg.size(), 0 ) )
            p_user->set_online( false );
        pthread_cond_wait( &(p_user->cond_message), &(p_user->mut_message) );
    }
    while( p_user->get_online() );

    // 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 );

    pthread_mutex_unlock( &(p_user->mut_message) );

    // remove the user from its room.
    string s_user( p_user->get_name() );
    p_user->get_p_room()->del_elem( s_user );

    // post the room that the user has left the chat.
    p_user->get_p_room()->msg_post( new string( p_user->get_name().append( s_lang::get
                                        ().get_val( "USERLEAV" ) ) ) );
    s_sman::get
        ().destroySession( p_user->get_id() );
#ifdef VERBOSE

    cout << s_user << " left | SessionCount: " << s_sman::get
        ().getSessionCount() << endl;
#endif

    p_user->~user();
}

int
sock::make_socket( uint16_t i_port )
{
    int sock;
    struct sockaddr_in name;

    // create the server socket.
    sock = socket (PF_INET, SOCK_STREAM, 0);
    if (sock < 0)
    {
        cerr << "Sock: socket error" << endl;

        if ( ((int)++i_port) > MAXPORT )
            exit(-1);

        cerr << SOCKERR << i_port << endl;
        return make_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)
    {
        cerr << "Sock: bind error" << endl;

        if ( ++i_port > MAXPORT )
            exit(-1);

        cout << SOCKERR << i_port << endl;
        return make_socket( i_port );
    }

    return sock;
}

int
sock::read_write( thrd* p_thrd, int i_sock )
{
    char c_req[2048];

    int i_bytes;
    i_bytes = read (i_sock, c_req, 2048);

    if (i_bytes < 0)
    {
        cerr << "Sock: read error " << endl;
    }

    else
    {
        // stores the request params.
        map_string map_params;

        // get the s_rep ( s_html response which will be send imediatly to the client
        // and fill map_params with request values.
        auto string s_temp=(string)c_req;
        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 );
        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()
{
    auto int i_port   = s_tool::string2int( s_conf::get
                                                ().get_val( "SRVRPORT" ) );

    int sock;
    fd_set active_fd_set, read_fd_set;
    int i;
    struct sockaddr_in clientname;
    size_t size;

#ifdef VERBOSE

    cout << SOCKCRT << "localhost:" << i_port << endl;
#endif

    // create the server socket and set it up to accept connections.
    sock = make_socket ( i_port );

    if (listen (sock, 1) < 0)
    {
        cerr << "Sock: listen error" << endl;
        exit( EXIT_FAILURE );
    }

#ifdef VERBOSE
    cout << SOCKRDY << endl;
#endif

    // 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)
        {
            cerr << "Sock: select error" << endl;
            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++;
                    int new_sock;
                    size = sizeof (clientname);
                    new_sock = accept (sock,
                                       (struct sockaddr *) &clientname,
                                       &size);

                    if (new_sock < 0)
                    {
                        cerr << "Sock: accept error" << endl;
                        close ( new_sock );
                    }

#ifdef VERBOSE
                    cout << CONNECT << i_req << " "
                    << inet_ntoa( clientname.sin_addr )
                    << ":"
                    << ntohs    ( clientname.sin_port )
                    << endl;
#endif

                    FD_SET (new_sock, &active_fd_set);
                }

                else
                {
                    thrd_pool->run( (void*) new thrd( i ) );
                    FD_CLR( i, &active_fd_set );
                }
            }
    }
}

#endif