librb/src/helper.c

   1 /*
   2  *  ircd-ratbox: A slightly useful ircd
   3  *  helper.c: Starts and deals with ircd helpers
   4  *
   5  *  Copyright (C) 2006 Aaron Sethman <androsyn@ratbox.org>
   6  *
   7  *  This program is free software; you can redistribute it and/or modify
   8  *  it under the terms of the GNU General Public License as published by
   9  *  the Free Software Foundation; either version 2 of the License, or
  10  *  (at your option) any later version.
  11  *
  12  *  This program is distributed in the hope that it will be useful,
  13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *  GNU General Public License for more details.
  16  *
  17  *  You should have received a copy of the GNU General Public License
  18  *  along with this program; if not, write to the Free Software
  19  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301
  20  *  USA
  21  *
  22  */
  23
  24 #include <librb_config.h>
  25 #include <rb_lib.h>
  26 #include <commio-int.h>
  27
  28 struct _rb_helper
  29 {
  30         char *path;
  31         buf_head_t sendq;
  32         buf_head_t recvq;
  33         rb_fde_t *ifd;
  34         rb_fde_t *ofd;
  35         pid_t pid;
  36         int fork_count;
  37         rb_helper_cb *read_cb;
  38         rb_helper_cb *error_cb;
  39 };
  40
  41
  42 /* setup all the stuff a new child needs */
  43 rb_helper *
  44 rb_helper_child(rb_helper_cb * read_cb, rb_helper_cb * error_cb, log_cb * ilog,
  45                 restart_cb * irestart, die_cb * idie, size_t lb_heap_size,
  46                 size_t dh_size, size_t fd_heap_size)
  47 {
  48         rb_helper *helper;
  49         int maxfd, x = 0;
  50         int ifd, ofd;
  51         char *tifd, *tofd, *tmaxfd;
  52
  53         tifd = getenv("IFD");
  54         tofd = getenv("OFD");
  55         tmaxfd = getenv("MAXFD");
  56
  57         if(tifd == NULL || tofd == NULL || tmaxfd == NULL)
  58                 return NULL;
  59
  60         helper = rb_malloc(sizeof(rb_helper));
  61         ifd = (int)strtol(tifd, NULL, 10);
  62         ofd = (int)strtol(tofd, NULL, 10);
  63         maxfd = (int)strtol(tmaxfd, NULL, 10);
  64
  65 #ifndef _WIN32
  66         for(x = 0; x < maxfd; x++)
  67         {
  68                 if(x != ifd && x != ofd)
  69                         close(x);
  70         }
  71         x = open("/dev/null", O_RDWR);
  72         if(ifd != 0 && ofd != 0)
  73                 dup2(x, 0);
  74         if(ifd != 1 && ofd != 1)
  75                 dup2(x, 1);
  76         if(ifd != 2 && ofd != 2)
  77                 dup2(x, 2);
  78         if(x > 2)               /* don't undo what we just did */
  79                 close(x);
  80 #else
  81         (void) x;       /* shut gcc up */
  82 #endif
  83
  84         rb_lib_init(ilog, irestart, idie, 0, maxfd, dh_size, fd_heap_size);
  85         rb_linebuf_init(lb_heap_size);
  86         rb_linebuf_newbuf(&helper->sendq);
  87         rb_linebuf_newbuf(&helper->recvq);
  88
  89         helper->ifd = rb_open(ifd, RB_FD_PIPE, "incoming connection");
  90         helper->ofd = rb_open(ofd, RB_FD_PIPE, "outgoing connection");
  91         rb_set_nb(helper->ifd);
  92         rb_set_nb(helper->ofd);
  93
  94         helper->read_cb = read_cb;
  95         helper->error_cb = error_cb;
  96         return helper;
  97 }
  98
  99 /*
 100  * start_fork_helper
 101  * starts a new ircd helper
 102  * note that this function doesn't start doing reading..thats the job of the caller
 103  */
 104
 105 rb_helper *
 106 rb_helper_start(const char *name, const char *fullpath, rb_helper_cb * read_cb,
 107                 rb_helper_cb * error_cb)
 108 {
 109         rb_helper *helper;
 110         const char *parv[2];
 111         char buf[128];
 112         char fx[16], fy[16];
 113         rb_fde_t *in_f[2];
 114         rb_fde_t *out_f[2];
 115         pid_t pid;
 116
 117         if(access(fullpath, X_OK) == -1)
 118                 return NULL;
 119
 120         helper = rb_malloc(sizeof(rb_helper));
 121
 122         snprintf(buf, sizeof(buf), "%s helper - read", name);
 123         if(rb_pipe(&in_f[0], &in_f[1], buf) < 0)
 124         {
 125                 rb_free(helper);
 126                 return NULL;
 127         }
 128         snprintf(buf, sizeof(buf), "%s helper - write", name);
 129         if(rb_pipe(&out_f[0], &out_f[1], buf) < 0)
 130         {
 131                 rb_free(helper);
 132                 return NULL;
 133         }
 134
 135         snprintf(fx, sizeof(fx), "%d", rb_get_fd(in_f[1]));
 136         snprintf(fy, sizeof(fy), "%d", rb_get_fd(out_f[0]));
 137
 138         rb_set_nb(in_f[0]);
 139         rb_set_nb(in_f[1]);
 140         rb_set_nb(out_f[0]);
 141         rb_set_nb(out_f[1]);
 142
 143         rb_setenv("IFD", fy, 1);
 144         rb_setenv("OFD", fx, 1);
 145         rb_setenv("MAXFD", "256", 1);
 146
 147         snprintf(buf, sizeof(buf), "-ircd %s daemon", name);
 148         parv[0] = buf;
 149         parv[1] = NULL;
 150
 151         rb_clear_cloexec(in_f[1]);
 152         rb_clear_cloexec(out_f[0]);
 153
 154         pid = rb_spawn_process(fullpath, (const char **)parv);
 155
 156         if(pid == -1)
 157         {
 158                 rb_close(in_f[0]);
 159                 rb_close(in_f[1]);
 160                 rb_close(out_f[0]);
 161                 rb_close(out_f[1]);
 162                 rb_free(helper);
 163                 return NULL;
 164         }
 165
 166         rb_close(in_f[1]);
 167         rb_close(out_f[0]);
 168
 169         rb_linebuf_newbuf(&helper->sendq);
 170         rb_linebuf_newbuf(&helper->recvq);
 171
 172         helper->ifd = in_f[0];
 173         helper->ofd = out_f[1];
 174         helper->read_cb = read_cb;
 175         helper->error_cb = error_cb;
 176         helper->fork_count = 0;
 177         helper->pid = pid;
 178
 179         return helper;
 180 }
 181
 182
 183 void
 184 rb_helper_restart(rb_helper *helper)
 185 {
 186         helper->error_cb(helper);
 187 }
 188
 189
 190 static void
 191 rb_helper_write_sendq(rb_fde_t *F, void *helper_ptr)
 192 {
 193         rb_helper *helper = helper_ptr;
 194         int retlen;
 195
 196         if(rb_linebuf_len(&helper->sendq) > 0)
 197         {
 198                 while((retlen = rb_linebuf_flush(F, &helper->sendq)) > 0)
 199                         ;
 200                 if(retlen == 0 || (retlen < 0 && !rb_ignore_errno(errno)))
 201                 {
 202                         rb_helper_restart(helper);
 203                         return;
 204                 }
 205         }
 206
 207         if(rb_linebuf_len(&helper->sendq) > 0)
 208                 rb_setselect(helper->ofd, RB_SELECT_WRITE, rb_helper_write_sendq, helper);
 209 }
 210
 211 void
 212 rb_helper_write_queue(rb_helper *helper, const char *format, ...)
 213 {
 214         va_list ap;
 215         rb_strf_t strings = { .format = format, .format_args = &ap, .next = NULL };
 216
 217         va_start(ap, format);
 218         rb_linebuf_put(&helper->sendq, &strings);
 219         va_end(ap);
 220 }
 221
 222 void
 223 rb_helper_write_flush(rb_helper *helper)
 224 {
 225         rb_helper_write_sendq(helper->ofd, helper);
 226 }
 227
 228
 229 void
 230 rb_helper_write(rb_helper *helper, const char *format, ...)
 231 {
 232         va_list ap;
 233         rb_strf_t strings = { .format = format, .format_args = &ap, .next = NULL };
 234
 235         va_start(ap, format);
 236         rb_linebuf_put(&helper->sendq, &strings);
 237         va_end(ap);
 238
 239         rb_helper_write_flush(helper);
 240 }
 241
 242 static void
 243 rb_helper_read_cb(rb_fde_t *F __attribute__((unused)), void *data)
 244 {
 245         rb_helper *helper = (rb_helper *)data;
 246         static char buf[32768];
 247         int length;
 248         if(helper == NULL)
 249                 return;
 250
 251         while((length = rb_read(helper->ifd, buf, sizeof(buf))) > 0)
 252         {
 253                 rb_linebuf_parse(&helper->recvq, buf, length, 0);
 254                 helper->read_cb(helper);
 255         }
 256
 257         if(length == 0 || (length < 0 && !rb_ignore_errno(errno)))
 258         {
 259                 rb_helper_restart(helper);
 260                 return;
 261         }
 262
 263         rb_setselect(helper->ifd, RB_SELECT_READ, rb_helper_read_cb, helper);
 264 }
 265
 266 void
 267 rb_helper_run(rb_helper *helper)
 268 {
 269         if(helper == NULL)
 270                 return;
 271         rb_helper_read_cb(helper->ifd, helper);
 272 }
 273
 274
 275 void
 276 rb_helper_close(rb_helper *helper)
 277 {
 278         if(helper == NULL)
 279                 return;
 280         rb_kill(helper->pid, SIGKILL);
 281         rb_close(helper->ifd);
 282         rb_close(helper->ofd);
 283         rb_free(helper);
 284 }
 285
 286 int
 287 rb_helper_read(rb_helper *helper, void *buf, size_t bufsize)
 288 {
 289         return rb_linebuf_get(&helper->recvq, buf, bufsize, LINEBUF_COMPLETE, LINEBUF_PARSED);
 290 }
 291
 292 void
 293 rb_helper_loop(rb_helper *helper, long delay)
 294 {
 295         rb_helper_run(helper);
 296         while(1)
 297         {
 298                 rb_lib_loop(delay);
 299         }
 300 }