[libt2n] / src / socket_server.cpp

/***************************************************************************
 *   Copyright (C) 2006 by Gerd v. Egidy                                   *
 *   gve@intra2net.com                                                     *
 *                                                                         *
 *   This library is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU Lesser General Public License version   *
 *   2.1 as published by the Free Software Foundation.                     *
 *                                                                         *
 *   This library 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 Lesser General Public License for more details.                   *
 *                                                                         *
 *   You should have received a copy of the GNU Lesser 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 <stdio.h>
#include <errno.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <sys/time.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <netdb.h>
#include <fcntl.h>
#include <time.h>
#include <pwd.h>
#include <grp.h>

#include "socket_server.hxx"
#include "t2n_exception.hxx"

using namespace std;

namespace libt2n
{

socket_server::socket_server(int port, const char* ip)
    : server()
{
    socket_type=tcp_s;

}

socket_server::socket_server(const char* path, mode_t filemode, const char* user, const char* group)
    : server()
{
    socket_type=unix_s;
    unix_path=path;

    /* Create the socket. */
    sock = socket (PF_UNIX, SOCK_STREAM, 0);
    if (sock < 0)
    {
        string err="error opening socket: ";
        err+=strerror(errno);
        log(error, err);
        throw t2n_server_error(err);
    }

    set_socket_options(sock);

    /* Give the socket a name. */
    struct sockaddr_un unix_name;
    unix_name.sun_family = AF_UNIX;
    strncpy (unix_name.sun_path, unix_path.c_str(),sizeof(unix_name.sun_path));

    /* just to make sure there is no other socket file */
    unlink (unix_name.sun_path);

    if (bind (sock, (struct sockaddr *) &unix_name, sizeof (unix_name)) < 0)
    {
        string err="error binding socket: ";
        err+=strerror(errno);
        log(error, err);
        throw t2n_server_error(err);
    }

    /* change permissions */
    if (chmod (unix_name.sun_path, filemode) != 0) 
    {
        string err="error changing permission: ";
        err+=strerror(errno);
        log(error, err);
        throw t2n_server_error(err);
    }

    struct passwd *socket_user = getpwnam (user);
    if (socket_user == NULL) 
    {
        string err="error getting socket user: ";
        err+=strerror(errno);
        log(error, err);
        throw t2n_server_error(err);
    }

    struct group *socket_group = getgrnam (group);
    if (socket_group == NULL) 
    {
        string err="error getting socket group: ";
        err+=strerror(errno);
        log(error, err);
        throw t2n_server_error(err);
    }

    if (chown (unix_name.sun_path, socket_user->pw_uid, socket_group->gr_gid) != 0) 
    {
        string err="error changing socket ownership: ";
        err+=strerror(errno);
        log(error, err);
        throw t2n_server_error(err);
    }

    if (listen (sock, 5) < 0)
    {
        string err="error listening to socket: ";
        err+=strerror(errno);
        log(error, err);
        throw t2n_server_error(err);
    }

    /* clear & insert server sock into the fd_tab to prepare select */
    FD_ZERO(&connection_set);
    FD_SET (sock, &connection_set);
}

void socket_server::set_socket_options(int sock)
{
    int i=1;

    /* fast reuse enable */
    if (setsockopt(sock,SOL_SOCKET, SO_REUSEADDR, &i, sizeof(i)) < 0)
    {
        string err="error setting socket option: ";
        err+=strerror(errno);
        log(error, err);
        throw t2n_server_error(err);
    }

    /* keepalive enable */
    if (setsockopt(sock,SOL_SOCKET, SO_KEEPALIVE, &i, sizeof(i)) < 0)
    {
        string err="error setting socket option: ";
        err+=strerror(errno);
        log(error, err);
        throw t2n_server_error(err);
    }

    /* close on exec */
    int fdflags;
    fdflags=fcntl(sock,F_GETFD, 0);
    if (fdflags < 0)
    {
        string err="fcntl error on socket: ";
        err+=strerror(errno);
        log(error, err);
        throw t2n_server_error(err);
    }
    fdflags |= FD_CLOEXEC;
    if (fcntl(sock,F_SETFD,fdflags) < 0)
    {
        string err="fcntl error on socket: ";
        err+=strerror(errno);
        log(error, err);
        throw t2n_server_error(err);
    }

    /* non-blocking mode */
    int flflags;
    flflags=fcntl(sock,F_GETFL,0);
    if (flflags < 0)
    {
        string err="fcntl error on socket: ";
        err+=strerror(errno);
        log(error, err);
        throw t2n_server_error(err);
    }
    flflags |= O_NONBLOCK;
    if (fcntl(sock,F_SETFL,flflags) < 0)
    {
        string err="fcntl error on socket: ";
        err+=strerror(errno);
        log(error, err);
        throw t2n_server_error(err);
    }
}

