source: ipc.c @ 85d7b85

Last change on this file since 85d7b85 was 85d7b85, checked in by Jelmer Vernooij <jelmer@…>, at 2008-04-02T14:22:57Z

Merge trunk.

  • Property mode set to 100644
File size: 13.8 KB
Line 
1  /********************************************************************\
2  * BitlBee -- An IRC to other IM-networks gateway                     *
3  *                                                                    *
4  * Copyright 2002-2006 Wilmer van der Gaast and others                *
5  \********************************************************************/
6
7/* IPC - communication between BitlBee processes                        */
8
9/*
10  This program is free software; you can redistribute it and/or modify
11  it under the terms of the GNU General Public License as published by
12  the Free Software Foundation; either version 2 of the License, or
13  (at your option) any later version.
14
15  This program is distributed in the hope that it will be useful,
16  but WITHOUT ANY WARRANTY; without even the implied warranty of
17  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  GNU General Public License for more details.
19
20  You should have received a copy of the GNU General Public License with
21  the Debian GNU/Linux distribution in /usr/share/common-licenses/GPL;
22  if not, write to the Free Software Foundation, Inc., 59 Temple Place,
23  Suite 330, Boston, MA  02111-1307  USA
24*/
25
26#define BITLBEE_CORE
27#include "bitlbee.h"
28#include "ipc.h"
29#include "commands.h"
30#ifndef _WIN32
31#include <sys/un.h>
32#endif
33
34GSList *child_list = NULL;
35static char *statefile = NULL;
36
37static void ipc_master_cmd_client( irc_t *data, char **cmd )
38{
39        /* Normally data points at an irc_t block, but for the IPC master
40           this is different. We think this scary cast is better than
41           creating a new command_t structure, just to make the compiler
42           happy. */
43        struct bitlbee_child *child = (void*) data;
44       
45        if( child && cmd[1] )
46        {
47                child->host = g_strdup( cmd[1] );
48                child->nick = g_strdup( cmd[2] );
49                child->realname = g_strdup( cmd[3] );
50        }
51       
52        if( g_strcasecmp( cmd[0], "CLIENT" ) == 0 )
53                ipc_to_children_str( "OPERMSG :Client connecting (PID=%d): %s@%s (%s)\r\n",
54                                     (int) ( child ? child->pid : -1 ), cmd[2], cmd[1], cmd[3] );
55}
56
57static void ipc_master_cmd_die( irc_t *data, char **cmd )
58{
59        if( global.conf->runmode == RUNMODE_FORKDAEMON )
60                ipc_to_children_str( "DIE\r\n" );
61       
62        bitlbee_shutdown( NULL, -1, 0 );
63}
64
65void ipc_master_cmd_rehash( irc_t *data, char **cmd )
66{
67        runmode_t oldmode;
68       
69        oldmode = global.conf->runmode;
70       
71        g_free( global.conf );
72        global.conf = conf_load( 0, NULL );
73       
74        if( global.conf->runmode != oldmode )
75        {
76                log_message( LOGLVL_WARNING, "Can't change RunMode setting at runtime, restoring original setting" );
77                global.conf->runmode = oldmode;
78        }
79       
80        if( global.conf->runmode == RUNMODE_FORKDAEMON )
81                ipc_to_children( cmd );
82}
83
84void ipc_master_cmd_restart( irc_t *data, char **cmd )
85{
86        if( global.conf->runmode != RUNMODE_FORKDAEMON )
87        {
88                /* Tell child that this is unsupported. */
89                return;
90        }
91       
92        global.restart = -1;
93        bitlbee_shutdown( NULL, -1, 0 );
94}
95
96static const command_t ipc_master_commands[] = {
97        { "client",     3, ipc_master_cmd_client,     0 },
98        { "hello",      0, ipc_master_cmd_client,     0 },
99        { "die",        0, ipc_master_cmd_die,        0 },
100        { "wallops",    1, NULL,                      IPC_CMD_TO_CHILDREN },
101        { "wall",       1, NULL,                      IPC_CMD_TO_CHILDREN },
102        { "opermsg",    1, NULL,                      IPC_CMD_TO_CHILDREN },
103        { "rehash",     0, ipc_master_cmd_rehash,     0 },
104        { "kill",       2, NULL,                      IPC_CMD_TO_CHILDREN },
105        { "restart",    0, ipc_master_cmd_restart,    0 },
106        { NULL }
107};
108
109
110static void ipc_child_cmd_die( irc_t *irc, char **cmd )
111{
112        irc_abort( irc, 0, "Shutdown requested by operator" );
113}
114
115static void ipc_child_cmd_wallops( irc_t *irc, char **cmd )
116{
117        if( !( irc->status & USTATUS_LOGGED_IN ) )
118                return;
119       
120        if( strchr( irc->umode, 'w' ) )
121                irc_write( irc, ":%s WALLOPS :%s", irc->myhost, cmd[1] );
122}
123
124static void ipc_child_cmd_wall( irc_t *irc, char **cmd )
125{
126        if( !( irc->status & USTATUS_LOGGED_IN ) )
127                return;
128       
129        if( strchr( irc->umode, 's' ) )
130                irc_write( irc, ":%s NOTICE %s :%s", irc->myhost, irc->nick, cmd[1] );
131}
132
133static void ipc_child_cmd_opermsg( irc_t *irc, char **cmd )
134{
135        if( !( irc->status & USTATUS_LOGGED_IN ) )
136                return;
137       
138        if( strchr( irc->umode, 'o' ) )
139                irc_write( irc, ":%s NOTICE %s :*** OperMsg *** %s", irc->myhost, irc->nick, cmd[1] );
140}
141
142static void ipc_child_cmd_rehash( irc_t *irc, char **cmd )
143{
144        runmode_t oldmode;
145       
146        oldmode = global.conf->runmode;
147       
148        g_free( global.conf );
149        global.conf = conf_load( 0, NULL );
150       
151        global.conf->runmode = oldmode;
152}
153
154static void ipc_child_cmd_kill( irc_t *irc, char **cmd )
155{
156        if( !( irc->status & USTATUS_LOGGED_IN ) )
157                return;
158       
159        if( nick_cmp( cmd[1], irc->nick ) != 0 )
160                return;         /* It's not for us. */
161       
162        irc_write( irc, ":%s!%s@%s KILL %s :%s", irc->mynick, irc->mynick, irc->myhost, irc->nick, cmd[2] );
163        irc_abort( irc, 0, "Killed by operator: %s", cmd[2] );
164}
165
166static void ipc_child_cmd_hello( irc_t *irc, char **cmd )
167{
168        if( !( irc->status & USTATUS_LOGGED_IN ) )
169                ipc_to_master_str( "HELLO\r\n" );
170        else
171                ipc_to_master_str( "HELLO %s %s :%s\r\n", irc->host, irc->nick, irc->realname );
172}
173
174static const command_t ipc_child_commands[] = {
175        { "die",        0, ipc_child_cmd_die,         0 },
176        { "wallops",    1, ipc_child_cmd_wallops,     0 },
177        { "wall",       1, ipc_child_cmd_wall,        0 },
178        { "opermsg",    1, ipc_child_cmd_opermsg,     0 },
179        { "rehash",     0, ipc_child_cmd_rehash,      0 },
180        { "kill",       2, ipc_child_cmd_kill,        0 },
181        { "hello",      0, ipc_child_cmd_hello,       0 },
182        { NULL }
183};
184
185
186static void ipc_command_exec( void *data, char **cmd, const command_t *commands )
187{
188        int i, j;
189       
190        if( !cmd[0] )
191                return;
192       
193        for( i = 0; commands[i].command; i ++ )
194                if( g_strcasecmp( commands[i].command, cmd[0] ) == 0 )
195                {
196                        /* There is no typo in this line: */
197                        for( j = 1; cmd[j]; j ++ ); j --;
198                       
199                        if( j < commands[i].required_parameters )
200                                break;
201                       
202                        if( commands[i].flags & IPC_CMD_TO_CHILDREN )
203                                ipc_to_children( cmd );
204                        else
205                                commands[i].execute( data, cmd );
206                       
207                        break;
208                }
209}
210
211static char *ipc_readline( int fd )
212{
213        char *buf, *eol;
214        int size;
215       
216        buf = g_new0( char, 513 );
217       
218        /* Because this is internal communication, it should be pretty safe
219           to just peek at the message, find its length (by searching for the
220           end-of-line) and then just read that message. With internal
221           sockets and limites message length, messages should always be
222           complete. Saves us quite a lot of code and buffering. */
223        size = recv( fd, buf, 512, MSG_PEEK );
224        if( size == 0 || ( size < 0 && !sockerr_again() ) )
225                return NULL;
226        else if( size < 0 ) /* && sockerr_again() */
227                return( g_strdup( "" ) );
228        else
229                buf[size] = 0;
230       
231        eol = strstr( buf, "\r\n" );
232        if( eol == NULL )
233                return NULL;
234        else
235                size = eol - buf + 2;
236       
237        g_free( buf );
238        buf = g_new0( char, size + 1 );
239       
240        if( recv( fd, buf, size, 0 ) != size )
241                return NULL;
242        else
243                buf[size-2] = 0;
244       
245        return buf;
246}
247
248gboolean ipc_master_read( gpointer data, gint source, b_input_condition cond )
249{
250        char *buf, **cmd;
251       
252        if( ( buf = ipc_readline( source ) ) )
253        {
254                cmd = irc_parse_line( buf );
255                if( cmd )
256                        ipc_command_exec( data, cmd, ipc_master_commands );
257        }
258        else
259        {
260                ipc_master_free_fd( source );
261        }
262       
263        return TRUE;
264}
265
266gboolean ipc_child_read( gpointer data, gint source, b_input_condition cond )
267{
268        char *buf, **cmd;
269       
270        if( ( buf = ipc_readline( source ) ) )
271        {
272                cmd = irc_parse_line( buf );
273                if( cmd )
274                        ipc_command_exec( data, cmd, ipc_child_commands );
275        }
276        else
277        {
278                ipc_child_disable();
279        }
280       
281        return TRUE;
282}
283
284void ipc_to_master( char **cmd )
285{
286        if( global.conf->runmode == RUNMODE_FORKDAEMON )
287        {
288                char *s = irc_build_line( cmd );
289                ipc_to_master_str( "%s", s );
290                g_free( s );
291        }
292        else if( global.conf->runmode == RUNMODE_DAEMON )
293        {
294                ipc_command_exec( NULL, cmd, ipc_master_commands );
295        }
296}
297
298void ipc_to_master_str( char *format, ... )
299{
300        char *msg_buf;
301        va_list params;
302
303        va_start( params, format );
304        msg_buf = g_strdup_vprintf( format, params );
305        va_end( params );
306       
307        if( strlen( msg_buf ) > 512 )
308        {
309                /* Don't send it, it's too long... */
310        }
311        else if( global.conf->runmode == RUNMODE_FORKDAEMON )
312        {
313                if( global.listen_socket >= 0 )
314                        if( write( global.listen_socket, msg_buf, strlen( msg_buf ) ) <= 0 )
315                                ipc_child_disable();
316        }
317        else if( global.conf->runmode == RUNMODE_DAEMON )
318        {
319                char **cmd, *s;
320               
321                if( ( s = strchr( msg_buf, '\r' ) ) )
322                        *s = 0;
323               
324                cmd = irc_parse_line( msg_buf );
325                ipc_command_exec( NULL, cmd, ipc_master_commands );
326                g_free( cmd );
327        }
328       
329        g_free( msg_buf );
330}
331
332void ipc_to_children( char **cmd )
333{
334        if( global.conf->runmode == RUNMODE_FORKDAEMON )
335        {
336                char *msg_buf = irc_build_line( cmd );
337                ipc_to_children_str( "%s", msg_buf );
338                g_free( msg_buf );
339        }
340        else if( global.conf->runmode == RUNMODE_DAEMON )
341        {
342                GSList *l;
343               
344                for( l = irc_connection_list; l; l = l->next )
345                        ipc_command_exec( l->data, cmd, ipc_child_commands );
346        }
347}
348
349void ipc_to_children_str( char *format, ... )
350{
351        char *msg_buf;
352        va_list params;
353
354        va_start( params, format );
355        msg_buf = g_strdup_vprintf( format, params );
356        va_end( params );
357       
358        if( strlen( msg_buf ) > 512 )
359        {
360                /* Don't send it, it's too long... */
361        }
362        else if( global.conf->runmode == RUNMODE_FORKDAEMON )
363        {
364                int msg_len = strlen( msg_buf );
365                GSList *l, *next;
366               
367                for( l = child_list; l; l = next )
368                {
369                        struct bitlbee_child *c = l->data;
370                       
371                        next = l->next;
372                        if( write( c->ipc_fd, msg_buf, msg_len ) <= 0 )
373                        {
374                                ipc_master_free_one( c );
375                                child_list = g_slist_remove( child_list, c );
376                        }
377                }
378        }
379        else if( global.conf->runmode == RUNMODE_DAEMON )
380        {
381                char **cmd, *s;
382               
383                if( ( s = strchr( msg_buf, '\r' ) ) )
384                        *s = 0;
385               
386                cmd = irc_parse_line( msg_buf );
387                ipc_to_children( cmd );
388                g_free( cmd );
389        }
390       
391        g_free( msg_buf );
392}
393
394void ipc_master_free_one( struct bitlbee_child *c )
395{
396        b_event_remove( c->ipc_inpa );
397        closesocket( c->ipc_fd );
398       
399        g_free( c->host );
400        g_free( c->nick );
401        g_free( c->realname );
402        g_free( c );
403}
404
405void ipc_master_free_fd( int fd )
406{
407        GSList *l;
408        struct bitlbee_child *c;
409       
410        for( l = child_list; l; l = l->next )
411        {
412                c = l->data;
413                if( c->ipc_fd == fd )
414                {
415                        ipc_master_free_one( c );
416                        child_list = g_slist_remove( child_list, c );
417                        break;
418                }
419        }
420}
421
422void ipc_master_free_all()
423{
424        GSList *l;
425       
426        for( l = child_list; l; l = l->next )
427                ipc_master_free_one( l->data );
428       
429        g_slist_free( child_list );
430        child_list = NULL;
431}
432
433void ipc_child_disable()
434{
435        b_event_remove( global.listen_watch_source_id );
436        close( global.listen_socket );
437       
438        global.listen_socket = -1;
439}
440
441#ifndef _WIN32
442char *ipc_master_save_state()
443{
444        char *fn = g_strdup( "/tmp/bee-restart.XXXXXX" );
445        int fd = mkstemp( fn );
446        GSList *l;
447        FILE *fp;
448        int i;
449       
450        if( fd == -1 )
451        {
452                log_message( LOGLVL_ERROR, "Could not create temporary file: %s", strerror( errno ) );
453                g_free( fn );
454                return NULL;
455        }
456       
457        /* This is more convenient now. */
458        fp = fdopen( fd, "w" );
459       
460        for( l = child_list, i = 0; l; l = l->next )
461                i ++;
462       
463        /* Number of client processes. */
464        fprintf( fp, "%d\n", i );
465       
466        for( l = child_list; l; l = l->next )
467                fprintf( fp, "%d %d\n", (int) ((struct bitlbee_child*)l->data)->pid,
468                                        ((struct bitlbee_child*)l->data)->ipc_fd );
469       
470        if( fclose( fp ) == 0 )
471        {
472                return fn;
473        }
474        else
475        {
476                unlink( fn );
477                g_free( fn );
478                return NULL;
479        }
480}
481
482void ipc_master_set_statefile( char *fn )
483{
484        statefile = g_strdup( fn );
485}
486
487
488static gboolean new_ipc_client( gpointer data, gint serversock, b_input_condition cond )
489{
490        struct bitlbee_child *child = g_new0( struct bitlbee_child, 1 );
491       
492        child->ipc_fd = accept( serversock, NULL, 0 );
493       
494        if( child->ipc_fd == -1 )
495        {
496                log_message( LOGLVL_WARNING, "Unable to accept connection on UNIX domain socket: %s", strerror(errno) );
497                return TRUE;
498        }
499               
500        child->ipc_inpa = b_input_add( child->ipc_fd, GAIM_INPUT_READ, ipc_master_read, child );
501       
502        child_list = g_slist_append( child_list, child );
503       
504        return TRUE;
505}
506
507int ipc_master_listen_socket()
508{
509        struct sockaddr_un un_addr;
510        int serversock;
511
512        /* Clean up old socket files that were hanging around.. */
513        if (unlink(IPCSOCKET) == -1 && errno != ENOENT) {
514                log_message( LOGLVL_ERROR, "Could not remove old IPC socket at %s: %s", IPCSOCKET, strerror(errno) );
515                return 0;
516        }
517
518        un_addr.sun_family = AF_UNIX;
519        strcpy(un_addr.sun_path, IPCSOCKET);
520
521        serversock = socket(AF_UNIX, SOCK_STREAM, PF_UNIX);
522
523        if (serversock == -1) {
524                log_message( LOGLVL_WARNING, "Unable to create UNIX socket: %s", strerror(errno) );
525                return 0;
526        }
527
528        if (bind(serversock, (struct sockaddr *)&un_addr, sizeof(un_addr)) == -1) {
529                log_message( LOGLVL_WARNING, "Unable to bind UNIX socket to %s: %s", IPCSOCKET, strerror(errno) );
530                return 0;
531        }
532
533        if (listen(serversock, 5) == -1) {
534                log_message( LOGLVL_WARNING, "Unable to listen on UNIX socket: %s", strerror(errno) );
535                return 0;
536        }
537       
538        b_input_add( serversock, GAIM_INPUT_READ, new_ipc_client, NULL );
539       
540        return 1;
541}
542#else
543int ipc_master_listen_socket()
544{
545        /* FIXME: Open named pipe \\.\BITLBEE */
546        return 0;
547}
548#endif
549
550int ipc_master_load_state()
551{
552        struct bitlbee_child *child;
553        FILE *fp;
554        int i, n;
555       
556        if( statefile == NULL )
557                return 0;
558        fp = fopen( statefile, "r" );
559        unlink( statefile );    /* Why do it later? :-) */
560        if( fp == NULL )
561                return 0;
562       
563        if( fscanf( fp, "%d", &n ) != 1 )
564        {
565                log_message( LOGLVL_WARNING, "Could not import state information for child processes." );
566                fclose( fp );
567                return 0;
568        }
569       
570        log_message( LOGLVL_INFO, "Importing information for %d child processes.", n );
571        for( i = 0; i < n; i ++ )
572        {
573                child = g_new0( struct bitlbee_child, 1 );
574               
575                if( fscanf( fp, "%d %d", (int *) &child->pid, &child->ipc_fd ) != 2 )
576                {
577                        log_message( LOGLVL_WARNING, "Unexpected end of file: Only processed %d clients.", i );
578                        g_free( child );
579                        fclose( fp );
580                        return 0;
581                }
582                child->ipc_inpa = b_input_add( child->ipc_fd, GAIM_INPUT_READ, ipc_master_read, child );
583               
584                child_list = g_slist_append( child_list, child );
585        }
586       
587        ipc_to_children_str( "HELLO\r\n" );
588        ipc_to_children_str( "OPERMSG :New BitlBee master process started (version " BITLBEE_VERSION ")\r\n" );
589       
590        fclose( fp );
591        return 1;
592}
Note: See TracBrowser for help on using the repository browser.