1 /* mod-hostserv.c - HostServ module for srvx
2 * Copyright 2012-2013 pk910, Stricted, NurPech
4 * This file is part of srvx.
6 * srvx is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with srvx; if not, write to the Free Software Foundation,
18 * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
21 /* Adds new section to srvx.conf:
26 "toplevel_access" "600";
30 * After you started srvx make the bot active:
31 /msg opserv bind hostserv * hostserv.*
32 /msg opserv bind hostserv help *modcmd.help
43 #define KEY_TOPLEVEL "TopLevel"
44 #define KEY_SECONDLEVEL "SecondLevel"
45 #define KEY_MANAGERS "Manager"
46 #define KEY_ASSIGNMENTS "Assignments"
47 #define KEY_ACTIVE "active"
48 #define KEY_TITLEHOST_SUFFIX "title_suffix"
50 static const struct message_entry msgtab[] = {
51 { "HSMSG_ASSIGNED_FAKEHOSTS", "Assigned Fakehosts for User $b%s$b:" },
52 { "HSMSG_ASSIGNED_FAKEHOST", " $b%s.%s$b" },
53 { "HSMSG_ASSIGNED_FAKEHOST_ACTTIVE", " $b%s.%s$b (active)" },
54 { "HSMSG_ASSIGNED_FAKEHOST_NOT_ACTIVE", "Fakehost $b%s.%s.$b is not active." },
55 { "HSMSG_ASSIGN_HOWTO", "Use $bset xxx.yyy$b to activate one of the listed fakehosts or $bset *$b to use the default fakehost." },
56 { "HSMSG_ASSIGNED_NONE", " None." },
57 { "HSMSG_MANAGED_FAKEHOSTS", "Fakehosts managed by User $b%s$b:" },
58 { "HSMSG_MANAGED_TOPLEVEL", " $b*.%s$b fakehosts: %d assignments: %d" },
59 { "HSMSG_MANAGED_TOPLEVEL_OWN", " $b*.%s$b fakehosts: %d assignments: %d (active)" },
60 { "HSMSG_MANAGED_FAKEHOST", " $b%s.%s$b assignments: %d" },
61 { "HSMSG_MANAGE_HOWTO", "Use $bview xxx.yyy$b to view more information about a fakehost group." },
62 { "HSMSG_UNKNOWN_FAKEHOST", "Fakehost $b%s.%s$b is unknown or you have no access to manage it." },
63 { "HSMSG_TOPLEVEL_FAKEHOSTS", "Fakehosts in group $b*.%s$b:" },
64 { "HSMSG_TOPLEVEL_FAKEHOST", " $b%s.%s$b assignments: %d managers: %d" },
65 { "HSMSG_TOPLEVEL_INVALID", "The name of the group you entered is invalid ($b%s$b)" },
66 { "HSMSG_MANAGERS_TOPLEVEL", "Managers of group $b*.%s$b:" },
67 { "HSMSG_MANAGERS_FAKEHOST", "Managers of group $b%s.%s$b:" },
68 { "HSMSG_MANAGERS_MANAGERS", " %s" },
69 { "HSMSG_FAKEHOST_ASSIGNMENTS", "Assignments in group $b%s.%s$b:" },
70 { "HSMSG_FAKEHOST_ASSIGNMENT", " $b%s$b (%s.%s.%s)" },
71 { "HSMSG_FAKEHOST_ASSIGNMENT_ACTIVE", " $b%s$b (%s.%s.%s) active" },
72 { "HSMSG_FAKEHOST_SET_SUCCESS", "$b%s.%s$b where set successfully." },
73 { "HSMSG_FAKEHOST_TOPLEVEL_ADDED", "Group $b%s$b successfully added." },
74 { "HSMSG_FAKEHOST_TOPLEVEL_ALREADY_EXISTS", "Group $b%s$b already exists." },
75 { "HSMSG_FAKEHOST_TOPLEVEL_DELETED", "Group $b%s$b successfully deleted." },
76 { "HSMSG_FAKEHOST_SECONDLEVEL_ADDED", "Group $b%s.%s$b successfully added." },
77 { "HSMSG_FAKEHOST_SECONDLEVEL_ALREADY_EXISTS", "Group $b%s.%s$b already exists." },
78 { "HSMSG_FAKEHOST_SECONDLEVEL_DELETED", "Group $b%s.%s$b successfully deleted." },
79 { "HSMSG_MANAGER_ALREADY", "$b%s$b is already a manager of %s.%s" },
80 { "HSMSG_MANAGER_ADDED", "$b%s$b is now a manager of %s.%s" },
81 { "HSMSG_MANAGER_NOT", "$b%s$b is not a manager of %s.%s" },
82 { "HSMSG_MANAGER_DELETED", "$b%s$b is no longer a manager of %s.%s" },
83 { "HSMSG_FAKEHOST_ASSIGN_SUCCESS", "Group $b%s.%s$b was assigned successfully." },
84 { "HSMSG_FAKEHOST_UNASSIGN_SUCCESS", "Group $b%s.%s$b was unassigned successfully." },
95 const char *hostserv_module_deps[] = { NULL };
96 struct userNode *hostserv;
97 struct helpfile *hostserv_helpfile;
98 static struct module *hostserv_module;
99 static struct service *hostserv_service;
100 static struct log_type *HS_LOG;
101 static struct hs_toplevel *toplevels = NULL;
102 static struct hs_user *hostserv_users = NULL;
103 const char *title_suffix = NULL;
105 /* FAKEHOST STRUCTS */
108 struct hs_manager *managers;
109 struct hs_secondlevel *secondlevel;
110 struct hs_toplevel *next;
113 struct hs_secondlevel {
114 struct hs_toplevel *toplevel;
116 struct hs_manager *managers;
117 struct hs_assignment *assignments;
118 struct hs_secondlevel *next;
121 struct hs_assignment {
122 struct hs_secondlevel *secondlevel;
123 struct hs_user *user;
125 struct hs_assignment *next;
126 struct hs_assignment *unext; /* for hs_user */
133 struct hs_user *user;
134 struct hs_manager *next;
135 struct hs_manager *unext; /* for hs_user */
139 struct handle_info *hi;
140 struct hs_assignment *assignments;
141 struct hs_manager *managements;
142 struct hs_user *next;
145 /* MANAGEMENT FUNCTIONS for FAKEHOST STRUCTS */
146 static void hs_del_secondlevel(struct hs_secondlevel *slfh, int remove_from_tlfh);
147 static void hs_del_manager(struct hs_manager *manager, int remove_from_object);
148 static void hs_del_assignment(struct hs_assignment *assignment, int remove_from_slfh);
149 static void hs_del_user(struct hs_user *user);
151 static void apply_fakehost(struct handle_info *handle, struct userNode *user);
154 generate_fakehost(struct handle_info *handle)
156 extern const char *hidden_host_suffix;
157 static char buffer[HOSTLEN+1];
159 if (!handle->fakehost) {
160 snprintf(buffer, sizeof(buffer), "%s.%s", handle->handle, hidden_host_suffix);
162 } else if (handle->fakehost[0] == '.') {
163 /* A leading dot indicates the stored value is actually a title. */
164 snprintf(buffer, sizeof(buffer), "%s.%s.%s", handle->handle, handle->fakehost+1, title_suffix);
166 } else if (handle->fakehost[0] == '$') {
167 /* A leading $ indicates the stored value begins with the user handle. */
168 snprintf(buffer, sizeof(buffer), "%s%s", handle->handle, handle->fakehost+1);
171 return handle->fakehost;
175 generate_fakeident(struct handle_info *handle, struct userNode *user)
177 static char buffer[USERLEN+1];
179 if (!handle->fakeident) {
182 safestrncpy(buffer, user->ident, sizeof(buffer));
185 return handle->fakeident;
189 apply_fakehost(struct handle_info *handle, struct userNode *user)
191 struct userNode *target;
192 char *fakehost, *fakeident;
197 fakehost = generate_fakehost(handle);
200 fakeident = generate_fakeident(handle, user);
201 assign_fakehost(user, fakehost, fakeident, 0, 1);
205 for (target = handle->users; target; target = target->next_authed) {
206 fakeident = generate_fakeident(handle, target);
207 assign_fakehost(target, fakehost, fakeident, 0, 1);
212 static void hs_free_all() {
213 struct hs_toplevel *tlfh, *next_tlfh;
214 struct hs_secondlevel *slfh, *next_slfh;
215 struct hs_assignment *assng, *next_assng;
216 struct hs_manager *manager, *next_manager;
217 struct hs_user *user, *next_user;
218 for(tlfh = toplevels; tlfh; tlfh = next_tlfh) {
219 next_tlfh = tlfh->next;
220 for(manager = tlfh->managers; manager; manager = next_manager) {
221 next_manager = manager->next;
224 for(slfh = tlfh->secondlevel; slfh; slfh = next_slfh) {
225 next_slfh = slfh->next;
226 for(manager = tlfh->managers; manager; manager = next_manager) {
227 next_manager = manager->next;
230 for(assng = slfh->assignments; assng; assng = next_assng) {
231 next_assng = assng->next;
234 free(slfh->fakehost);
237 free(tlfh->fakehost);
240 for(user = hostserv_users; user; user = next_user) {
241 next_user = user->next;
245 hostserv_users = NULL;
248 static struct hs_toplevel *hs_add_toplevel(const char *name) {
249 struct hs_toplevel *tlfh = calloc(1, sizeof(*tlfh));
250 tlfh->fakehost = strdup(name);
251 tlfh->next = toplevels;
256 static void hs_del_toplevel(struct hs_toplevel *tlfh) {
257 //unassign all assignments
258 struct hs_secondlevel *slfh, *next_slfh;
259 struct hs_manager *manager, *next_manager;
260 for(manager = tlfh->managers; manager; manager = next_manager) {
261 next_manager = manager->next;
262 hs_del_manager(manager, 0);
264 for(slfh = tlfh->secondlevel; slfh; slfh = next_slfh) {
265 next_slfh = slfh->next;
266 hs_del_secondlevel(slfh, 0);
269 struct hs_toplevel *ctlfh, *last_tlfh = NULL;
270 for(ctlfh = toplevels; ctlfh; ctlfh = ctlfh->next) {
273 last_tlfh->next = ctlfh->next;
275 toplevels = ctlfh->next;
279 free(tlfh->fakehost);
283 static struct hs_secondlevel *hs_add_secondlevel(struct hs_toplevel *tlfh, const char *name) {
284 struct hs_secondlevel *slfh = calloc(1, sizeof(*slfh));
285 slfh->toplevel = tlfh;
286 slfh->fakehost = strdup(name);
287 slfh->next = tlfh->secondlevel;
288 tlfh->secondlevel = slfh;
292 static void hs_del_secondlevel(struct hs_secondlevel *slfh, int remove_from_tlfh) {
293 if(remove_from_tlfh) {
294 struct hs_secondlevel *cslfh, *prev_slfh = NULL;
295 for(cslfh = slfh->toplevel->secondlevel; cslfh; cslfh = cslfh->next) {
298 prev_slfh->next = slfh->next;
300 slfh->toplevel->secondlevel = slfh->next;
306 struct hs_assignment *assng, *next_assng;
307 struct hs_manager *manager, *next_manager;
308 for(manager = slfh->managers; manager; manager = next_manager) {
309 next_manager = manager->next;
310 hs_del_manager(manager, 0);
312 for(assng = slfh->assignments; assng; assng = next_assng) {
313 next_assng = assng->next;
314 hs_del_assignment(assng, 0);
316 free(slfh->fakehost);
320 static struct hs_manager *hs_add_manager_toplevel(struct hs_toplevel *tlfh, struct hs_user *user) {
321 struct hs_manager *manager = calloc(1, sizeof(*manager));
322 manager->user = user;
324 manager->object = tlfh;
325 manager->unext = user->managements;
326 user->managements = manager;
327 manager->next = tlfh->managers;
328 tlfh->managers = manager;
332 static struct hs_manager *hs_add_manager_secondlevel(struct hs_secondlevel *slfh, struct hs_user *user) {
333 struct hs_manager *manager = calloc(1, sizeof(*manager));
334 manager->user = user;
336 manager->object = slfh;
337 manager->unext = user->managements;
338 user->managements = manager;
339 manager->next = slfh->managers;
340 slfh->managers = manager;
344 static void hs_del_manager(struct hs_manager *manager, int remove_from_object) {
345 struct hs_manager *cmanager, *prev_manager = NULL;
346 if(remove_from_object) {
347 if(manager->type == 1) {
348 struct hs_toplevel *tlfh = manager->object;
349 for(cmanager = tlfh->managers; cmanager; cmanager = cmanager->next) {
350 if(cmanager == manager) {
352 prev_manager->next = manager->next;
354 tlfh->managers = manager->next;
357 prev_manager = cmanager;
359 } else if(manager->type == 2) {
360 struct hs_secondlevel *slfh = manager->object;
361 for(cmanager = slfh->managers; cmanager; cmanager = cmanager->next) {
362 if(cmanager == manager) {
364 prev_manager->next = manager->next;
366 slfh->managers = manager->next;
369 prev_manager = cmanager;
374 if(remove_from_object != 2) {
375 for(cmanager = manager->user->managements; cmanager; cmanager = cmanager->unext) {
376 if(cmanager == manager) {
378 prev_manager->unext = manager->unext;
380 manager->user->managements = manager->unext;
383 prev_manager = cmanager;
385 if(manager->user->managements == NULL && manager->user->assignments == NULL)
386 hs_del_user(manager->user);
391 static void activateAssignment(struct hs_assignment *assignment) {
392 struct hs_toplevel *tlfh;
393 struct hs_secondlevel *slfh;
394 struct hs_user *hs_user;
395 struct hs_assignment *assgn;
399 hs_user = assignment->user;
400 if(hs_user->assignments) {
401 for(assgn = hs_user->assignments; assgn; assgn = assgn->unext) {
405 slfh = assignment->secondlevel;
406 tlfh = slfh->toplevel;
407 sprintf(fakehost, "%s.%s.%s", prefix, slfh->fakehost, tlfh->fakehost);
408 hs_user->hi->fakehost = strdup(fakehost);
409 apply_fakehost(hs_user->hi, NULL);
410 assignment->active = 1;
413 static struct hs_assignment *hs_add_assignment(struct hs_secondlevel *slfh, struct hs_user *user) {
414 struct hs_assignment *assignment = calloc(1, sizeof(*assignment));
415 assignment->secondlevel = slfh;
416 assignment->user = user;
417 if(user->assignments == NULL)
418 assignment->active = 1;
419 assignment->next = slfh->assignments;
420 slfh->assignments = assignment;
421 assignment->unext = user->assignments;
422 user->assignments = assignment;
423 if(assignment->active) {
424 activateAssignment(assignment);
429 static void hs_del_assignment(struct hs_assignment *assignment, int remove_from_slfh) {
430 struct hs_assignment *cassignment, *prev_assignment = NULL;
431 if(remove_from_slfh) {
432 for(cassignment = assignment->secondlevel->assignments; cassignment; cassignment = cassignment->next) {
433 if(cassignment == assignment) {
435 prev_assignment->next = assignment->next;
437 assignment->secondlevel->assignments = assignment->next;
440 prev_assignment = cassignment;
442 prev_assignment = NULL;
444 if(remove_from_slfh != 2) {
445 prev_assignment = NULL;
446 for(cassignment = assignment->user->assignments; cassignment; cassignment = cassignment->unext) {
447 if(cassignment == assignment) {
449 prev_assignment->unext = assignment->unext;
451 assignment->user->assignments = assignment->unext;
454 prev_assignment = cassignment;
457 if(assignment->active) {
458 struct handle_info *hi;
460 hi = assignment->user->hi;
462 apply_fakehost(hi, NULL);
465 if(assignment->user->managements == NULL && assignment->user->assignments == NULL)
466 hs_del_user(assignment->user);
471 static struct hs_user *hs_get_user(struct handle_info *hi, int create) {
472 struct hs_user *cuser;
473 for(cuser = hostserv_users; cuser; cuser = cuser->next) {
478 cuser = calloc(1, sizeof(*cuser));
480 cuser->next = hostserv_users;
481 hostserv_users = cuser;
487 static void hs_del_user(struct hs_user *user) {
488 if(user->managements) {
489 struct hs_manager *manager, *next_manager;
490 for(manager = user->managements; manager; manager = next_manager) {
491 next_manager = manager->unext;
492 hs_del_manager(manager, 2);
495 if(user->assignments) {
496 struct hs_assignment *assng, *next_assng;
497 for(assng = user->assignments; assng; assng = next_assng) {
498 next_assng = assng->unext;
499 hs_del_assignment(assng, 2);
502 struct hs_user *cuser, *prev_user = NULL;
503 for(cuser = hostserv_users; cuser; cuser = cuser->next) {
506 prev_user->next = user->next;
508 hostserv_users = user->next;
516 /* END OF MANAGEMENT FUNCTIONS */
518 static int check_management_access(struct handle_info *hi, struct hs_toplevel *tlfh, struct hs_secondlevel *slfh) {
521 if(hi->opserv_level >= hostserv_conf.toplevel_access)
523 struct hs_user *user = hs_get_user(hi, 0);
526 struct hs_manager *manager;
528 for(manager = user->managements; manager; manager = manager->next) {
529 if(manager->type == 2 && manager->object == slfh)
534 for(manager = user->managements; manager; manager = manager->next) {
535 if(manager->type == 1 && manager->object == tlfh)
543 static void cmd_view_toplevel_information(UNUSED_ARG(struct userNode *user), UNUSED_ARG(struct svccmd *cmd), struct hs_toplevel *tlfh) {
544 reply("HSMSG_TOPLEVEL_FAKEHOSTS", tlfh->fakehost);
545 struct hs_secondlevel *slfh;
546 if(!tlfh->secondlevel)
547 reply("HSMSG_ASSIGNED_NONE");
549 for(slfh = tlfh->secondlevel; slfh; slfh = slfh->next) {
550 struct hs_manager *cmanager;
552 for(cmanager = slfh->managers; cmanager; cmanager = cmanager->next)
554 struct hs_assignment *assignment;
556 for(assignment = slfh->assignments; assignment; assignment = assignment->next)
558 reply("HSMSG_TOPLEVEL_FAKEHOST", slfh->fakehost, tlfh->fakehost, assignments, managers);
560 reply("HSMSG_MANAGERS_TOPLEVEL", tlfh->fakehost);
561 struct hs_manager *cmanager;
563 reply("HSMSG_ASSIGNED_NONE");
565 char managerBuf[351];
567 for(cmanager = tlfh->managers; cmanager; cmanager = cmanager->next) {
568 if(managerPos + strlen(cmanager->user->hi->handle) + 2 >= 350) {
569 reply("HSMSG_MANAGERS_MANAGERS", managerBuf);
572 managerPos += sprintf(managerBuf + managerPos, (managerPos ? ", %s" : "%s"), cmanager->user->hi->handle);
574 reply("HSMSG_MANAGERS_MANAGERS", managerBuf);
578 static void cmd_view_secondlevel_information(UNUSED_ARG(struct userNode *user), UNUSED_ARG(struct svccmd *cmd), struct hs_secondlevel *slfh) {
579 reply("HSMSG_FAKEHOST_ASSIGNMENTS", slfh->fakehost, slfh->toplevel->fakehost);
580 struct hs_assignment *assignment;
581 for(assignment = slfh->assignments; assignment; assignment = assignment->next) {
582 reply((assignment->active ? "HSMSG_FAKEHOST_ASSIGNMENT_ACTIVE" : "HSMSG_FAKEHOST_ASSIGNMENT"), assignment->user->hi->handle, assignment->user->hi->handle, slfh->fakehost, slfh->toplevel->fakehost);
584 reply("HSMSG_MANAGERS_FAKEHOST", slfh->fakehost, slfh->toplevel->fakehost);
585 struct hs_manager *cmanager;
587 reply("HSMSG_ASSIGNED_NONE");
589 char managerBuf[351];
591 for(cmanager = slfh->managers; cmanager; cmanager = cmanager->next) {
592 if(managerPos + strlen(cmanager->user->hi->handle) + 2 >= 350) {
593 reply("HSMSG_MANAGERS_MANAGERS", managerBuf);
596 managerPos += sprintf(managerBuf + managerPos, (managerPos ? ", %s" : "%s"), cmanager->user->hi->handle);
598 reply("HSMSG_MANAGERS_MANAGERS", managerBuf);
602 static MODCMD_FUNC(cmd_addhost) {
603 struct handle_info *hi;
604 if (!(hi = user->handle_info)) {
605 reply("NSMSG_MUST_AUTH");
608 char *slfh_name = argv[1];
609 char *tlfh_name = strchr(argv[1], '.');
611 reply("HSMSG_TOPLEVEL_INVALID", slfh_name);
616 if(strchr(tlfh_name, '.')) {
617 reply("HSMSG_UNKNOWN_FAKEHOST", slfh_name, tlfh_name);
620 if(!irccasecmp(slfh_name, "*")) {
621 if(hi->opserv_level >= hostserv_conf.toplevel_access) {
622 struct hs_toplevel *tlfh;
623 for(tlfh = toplevels; tlfh; tlfh = tlfh->next) {
624 if(!irccasecmp(tlfh->fakehost, tlfh_name)) break;
627 reply("HSMSG_FAKEHOST_TOPLEVEL_ALREADY_EXISTS", slfh_name, tlfh_name);
630 hs_add_toplevel(tlfh_name);
631 reply("HSMSG_FAKEHOST_TOPLEVEL_ADDED", tlfh_name);
634 reply("HSMSG_UNKNOWN_FAKEHOST", slfh_name, tlfh_name);
637 struct hs_secondlevel *slfh;
638 struct hs_toplevel *tlfh;
639 for(tlfh = toplevels; tlfh; tlfh = tlfh->next) {
640 if(!irccasecmp(tlfh->fakehost, tlfh_name)) break;
643 reply("HSMSG_UNKNOWN_FAKEHOST", slfh_name, tlfh_name);
646 for(slfh = tlfh->secondlevel; slfh; slfh = slfh->next) {
647 if(!irccasecmp(slfh->fakehost, slfh_name)) break;
650 reply("HSMSG_UNKNOWN_FAKEHOST", slfh_name, tlfh_name);
653 if(!check_management_access(hi, tlfh, NULL)) {
654 reply("HSMSG_FAKEHOST_SECONDLEVEL_ALREADY_EXISTS", slfh_name, tlfh_name);
657 hs_add_secondlevel(tlfh, slfh_name);
658 reply("HSMSG_FAKEHOST_SECONDLEVEL_ADDED", slfh_name, tlfh_name);
663 static MODCMD_FUNC(cmd_delhost) {
664 struct handle_info *hi;
665 if (!(hi = user->handle_info)) {
666 reply("NSMSG_MUST_AUTH");
669 char *slfh_name = argv[1];
670 char *tlfh_name = strchr(argv[1], '.');
673 if(strchr(tlfh_name, '.')) {
674 reply("HSMSG_UNKNOWN_FAKEHOST", slfh_name, tlfh_name);
677 struct hs_toplevel *tlfh;
678 for(tlfh = toplevels; tlfh; tlfh = tlfh->next) {
679 if(!irccasecmp(tlfh->fakehost, tlfh_name)) break;
682 reply("HSMSG_UNKNOWN_FAKEHOST", slfh_name, tlfh_name);
685 if(!irccasecmp(slfh_name, "*")) {
686 if(hi->opserv_level < hostserv_conf.toplevel_access) {
687 reply("HSMSG_UNKNOWN_FAKEHOST", slfh_name, tlfh_name);
690 hs_del_toplevel(tlfh);
691 reply("HSMSG_FAKEHOST_TOPLEVEL_DELETED", tlfh_name);
694 struct hs_secondlevel *slfh;
695 for(slfh = tlfh->secondlevel; slfh; slfh = slfh->next) {
696 if(!irccasecmp(slfh->fakehost, slfh_name)) break;
698 if(!slfh || !check_management_access(hi, tlfh, NULL)) {
699 reply("HSMSG_UNKNOWN_FAKEHOST", slfh_name, tlfh_name);
702 hs_del_secondlevel(slfh, 1);
703 reply("HSMSG_FAKEHOST_SECONDLEVEL_DELETED", slfh_name, tlfh_name);
708 static MODCMD_FUNC(cmd_view) {
709 struct handle_info *hi;
710 if(argc >= 2 && !strchr(argv[1], '.')) {
711 if (!(hi = modcmd_get_handle_info(user, argv[1])))
713 } else if(argc >= 2) {
714 if (!(hi = user->handle_info)) {
715 reply("NSMSG_MUST_AUTH");
718 char *slfh_name = argv[1];
719 char *tlfh_name = strchr(argv[1], '.');
722 if(strchr(tlfh_name, '.')) {
723 reply("HSMSG_UNKNOWN_FAKEHOST", slfh_name, tlfh_name);
726 struct hs_toplevel *tlfh;
727 for(tlfh = toplevels; tlfh; tlfh = tlfh->next) {
728 if(!irccasecmp(tlfh->fakehost, tlfh_name)) break;
731 reply("HSMSG_UNKNOWN_FAKEHOST", slfh_name, tlfh_name);
734 if(!irccasecmp(slfh_name, "*")) {
735 if(!check_management_access(hi, tlfh, NULL)) {
736 reply("HSMSG_UNKNOWN_FAKEHOST", slfh_name, tlfh_name);
739 cmd_view_toplevel_information(user, cmd, tlfh);
742 struct hs_secondlevel *slfh;
743 for(slfh = tlfh->secondlevel; slfh; slfh = slfh->next) {
744 if(!irccasecmp(slfh->fakehost, slfh_name)) break;
746 if(!slfh || !check_management_access(hi, tlfh, slfh)) {
747 reply("HSMSG_UNKNOWN_FAKEHOST", slfh_name, tlfh_name);
750 cmd_view_secondlevel_information(user, cmd, slfh);
754 if (!(hi = user->handle_info)) {
755 reply("NSMSG_MUST_AUTH");
759 struct hs_user *huser = hs_get_user(hi, 0);
760 reply("HSMSG_ASSIGNED_FAKEHOSTS", hi->handle);
763 struct hs_assignment *assignment;
764 for(assignment = huser->assignments; assignment; assignment = assignment->unext) {
765 reply((assignment->active ? "HSMSG_ASSIGNED_FAKEHOST_ACTTIVE" : "HSMSG_ASSIGNED_FAKEHOST"), assignment->secondlevel->fakehost, assignment->secondlevel->toplevel->fakehost);
768 if(assigncount && huser->hi == user->handle_info)
769 reply("HSMSG_ASSIGN_HOWTO");
772 reply("HSMSG_ASSIGNED_NONE");
773 if(user->handle_info == hi && hi->opserv_level >= hostserv_conf.toplevel_access) {
774 struct hs_toplevel *tlfh;
775 for(tlfh = toplevels; tlfh; tlfh = tlfh->next) {
776 struct hs_secondlevel *slfh;
777 struct hs_assignment *assignment;
778 int slfhs = 0, assignments = 0;
779 for(slfh = tlfh->secondlevel; slfh; slfh = slfh->next) {
781 for(assignment = slfh->assignments; assignment; assignment = assignment->next)
784 reply("HSMSG_MANAGED_TOPLEVEL", tlfh->fakehost, slfhs, assignments);
786 reply("HSMSG_MANAGE_HOWTO");
787 } else if(huser && huser->managements) {
788 reply("HSMSG_MANAGED_FAKEHOSTS", hi->handle);
789 struct hs_manager *manager;
790 for(manager = huser->managements; manager; manager = manager->unext) {
791 if(manager->type == 1) {
792 struct hs_toplevel *tlfh = manager->object;
793 struct hs_secondlevel *slfh;
794 struct hs_assignment *assignment;
795 int slfhs = 0, assignments = 0;
796 for(slfh = tlfh->secondlevel; slfh; slfh = slfh->next) {
798 for(assignment = slfh->assignments; assignment; assignment = assignment->next)
801 reply("HSMSG_MANAGED_TOPLEVEL", tlfh->fakehost, slfhs, assignments);
804 for(manager = huser->managements; manager; manager = manager->next) {
805 if(manager->type == 2) {
806 struct hs_secondlevel *slfh = manager->object;
807 struct hs_toplevel *tlfh = slfh->toplevel;
808 //check if the user is already a manager of the tlfh
809 struct hs_manager *cmanager;
810 for(cmanager = tlfh->managers; cmanager; cmanager = cmanager->next) {
811 if(cmanager->user == huser) break;
813 if(cmanager) continue;
814 struct hs_assignment *assignment;
816 for(assignment = slfh->assignments; assignment; assignment = assignment->next)
818 reply("HSMSG_MANAGED_FAKEHOST", slfh->fakehost, tlfh->fakehost, assignments);
821 if(huser->hi == user->handle_info)
822 reply("HSMSG_MANAGE_HOWTO");
827 static MODCMD_FUNC(cmd_addmanager) {
828 struct handle_info *hi;
831 if(!strchr(argv[1], '.')) {
832 if (!(hi = modcmd_get_handle_info(user, argv[1])))
836 if (!(hi = modcmd_get_handle_info(user, argv[2])))
840 char *slfh_name = fakehost;
841 char *tlfh_name = strchr(fakehost, '.');
844 if(strchr(tlfh_name, '.')) {
845 reply("HSMSG_UNKNOWN_FAKEHOST", slfh_name, tlfh_name);
848 struct hs_toplevel *tlfh;
849 struct hs_secondlevel *slfh = NULL;
850 for(tlfh = toplevels; tlfh; tlfh = tlfh->next) {
851 if(!irccasecmp(tlfh->fakehost, tlfh_name)) break;
854 reply("HSMSG_UNKNOWN_FAKEHOST", slfh_name, tlfh_name);
857 if(!irccasecmp(slfh_name, "*")) {
858 if(!check_management_access(user->handle_info, tlfh, NULL)) {
859 reply("HSMSG_UNKNOWN_FAKEHOST", slfh_name, tlfh_name);
863 for(slfh = tlfh->secondlevel; slfh; slfh = slfh->next) {
864 if(!irccasecmp(slfh->fakehost, slfh_name)) break;
866 if(!slfh || !check_management_access(user->handle_info, tlfh, slfh)) {
867 reply("HSMSG_UNKNOWN_FAKEHOST", slfh_name, tlfh_name);
871 struct hs_user *huser = hs_get_user(hi, 1);
872 struct hs_manager *manager;
874 for(manager = huser->managements; manager; manager = manager->next) {
875 if(manager->type == 2 && manager->object == slfh) {
876 reply("HSMSG_MANAGER_ALREADY", hi->handle, slfh_name, tlfh_name);
881 for(manager = huser->managements; manager; manager = manager->next) {
882 if(manager->type == 1 && manager->object == tlfh) {
883 reply("HSMSG_MANAGER_ALREADY", hi->handle, "*", tlfh_name);
888 hs_add_manager_secondlevel(slfh, huser);
890 hs_add_manager_toplevel(tlfh, huser);
891 reply("HSMSG_MANAGER_ADDED", hi->handle, slfh_name, tlfh_name);
897 static MODCMD_FUNC(cmd_delmanager) {
898 struct handle_info *hi;
900 if(!strchr(argv[1], '.')) {
901 if (!(hi = modcmd_get_handle_info(user, argv[1])))
905 if (!(hi = modcmd_get_handle_info(user, argv[2])))
910 reply("HSMSG_ASSIGNED_NONE");
913 char *slfh_name = fakehost;
914 char *tlfh_name = strchr(fakehost, '.');
918 reply("HSMSG_ASSIGNED_NONE");
922 if(strchr(tlfh_name, '.')) {
923 reply("HSMSG_UNKNOWN_FAKEHOST", slfh_name, tlfh_name);
926 struct hs_toplevel *tlfh;
927 struct hs_secondlevel *slfh = NULL;
928 for(tlfh = toplevels; tlfh; tlfh = tlfh->next) {
929 if(!irccasecmp(tlfh->fakehost, tlfh_name)) break;
932 reply("HSMSG_UNKNOWN_FAKEHOST", slfh_name, tlfh_name);
935 if(!irccasecmp(slfh_name, "*")) {
936 if(!check_management_access(user->handle_info, tlfh, NULL)) {
937 reply("HSMSG_UNKNOWN_FAKEHOST", slfh_name, tlfh_name);
941 for(slfh = tlfh->secondlevel; slfh; slfh = slfh->next) {
942 if(!irccasecmp(slfh->fakehost, slfh_name)) break;
944 if(!slfh || !check_management_access(user->handle_info, tlfh, slfh)) {
945 reply("HSMSG_UNKNOWN_FAKEHOST", slfh_name, tlfh_name);
949 struct hs_user *huser = hs_get_user(hi, 0);
950 struct hs_manager *manager;
952 reply("HSMSG_MANAGER_NOT", hi->handle, slfh_name, tlfh_name);
956 for(manager = huser->managements; manager; manager = manager->next) {
957 if(manager->type == 2 && manager->object == slfh)
961 reply("HSMSG_MANAGER_NOT", hi->handle, slfh_name, tlfh_name);
965 for(manager = huser->managements; manager; manager = manager->next) {
966 if(manager->type == 1 && manager->object == tlfh)
970 reply("HSMSG_MANAGER_NOT", hi->handle, "*", tlfh_name);
974 hs_del_manager(manager, 1);
975 reply("HSMSG_MANAGER_DELETED", hi->handle, slfh_name, tlfh_name);
979 static MODCMD_FUNC(cmd_set) {
980 struct handle_info *hi;
981 struct hs_user *hs_user;
982 struct hs_assignment *assignment;
983 struct hs_assignment *assgn;
984 struct hs_toplevel *tlfh;
985 struct hs_secondlevel *slfh;
988 if (!(hi = user->handle_info)) {
989 reply("NSMSG_MUST_AUTH");
992 hs_user = hs_get_user(hi, 0);
993 if(!strcmp(argv[1], "*")) {
995 apply_fakehost(hi, NULL);
996 if(hs_user->assignments) {
997 for(assgn = hs_user->assignments; assgn; assgn = assgn->unext) {
1003 if(!strchr(argv[1], '.')) {
1007 char *slfh_name = fakehost;
1008 char *tlfh_name = strchr(fakehost, '.');
1011 if(strchr(tlfh_name, '.')) {
1012 reply("HSMSG_UNKNOWN_FAKEHOST", slfh_name, tlfh_name);
1015 for(assignment = hs_user->assignments; assignment; assignment = assignment->unext) {
1016 slfh = assignment->secondlevel;
1017 tlfh = slfh->toplevel;
1018 if(!irccasecmp(slfh_name, slfh->fakehost)) {
1019 if(!irccasecmp(tlfh_name, tlfh->fakehost)) {
1020 activateAssignment(assignment);
1021 reply("HSMSG_FAKEHOST_SET_SUCCESS", slfh->fakehost, tlfh->fakehost);
1026 reply("HSMSG_UNKNOWN_FAKEHOST", slfh_name, tlfh_name);
1031 static MODCMD_FUNC(cmd_assign) {
1032 struct handle_info *hi;
1033 struct handle_info *hiuser;
1035 if(!strchr(argv[1], '.')) {
1036 if (!(hi = modcmd_get_handle_info(user, argv[1])))
1040 if (!(hi = modcmd_get_handle_info(user, argv[2])))
1044 if (!(hiuser = user->handle_info)) {
1045 reply("NSMSG_MUST_AUTH");
1049 reply("HSMSG_ASSIGNED_NONE");
1052 char *slfh_name = fakehost;
1053 char *tlfh_name = strchr(fakehost, '.');
1057 reply("HSMSG_ASSIGNED_NONE");
1061 if(strchr(tlfh_name, '.')) {
1062 reply("HSMSG_UNKNOWN_FAKEHOST", slfh_name, tlfh_name);
1065 struct hs_toplevel *tlfh;;
1066 struct hs_secondlevel *slfh;
1067 struct hs_user *hs_user = hs_get_user(hi, 1);
1068 for(tlfh = toplevels; tlfh; tlfh = tlfh->next) {
1069 if(!irccasecmp(tlfh_name, tlfh->fakehost)) {
1070 for(slfh = tlfh->secondlevel; slfh; slfh = slfh->next) {
1071 if(!irccasecmp(slfh_name, slfh->fakehost)) {
1072 if(check_management_access(hiuser, tlfh, slfh)) {
1073 hs_add_assignment(slfh, hs_user);
1074 reply("HSMSG_FAKEHOST_ASSIGN_SUCCESS", slfh_name, tlfh_name);
1077 reply("HSMSG_UNKNOWN_FAKEHOST", slfh_name, tlfh_name);
1083 reply("HSMSG_UNKNOWN_FAKEHOST", slfh_name, tlfh_name);
1087 static MODCMD_FUNC(cmd_unassign) {
1088 struct handle_info *hi;
1089 struct handle_info *hiuser;
1091 if(!strchr(argv[1], '.')) {
1092 if (!(hi = modcmd_get_handle_info(user, argv[1])))
1096 if (!(hi = modcmd_get_handle_info(user, argv[2])))
1100 if (!(hiuser = user->handle_info)) {
1101 reply("NSMSG_MUST_AUTH");
1105 reply("HSMSG_ASSIGNED_NONE");
1108 char *slfh_name = fakehost;
1109 char *tlfh_name = strchr(fakehost, '.');
1113 reply("HSMSG_ASSIGNED_NONE");
1117 if(strchr(tlfh_name, '.')) {
1118 reply("HSMSG_UNKNOWN_FAKEHOST", slfh_name, tlfh_name);
1121 struct hs_assignment *assignment;
1122 struct hs_user *hs_user = hs_get_user(hi, 0);
1123 for(assignment = hs_user->assignments; assignment; assignment = assignment->unext) {
1124 if(!irccasecmp(slfh_name, assignment->secondlevel->fakehost)) {
1125 if(!irccasecmp(tlfh_name, assignment->secondlevel->toplevel->fakehost)) {
1126 if(check_management_access(hiuser, assignment->secondlevel->toplevel, assignment->secondlevel)) {
1127 hs_del_assignment(assignment, 1);
1128 reply("HSMSG_FAKEHOST_UNASSIGN_SUCCESS", slfh_name, tlfh_name);
1131 reply("HSMSG_UNKNOWN_FAKEHOST", slfh_name, tlfh_name);
1136 reply("HSMSG_UNKNOWN_FAKEHOST", slfh_name, tlfh_name);
1140 static void hostserv_conf_read(void)
1145 str = "modules/hostserv";
1146 if (!(conf_node = conf_get_data(str, RECDB_OBJECT))) {
1147 log_module(HS_LOG, LOG_ERROR, "config node `%s' is missing or has wrong type.", str);
1151 str = database_get_data(conf_node, "nick", RECDB_QSTRING);
1152 if(hostserv_conf.nick && strcmp(hostserv_conf.nick, str)) {
1155 hostserv_conf.nick = str;
1157 str = database_get_data(conf_node, "modes", RECDB_QSTRING);
1158 hostserv_conf.modes = (str ? str : NULL);
1160 str = database_get_data(conf_node, "toplevel_access", RECDB_QSTRING);
1161 unsigned int toplevel_access = atoi(str);
1162 hostserv_conf.toplevel_access = (toplevel_access ? toplevel_access : 600);
1164 /*str = database_get_data(conf_node, "description", RECDB_QSTRING);
1165 hostserv_conf.description = (str ? str : NULL);*/
1166 str = database_get_data(conf_node, KEY_TITLEHOST_SUFFIX, RECDB_QSTRING);
1167 title_suffix = str ? str : "example.net";
1170 static int hostserv_saxdb_read_secondlevel(const char *name, void *data, UNUSED_ARG(void *extra));
1171 static int hostserv_saxdb_read_assignments(const char *name, void *data, UNUSED_ARG(void *extra));
1173 static int hostserv_saxdb_read_toplevel(const char *name, void *data, UNUSED_ARG(void *extra)) {
1174 struct record_data *rd = data;
1175 struct hs_toplevel *tlfh;
1176 struct hs_manager *managerTL;
1177 struct hs_user *user;
1178 struct dict *object;
1180 if (rd->type == RECDB_OBJECT) {
1181 dict_t db = GET_RECORD_OBJECT(rd);
1184 tlfh = hs_add_toplevel(name);
1186 if ((object = database_get_data(db, KEY_MANAGERS, RECDB_OBJECT))) {
1187 for (it = dict_first(object); it; it = iter_next(it)) {
1188 user = hs_get_user(get_handle_info(iter_key(it)), 1);
1189 //rd = iter_data(it);
1190 /* nothing in here, yet */
1191 managerTL = hs_add_manager_toplevel(tlfh, user);
1192 if (database_get_data(db, KEY_ACTIVE, RECDB_QSTRING))
1193 managerTL->active = 1;
1195 managerTL->active = 0;
1199 if ((object = database_get_data(db, KEY_SECONDLEVEL, RECDB_OBJECT)))
1200 dict_foreach(object, hostserv_saxdb_read_secondlevel, tlfh);
1205 static int hostserv_saxdb_read_secondlevel(const char *name, void *data, UNUSED_ARG(void *extra)) {
1206 struct record_data *rd = data;
1207 struct hs_toplevel *tlfh = extra;
1208 struct hs_secondlevel *slfh;
1209 struct hs_manager *managerSL;
1210 struct hs_user *user;
1211 struct dict *object;
1213 if (rd->type == RECDB_OBJECT) {
1214 dict_t db = GET_RECORD_OBJECT(rd);
1217 slfh = hs_add_secondlevel(tlfh, name);
1219 if ((object = database_get_data(db, KEY_MANAGERS, RECDB_OBJECT))) {
1220 for (it = dict_first(object); it; it = iter_next(it)) {
1221 user = hs_get_user(get_handle_info(iter_key(it)), 1);
1222 //rd = iter_data(it);
1223 /* nothing in here, yet */
1224 managerSL = hs_add_manager_secondlevel(slfh, user);
1225 if (database_get_data(db, KEY_ACTIVE, RECDB_QSTRING))
1226 managerSL->active = 1;
1228 managerSL->active = 0;
1232 if ((object = database_get_data(db, KEY_ASSIGNMENTS, RECDB_OBJECT)))
1233 dict_foreach(object, hostserv_saxdb_read_assignments, slfh);
1238 static int hostserv_saxdb_read_assignments(const char *name, void *data, UNUSED_ARG(void *extra)) {
1239 struct record_data *rd = data;
1240 struct hs_secondlevel *slfh = extra;
1241 struct hs_user *user;
1242 struct hs_assignment *assng;
1244 if (rd->type == RECDB_OBJECT) {
1245 dict_t db = GET_RECORD_OBJECT(rd);
1247 user = hs_get_user(get_handle_info(name), 1);
1248 assng = hs_add_assignment(slfh, user);
1250 if (database_get_data(db, KEY_ACTIVE, RECDB_QSTRING))
1260 hostserv_saxdb_read(struct dict *db)
1262 struct dict *object;
1264 if ((object = database_get_data(db, KEY_TOPLEVEL, RECDB_OBJECT)))
1265 dict_foreach(object, hostserv_saxdb_read_toplevel, NULL);
1271 hostserv_saxdb_write(struct saxdb_context *ctx)
1273 struct hs_toplevel *tlfh;
1274 struct hs_secondlevel *slfh;
1275 struct hs_assignment *assng;
1276 struct hs_manager *manager;
1278 saxdb_start_record(ctx, KEY_TOPLEVEL, 1);
1279 for(tlfh = toplevels; tlfh; tlfh = tlfh->next) {
1280 saxdb_start_record(ctx, tlfh->fakehost, 1);
1282 saxdb_start_record(ctx, KEY_MANAGERS, 1);
1283 for(manager = tlfh->managers; manager; manager = manager->next) {
1284 saxdb_start_record(ctx, manager->user->hi->handle, 0);
1285 //additional manager information?
1287 saxdb_write_int(ctx, KEY_ACTIVE, manager->active);
1288 saxdb_end_record(ctx);
1290 saxdb_end_record(ctx);
1292 saxdb_start_record(ctx, KEY_SECONDLEVEL, 1);
1293 for(slfh = tlfh->secondlevel; slfh; slfh = slfh->next) {
1294 saxdb_start_record(ctx, slfh->fakehost, 1);
1296 saxdb_start_record(ctx, KEY_MANAGERS, 1);
1297 for(manager = slfh->managers; manager; manager = manager->next) {
1298 saxdb_start_record(ctx, manager->user->hi->handle, 0);
1299 //additional manager information?
1301 saxdb_write_int(ctx, KEY_ACTIVE, manager->active);
1302 saxdb_end_record(ctx);
1304 saxdb_end_record(ctx);
1306 saxdb_start_record(ctx, KEY_ASSIGNMENTS, 1);
1307 for(assng = slfh->assignments; assng; assng = assng->next) {
1308 saxdb_start_record(ctx, assng->user->hi->handle, 0);
1309 //additional assignment information?
1311 saxdb_write_int(ctx, KEY_ACTIVE, assng->active);
1312 saxdb_end_record(ctx);
1314 saxdb_end_record(ctx);
1316 saxdb_end_record(ctx);
1318 saxdb_end_record(ctx);
1320 saxdb_end_record(ctx);
1322 saxdb_end_record(ctx);
1328 static void hostserv_db_cleanup(void) {
1332 int hostserv_init() {
1333 HS_LOG = log_register_type("HostServ", "file:hostserv.log");
1335 const char *nick, *modes;
1336 if((nick = conf_get_data("modules/hostserv/nick", RECDB_QSTRING))) {
1337 modes = conf_get_data("modules/hostserv/modes", RECDB_QSTRING);
1338 hostserv = AddLocalUser(nick, nick, NULL, "Host Service", modes);
1339 hostserv_service = service_register(hostserv);
1340 hostserv_service->trigger = '*';
1343 conf_register_reload(hostserv_conf_read);
1344 reg_exit_func(hostserv_db_cleanup);
1345 saxdb_register("HostServ", hostserv_saxdb_read, hostserv_saxdb_write);
1346 hostserv_module = module_register("HostServ", HS_LOG, "mod-hostserv.help", NULL);
1347 modcmd_register(hostserv_module, "view", cmd_view, 0, MODCMD_REQUIRE_AUTHED, NULL);
1348 modcmd_register(hostserv_module, "addmanager", cmd_addmanager, 3, MODCMD_REQUIRE_AUTHED, NULL);
1349 modcmd_register(hostserv_module, "delmanager", cmd_delmanager, 3, MODCMD_REQUIRE_AUTHED, NULL);
1350 modcmd_register(hostserv_module, "set", cmd_set, 2, MODCMD_REQUIRE_AUTHED, NULL);
1351 modcmd_register(hostserv_module, "assign", cmd_assign, 3, MODCMD_REQUIRE_AUTHED, NULL);
1352 modcmd_register(hostserv_module, "unassign", cmd_unassign, 3, MODCMD_REQUIRE_AUTHED, NULL);
1353 modcmd_register(hostserv_module, "addhost", cmd_addhost, 2, MODCMD_REQUIRE_AUTHED, NULL);
1354 modcmd_register(hostserv_module, "delhost", cmd_delhost, 2, MODCMD_REQUIRE_AUTHED, NULL);
1355 message_register_table(msgtab);
1359 int hostserv_finalize(void) {
1363 str = "modules/hostserv";
1364 if (!(conf_node = conf_get_data(str, RECDB_OBJECT))) {
1365 log_module(HS_LOG, LOG_ERROR, "config node `%s' is missing or has wrong type.", str);
1369 str = database_get_data(conf_node, "nick", RECDB_QSTRING);
1370 if (str) hostserv_conf.nick = str;
1372 str = database_get_data(conf_node, "modes", RECDB_QSTRING);
1373 if (str) hostserv_conf.modes = str;