research.m1stereo.tv/gitweb/ - melted/blob - src/miracle/miracle_server.c

   1 /*
   2  * dvserver.c -- DV Server
   3  * Copyright (C) 2002-2003 Ushodaya Enterprises Limited
   4  * Author: Charles Yates <charles.yates@pandora.be>
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software Foundation,
  18  * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  19  */
  20
  21 #ifdef HAVE_CONFIG_H
  22 #include <config.h>
  23 #endif
  24
  25 /* System header files */
  26 #include <stdio.h>
  27 #include <stdlib.h>
  28 #include <string.h>
  29 #include <signal.h>
  30
  31 #include <fcntl.h>
  32 #include <pthread.h>
  33 #include <signal.h>
  34 #include <stdlib.h>
  35 #include <unistd.h>
  36
  37 #include <string.h>
  38 #include <netinet/in.h>
  39 #include "log.h"
  40 #include <netdb.h>
  41 #include <errno.h>
  42 #include <arpa/inet.h>
  43
  44 /* Application header files */
  45 #include "dvserver.h"
  46 #include "dvconnection.h"
  47 #include "dvlocal.h"
  48 #include "log.h"
  49 #include <dvremote.h>
  50 #include <dvtokeniser.h>
  51
  52 /** Initialise a server structure.
  53 */
  54
  55 dv_server dv_server_init( char *id )
  56 {
  57         dv_server server = malloc( sizeof( dv_server_t ) );
  58         if ( server != NULL )
  59         {
  60                 memset( server, 0, sizeof( dv_server_t ) );
  61                 server->id = id;
  62                 server->port = DEFAULT_TCP_PORT;
  63                 server->socket = -1;
  64         }
  65         return server;
  66 }
  67
  68 /** Set the port of the server.
  69 */
  70
  71 void dv_server_set_port( dv_server server, int port )
  72 {
  73         server->port = port;
  74 }
  75
  76 void dv_server_set_proxy( dv_server server, char *proxy )
  77 {
  78         dv_tokeniser tokeniser = dv_tokeniser_init( );
  79         server->proxy = 1;
  80         server->remote_port = DEFAULT_TCP_PORT;
  81         dv_tokeniser_parse_new( tokeniser, proxy, ":" );
  82         strcpy( server->remote_server, dv_tokeniser_get_string( tokeniser, 0 ) );
  83         if ( dv_tokeniser_count( tokeniser ) == 2 )
  84                 server->remote_port = atoi( dv_tokeniser_get_string( tokeniser, 1 ) );
  85         dv_tokeniser_close( tokeniser );
  86 }
  87
  88 /** Wait for a connection.
  89 */
  90
  91 static int dv_server_wait_for_connect( dv_server server )
  92 {
  93     struct timeval tv;
  94     fd_set rfds;
  95
  96     /* Wait for a 1 second. */
  97     tv.tv_sec = 1;
  98     tv.tv_usec = 0;
  99
 100     FD_ZERO( &rfds );
 101     FD_SET( server->socket, &rfds );
 102
 103     return select( server->socket + 1, &rfds, NULL, NULL, &tv);
 104 }
 105
 106 /** Run the server thread.
 107 */
 108
 109 static void *dv_server_run( void *arg )
 110 {
 111         dv_server server = arg;
 112         pthread_t cmd_parse_info;
 113         connection_t *tmp = NULL;
 114         pthread_attr_t thread_attributes;
 115         int socksize;
 116
 117         socksize = sizeof( struct sockaddr );
 118
 119         dv1394d_log( LOG_NOTICE, "%s version %s listening on port %i", server->id, VERSION, server->port );
 120
 121         /* Create the initial thread. We want all threads to be created detached so
 122            their resources get freed automatically. (CY: ... hmmph...) */
 123         pthread_attr_init( &thread_attributes );
 124         pthread_attr_setdetachstate( &thread_attributes, PTHREAD_CREATE_DETACHED );
 125         pthread_attr_init( &thread_attributes );
 126         pthread_attr_setinheritsched( &thread_attributes, PTHREAD_INHERIT_SCHED );
 127         /* pthread_attr_setschedpolicy( &thread_attributes, SCHED_RR ); */
 128
 129         while ( !server->shutdown )
 130         {
 131                 /* Wait for a new connection. */
 132                 if ( dv_server_wait_for_connect( server ) )
 133                 {
 134                         /* Create a new block of data to hold a copy of the incoming connection for
 135                            our server thread. The thread should free this when it terminates. */
 136
 137                         tmp = (connection_t*) malloc( sizeof(connection_t) );
 138                         tmp->parser = server->parser;
 139                         tmp->fd = accept( server->socket, (struct sockaddr*) &(tmp->sin), &socksize );
 140
 141                         /* Pass the connection to a parser thread :-/ */
 142                         if ( tmp->fd != -1 )
 143                                 pthread_create( &cmd_parse_info, &thread_attributes, parser_thread, tmp );
 144                 }
 145         }
 146
 147         dv1394d_log( LOG_NOTICE, "%s version %s server terminated.", server->id, VERSION );
 148
 149         return NULL;
 150 }
 151
 152 /** Execute the server thread.
 153 */
 154
 155 int dv_server_execute( dv_server server )
 156 {
 157         int error = 0;
 158         dv_response response = NULL;
 159         int index = 0;
 160         struct sockaddr_in ServerAddr;
 161         int flag = 1;
 162
 163         ServerAddr.sin_family = AF_INET;
 164         ServerAddr.sin_port = htons( server->port );
 165         ServerAddr.sin_addr.s_addr = INADDR_ANY;
 166
 167         /* Create socket, and bind to port. Listen there. Backlog = 5
 168            should be sufficient for listen (). */
 169         server->socket = socket( AF_INET, SOCK_STREAM, 0 );
 170
 171         if ( server->socket == -1 )
 172         {
 173                 server->shutdown = 1;
 174                 perror( "socket" );
 175                 dv1394d_log( LOG_ERR, "%s unable to create socket.", server->id );
 176                 return -1;
 177         }
 178
 179     setsockopt( server->socket, SOL_SOCKET, SO_REUSEADDR, (char *)&flag, sizeof( int ) );
 180
 181         if ( bind( server->socket, (struct sockaddr *) &ServerAddr, sizeof (ServerAddr) ) != 0 )
 182         {
 183                 server->shutdown = 1;
 184                 perror( "bind" );
 185                 dv1394d_log( LOG_ERR, "%s unable to bind to port %d.", server->id, server->port );
 186                 return -1;
 187         }
 188
 189         if ( listen( server->socket, 5 ) != 0 )
 190         {
 191                 server->shutdown = 1;
 192                 perror( "listen" );
 193                 dv1394d_log( LOG_ERR, "%s unable to listen on port %d.", server->id, server->port );
 194                 return -1;
 195         }
 196
 197         fcntl( server->socket, F_SETFL, O_NONBLOCK );
 198
 199         if ( !server->proxy )
 200         {
 201                 dv1394d_log( LOG_NOTICE, "Starting server on %d.", server->port );
 202                 server->parser = dv_parser_init_local( );
 203         }
 204         else
 205         {
 206                 dv1394d_log( LOG_NOTICE, "Starting proxy for %s:%d on %d.", server->remote_server, server->remote_port, server->port );
 207                 server->parser = dv_parser_init_remote( server->remote_server, server->remote_port );
 208         }
 209
 210         response = dv_parser_connect( server->parser );
 211
 212         if ( response != NULL && dv_response_get_error_code( response ) == 100 )
 213         {
 214                 /* read configuration file */
 215                 if ( response != NULL && !server->proxy )
 216                 {
 217                         dv_response_close( response );
 218                         response = dv_parser_run( server->parser, "/etc/dv1394d.conf" );
 219
 220                         if ( dv_response_count( response ) > 1 )
 221                         {
 222                                 if ( dv_response_get_error_code( response ) > 299 )
 223                                         dv1394d_log( LOG_ERR, "Error evaluating server configuration. Processing stopped." );
 224                                 for ( index = 0; index < dv_response_count( response ); index ++ )
 225                                         dv1394d_log( LOG_DEBUG, "%4d: %s", index, dv_response_get_line( response, index ) );
 226                         }
 227                 }
 228
 229                 if ( response != NULL )
 230                 {
 231                         pthread_attr_t attr;
 232                         int result;
 233                         pthread_attr_init( &attr );
 234                         pthread_attr_setdetachstate( &attr, PTHREAD_CREATE_JOINABLE );
 235                         pthread_attr_setinheritsched( &attr, PTHREAD_EXPLICIT_SCHED );
 236                         pthread_attr_setschedpolicy( &attr, SCHED_FIFO );
 237                         pthread_attr_setscope( &attr, PTHREAD_SCOPE_SYSTEM );
 238                         dv_response_close( response );
 239                         result = pthread_create( &server->thread, &attr, dv_server_run, server );
 240                         if ( result )
 241                         {
 242                                 dv1394d_log( LOG_WARNING, "Failed to schedule realtime (%s)", strerror(errno) );
 243                                 pthread_attr_setschedpolicy( &attr, SCHED_OTHER );
 244                                 result = pthread_create( &server->thread, &attr, dv_server_run, server );
 245                                 if ( result )
 246                                 {
 247                                         dv1394d_log( LOG_CRIT, "Failed to launch TCP listener thread" );
 248                                         error = -1;
 249                                 }
 250                         }
 251                 }
 252         }
 253         else
 254         {
 255                 dv1394d_log( LOG_ERR, "Error connecting to parser. Processing stopped." );
 256                 server->shutdown = 1;
 257                 error = -1;
 258         }
 259
 260         return error;
 261 }
 262
 263 /** Shutdown the server.
 264 */
 265
 266 void dv_server_shutdown( dv_server server )
 267 {
 268         if ( server != NULL && !server->shutdown )
 269         {
 270                 server->shutdown = 1;
 271                 pthread_join( server->thread, NULL );
 272                 dv_parser_close( server->parser );
 273                 close( server->socket );
 274         }
 275 }