source: ipc.c @ 2e815e5

Last change on this file since 2e815e5 was e277e80, checked in by Wilmer van der Gaast <wilmer@…>, at 2013-04-20T22:50:31Z

Add irc_t* argument to all relevant nick_*() functions.

  • Property mode set to 100644
File size: 24.5 KB
Line 
1  /********************************************************************\
2  * BitlBee -- An IRC to other IM-networks gateway                     *
3  *                                                                    *
4  * Copyright 2002-2012 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/uio.h>
32#include <sys/un.h>
33#endif
34
35GSList *child_list = NULL;
36static int ipc_child_recv_fd = -1;
37
38static void ipc_master_takeover_fail( struct bitlbee_child *child, gboolean both );
39static gboolean ipc_send_fd( int fd, int send_fd );
40
41/* On Solaris and possibly other systems passing FDs between processes is
42 * not possible (or at least not using the method used in this file.
43 * Just disable that code, the functionality is not that important. */
44#if defined(NO_FD_PASSING) && !defined(CMSG_SPACE)
45#define CMSG_SPACE(len) 1
46#endif
47
48static void ipc_master_cmd_client( irc_t *data, char **cmd )
49{
50        /* Normally data points at an irc_t block, but for the IPC master
51           this is different. We think this scary cast is better than
52           creating a new command_t structure, just to make the compiler
53           happy. */
54        struct bitlbee_child *child = (void*) data;
55       
56        if( child && cmd[1] )
57        {
58                child->host = g_strdup( cmd[1] );
59                child->nick = g_strdup( cmd[2] );
60                child->realname = g_strdup( cmd[3] );
61        }
62       
63        /* CLIENT == On initial connects, HELLO is after /RESTARTs. */
64        if( g_strcasecmp( cmd[0], "CLIENT" ) == 0 )
65                ipc_to_children_str( "OPERMSG :Client connecting (PID=%d): %s@%s (%s)\r\n",
66                                     (int) ( child ? child->pid : -1 ), cmd[2], cmd[1], cmd[3] );
67}
68
69static void ipc_master_cmd_nick( irc_t *data, char **cmd )
70{
71        struct bitlbee_child *child = (void*) data;
72       
73        if( child && cmd[1] )
74        {
75                g_free( child->nick );
76                child->nick = g_strdup( cmd[1] );
77        }
78}
79
80static void ipc_master_cmd_die( irc_t *data, char **cmd )
81{
82        if( global.conf->runmode == RUNMODE_FORKDAEMON )
83                ipc_to_children_str( "DIE\r\n" );
84       
85        bitlbee_shutdown( NULL, -1, 0 );
86}
87
88static void ipc_master_cmd_deaf( irc_t *data, char **cmd )
89{
90        if( global.conf->runmode == RUNMODE_DAEMON )
91        {
92                b_event_remove( global.listen_watch_source_id );
93                close( global.listen_socket );
94               
95                global.listen_socket = global.listen_watch_source_id = -1;
96       
97                ipc_to_children_str( "OPERMSG :Closed listening socket, waiting "
98                                     "for all users to disconnect." );
99        }
100        else
101        {
102                ipc_to_children_str( "OPERMSG :The DEAF command only works in "
103                                     "normal daemon mode. Try DIE instead." );
104        }
105}
106
107void ipc_master_cmd_rehash( irc_t *data, char **cmd )
108{
109        runmode_t oldmode;
110       
111        oldmode = global.conf->runmode;
112       
113        g_free( global.conf );
114        global.conf = conf_load( 0, NULL );
115       
116        if( global.conf->runmode != oldmode )
117        {
118                log_message( LOGLVL_WARNING, "Can't change RunMode setting at runtime, restoring original setting" );
119                global.conf->runmode = oldmode;
120        }
121       
122        if( global.conf->runmode == RUNMODE_FORKDAEMON )
123                ipc_to_children( cmd );
124}
125
126void ipc_master_cmd_restart( irc_t *data, char **cmd )
127{
128        if( global.conf->runmode != RUNMODE_FORKDAEMON )
129        {
130                /* Tell child that this is unsupported. */
131                return;
132        }
133       
134        global.restart = -1;
135        bitlbee_shutdown( NULL, -1, 0 );
136}
137
138void ipc_master_cmd_identify( irc_t *data, char **cmd )
139{
140        struct bitlbee_child *child = (void*) data, *old = NULL;
141        char *resp;
142        GSList *l;
143       
144        if( !child || !child->nick || strcmp( child->nick, cmd[1] ) != 0 )
145                return;
146       
147        g_free( child->password );
148        child->password = g_strdup( cmd[2] );
149       
150        for( l = child_list; l; l = l->next )
151        {
152                old = l->data;
153                if( child != old &&
154                    old->nick && nick_cmp( NULL, old->nick, child->nick ) == 0 &&
155                    old->password && strcmp( old->password, child->password ) == 0 )
156                        break;
157        }
158       
159        if( l && !child->to_child && !old->to_child )
160        {
161                resp = "TAKEOVER INIT\r\n";
162                child->to_child = old;
163                old->to_child = child;
164        }
165        else
166        {
167                /* Won't need the fd since we can't send it anywhere. */
168                closesocket( child->to_fd );
169                child->to_fd = -1;
170                resp = "TAKEOVER NO\r\n";
171        }
172       
173        if( write( child->ipc_fd, resp, strlen( resp ) ) != strlen( resp ) )
174                ipc_master_free_one( child );
175}
176
177
178void ipc_master_cmd_takeover( irc_t *data, char **cmd )
179{
180        struct bitlbee_child *child = (void*) data;
181        char *fwd = NULL;
182       
183        /* Normal daemon mode doesn't keep these and has simplified code for
184           takeovers. */
185        if( child == NULL )
186                return;
187       
188        if( child->to_child == NULL ||
189            g_slist_find( child_list, child->to_child ) == NULL )
190                return ipc_master_takeover_fail( child, FALSE );
191       
192        if( strcmp( cmd[1], "AUTH" ) == 0 )
193        {
194                /* New connection -> Master */
195                if( child->to_child &&
196                    child->nick && child->to_child->nick && cmd[2] &&
197                    child->password && child->to_child->password && cmd[3] &&
198                    strcmp( child->nick, child->to_child->nick ) == 0 &&
199                    strcmp( child->nick, cmd[2] ) == 0 &&
200                    strcmp( child->password, child->to_child->password ) == 0 &&
201                    strcmp( child->password, cmd[3] ) == 0 )
202                {
203                        ipc_send_fd( child->to_child->ipc_fd, child->to_fd );
204                       
205                        fwd = irc_build_line( cmd );
206                        if( write( child->to_child->ipc_fd, fwd, strlen( fwd ) ) != strlen( fwd ) )
207                                ipc_master_free_one( child );
208                        g_free( fwd );
209                }
210                else
211                        return ipc_master_takeover_fail( child, TRUE );
212        }
213        else if( strcmp( cmd[1], "DONE" ) == 0 || strcmp( cmd[1], "FAIL" ) == 0 )
214        {
215                /* Old connection -> Master */
216                int fd;
217               
218                /* The copy was successful (or not), we don't need it anymore. */
219                closesocket( child->to_fd );
220                child->to_fd = -1;
221               
222                /* Pass it through to the other party, and flush all state. */
223                fwd = irc_build_line( cmd );
224                fd = child->to_child->ipc_fd;
225                child->to_child->to_child = NULL;
226                child->to_child = NULL;
227                if( write( fd, fwd, strlen( fwd ) ) != strlen( fwd ) )
228                        ipc_master_free_one( child );
229                g_free( fwd );
230        }
231}
232
233static const command_t ipc_master_commands[] = {
234        { "client",     3, ipc_master_cmd_client,     0 },
235        { "hello",      0, ipc_master_cmd_client,     0 },
236        { "nick",       1, ipc_master_cmd_nick,       0 },
237        { "die",        0, ipc_master_cmd_die,        0 },
238        { "deaf",       0, ipc_master_cmd_deaf,       0 },
239        { "wallops",    1, NULL,                      IPC_CMD_TO_CHILDREN },
240        { "wall",       1, NULL,                      IPC_CMD_TO_CHILDREN },
241        { "opermsg",    1, NULL,                      IPC_CMD_TO_CHILDREN },
242        { "rehash",     0, ipc_master_cmd_rehash,     0 },
243        { "kill",       2, NULL,                      IPC_CMD_TO_CHILDREN },
244        { "restart",    0, ipc_master_cmd_restart,    0 },
245        { "identify",   2, ipc_master_cmd_identify,   0 },
246        { "takeover",   1, ipc_master_cmd_takeover,   0 },
247        { NULL }
248};
249
250
251static void ipc_child_cmd_die( irc_t *irc, char **cmd )
252{
253        irc_abort( irc, 0, "Shutdown requested by operator" );
254}
255
256static void ipc_child_cmd_wallops( irc_t *irc, char **cmd )
257{
258        if( !( irc->status & USTATUS_LOGGED_IN ) )
259                return;
260       
261        if( strchr( irc->umode, 'w' ) )
262                irc_write( irc, ":%s WALLOPS :%s", irc->root->host, cmd[1] );
263}
264
265static void ipc_child_cmd_wall( irc_t *irc, char **cmd )
266{
267        if( !( irc->status & USTATUS_LOGGED_IN ) )
268                return;
269       
270        if( strchr( irc->umode, 's' ) )
271                irc_write( irc, ":%s NOTICE %s :%s", irc->root->host, irc->user->nick, cmd[1] );
272}
273
274static void ipc_child_cmd_opermsg( irc_t *irc, char **cmd )
275{
276        if( !( irc->status & USTATUS_LOGGED_IN ) )
277                return;
278       
279        if( strchr( irc->umode, 'o' ) )
280                irc_write( irc, ":%s NOTICE %s :*** OperMsg *** %s", irc->root->host, irc->user->nick, cmd[1] );
281}
282
283static void ipc_child_cmd_rehash( irc_t *irc, char **cmd )
284{
285        runmode_t oldmode;
286       
287        oldmode = global.conf->runmode;
288       
289        g_free( global.conf );
290        global.conf = conf_load( 0, NULL );
291       
292        global.conf->runmode = oldmode;
293}
294
295static void ipc_child_cmd_kill( irc_t *irc, char **cmd )
296{
297        if( !( irc->status & USTATUS_LOGGED_IN ) )
298                return;
299       
300        if( nick_cmp( NULL, cmd[1], irc->user->nick ) != 0 )
301                return;         /* It's not for us. */
302       
303        irc_write( irc, ":%s!%s@%s KILL %s :%s", irc->root->nick, irc->root->nick, irc->root->host, irc->user->nick, cmd[2] );
304        irc_abort( irc, 0, "Killed by operator: %s", cmd[2] );
305}
306
307static void ipc_child_cmd_hello( irc_t *irc, char **cmd )
308{
309        if( !( irc->status & USTATUS_LOGGED_IN ) )
310                ipc_to_master_str( "HELLO\r\n" );
311        else
312                ipc_to_master_str( "HELLO %s %s :%s\r\n", irc->user->host, irc->user->nick, irc->user->fullname );
313}
314
315static void ipc_child_cmd_takeover_yes( void *data );
316static void ipc_child_cmd_takeover_no( void *data );
317
318static void ipc_child_cmd_takeover( irc_t *irc, char **cmd )
319{
320        if( strcmp( cmd[1], "NO" ) == 0 )
321        {
322                /* Master->New connection */
323                /* No takeover, finish the login. */
324        }
325        else if( strcmp( cmd[1], "INIT" ) == 0 )
326        {
327                /* Master->New connection */
328                if( !set_getbool( &irc->b->set, "allow_takeover" ) )
329                {
330                        ipc_child_cmd_takeover_no( irc );
331                        return;
332                }
333               
334                /* Offer to take over the old session, unless for some reason
335                   we're already logging into IM connections. */
336                if( irc->login_source_id != -1 )
337                        query_add( irc, NULL,
338                                   "You're already connected to this server. "
339                                   "Would you like to take over this session?",
340                                   ipc_child_cmd_takeover_yes,
341                                   ipc_child_cmd_takeover_no, NULL, irc );
342               
343                /* This one's going to connect to accounts, avoid that. */
344                b_event_remove( irc->login_source_id );
345                irc->login_source_id = -1;
346        }
347        else if( strcmp( cmd[1], "AUTH" ) == 0 )
348        {
349                /* Master->Old connection */
350                if( irc->password && cmd[2] && cmd[3] &&
351                    ipc_child_recv_fd != -1 &&
352                    strcmp( irc->user->nick, cmd[2] ) == 0 &&
353                    strcmp( irc->password, cmd[3] ) == 0 &&
354                    set_getbool( &irc->b->set, "allow_takeover" ) )
355                {
356                        irc_switch_fd( irc, ipc_child_recv_fd );
357                        irc_sync( irc );
358                        irc_rootmsg( irc, "You've successfully taken over your old session" );
359                        ipc_child_recv_fd = -1;
360                       
361                        ipc_to_master_str( "TAKEOVER DONE\r\n" );
362                }
363                else
364                {
365                        ipc_to_master_str( "TAKEOVER FAIL\r\n" );
366                }
367        }
368        else if( strcmp( cmd[1], "DONE" ) == 0 ) 
369        {
370                /* Master->New connection (now taken over by old process) */
371                irc_free( irc );
372        }
373        else if( strcmp( cmd[1], "FAIL" ) == 0 ) 
374        {
375                /* Master->New connection */
376                irc_rootmsg( irc, "Could not take over old session" );
377        }
378}
379
380static void ipc_child_cmd_takeover_yes( void *data )
381{
382        irc_t *irc = data, *old = NULL;
383        char *to_auth[] = { "TAKEOVER", "AUTH", irc->user->nick, irc->password, NULL };
384       
385        /* Master->New connection */
386        ipc_to_master_str( "TAKEOVER AUTH %s :%s\r\n",
387                           irc->user->nick, irc->password );
388       
389        if( global.conf->runmode == RUNMODE_DAEMON )
390        {
391                GSList *l;
392               
393                for( l = irc_connection_list; l; l = l->next )
394                {
395                        old = l->data;
396                       
397                        if( irc != old &&
398                            irc->user->nick && old->user->nick &&
399                            irc->password && old->password &&
400                            strcmp( irc->user->nick, old->user->nick ) == 0 &&
401                            strcmp( irc->password, old->password ) == 0 )
402                                break;
403                }
404                if( l == NULL )
405                {
406                        to_auth[1] = "FAIL";
407                        ipc_child_cmd_takeover( irc, to_auth );
408                        return;
409                }
410        }
411       
412        /* Drop credentials, we'll shut down soon and shouldn't overwrite
413           any settings. */
414        irc_rootmsg( irc, "Trying to take over existing session" );
415       
416        irc_desync( irc );
417       
418        if( old )
419        {
420                ipc_child_recv_fd = dup( irc->fd );
421                ipc_child_cmd_takeover( old, to_auth );
422        }
423       
424        /* TODO: irc_setpass() should do all of this. */
425        irc_setpass( irc, NULL );
426        irc->status &= ~USTATUS_IDENTIFIED;
427        irc_umode_set( irc, "-R", 1 );
428       
429        if( old )
430                irc_abort( irc, FALSE, NULL );
431}
432
433static void ipc_child_cmd_takeover_no( void *data )
434{
435        ipc_to_master_str( "TAKEOVER NO\r\n" );
436        cmd_identify_finish( data, 0, 0 );
437}
438
439static const command_t ipc_child_commands[] = {
440        { "die",        0, ipc_child_cmd_die,         0 },
441        { "wallops",    1, ipc_child_cmd_wallops,     0 },
442        { "wall",       1, ipc_child_cmd_wall,        0 },
443        { "opermsg",    1, ipc_child_cmd_opermsg,     0 },
444        { "rehash",     0, ipc_child_cmd_rehash,      0 },
445        { "kill",       2, ipc_child_cmd_kill,        0 },
446        { "hello",      0, ipc_child_cmd_hello,       0 },
447        { "takeover",   1, ipc_child_cmd_takeover,    0 },
448        { NULL }
449};
450
451gboolean ipc_child_identify( irc_t *irc )
452{
453        if( global.conf->runmode == RUNMODE_FORKDAEMON )
454        {
455#ifndef NO_FD_PASSING
456                if( !ipc_send_fd( global.listen_socket, irc->fd ) )
457                        ipc_child_disable();
458       
459                ipc_to_master_str( "IDENTIFY %s :%s\r\n", irc->user->nick, irc->password );
460#endif
461               
462                return TRUE;
463        }
464        else if( global.conf->runmode == RUNMODE_DAEMON )
465        {
466                GSList *l;
467                irc_t *old;
468                char *to_init[] = { "TAKEOVER", "INIT", NULL };
469               
470                for( l = irc_connection_list; l; l = l->next )
471                {
472                        old = l->data;
473                       
474                        if( irc != old &&
475                            irc->user->nick && old->user->nick &&
476                            irc->password && old->password &&
477                            strcmp( irc->user->nick, old->user->nick ) == 0 &&
478                            strcmp( irc->password, old->password ) == 0 )
479                                break;
480                }
481                if( l == NULL ||
482                    !set_getbool( &irc->b->set, "allow_takeover" ) ||
483                    !set_getbool( &old->b->set, "allow_takeover" ) )
484                        return FALSE;
485               
486                ipc_child_cmd_takeover( irc, to_init );
487               
488                return TRUE;
489        }
490        else
491                return FALSE;
492}
493
494static void ipc_master_takeover_fail( struct bitlbee_child *child, gboolean both )
495{
496        if( child == NULL || g_slist_find( child_list, child ) == NULL )
497                return;
498       
499        if( both && child->to_child != NULL )
500                ipc_master_takeover_fail( child->to_child, FALSE );
501       
502        if( child->to_fd > -1 )
503        {
504                /* Send this error only to the new connection, which can be
505                   recognised by to_fd being set. */
506                if( write( child->ipc_fd, "TAKEOVER FAIL\r\n", 15 ) != 15 )
507                {
508                        ipc_master_free_one( child );
509                        return;
510                }
511                close( child->to_fd );
512                child->to_fd = -1;
513        }
514        child->to_child = NULL;
515}
516
517static void ipc_command_exec( void *data, char **cmd, const command_t *commands )
518{
519        int i, j;
520       
521        if( !cmd[0] )
522                return;
523       
524        for( i = 0; commands[i].command; i ++ )
525                if( g_strcasecmp( commands[i].command, cmd[0] ) == 0 )
526                {
527                        /* There is no typo in this line: */
528                        for( j = 1; cmd[j]; j ++ ); j --;
529                       
530                        if( j < commands[i].required_parameters )
531                                break;
532                       
533                        if( commands[i].flags & IPC_CMD_TO_CHILDREN )
534                                ipc_to_children( cmd );
535                        else
536                                commands[i].execute( data, cmd );
537                       
538                        break;
539                }
540}
541
542/* Return just one line. Returns NULL if something broke, an empty string
543   on temporary "errors" (EAGAIN and friends). */
544static char *ipc_readline( int fd, int *recv_fd )
545{
546        struct msghdr msg;
547        struct iovec iov;
548        char ccmsg[CMSG_SPACE(sizeof(recv_fd))];
549        struct cmsghdr *cmsg;
550        char buf[513], *eol;
551        int size;
552       
553        /* Because this is internal communication, it should be pretty safe
554           to just peek at the message, find its length (by searching for the
555           end-of-line) and then just read that message. With internal
556           sockets and limites message length, messages should always be
557           complete. Saves us quite a lot of code and buffering. */
558        size = recv( fd, buf, sizeof( buf ) - 1, MSG_PEEK );
559        if( size == 0 || ( size < 0 && !sockerr_again() ) )
560                return NULL;
561        else if( size < 0 ) /* && sockerr_again() */
562                return( g_strdup( "" ) );
563        else
564                buf[size] = 0;
565       
566        if( ( eol = strstr( buf, "\r\n" ) ) == NULL )
567                return NULL;
568        else
569                size = eol - buf + 2;
570       
571        iov.iov_base = buf;
572        iov.iov_len = size;
573       
574        memset( &msg, 0, sizeof( msg ) );
575        msg.msg_iov = &iov;
576        msg.msg_iovlen = 1;
577#ifndef NO_FD_PASSING
578        msg.msg_control = ccmsg;
579        msg.msg_controllen = sizeof( ccmsg );
580#endif
581       
582        if( recvmsg( fd, &msg, 0 ) != size )
583                return NULL;
584       
585#ifndef NO_FD_PASSING
586        if( recv_fd )
587                for( cmsg = CMSG_FIRSTHDR( &msg ); cmsg; cmsg = CMSG_NXTHDR( &msg, cmsg ) )
588                        if( cmsg->cmsg_level == SOL_SOCKET && cmsg->cmsg_type == SCM_RIGHTS )
589                        {
590                                /* Getting more than one shouldn't happen but if it does,
591                                   make sure we don't leave them around. */
592                                if( *recv_fd != -1 )
593                                        close( *recv_fd );
594                               
595                                *recv_fd = *(int*) CMSG_DATA( cmsg );
596                                /*
597                                fprintf( stderr, "pid %d received fd %d\n", (int) getpid(), *recv_fd );
598                                */
599                        }
600#endif
601       
602        /*
603        fprintf( stderr, "pid %d received: %s", (int) getpid(), buf );
604        */
605        return g_strndup( buf, size - 2 );
606}
607
608gboolean ipc_master_read( gpointer data, gint source, b_input_condition cond )
609{
610        struct bitlbee_child *child = data;
611        char *buf, **cmd;
612       
613        if( ( buf = ipc_readline( source, &child->to_fd ) ) )
614        {
615                cmd = irc_parse_line( buf );
616                if( cmd )
617                {
618                        ipc_command_exec( child, cmd, ipc_master_commands );
619                        g_free( cmd );
620                }
621                g_free( buf );
622        }
623        else
624        {
625                ipc_master_free_fd( source );
626        }
627       
628        return TRUE;
629}
630
631gboolean ipc_child_read( gpointer data, gint source, b_input_condition cond )
632{
633        char *buf, **cmd;
634       
635        if( ( buf = ipc_readline( source, &ipc_child_recv_fd ) ) )
636        {
637                cmd = irc_parse_line( buf );
638                if( cmd )
639                {
640                        ipc_command_exec( data, cmd, ipc_child_commands );
641                        g_free( cmd );
642                }
643                g_free( buf );
644        }
645        else
646        {
647                ipc_child_disable();
648        }
649       
650        return TRUE;
651}
652
653void ipc_to_master( char **cmd )
654{
655        if( global.conf->runmode == RUNMODE_FORKDAEMON )
656        {
657                char *s = irc_build_line( cmd );
658                ipc_to_master_str( "%s", s );
659                g_free( s );
660        }
661        else if( global.conf->runmode == RUNMODE_DAEMON )
662        {
663                ipc_command_exec( NULL, cmd, ipc_master_commands );
664        }
665}
666
667void ipc_to_master_str( char *format, ... )
668{
669        char *msg_buf;
670        va_list params;
671
672        va_start( params, format );
673        msg_buf = g_strdup_vprintf( format, params );
674        va_end( params );
675       
676        if( strlen( msg_buf ) > 512 )
677        {
678                /* Don't send it, it's too long... */
679        }
680        else if( global.conf->runmode == RUNMODE_FORKDAEMON )
681        {
682                if( global.listen_socket >= 0 )
683                        if( write( global.listen_socket, msg_buf, strlen( msg_buf ) ) <= 0 )
684                                ipc_child_disable();
685        }
686        else if( global.conf->runmode == RUNMODE_DAEMON )
687        {
688                char **cmd, *s;
689               
690                if( ( s = strchr( msg_buf, '\r' ) ) )
691                        *s = 0;
692               
693                cmd = irc_parse_line( msg_buf );
694                ipc_command_exec( NULL, cmd, ipc_master_commands );
695                g_free( cmd );
696        }
697       
698        g_free( msg_buf );
699}
700
701void ipc_to_children( char **cmd )
702{
703        if( global.conf->runmode == RUNMODE_FORKDAEMON )
704        {
705                char *msg_buf = irc_build_line( cmd );
706                ipc_to_children_str( "%s", msg_buf );
707                g_free( msg_buf );
708        }
709        else if( global.conf->runmode == RUNMODE_DAEMON )
710        {
711                GSList *l;
712               
713                for( l = irc_connection_list; l; l = l->next )
714                        ipc_command_exec( l->data, cmd, ipc_child_commands );
715        }
716}
717
718void ipc_to_children_str( char *format, ... )
719{
720        char *msg_buf;
721        va_list params;
722
723        va_start( params, format );
724        msg_buf = g_strdup_vprintf( format, params );
725        va_end( params );
726       
727        if( strlen( msg_buf ) > 512 )
728        {
729                /* Don't send it, it's too long... */
730        }
731        else if( global.conf->runmode == RUNMODE_FORKDAEMON )
732        {
733                int msg_len = strlen( msg_buf );
734                GSList *l, *next;
735               
736                for( l = child_list; l; l = next )
737                {
738                        struct bitlbee_child *c = l->data;
739                       
740                        next = l->next;
741                        if( write( c->ipc_fd, msg_buf, msg_len ) <= 0 )
742                                ipc_master_free_one( c );
743                }
744        }
745        else if( global.conf->runmode == RUNMODE_DAEMON )
746        {
747                char **cmd, *s;
748               
749                if( ( s = strchr( msg_buf, '\r' ) ) )
750                        *s = 0;
751               
752                cmd = irc_parse_line( msg_buf );
753                ipc_to_children( cmd );
754                g_free( cmd );
755        }
756       
757        g_free( msg_buf );
758}
759
760static gboolean ipc_send_fd( int fd, int send_fd )
761{
762        struct msghdr msg;
763        struct iovec iov;
764        char ccmsg[CMSG_SPACE(sizeof(fd))];
765        struct cmsghdr *cmsg;
766       
767        memset( &msg, 0, sizeof( msg ) );
768        iov.iov_base = "0x90\r\n";         /* Ja, noppes */
769        iov.iov_len = 6;
770        msg.msg_iov = &iov;
771        msg.msg_iovlen = 1;
772       
773#ifndef NO_FD_PASSING
774        msg.msg_control = ccmsg;
775        msg.msg_controllen = sizeof( ccmsg );
776        cmsg = CMSG_FIRSTHDR( &msg );
777        cmsg->cmsg_level = SOL_SOCKET;
778        cmsg->cmsg_type = SCM_RIGHTS;
779        cmsg->cmsg_len = CMSG_LEN( sizeof( send_fd ) );
780        *(int*)CMSG_DATA( cmsg ) = send_fd;
781        msg.msg_controllen = cmsg->cmsg_len;
782#endif
783       
784        return sendmsg( fd, &msg, 0 ) == 6;
785}
786
787void ipc_master_free_one( struct bitlbee_child *c )
788{
789        GSList *l;
790       
791        b_event_remove( c->ipc_inpa );
792        closesocket( c->ipc_fd );
793       
794        if( c->to_fd != -1 )
795                close( c->to_fd );
796       
797        g_free( c->host );
798        g_free( c->nick );
799        g_free( c->realname );
800        g_free( c->password );
801        g_free( c );
802       
803        child_list = g_slist_remove( child_list, c );
804       
805        /* Also, if any child has a reference to this one, remove it. */
806        for( l = child_list; l; l = l->next )
807        {
808                struct bitlbee_child *oc = l->data;
809               
810                if( oc->to_child == c )
811                        ipc_master_takeover_fail( oc, FALSE );
812        }
813}
814
815void ipc_master_free_fd( int fd )
816{
817        GSList *l;
818        struct bitlbee_child *c;
819       
820        for( l = child_list; l; l = l->next )
821        {
822                c = l->data;
823                if( c->ipc_fd == fd )
824                {
825                        ipc_master_free_one( c );
826                        break;
827                }
828        }
829}
830
831void ipc_master_free_all()
832{
833        while( child_list )
834                ipc_master_free_one( child_list->data );
835}
836
837void ipc_child_disable()
838{
839        b_event_remove( global.listen_watch_source_id );
840        close( global.listen_socket );
841       
842        global.listen_socket = -1;
843}
844
845#ifndef _WIN32
846char *ipc_master_save_state()
847{
848        char *fn = g_strdup( "/tmp/bee-restart.XXXXXX" );
849        int fd = mkstemp( fn );
850        GSList *l;
851        FILE *fp;
852        int i;
853       
854        if( fd == -1 )
855        {
856                log_message( LOGLVL_ERROR, "Could not create temporary file: %s", strerror( errno ) );
857                g_free( fn );
858                return NULL;
859        }
860       
861        /* This is more convenient now. */
862        fp = fdopen( fd, "w" );
863       
864        for( l = child_list, i = 0; l; l = l->next )
865                i ++;
866       
867        /* Number of client processes. */
868        fprintf( fp, "%d\n", i );
869       
870        for( l = child_list; l; l = l->next )
871                fprintf( fp, "%d %d\n", (int) ((struct bitlbee_child*)l->data)->pid,
872                                        ((struct bitlbee_child*)l->data)->ipc_fd );
873       
874        if( fclose( fp ) == 0 )
875        {
876                return fn;
877        }
878        else
879        {
880                unlink( fn );
881                g_free( fn );
882                return NULL;
883        }
884}
885
886
887static gboolean new_ipc_client( gpointer data, gint serversock, b_input_condition cond )
888{
889        struct bitlbee_child *child = g_new0( struct bitlbee_child, 1 );
890       
891        child->to_fd = -1;
892        child->ipc_fd = accept( serversock, NULL, 0 );
893        if( child->ipc_fd == -1 )
894        {
895                log_message( LOGLVL_WARNING, "Unable to accept connection on UNIX domain socket: %s", strerror(errno) );
896                return TRUE;
897        }
898               
899        child->ipc_inpa = b_input_add( child->ipc_fd, B_EV_IO_READ, ipc_master_read, child );
900       
901        child_list = g_slist_prepend( child_list, child );
902       
903        return TRUE;
904}
905
906int ipc_master_listen_socket()
907{
908        struct sockaddr_un un_addr;
909        int serversock;
910
911        if (!IPCSOCKET || !*IPCSOCKET)
912                return 1;
913
914        /* Clean up old socket files that were hanging around.. */
915        if (unlink(IPCSOCKET) == -1 && errno != ENOENT) {
916                log_message( LOGLVL_ERROR, "Could not remove old IPC socket at %s: %s", IPCSOCKET, strerror(errno) );
917                return 0;
918        }
919
920        un_addr.sun_family = AF_UNIX;
921        strcpy(un_addr.sun_path, IPCSOCKET);
922
923        serversock = socket(AF_UNIX, SOCK_STREAM, PF_UNIX);
924
925        if (serversock == -1) {
926                log_message( LOGLVL_WARNING, "Unable to create UNIX socket: %s", strerror(errno) );
927                return 0;
928        }
929
930        if (bind(serversock, (struct sockaddr *)&un_addr, sizeof(un_addr)) == -1) {
931                log_message( LOGLVL_WARNING, "Unable to bind UNIX socket to %s: %s", IPCSOCKET, strerror(errno) );
932                return 0;
933        }
934
935        if (listen(serversock, 5) == -1) {
936                log_message( LOGLVL_WARNING, "Unable to listen on UNIX socket: %s", strerror(errno) );
937                return 0;
938        }
939       
940        b_input_add( serversock, B_EV_IO_READ, new_ipc_client, NULL );
941       
942        return 1;
943}
944#else
945int ipc_master_listen_socket()
946{
947        /* FIXME: Open named pipe \\.\BITLBEE */
948        return 0;
949}
950#endif
951
952int ipc_master_load_state( char *statefile )
953{
954        struct bitlbee_child *child;
955        FILE *fp;
956        int i, n;
957       
958        if( statefile == NULL )
959                return 0;
960       
961        fp = fopen( statefile, "r" );
962        unlink( statefile );    /* Why do it later? :-) */
963        if( fp == NULL )
964                return 0;
965       
966        if( fscanf( fp, "%d", &n ) != 1 )
967        {
968                log_message( LOGLVL_WARNING, "Could not import state information for child processes." );
969                fclose( fp );
970                return 0;
971        }
972       
973        log_message( LOGLVL_INFO, "Importing information for %d child processes.", n );
974        for( i = 0; i < n; i ++ )
975        {
976                child = g_new0( struct bitlbee_child, 1 );
977               
978                if( fscanf( fp, "%d %d", (int *) &child->pid, &child->ipc_fd ) != 2 )
979                {
980                        log_message( LOGLVL_WARNING, "Unexpected end of file: Only processed %d clients.", i );
981                        g_free( child );
982                        fclose( fp );
983                        return 0;
984                }
985                child->ipc_inpa = b_input_add( child->ipc_fd, B_EV_IO_READ, ipc_master_read, child );
986                child->to_fd = -1;
987               
988                child_list = g_slist_prepend( child_list, child );
989        }
990       
991        ipc_to_children_str( "HELLO\r\n" );
992        ipc_to_children_str( "OPERMSG :New %s master process started (version %s)\r\n", PACKAGE, BITLBEE_VERSION );
993       
994        fclose( fp );
995        return 1;
996}
Note: See TracBrowser for help on using the repository browser.