xsb/xsb-postircd.c

   1 /* TODO: catch control messages */
   2
   3 #include <string.h>
   4 #include <stdio.h>
   5 #include <stdarg.h>
   6 #include "../core/hooks.h"
   7 #include "../lib/splitline.h"
   8 #include "../core/config.h"
   9 #include "../irc/irc.h"
  10 #include "../lib/array.h"
  11 #include "../lib/base64.h"
  12 #include "../lib/irc_string.h"
  13 #include "../core/error.h"
  14 #include "../localuser/localuser.h"
  15 #include "../lib/strlfunc.h"
  16 #include "../lib/version.h"
  17 #include "xsb.h"
  18
  19 MODULE_VERSION("");
  20
  21 static const char *DEFAULT_SERVICE_MASKS[] = { "services*.*.quakenet.org", (char *)0 };
  22
  23 static array defaultservicemasks_a;
  24 static sstring **defaultservicemasks;
  25
  26 static void handlemaskprivmsg(int, void *);
  27 static void handlecontrolregistered(int, void *);
  28 static CommandTree *cmds;
  29
  30 static char controlnum[6];
  31
  32 struct messagequeue {
  33   struct messagequeue *next;
  34   char buf[];
  35 };
  36
  37 struct messagequeue *head, *tail;
  38
  39 void _init(void) {
  40   const char **p;
  41   array *servicemasks;
  42
  43   controlnum[0] = '\0';
  44
  45   cmds = newcommandtree();
  46   if(!cmds)
  47     return;
  48
  49   registerhook(HOOK_NICK_MASKPRIVMSG, &handlemaskprivmsg);
  50   registerhook(HOOK_CONTROL_REGISTERED, &handlecontrolregistered);
  51
  52   array_init(&defaultservicemasks_a, sizeof(sstring *));
  53
  54   for(p=DEFAULT_SERVICE_MASKS;*p;p++) {
  55     int i = array_getfreeslot(&defaultservicemasks_a);
  56     defaultservicemasks = (sstring **)defaultservicemasks_a.content;
  57
  58     defaultservicemasks[i] = getsstring(*p, strlen(*p));
  59   }
  60
  61   servicemasks = getconfigitems("xsb", "servicemask");
  62   if(!servicemasks || !servicemasks->cursi)
  63     Error("xsb", ERR_WARNING, "No service masks in config file (xsb/servicemask), using defaults.");
  64 }
  65
  66 void _fini(void) {
  67   int i;
  68   struct messagequeue *q, *nq;
  69
  70   if(!cmds)
  71     return;
  72
  73   destroycommandtree(cmds);
  74
  75   deregisterhook(HOOK_NICK_MASKPRIVMSG, &handlemaskprivmsg);
  76   deregisterhook(HOOK_CONTROL_REGISTERED, &handlecontrolregistered);
  77
  78   for(i=0;i<defaultservicemasks_a.cursi;i++)
  79     freesstring(defaultservicemasks[i]);
  80   array_free(&defaultservicemasks_a);
  81
  82   for(q=head;q;q=nq) {
  83     nq = q->next;
  84     free(q);
  85   }
  86
  87   head = NULL;
  88   tail = NULL;
  89 }
  90
  91 void xsb_addcommand(const char *name, const int maxparams, CommandHandler handler) {
  92   addcommandtotree(cmds, name, 0, maxparams, handler);
  93 }
  94
  95 void xsb_delcommand(const char *name, CommandHandler handler) {
  96   deletecommandfromtree(cmds, name, handler);
  97 }
  98
  99 static void handlemaskprivmsg(int hooknum, void *args) {
 100   void **hargs = (void **)args;
 101   nick *source = hargs[0];
 102   char *message = hargs[2];
 103   Command *cmd;
 104   int cargc;
 105   char *cargv[50];
 106   server *s;
 107
 108   if(!source)
 109     return;
 110
 111   if(!IsOper(source) || !IsService(source))
 112     return;
 113
 114   cargc = splitline(message, cargv, 50, 0);
 115   if(cargc < 2)
 116     return;
 117
 118   if(strcmp(cargv[0], "XSB1"))
 119     return;
 120
 121   s = &serverlist[homeserver(source->numeric)];
 122   if(s->linkstate != LS_LINKED) {
 123     Error("xsb", ERR_WARNING, "Got XSB message from unlinked server (%s): %s", s->name->content, source->nick);
 124     return;
 125   }
 126
 127 #ifndef XSB_DEBUG
 128   if(!(s->flags & SMODE_SERVICE)) {
 129     Error("xsb", ERR_WARNING, "Got XSB message from non-service server (%s): %s", s->name->content, source->nick);
 130     return;
 131   }
 132 #endif
 133
 134   cmd = findcommandintree(cmds, cargv[1], 1);
 135   if(!cmd)
 136     return;
 137
 138   if(cmd->maxparams < (cargc - 2)) {
 139     rejoinline(cargv[cmd->maxparams], cargc - (cmd->maxparams));
 140     cargc = (cmd->maxparams) + 2;
 141   }
 142
 143   (cmd->handler)(source, cargc - 2, &cargv[2]);
 144 }
 145
 146 static void directsend(char *buf) {
 147   irc_send("%s P %s", controlnum, buf);
 148 }
 149
 150 static void handlecontrolregistered(int hooknum, void *args) {
 151   nick *np = (nick *)args;
 152
 153   if(np) {
 154     struct messagequeue *q, *nq;
 155
 156     longtonumeric2(np->numeric, 5, controlnum);
 157
 158     for(q=head;q;q=nq) {
 159       nq = q->next;
 160
 161       directsend(q->buf);
 162       free(q);
 163     }
 164     head = NULL;
 165     tail = NULL;
 166   } else {
 167     controlnum[0] = '\0';
 168   }
 169 }
 170
 171 static int getservicemasks(sstring ***masks) {
 172   array *aservicemasks = getconfigitems("xsb", "servicemask");
 173   if(!aservicemasks || !aservicemasks->cursi)
 174     aservicemasks = &defaultservicemasks_a;
 175
 176   *masks = (sstring **)aservicemasks->content;
 177
 178   return aservicemasks->cursi;
 179 }
 180
 181 static void xsb_send(const char *format, ...) {
 182   char buf[512];
 183   va_list va;
 184   size_t len;
 185
 186   va_start(va, format);
 187   len = vsnprintf(buf, sizeof(buf), format, va);
 188   va_end(va);
 189   if(len >= sizeof(buf))
 190     len = sizeof(buf);
 191
 192   if(controlnum[0]) {
 193     directsend(buf);
 194   } else {
 195     struct messagequeue *q = (struct messagequeue *)malloc(sizeof(struct messagequeue) + len + 5);
 196
 197     strlcpy(q->buf, buf, len + 2);
 198     q->next = NULL;
 199     if(tail) {
 200       tail->next = q;
 201     } else {
 202       head = q;
 203     }
 204     tail = q;
 205   }
 206 }
 207
 208 void xsb_broadcast(const char *command, server *service, const char *format, ...) {
 209   char buf[512];
 210   va_list va;
 211   sstring **servicemasks;
 212   int i;
 213
 214   va_start(va, format);
 215   vsnprintf(buf, sizeof(buf), format, va);
 216   va_end(va);
 217
 218   if(service) {
 219     xsb_send("$%s :XSB1 %s %s", service->name->content, command, buf);
 220     return;
 221   }
 222
 223   for(i=getservicemasks(&servicemasks)-1;i>=0;i--)
 224     xsb_send("$%s :XSB1 %s %s", servicemasks[i]->content, command, buf);
 225 }
 226
 227 void xsb_unicast(const char *command, nick *np, const char *format, ...) {
 228   char buf[512];
 229   va_list va;
 230
 231   va_start(va, format);
 232   vsnprintf(buf, sizeof(buf), format, va);
 233   va_end(va);
 234
 235   /* TODO */
 236   xsb_send("$%s :XSB1 %s %s", serverlist[homeserver(np->numeric)].name, command, buf);
 237   /* xsb_send("%s :XSB1 %s %s", longtonumeric(np->numeric, 5), command, buf);*/
 238
 239 }
 240
 241 int xsb_isservice(server *service) {
 242   int i;
 243   sstring **servicemasks;
 244   char *name = service->name->content;
 245
 246   if(!(service->flags & SMODE_SERVICE))
 247     return 0;
 248
 249   for(i=getservicemasks(&servicemasks)-1;i>=0;i--)
 250     if(match2strings(servicemasks[i]->content, name))
 251       return 1;
 252
 253   return 0;
 254 }
 255