ircd/authproc.c

   1 /*
   2  *  authd.c: An interface to authd.
   3  *  (based somewhat on ircd-ratbox dns.c)
   4  *
   5  *  Copyright (C) 2005 Aaron Sethman <androsyn@ratbox.org>
   6  *  Copyright (C) 2005-2012 ircd-ratbox development team
   7  *  Copyright (C) 2016 William Pitcock <nenolod@dereferenced.org>
   8  *
   9  *  This program is free software; you can redistribute it and/or modify
  10  *  it under the terms of the GNU General Public License as published by
  11  *  the Free Software Foundation; either version 2 of the License, or
  12  *  (at your option) any later version.
  13  *
  14  *  This program is distributed in the hope that it will be useful,
  15  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  *  GNU General Public License for more details.
  18  *
  19  *  You should have received a copy of the GNU General Public License
  20  *  along with this program; if not, write to the Free Software
  21  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301
  22  *  USA
  23  */
  24
  25 #include "stdinc.h"
  26 #include "rb_lib.h"
  27 #include "client.h"
  28 #include "ircd_defs.h"
  29 #include "parse.h"
  30 #include "authproc.h"
  31 #include "match.h"
  32 #include "logger.h"
  33 #include "s_conf.h"
  34 #include "s_stats.h"
  35 #include "client.h"
  36 #include "packet.h"
  37 #include "hash.h"
  38 #include "send.h"
  39 #include "numeric.h"
  40 #include "msg.h"
  41 #include "dns.h"
  42
  43 typedef void (*authd_cb_t)(int, char **);
  44
  45 struct authd_cb
  46 {
  47         authd_cb_t fn;
  48         int min_parc;
  49 };
  50
  51 static int start_authd(void);
  52 static void parse_authd_reply(rb_helper * helper);
  53 static void restart_authd_cb(rb_helper * helper);
  54 static EVH timeout_dead_authd_clients;
  55
  56 static void cmd_accept_client(int parc, char **parv);
  57 static void cmd_reject_client(int parc, char **parv);
  58 static void cmd_dns_result(int parc, char **parv);
  59 static void cmd_notice_client(int parc, char **parv);
  60 static void cmd_oper_warn(int parc, char **parv);
  61 static void cmd_stats_results(int parc, char **parv);
  62
  63 rb_helper *authd_helper;
  64 static char *authd_path;
  65
  66 uint32_t cid;
  67 static rb_dictionary *cid_clients;
  68 static struct ev_entry *timeout_ev;
  69
  70 rb_dictionary *bl_stats;
  71
  72 rb_dlink_list opm_list;
  73 struct OPMListener opm_listeners[LISTEN_LAST];
  74
  75 static struct authd_cb authd_cmd_tab[256] =
  76 {
  77         ['A'] = { cmd_accept_client,    4 },
  78         ['E'] = { cmd_dns_result,       5 },
  79         ['N'] = { cmd_notice_client,    3 },
  80         ['R'] = { cmd_reject_client,    7 },
  81         ['W'] = { cmd_oper_warn,        3 },
  82         ['X'] = { cmd_stats_results,    3 },
  83         ['Y'] = { cmd_stats_results,    3 },
  84         ['Z'] = { cmd_stats_results,    3 },
  85 };
  86
  87 static int
  88 start_authd(void)
  89 {
  90         char fullpath[PATH_MAX + 1];
  91 #ifdef _WIN32
  92         const char *suffix = ".exe";
  93 #else
  94         const char *suffix = "";
  95 #endif
  96         if(authd_path == NULL)
  97         {
  98                 snprintf(fullpath, sizeof(fullpath), "%s%cauthd%s", ircd_paths[IRCD_PATH_LIBEXEC], RB_PATH_SEPARATOR, suffix);
  99
 100                 if(access(fullpath, X_OK) == -1)
 101                 {
 102                         snprintf(fullpath, sizeof(fullpath), "%s%cbin%cauthd%s",
 103                                  ConfigFileEntry.dpath, RB_PATH_SEPARATOR, RB_PATH_SEPARATOR, suffix);
 104                         if(access(fullpath, X_OK) == -1)
 105                         {
 106                                 ierror("Unable to execute authd in %s or %s/bin",
 107                                         ircd_paths[IRCD_PATH_LIBEXEC], ConfigFileEntry.dpath);
 108                                 sendto_realops_snomask(SNO_GENERAL, L_ALL,
 109                                                        "Unable to execute authd in %s or %s/bin",
 110                                                        ircd_paths[IRCD_PATH_LIBEXEC], ConfigFileEntry.dpath);
 111                                 return 1;
 112                         }
 113
 114                 }
 115
 116                 authd_path = rb_strdup(fullpath);
 117         }
 118
 119         if(cid_clients == NULL)
 120                 cid_clients = rb_dictionary_create("authd cid to uid mapping", rb_uint32cmp);
 121
 122         if(bl_stats == NULL)
 123                 bl_stats = rb_dictionary_create("blacklist statistics", rb_strcasecmp);
 124
 125         if(timeout_ev == NULL)
 126                 timeout_ev = rb_event_addish("timeout_dead_authd_clients", timeout_dead_authd_clients, NULL, 1);
 127
 128         authd_helper = rb_helper_start("authd", authd_path, parse_authd_reply, restart_authd_cb);
 129
 130         if(authd_helper == NULL)
 131         {
 132                 ierror("Unable to start authd helper: %s", strerror(errno));
 133                 sendto_realops_snomask(SNO_GENERAL, L_ALL, "Unable to start authd helper: %s", strerror(errno));
 134                 return 1;
 135         }
 136         ilog(L_MAIN, "authd helper started");
 137         sendto_realops_snomask(SNO_GENERAL, L_ALL, "authd helper started");
 138         rb_helper_run(authd_helper);
 139         return 0;
 140 }
 141
 142 static inline uint32_t
 143 str_to_cid(const char *str)
 144 {
 145         long lcid = strtol(str, NULL, 16);
 146
 147         if(lcid > UINT32_MAX || lcid <= 0)
 148         {
 149                 iwarn("authd sent us back a bad client ID: %lx", lcid);
 150                 restart_authd();
 151                 return 0;
 152         }
 153
 154         return (uint32_t)lcid;
 155 }
 156
 157 static inline struct Client *
 158 cid_to_client(uint32_t cid, bool delete)
 159 {
 160         struct Client *client_p;
 161
 162         if(delete)
 163                 client_p = rb_dictionary_delete(cid_clients, RB_UINT_TO_POINTER(cid));
 164         else
 165                 client_p = rb_dictionary_retrieve(cid_clients, RB_UINT_TO_POINTER(cid));
 166
 167         /* If the client's not found, that's okay, it may have already gone away.
 168          * --Elizafox */
 169
 170         return client_p;
 171 }
 172
 173 static inline struct Client *
 174 str_cid_to_client(const char *str, bool delete)
 175 {
 176         uint32_t cid = str_to_cid(str);
 177
 178         if(cid == 0)
 179                 return NULL;
 180
 181         return cid_to_client(cid, delete);
 182 }
 183
 184 static void
 185 cmd_accept_client(int parc, char **parv)
 186 {
 187         struct Client *client_p;
 188
 189         /* cid to uid (retrieve and delete) */
 190         if((client_p = str_cid_to_client(parv[1], true)) == NULL)
 191                 return;
 192
 193         authd_accept_client(client_p, parv[2], parv[3]);
 194 }
 195
 196 static void
 197 cmd_dns_result(int parc, char **parv)
 198 {
 199         dns_results_callback(parv[1], parv[2], parv[3], parv[4]);
 200 }
 201
 202 static void
 203 cmd_notice_client(int parc, char **parv)
 204 {
 205         struct Client *client_p;
 206
 207         if((client_p = str_cid_to_client(parv[1], false)) == NULL)
 208                 return;
 209
 210         sendto_one_notice(client_p, ":%s", parv[2]);
 211 }
 212
 213 static void
 214 cmd_reject_client(int parc, char **parv)
 215 {
 216         struct Client *client_p;
 217
 218         /* cid to uid (retrieve and delete) */
 219         if((client_p = str_cid_to_client(parv[1], true)) == NULL)
 220                 return;
 221
 222         authd_reject_client(client_p, parv[3], parv[4], toupper(*parv[2]), parv[5], parv[6]);
 223 }
 224
 225 static void
 226 cmd_oper_warn(int parc, char **parv)
 227 {
 228         switch(*parv[1])
 229         {
 230         case 'D':       /* Debug */
 231                 sendto_realops_snomask(SNO_DEBUG, L_ALL, "authd debug: %s", parv[2]);
 232                 idebug("authd: %s", parv[2]);
 233                 break;
 234         case 'I':       /* Info */
 235                 sendto_realops_snomask(SNO_GENERAL, L_ALL, "authd info: %s", parv[2]);
 236                 inotice("authd: %s", parv[2]);
 237                 break;
 238         case 'W':       /* Warning */
 239                 sendto_realops_snomask(SNO_GENERAL, L_ALL, "authd WARNING: %s", parv[2]);
 240                 iwarn("authd: %s", parv[2]);
 241                 break;
 242         case 'C':       /* Critical (error) */
 243                 sendto_realops_snomask(SNO_GENERAL, L_ALL, "authd CRITICAL: %s", parv[2]);
 244                 ierror("authd: %s", parv[2]);
 245                 break;
 246         default:        /* idk */
 247                 sendto_realops_snomask(SNO_GENERAL, L_ALL, "authd sent us an unknown oper notice type (%s): %s", parv[1], parv[2]);
 248                 ilog(L_MAIN, "authd unknown oper notice type (%s): %s", parv[1], parv[2]);
 249                 break;
 250         }
 251 }
 252
 253 static void
 254 cmd_stats_results(int parc, char **parv)
 255 {
 256         /* Select by type */
 257         switch(*parv[2])
 258         {
 259         case 'D':
 260                 /* parv[0] conveys status */
 261                 if(parc < 4)
 262                 {
 263                         iwarn("authd sent a result with wrong number of arguments: got %d", parc);
 264                         restart_authd();
 265                         return;
 266                 }
 267                 dns_stats_results_callback(parv[1], parv[0], parc - 3, (const char **)&parv[3]);
 268                 break;
 269         default:
 270                 break;
 271         }
 272 }
 273
 274 static void
 275 parse_authd_reply(rb_helper * helper)
 276 {
 277         ssize_t len;
 278         int parc;
 279         char buf[READBUF_SIZE];
 280         char *parv[MAXPARA + 1];
 281
 282         while((len = rb_helper_read(helper, buf, sizeof(buf))) > 0)
 283         {
 284                 struct authd_cb *cmd;
 285
 286                 parc = rb_string_to_array(buf, parv, MAXPARA+1);
 287                 cmd = &authd_cmd_tab[(unsigned char)*parv[0]];
 288                 if(cmd->fn != NULL)
 289                 {
 290                         if(cmd->min_parc > parc)
 291                         {
 292                                 iwarn("authd sent a result with wrong number of arguments: expected %d, got %d",
 293                                         cmd->min_parc, parc);
 294                                 restart_authd();
 295                                 continue;
 296                         }
 297
 298                         cmd->fn(parc, parv);
 299                 }
 300                 else
 301                 {
 302                         iwarn("authd sent us a bad command type: %c", *parv[0]);
 303                         restart_authd();
 304                         continue;
 305                 }
 306         }
 307 }
 308
 309 void
 310 init_authd(void)
 311 {
 312         if(start_authd())
 313         {
 314                 ierror("Unable to start authd helper: %s", strerror(errno));
 315                 exit(0);
 316         }
 317 }
 318
 319 void
 320 configure_authd(void)
 321 {
 322         /* Timeouts */
 323         set_authd_timeout("ident_timeout", GlobalSetOptions.ident_timeout);
 324         set_authd_timeout("rdns_timeout", ConfigFileEntry.connect_timeout);
 325         set_authd_timeout("rbl_timeout", ConfigFileEntry.connect_timeout);
 326
 327         ident_check_enable(!ConfigFileEntry.disable_auth);
 328
 329         /* Configure OPM */
 330         if(rb_dlink_list_length(&opm_list) > 0 &&
 331                 (opm_listeners[LISTEN_IPV4].ipaddr[0] != '\0' ||
 332                 opm_listeners[LISTEN_IPV6].ipaddr[0] != '\0'))
 333         {
 334                 rb_dlink_node *ptr;
 335
 336                 if(opm_listeners[LISTEN_IPV4].ipaddr[0] != '\0')
 337                         rb_helper_write(authd_helper, "O opm_listener %s %hu",
 338                                 opm_listeners[LISTEN_IPV4].ipaddr, opm_listeners[LISTEN_IPV4].port);
 339
 340 #ifdef RB_IPV6
 341                 if(opm_listeners[LISTEN_IPV6].ipaddr[0] != '\0')
 342                         rb_helper_write(authd_helper, "O opm_listener %s %hu",
 343                                 opm_listeners[LISTEN_IPV6].ipaddr, opm_listeners[LISTEN_IPV6].port);
 344 #endif
 345
 346                 RB_DLINK_FOREACH(ptr, opm_list.head)
 347                 {
 348                         struct OPMScanner *scanner = ptr->data;
 349                         rb_helper_write(authd_helper, "O opm_scanner %s %hu",
 350                                 scanner->type, scanner->port);
 351                 }
 352
 353                 opm_check_enable(true);
 354         }
 355         else
 356                 opm_check_enable(false);
 357 }
 358
 359 static void
 360 restart_authd_cb(rb_helper * helper)
 361 {
 362         rb_dictionary_iter iter;
 363         struct Client *client_p;
 364
 365         iwarn("authd: restart_authd_cb called, authd died?");
 366         sendto_realops_snomask(SNO_GENERAL, L_ALL, "authd: restart_authd_cb called, authd died?");
 367
 368         if(helper != NULL)
 369         {
 370                 rb_helper_close(helper);
 371                 authd_helper = NULL;
 372         }
 373
 374         RB_DICTIONARY_FOREACH(client_p, &iter, cid_clients)
 375         {
 376                 /* Abort any existing clients */
 377                 authd_abort_client(client_p);
 378         }
 379
 380         start_authd();
 381         configure_authd();
 382 }
 383
 384 void
 385 restart_authd(void)
 386 {
 387         ierror("authd restarting...");
 388         restart_authd_cb(authd_helper);
 389 }
 390
 391 void
 392 rehash_authd(void)
 393 {
 394         rb_helper_write(authd_helper, "R");
 395 }
 396
 397 void
 398 check_authd(void)
 399 {
 400         if(authd_helper == NULL)
 401                 restart_authd();
 402 }
 403
 404 static inline uint32_t
 405 generate_cid(void)
 406 {
 407         if(++cid == 0)
 408                 cid = 1;
 409
 410         return cid;
 411 }
 412
 413 /* Basically when this is called we begin handing off the client to authd for
 414  * processing. authd "owns" the client until processing is finished, or we
 415  * timeout from authd. authd will make a decision whether or not to accept the
 416  * client, but it's up to other parts of the code (for now) to decide if we're
 417  * gonna accept the client and ignore authd's suggestion.
 418  *
 419  * --Elizafox
 420  */
 421 void
 422 authd_initiate_client(struct Client *client_p)
 423 {
 424         char client_ipaddr[HOSTIPLEN+1];
 425         char listen_ipaddr[HOSTIPLEN+1];
 426         uint16_t client_port, listen_port;
 427         uint32_t authd_cid;
 428
 429         if(client_p->preClient == NULL || client_p->preClient->auth.cid != 0)
 430                 return;
 431
 432         authd_cid = client_p->preClient->auth.cid = generate_cid();
 433
 434         /* Collisions are extremely unlikely, so disregard the possibility */
 435         rb_dictionary_add(cid_clients, RB_UINT_TO_POINTER(authd_cid), client_p);
 436
 437         /* Retrieve listener and client IP's */
 438         rb_inet_ntop_sock((struct sockaddr *)&client_p->preClient->lip, listen_ipaddr, sizeof(listen_ipaddr));
 439         rb_inet_ntop_sock((struct sockaddr *)&client_p->localClient->ip, client_ipaddr, sizeof(client_ipaddr));
 440
 441         /* Retrieve listener and client ports */
 442         listen_port = ntohs(GET_SS_PORT(&client_p->preClient->lip));
 443         client_port = ntohs(GET_SS_PORT(&client_p->localClient->ip));
 444
 445         /* Add a bit of a fudge factor... */
 446         client_p->preClient->auth.timeout = rb_current_time() + ConfigFileEntry.connect_timeout + 10;
 447
 448         rb_helper_write(authd_helper, "C %x %s %hu %s %hu", authd_cid, listen_ipaddr, listen_port, client_ipaddr, client_port);
 449 }
 450
 451 /* When this is called we have a decision on client acceptance.
 452  *
 453  * After this point authd no longer "owns" the client.
 454  */
 455 static inline void
 456 authd_decide_client(struct Client *client_p, const char *ident, const char *host, bool accept, char cause, const char *data, const char *reason)
 457 {
 458         if(client_p->preClient == NULL || client_p->preClient->auth.cid == 0)
 459                 return;
 460
 461         if(*ident != '*')
 462         {
 463                 rb_strlcpy(client_p->username, ident, sizeof(client_p->username));
 464                 SetGotId(client_p);
 465                 ServerStats.is_asuc++;
 466         }
 467         else
 468                 ServerStats.is_abad++; /* s_auth used to do this, stay compatible */
 469
 470         if(*host != '*')
 471                 rb_strlcpy(client_p->host, host, sizeof(client_p->host));
 472
 473         rb_dictionary_delete(cid_clients, RB_UINT_TO_POINTER(client_p->preClient->auth.cid));
 474
 475         client_p->preClient->auth.accepted = accept;
 476         client_p->preClient->auth.cause = cause;
 477         client_p->preClient->auth.data = (data == NULL ? NULL : rb_strdup(data));
 478         client_p->preClient->auth.reason = (reason == NULL ? NULL : rb_strdup(reason));
 479         client_p->preClient->auth.cid = 0;
 480
 481         /*
 482          * When a client has auth'ed, we want to start reading what it sends
 483          * us. This is what read_packet() does.
 484          *     -- adrian
 485          *
 486          * Above comment was originally in s_auth.c, but moved here with below code.
 487          * --Elizafox
 488          */
 489         rb_dlinkAddTail(client_p, &client_p->node, &global_client_list);
 490         read_packet(client_p->localClient->F, client_p);
 491 }
 492
 493 /* Convenience function to accept client */
 494 void
 495 authd_accept_client(struct Client *client_p, const char *ident, const char *host)
 496 {
 497         authd_decide_client(client_p, ident, host, true, '\0', NULL, NULL);
 498 }
 499
 500 /* Convenience function to reject client */
 501 void
 502 authd_reject_client(struct Client *client_p, const char *ident, const char *host, char cause, const char *data, const char *reason)
 503 {
 504         authd_decide_client(client_p, ident, host, false, cause, data, reason);
 505 }
 506
 507 void
 508 authd_abort_client(struct Client *client_p)
 509 {
 510         if(client_p == NULL || client_p->preClient == NULL)
 511                 return;
 512
 513         if(client_p->preClient->auth.cid == 0)
 514                 return;
 515
 516         rb_dictionary_delete(cid_clients, RB_UINT_TO_POINTER(client_p->preClient->auth.cid));
 517
 518         if(authd_helper != NULL)
 519                 rb_helper_write(authd_helper, "E %x", client_p->preClient->auth.cid);
 520
 521         client_p->preClient->auth.accepted = true;
 522         client_p->preClient->auth.cid = 0;
 523 }
 524
 525 static void
 526 timeout_dead_authd_clients(void *notused __unused)
 527 {
 528         rb_dictionary_iter iter;
 529         struct Client *client_p;
 530
 531         RB_DICTIONARY_FOREACH(client_p, &iter, cid_clients)
 532         {
 533                 if(client_p->preClient->auth.timeout < rb_current_time())
 534                         authd_abort_client(client_p);
 535         }
 536 }
 537
 538 /* Send a new blacklist to authd */
 539 void
 540 add_blacklist(const char *host, const char *reason, uint8_t iptype, rb_dlink_list *filters)
 541 {
 542         rb_dlink_node *ptr;
 543         struct BlacklistStats *stats = rb_malloc(sizeof(struct BlacklistStats));
 544         char filterbuf[BUFSIZE] = "*";
 545         size_t s = 0;
 546
 547         /* Build a list of comma-separated values for authd.
 548          * We don't check for validity - do it elsewhere.
 549          */
 550         RB_DLINK_FOREACH(ptr, filters->head)
 551         {
 552                 char *filter = ptr->data;
 553                 size_t filterlen = strlen(filter) + 1;
 554
 555                 if(s + filterlen > sizeof(filterbuf))
 556                         break;
 557
 558                 snprintf(&filterbuf[s], sizeof(filterbuf) - s, "%s,", filter);
 559
 560                 s += filterlen;
 561         }
 562
 563         if(s)
 564                 filterbuf[s - 1] = '\0';
 565
 566         stats->host = rb_strdup(host);
 567         stats->iptype = iptype;
 568         stats->hits = 0;
 569         rb_dictionary_add(bl_stats, host, stats);
 570
 571         rb_helper_write(authd_helper, "O rbl %s %hhu %s :%s", host, iptype, filterbuf, reason);
 572 }
 573
 574 /* Delete a blacklist */
 575 void
 576 del_blacklist(const char *host)
 577 {
 578         struct BlacklistStats *stats = rb_dictionary_retrieve(bl_stats, host);
 579         if(stats != NULL)
 580         {
 581                 rb_dictionary_delete(bl_stats, host);
 582                 rb_free(stats->host);
 583                 rb_free(stats);
 584         }
 585
 586         rb_helper_write(authd_helper, "O rbl_del %s", host);
 587 }
 588
 589 /* Delete all the blacklists */
 590 void
 591 del_blacklist_all(void)
 592 {
 593         struct BlacklistStats *stats;
 594         rb_dictionary_iter iter;
 595
 596         RB_DICTIONARY_FOREACH(stats, &iter, bl_stats)
 597         {
 598                 rb_dictionary_delete(bl_stats, stats->host);
 599                 rb_free(stats->host);
 600                 rb_free(stats);
 601         }
 602
 603         rb_helper_write(authd_helper, "O rbl_del_all");
 604 }
 605
 606 /* Adjust an authd timeout value */
 607 bool
 608 set_authd_timeout(const char *key, int timeout)
 609 {
 610         if(timeout <= 0)
 611                 return false;
 612
 613         rb_helper_write(authd_helper, "O %s %d", key, timeout);
 614         return true;
 615 }
 616
 617 /* Enable identd checks */
 618 void
 619 ident_check_enable(bool enabled)
 620 {
 621         rb_helper_write(authd_helper, "O ident_enabled %d", enabled ? 1 : 0);
 622 }
 623
 624 /* Create an OPM listener
 625  * XXX - This is a big nasty hack, but it avoids resending duplicate data when
 626  * configure_authd() is called.
 627  */
 628 void
 629 conf_create_opm_listener(const char *ip, uint16_t port)
 630 {
 631         char ipbuf[HOSTIPLEN];
 632         struct OPMListener *listener;
 633
 634         rb_strlcpy(ipbuf, ip, sizeof(ipbuf));
 635         if(ipbuf[0] == ':')
 636         {
 637                 memmove(ipbuf + 1, ipbuf, sizeof(ipbuf) - 1);
 638                 ipbuf[0] = '0';
 639         }
 640
 641         /* I am much too lazy to use rb_inet_pton and GET_SS_FAMILY for now --Elizafox */
 642         listener = &opm_listeners[(strchr(ipbuf, ':') != NULL ? LISTEN_IPV6 : LISTEN_IPV4)];
 643         rb_strlcpy(listener->ipaddr, ipbuf, sizeof(listener->ipaddr));
 644         listener->port = port;
 645 }
 646
 647 void
 648 create_opm_listener(const char *ip, uint16_t port)
 649 {
 650         char ipbuf[HOSTIPLEN];
 651
 652         /* XXX duplicated in conf_create_opm_listener */
 653         rb_strlcpy(ipbuf, ip, sizeof(ipbuf));
 654         if(ipbuf[0] == ':')
 655         {
 656                 memmove(ipbuf + 1, ipbuf, sizeof(ipbuf) - 1);
 657                 ipbuf[0] = '0';
 658         }
 659
 660         conf_create_opm_listener(ip, port);
 661         rb_helper_write(authd_helper, "O opm_listener %s %hu", ipbuf, port);
 662 }
 663
 664 void
 665 delete_opm_listener_all(void)
 666 {
 667         memset(&opm_listeners, 0, sizeof(opm_listeners));
 668         rb_helper_write(authd_helper, "O opm_listener_del_all");
 669 }
 670
 671 /* Disable all OPM scans */
 672 void
 673 opm_check_enable(bool enabled)
 674 {
 675         rb_helper_write(authd_helper, "O opm_enabled %d", enabled ? 1 : 0);
 676 }
 677
 678 /* Create an OPM proxy scanner
 679  * XXX - This is a big nasty hack, but it avoids resending duplicate data when
 680  * configure_authd() is called.
 681  */
 682 void
 683 conf_create_opm_proxy_scanner(const char *type, uint16_t port)
 684 {
 685         struct OPMScanner *scanner = rb_malloc(sizeof(struct OPMScanner));
 686
 687         rb_strlcpy(scanner->type, type, sizeof(scanner->type));
 688         scanner->port = port;
 689         rb_dlinkAdd(scanner, &scanner->node, &opm_list);
 690 }
 691
 692 void
 693 create_opm_proxy_scanner(const char *type, uint16_t port)
 694 {
 695         conf_create_opm_proxy_scanner(type, port);
 696         rb_helper_write(authd_helper, "O opm_scanner %s %hu", type, port);
 697 }
 698
 699 void
 700 delete_opm_proxy_scanner(const char *type, uint16_t port)
 701 {
 702         rb_dlink_node *ptr, *nptr;
 703
 704         RB_DLINK_FOREACH_SAFE(ptr, nptr, opm_list.head)
 705         {
 706                 struct OPMScanner *scanner = ptr->data;
 707
 708                 if(rb_strncasecmp(scanner->type, type, sizeof(scanner->type)) == 0 &&
 709                         scanner->port == port)
 710                 {
 711                         rb_dlinkDelete(ptr, &opm_list);
 712                         rb_free(scanner);
 713                         break;
 714                 }
 715         }
 716
 717         rb_helper_write(authd_helper, "O opm_scanner_del %s %hu", type, port);
 718 }
 719
 720 void
 721 delete_opm_proxy_scanner_all(void)
 722 {
 723         rb_dlink_node *ptr, *nptr;
 724
 725         RB_DLINK_FOREACH_SAFE(ptr, nptr, opm_list.head)
 726         {
 727                 struct OPMScanner *scanner = ptr->data;
 728
 729                 rb_dlinkDelete(ptr, &opm_list);
 730                 rb_free(scanner);
 731         }
 732
 733         rb_helper_write(authd_helper, "O opm_scanner_del_all");
 734 }