socket_server::~socket_server()
{
    close(sock);

    if (socket_type==unix_s)
        unlink(unix_path.c_str());
}

void socket_server::new_connection()
{
    struct sockaddr_un clientname;

    unsigned int size = sizeof (clientname);
    int newsock = accept (sock,(struct sockaddr *) &clientname,&size);
    if (newsock < 0)
    {
        if (errno == EAGAIN)
        {
            log(error, "accept error (EAGAIN): no connection waiting");
            return;
        }

        /* default: break */
        string err="error accepting connection: ";
        err+=strerror(errno);
        log(error, err);
        throw t2n_server_error(err);
    }

    FD_SET (newsock, &connection_set);

    int i=1;

    /* keepalive enable */
    if (setsockopt(newsock,SOL_SOCKET, SO_KEEPALIVE, &i, sizeof(i)) < 0)
    {
        string err="error setting socket option: ";
        err+=strerror(errno);
        log(error, err);
        throw t2n_server_error(err);
    }

    /* close on exec */
    int fdflags;
    fdflags=fcntl(newsock,F_GETFD, 0);
    if (fdflags < 0)
    {
        string err="fcntl error on socket: ";
        err+=strerror(errno);
        log(error, err);
        throw t2n_server_error(err);
    }
    fdflags |= FD_CLOEXEC;
    if (fcntl(newsock,F_SETFD,fdflags) < 0)
    {
        string err="fcntl error on socket: ";
        err+=strerror(errno);
        log(error, err);
        throw t2n_server_error(err);
    }

    /* non-blocking mode */
    int flflags;
    flflags=fcntl(newsock,F_GETFL,0);
    if (flflags < 0)
    {
        string err="fcntl error on socket: ";
        err+=strerror(errno);
        log(error, err);
        throw t2n_server_error(err);
    }
    flflags |= O_NONBLOCK;
    if (fcntl(newsock,F_SETFL,flflags) < 0)
    {
        string err="fcntl error on socket: ";
        err+=strerror(errno);
        log(error, err);
        throw t2n_server_error(err);
    }

    add_connection(new socket_connection(newsock, get_default_timeout()));

    return;
}

void socket_server::fill_buffer(long long usec_timeout)
{
    fd_set used_fdset=connection_set;

    /* set timeout */
    struct timeval tval;
    struct timeval *timeout_ptr;

    if (usec_timeout == -1)
        timeout_ptr = NULL;
    else
    {
        timeout_ptr = &tval;

        // timeout von long long usec in int sec + int usec umrechnen
        tval.tv_sec = usec_timeout / 1000000;
        tval.tv_usec = usec_timeout % 1000000;
    }

    int ret=select (FD_SETSIZE, &used_fdset, NULL, NULL, timeout_ptr);

    if (ret < 0)
    {
        if (errno == EINTR)
        {
            // select interrupted by signal
            ret=0;
        }
        else
        {
            string err="select error: ";
            err+=strerror(errno);
            log(error, err);
            throw t2n_server_error(err);
        }
    }

    if (ret > 0)
    {
        // we have data pending

        // check for new connection
        if (FD_ISSET (sock, &used_fdset))
        {
            new_connection();
        }

        // check all connections for pending data
        fill_connection_buffers();
    }

    return;
}

socket_connection::socket_connection(int _sock, int _timeout)
    : connection(_timeout)
{
    sock=_sock;
}

void socket_connection::close()
{

}

void socket_connection::fill_buffer(void)
{

}

