source: ipc.c @ fa1bc1d

Last change on this file since fa1bc1d was c9e9c9c, checked in by dx <dx@…>, at 2017-03-12T04:27:59Z

Another instance where PF_UNIX was used and shouldn't.

I couldn't find anyplace that actually enables the IPC, but I hand
edited the config.h to enable it, and did see the protocol not supported
failure, so modified this file and it went away.

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