void socket_connection::write(const std::string& data)
{

}

}
Commit	Line	Data
	1	/***************************************************************************
	2	* Copyright (C) 2006 by Gerd v. Egidy *
	3	* gve@intra2net.com *
	4	* *
	5	* This library is free software; you can redistribute it and/or modify *
	6	* it under the terms of the GNU Lesser General Public License version *
	7	* 2.1 as published by the Free Software Foundation. *
	8	* *
	9	* This library is distributed in the hope that it will be useful, *
	10	* but WITHOUT ANY WARRANTY; without even the implied warranty of *
	11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
	12	* GNU Lesser General Public License for more details. *
	13	* *
	14	* You should have received a copy of the GNU Lesser General Public *
	15	* License along with this program; if not, write to the *
	16	* Free Software Foundation, Inc., *
	17	* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
	18	***************************************************************************/
	19
	20	#include <stdio.h>
	21	#include <errno.h>
	22	#include <stdlib.h>
	23	#include <unistd.h>
	24	#include <sys/types.h>
	25	#include <sys/socket.h>
	26	#include <sys/un.h>
	27	#include <sys/time.h>
	28	#include <arpa/inet.h>
	29	#include <netinet/in.h>
	30	#include <netdb.h>
	31	#include <fcntl.h>
	32	#include <time.h>
	33	#include <pwd.h>
	34	#include <grp.h>
	35
	36	#include "socket_server.hxx"
	37	#include "t2n_exception.hxx"
	38
	39	using namespace std;
	40
	41	namespace libt2n
	42	{
	43
	44	socket_server::socket_server(int port, const char* ip)
	45	: server()
	46	{
	47	socket_type=tcp_s;
	48
	49	}
	50
	51	socket_server::socket_server(const char* path, mode_t filemode, const char* user, const char* group)
	52	: server()
	53	{
	54	socket_type=unix_s;
	55	unix_path=path;
	56
	57	/* Create the socket. */
	58	sock = socket (PF_UNIX, SOCK_STREAM, 0);
	59	if (sock < 0)
	60	{
	61	string err="error opening socket: ";
	62	err+=strerror(errno);
	63	log(error, err);
	64	throw t2n_server_error(err);
	65	}
	66
	67	set_socket_options(sock);
	68
	69	/* Give the socket a name. */
	70	struct sockaddr_un unix_name;
	71	unix_name.sun_family = AF_UNIX;
	72	strncpy (unix_name.sun_path, unix_path.c_str(),sizeof(unix_name.sun_path));
	73
	74	/* just to make sure there is no other socket file */
	75	unlink (unix_name.sun_path);
	76
	77	if (bind (sock, (struct sockaddr *) &unix_name, sizeof (unix_name)) < 0)
	78	{
	79	string err="error binding socket: ";
	80	err+=strerror(errno);
	81	log(error, err);
	82	throw t2n_server_error(err);
	83	}
	84
	85	/* change permissions */
	86	if (chmod (unix_name.sun_path, filemode) != 0)
	87	{
	88	string err="error changing permission: ";
	89	err+=strerror(errno);
	90	log(error, err);
	91	throw t2n_server_error(err);
	92	}
	93
	94	struct passwd *socket_user = getpwnam (user);
	95	if (socket_user == NULL)
	96	{
	97	string err="error getting socket user: ";
	98	err+=strerror(errno);
	99	log(error, err);
	100	throw t2n_server_error(err);
	101	}
	102
	103	struct group *socket_group = getgrnam (group);
	104	if (socket_group == NULL)
	105	{
	106	string err="error getting socket group: ";
	107	err+=strerror(errno);
	108	log(error, err);
	109	throw t2n_server_error(err);
	110	}
	111
	112	if (chown (unix_name.sun_path, socket_user->pw_uid, socket_group->gr_gid) != 0)
	113	{
	114	string err="error changing socket ownership: ";
	115	err+=strerror(errno);
	116	log(error, err);
	117	throw t2n_server_error(err);
	118	}
	119
	120	if (listen (sock, 5) < 0)
	121	{
	122	string err="error listening to socket: ";
	123	err+=strerror(errno);
	124	log(error, err);
	125	throw t2n_server_error(err);
	126	}
	127
	128	/* clear & insert server sock into the fd_tab to prepare select */
	129	FD_ZERO(&connection_set);
	130	FD_SET (sock, &connection_set);
	131	}
	132
	133	void socket_server::set_socket_options(int sock)
	134	{
	135	int i=1;
	136
	137	/* fast reuse enable */
	138	if (setsockopt(sock,SOL_SOCKET, SO_REUSEADDR, &i, sizeof(i)) < 0)
	139	{
	140	string err="error setting socket option: ";
	141	err+=strerror(errno);
	142	log(error, err);
	143	throw t2n_server_error(err);
	144	}
	145
	146	/* keepalive enable */
	147	if (setsockopt(sock,SOL_SOCKET, SO_KEEPALIVE, &i, sizeof(i)) < 0)
	148	{
	149	string err="error setting socket option: ";
	150	err+=strerror(errno);
	151	log(error, err);
	152	throw t2n_server_error(err);
	153	}
	154
	155	/* close on exec */
	156	int fdflags;
	157	fdflags=fcntl(sock,F_GETFD, 0);
	158	if (fdflags < 0)
	159	{
	160	string err="fcntl error on socket: ";
	161	err+=strerror(errno);
	162	log(error, err);
	163	throw t2n_server_error(err);
	164	}
	165	fdflags \|= FD_CLOEXEC;
	166	if (fcntl(sock,F_SETFD,fdflags) < 0)
	167	{
	168	string err="fcntl error on socket: ";
	169	err+=strerror(errno);
	170	log(error, err);
	171	throw t2n_server_error(err);
	172	}
	173
	174	/* non-blocking mode */
	175	int flflags;
	176	flflags=fcntl(sock,F_GETFL,0);
	177	if (flflags < 0)
	178	{
	179	string err="fcntl error on socket: ";
	180	err+=strerror(errno);
	181	log(error, err);
	182	throw t2n_server_error(err);
	183	}
	184	flflags \|= O_NONBLOCK;
	185	if (fcntl(sock,F_SETFL,flflags) < 0)
	186	{
	187	string err="fcntl error on socket: ";
	188	err+=strerror(errno);
	189	log(error, err);
	190	throw t2n_server_error(err);
	191	}
	192	}
	193
	194	socket_server::~socket_server()
	195	{
	196	close(sock);
	197
	198	if (socket_type==unix_s)
	199	unlink(unix_path.c_str());
	200	}
	201
	202	void socket_server::new_connection()
	203	{
	204	struct sockaddr_un clientname;
	205
	206	unsigned int size = sizeof (clientname);
	207	int newsock = accept (sock,(struct sockaddr *) &clientname,&size);
	208	if (newsock < 0)
	209	{
	210	if (errno == EAGAIN)
	211	{
	212	log(error, "accept error (EAGAIN): no connection waiting");
	213	return;
	214	}
	215
	216	/* default: break */
	217	string err="error accepting connection: ";
	218	err+=strerror(errno);
	219	log(error, err);
	220	throw t2n_server_error(err);
	221	}
	222
	223	FD_SET (newsock, &connection_set);
	224
	225	int i=1;
	226
	227	/* keepalive enable */
	228	if (setsockopt(newsock,SOL_SOCKET, SO_KEEPALIVE, &i, sizeof(i)) < 0)
	229	{
	230	string err="error setting socket option: ";
	231	err+=strerror(errno);
	232	log(error, err);
	233	throw t2n_server_error(err);
	234	}
	235
	236	/* close on exec */
	237	int fdflags;
	238	fdflags=fcntl(newsock,F_GETFD, 0);
	239	if (fdflags < 0)
	240	{
	241	string err="fcntl error on socket: ";
	242	err+=strerror(errno);
	243	log(error, err);
	244	throw t2n_server_error(err);
	245	}
	246	fdflags \|= FD_CLOEXEC;
	247	if (fcntl(newsock,F_SETFD,fdflags) < 0)
	248	{
	249	string err="fcntl error on socket: ";
	250	err+=strerror(errno);
	251	log(error, err);
	252	throw t2n_server_error(err);
	253	}
	254
	255	/* non-blocking mode */
	256	int flflags;
	257	flflags=fcntl(newsock,F_GETFL,0);
	258	if (flflags < 0)
	259	{
	260	string err="fcntl error on socket: ";
	261	err+=strerror(errno);
	262	log(error, err);
	263	throw t2n_server_error(err);
	264	}
	265	flflags \|= O_NONBLOCK;
	266	if (fcntl(newsock,F_SETFL,flflags) < 0)
	267	{
	268	string err="fcntl error on socket: ";
	269	err+=strerror(errno);
	270	log(error, err);
	271	throw t2n_server_error(err);
	272	}
	273
	274	add_connection(new socket_connection(newsock, get_default_timeout()));
	275
	276	return;
	277	}
	278
	279	void socket_server::fill_buffer(long long usec_timeout)
	280	{
	281	fd_set used_fdset=connection_set;
	282
	283	/* set timeout */
	284	struct timeval tval;
	285	struct timeval *timeout_ptr;
	286
	287	if (usec_timeout == -1)
	288	timeout_ptr = NULL;
	289	else
	290	{
	291	timeout_ptr = &tval;
	292
	293	// timeout von long long usec in int sec + int usec umrechnen
	294	tval.tv_sec = usec_timeout / 1000000;
	295	tval.tv_usec = usec_timeout % 1000000;
	296	}
	297
	298	int ret=select (FD_SETSIZE, &used_fdset, NULL, NULL, timeout_ptr);
	299
	300	if (ret < 0)
	301	{
	302	if (errno == EINTR)
	303	{
	304	// select interrupted by signal
	305	ret=0;
	306	}
	307	else
	308	{
	309	string err="select error: ";
	310	err+=strerror(errno);
	311	log(error, err);
	312	throw t2n_server_error(err);
	313	}
	314	}
	315
	316	if (ret > 0)
	317	{
	318	// we have data pending
	319
	320	// check for new connection
	321	if (FD_ISSET (sock, &used_fdset))
	322	{
	323	new_connection();
	324	}
	325
	326	// check all connections for pending data
	327	fill_connection_buffers();
	328	}
	329
	330	return;
	331	}
	332
	333	socket_connection::socket_connection(int _sock, int _timeout)
	334	: connection(_timeout)
	335	{
	336	sock=_sock;
	337	}
	338
	339	void socket_connection::close()
	340	{
	341
	342	}
	343
	344	void socket_connection::fill_buffer(void)
	345	{
	346
	347	}
	348
	349	void socket_connection::write(const std::string& data)
	350	{
	351
	352	}
	353
	354	}