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";
41 #define KEY_TOPLEVEL "TopLevel"
42 #define KEY_SECONDLEVEL "SecondLevel"
43 #define KEY_MANAGERS "Manager"
44 #define KEY_ASSIGNMENTS "Assignments"
45 #define KEY_ACTIVE "active"
46 #define KEY_TITLEHOST_SUFFIX "title_suffix"
48 static const struct message_entry msgtab[] = {
49 { "HSMSG_ASSIGNED_FAKEHOSTS", "Assigned Fakehosts for User $b%s$b:" },
50 { "HSMSG_ASSIGNED_FAKEHOST", " $b%s.%s$b" },
51 { "HSMSG_ASSIGNED_FAKEHOST_ACTTIVE", " $b%s.%s$b (active)" },
52 { "HSMSG_ASSIGNED_FAKEHOST_NOT_ACTIVE", "Fakehost $b%s.%s.$b is not active." },
53 { "HSMSG_ASSIGN_HOWTO", "Use $bset xxx.yyy$b to activate one of the listed fakehosts or $bset *$b to use the default fakehost." },
54 { "HSMSG_ASSIGNED_NONE", " None." },
55 { "HSMSG_MANAGED_FAKEHOSTS", "Fakehosts managed by User $b%s$b:" },
56 { "HSMSG_MANAGED_TOPLEVEL", " $b*.%s$b fakehosts: %d assignments: %d" },
57 { "HSMSG_MANAGED_TOPLEVEL_OWN", " $b*.%s$b fakehosts: %d assignments: %d (active)" },
58 { "HSMSG_MANAGED_FAKEHOST", " $b%s.%s$b assignments: %d" },
59 { "HSMSG_MANAGE_HOWTO", "Use $bview xxx.yyy$b to view more information about a fakehost group." },
60 { "HSMSG_UNKNOWN_FAKEHOST", "Fakehost $b%s.%s$b is unknown or you have no access to manage it." },
61 { "HSMSG_TOPLEVEL_FAKEHOSTS", "Fakehosts in group $b*.%s$b:" },
62 { "HSMSG_TOPLEVEL_FAKEHOST", " $b%s.%s$b assignments: %d managers: %d" },
63 { "HSMSG_TOPLEVEL_INVALID", "The name of the group you entered is invalid ($b%s$b)" },
64 { "HSMSG_MANAGERS_TOPLEVEL", "Managers of group $b*.%s$b:" },
65 { "HSMSG_MANAGERS_FAKEHOST", "Managers of group $b%s.%s$b:" },
66 { "HSMSG_MANAGERS_MANAGERS", " %s" },
67 { "HSMSG_FAKEHOST_ASSIGNMENTS", "Assignments in group $b%s.%s$b:" },
68 { "HSMSG_FAKEHOST_ASSIGNMENT", " $b%s$b (%s.%s.%s)" },
69 { "HSMSG_FAKEHOST_ASSIGNMENT_ACTIVE", " $b%s$b (%s.%s.%s) active" },
70 { "HSMSG_FAKEHOST_SET_SUCCESS", "$b%s.%s$b where set successfully." },
71 { "HSMSG_FAKEHOST_TOPLEVEL_ADDED", "Group $b%s$b successfully added." },
72 { "HSMSG_FAKEHOST_TOPLEVEL_ALREADY_EXISTS", "Group $b%s$b already exists." },
73 { "HSMSG_FAKEHOST_TOPLEVEL_DELETED", "Group $b%s$b successfully deleted." },
74 { "HSMSG_FAKEHOST_SECONDLEVEL_ADDED", "Group $b%s.%s$b successfully added." },
75 { "HSMSG_FAKEHOST_SECONDLEVEL_ALREADY_EXISTS", "Group $b%s.%s$b already exists." },
76 { "HSMSG_FAKEHOST_SECONDLEVEL_DELETED", "Group $b%s.%s$b successfully deleted." },
77 { "HSMSG_MANAGER_ALREADY", "$b%s$b is already a manager of %s.%s" },
78 { "HSMSG_MANAGER_ADDED", "$b%s$b is now a manager of %s.%s" },
79 { "HSMSG_MANAGER_NOT", "$b%s$b is not a manager of %s.%s" },
80 { "HSMSG_MANAGER_DELETED", "$b%s$b is no longer a manager of %s.%s" },
81 { "HSMSG_FAKEHOST_ASSIGN_SUCCESS", "Group $b%s.%s$b was assigned successfully." },
82 { "HSMSG_FAKEHOST_REVOKE_SUCCESS", "Group $b%s.%s$b was revoked successfully." },
93 const char *hostserv_module_deps[] = { NULL };
94 struct userNode *hostserv;
95 struct helpfile *hostserv_helpfile;
96 static struct module *hostserv_module;
97 static struct service *hostserv_service;
98 static struct log_type *HS_LOG;
99 static struct hs_toplevel *toplevels = NULL;
100 static struct hs_user *hostserv_users = NULL;
101 const char *title_suffix = NULL;
103 /* FAKEHOST STRUCTS */
106 struct hs_manager *managers;
107 struct hs_secondlevel *secondlevel;
108 struct hs_toplevel *next;
111 struct hs_secondlevel {
112 struct hs_toplevel *toplevel;
114 struct hs_manager *managers;
115 struct hs_assignment *assignments;
116 struct hs_secondlevel *next;
119 struct hs_assignment {
120 struct hs_secondlevel *secondlevel;
121 struct hs_user *user;
123 struct hs_assignment *next;
124 struct hs_assignment *unext; /* for hs_user */
131 struct hs_user *user;
132 struct hs_manager *next;
133 struct hs_manager *unext; /* for hs_user */
137 struct handle_info *hi;
138 struct hs_assignment *assignments;
139 struct hs_manager *managements;
140 struct hs_user *next;
143 /* MANAGEMENT FUNCTIONS for FAKEHOST STRUCTS */
144 static void hs_del_secondlevel(struct hs_secondlevel *slfh, int remove_from_tlfh);
145 static void hs_del_manager(struct hs_manager *manager, int remove_from_object);
146 static void hs_del_assignment(struct hs_assignment *assignment, int remove_from_slfh);
147 static void hs_del_user(struct hs_user *user);
149 static void apply_fakehost(struct handle_info *handle, struct userNode *user);
152 generate_fakehost(struct handle_info *handle)
154 extern const char *hidden_host_suffix;
155 static char buffer[HOSTLEN+1];
157 if (!handle->fakehost) {
158 snprintf(buffer, sizeof(buffer), "%s.%s", handle->handle, hidden_host_suffix);
160 } else if (handle->fakehost[0] == '.') {
161 /* A leading dot indicates the stored value is actually a title. */
162 snprintf(buffer, sizeof(buffer), "%s.%s.%s", handle->handle, handle->fakehost+1, title_suffix);
164 } else if (handle->fakehost[0] == '$') {
165 /* A leading $ indicates the stored value begins with the user handle. */
166 snprintf(buffer, sizeof(buffer), "%s%s", handle->handle, handle->fakehost+1);
169 return handle->fakehost;
173 generate_fakeident(struct handle_info *handle, struct userNode *user)
175 static char buffer[USERLEN+1];
177 if (!handle->fakeident) {
180 safestrncpy(buffer, user->ident, sizeof(buffer));
183 return handle->fakeident;
187 apply_fakehost(struct handle_info *handle, struct userNode *user)
189 struct userNode *target;
190 char *fakehost, *fakeident;
195 fakehost = generate_fakehost(handle);
198 fakeident = generate_fakeident(handle, user);
199 assign_fakehost(user, fakehost, fakeident, 0, 1);
203 for (target = handle->users; target; target = target->next_authed) {
204 fakeident = generate_fakeident(handle, target);
205 assign_fakehost(target, fakehost, fakeident, 0, 1);
210 static void hs_free_all() {
211 struct hs_toplevel *tlfh, *next_tlfh;
212 struct hs_secondlevel *slfh, *next_slfh;
213 struct hs_assignment *assng, *next_assng;
214 struct hs_manager *manager, *next_manager;
215 struct hs_user *user, *next_user;
216 for(tlfh = toplevels; tlfh; tlfh = next_tlfh) {
217 next_tlfh = tlfh->next;
218 for(manager = tlfh->managers; manager; manager = next_manager) {
219 next_manager = manager->next;
222 for(slfh = tlfh->secondlevel; slfh; slfh = next_slfh) {
223 next_slfh = slfh->next;
224 for(manager = tlfh->managers; manager; manager = next_manager) {
225 next_manager = manager->next;
228 for(assng = slfh->assignments; assng; assng = next_assng) {
229 next_assng = assng->next;
232 free(slfh->fakehost);
235 free(tlfh->fakehost);
238 for(user = hostserv_users; user; user = next_user) {
239 next_user = user->next;
243 hostserv_users = NULL;
246 static struct hs_toplevel *hs_add_toplevel(const char *name) {
247 struct hs_toplevel *tlfh = calloc(1, sizeof(*tlfh));
248 tlfh->fakehost = strdup(name);
249 tlfh->next = toplevels;
254 static void hs_del_toplevel(struct hs_toplevel *tlfh) {
255 //unassign all assignments
256 struct hs_secondlevel *slfh, *next_slfh;
257 struct hs_manager *manager, *next_manager;
258 for(manager = tlfh->managers; manager; manager = next_manager) {
259 next_manager = manager->next;
260 hs_del_manager(manager, 0);
262 for(slfh = tlfh->secondlevel; slfh; slfh = next_slfh) {
263 next_slfh = slfh->next;
264 hs_del_secondlevel(slfh, 0);
267 struct hs_toplevel *ctlfh, *last_tlfh = NULL;
268 for(ctlfh = toplevels; ctlfh; ctlfh = ctlfh->next) {
271 last_tlfh->next = ctlfh->next;
273 toplevels = ctlfh->next;
277 free(tlfh->fakehost);
281 static struct hs_secondlevel *hs_add_secondlevel(struct hs_toplevel *tlfh, const char *name) {
282 struct hs_secondlevel *slfh = calloc(1, sizeof(*slfh));
283 slfh->toplevel = tlfh;
284 slfh->fakehost = strdup(name);
285 slfh->next = tlfh->secondlevel;
286 tlfh->secondlevel = slfh;
290 static void hs_del_secondlevel(struct hs_secondlevel *slfh, int remove_from_tlfh) {
291 if(remove_from_tlfh) {
292 struct hs_secondlevel *cslfh, *prev_slfh = NULL;
293 for(cslfh = slfh->toplevel->secondlevel; cslfh; cslfh = cslfh->next) {
296 prev_slfh->next = slfh->next;
298 slfh->toplevel->secondlevel = slfh->next;
304 struct hs_assignment *assng, *next_assng;
305 struct hs_manager *manager, *next_manager;
306 for(manager = slfh->managers; manager; manager = next_manager) {
307 next_manager = manager->next;
308 hs_del_manager(manager, 0);
310 for(assng = slfh->assignments; assng; assng = next_assng) {
311 next_assng = assng->next;
312 hs_del_assignment(assng, 0);
314 free(slfh->fakehost);
318 static struct hs_manager *hs_add_manager_toplevel(struct hs_toplevel *tlfh, struct hs_user *user) {
319 struct hs_manager *manager = calloc(1, sizeof(*manager));
320 manager->user = user;
322 manager->object = tlfh;
323 manager->unext = user->managements;
324 user->managements = manager;
325 manager->next = tlfh->managers;
326 tlfh->managers = manager;
330 static struct hs_manager *hs_add_manager_secondlevel(struct hs_secondlevel *slfh, struct hs_user *user) {
331 struct hs_manager *manager = calloc(1, sizeof(*manager));
332 manager->user = user;
334 manager->object = slfh;
335 manager->unext = user->managements;
336 user->managements = manager;
337 manager->next = slfh->managers;
338 slfh->managers = manager;
342 static void hs_del_manager(struct hs_manager *manager, int remove_from_object) {
343 struct hs_manager *cmanager, *prev_manager = NULL;
344 if(remove_from_object) {
345 if(manager->type == 1) {
346 struct hs_toplevel *tlfh = manager->object;
347 for(cmanager = tlfh->managers; cmanager; cmanager = cmanager->next) {
348 if(cmanager == manager) {
350 prev_manager->next = manager->next;
352 tlfh->managers = manager->next;
355 prev_manager = cmanager;
357 } else if(manager->type == 2) {
358 struct hs_secondlevel *slfh = manager->object;
359 for(cmanager = slfh->managers; cmanager; cmanager = cmanager->next) {
360 if(cmanager == manager) {
362 prev_manager->next = manager->next;
364 slfh->managers = manager->next;
367 prev_manager = cmanager;
372 if(remove_from_object != 2) {
373 for(cmanager = manager->user->managements; cmanager; cmanager = cmanager->unext) {
374 if(cmanager == manager) {
376 prev_manager->unext = manager->unext;
378 manager->user->managements = manager->unext;
381 prev_manager = cmanager;
383 if(manager->user->managements == NULL && manager->user->assignments == NULL)
384 hs_del_user(manager->user);
389 static void activateAssignment(struct hs_assignment *assignment) {
390 struct hs_toplevel *tlfh;
391 struct hs_secondlevel *slfh;
392 struct hs_user *hs_user;
393 struct hs_assignment *assgn;
397 hs_user = assignment->user;
398 if(hs_user->assignments) {
399 for(assgn = hs_user->assignments; assgn; assgn = assgn->unext) {
403 slfh = assignment->secondlevel;
404 tlfh = slfh->toplevel;
405 sprintf(fakehost, "%s.%s.%s", prefix, slfh->fakehost, tlfh->fakehost);
406 hs_user->hi->fakehost = strdup(fakehost);
407 apply_fakehost(hs_user->hi, NULL);
408 assignment->active = 1;
411 static struct hs_assignment *hs_add_assignment(struct hs_secondlevel *slfh, struct hs_user *user) {
412 struct hs_assignment *assignment = calloc(1, sizeof(*assignment));
413 assignment->secondlevel = slfh;
414 assignment->user = user;
415 if(user->assignments == NULL)
416 assignment->active = 1;
417 assignment->next = slfh->assignments;
418 slfh->assignments = assignment;
419 assignment->unext = user->assignments;
420 user->assignments = assignment;
421 if(assignment->active) {
422 activateAssignment(assignment);
427 static void hs_del_assignment(struct hs_assignment *assignment, int remove_from_slfh) {
428 struct hs_assignment *cassignment, *prev_assignment = NULL;
429 if(remove_from_slfh) {
430 for(cassignment = assignment->secondlevel->assignments; cassignment; cassignment = cassignment->next) {
431 if(cassignment == assignment) {
433 prev_assignment->next = assignment->next;
435 assignment->secondlevel->assignments = assignment->next;
438 prev_assignment = cassignment;
440 prev_assignment = NULL;
442 if(remove_from_slfh != 2) {
443 prev_assignment = NULL;
444 for(cassignment = assignment->user->assignments; cassignment; cassignment = cassignment->unext) {
445 if(cassignment == assignment) {
447 prev_assignment->unext = assignment->unext;
449 assignment->user->assignments = assignment->unext;
452 prev_assignment = cassignment;
455 if(assignment->active) {
456 struct handle_info *hi;
458 hi = assignment->user->hi;
460 apply_fakehost(hi, NULL);
463 if(assignment->user->managements == NULL && assignment->user->assignments == NULL)
464 hs_del_user(assignment->user);
469 static struct hs_user *hs_get_user(struct handle_info *hi, int create) {
470 struct hs_user *cuser;
471 for(cuser = hostserv_users; cuser; cuser = cuser->next) {
476 cuser = calloc(1, sizeof(*cuser));
478 cuser->next = hostserv_users;
479 hostserv_users = cuser;
485 static void hs_del_user(struct hs_user *user) {
486 if(user->managements) {
487 struct hs_manager *manager, *next_manager;
488 for(manager = user->managements; manager; manager = next_manager) {
489 next_manager = manager->unext;
490 hs_del_manager(manager, 2);
493 if(user->assignments) {
494 struct hs_assignment *assng, *next_assng;
495 for(assng = user->assignments; assng; assng = next_assng) {
496 next_assng = assng->unext;
497 hs_del_assignment(assng, 2);
500 struct hs_user *cuser, *prev_user = NULL;
501 for(cuser = hostserv_users; cuser; cuser = cuser->next) {
504 prev_user->next = user->next;
506 hostserv_users = user->next;
514 /* END OF MANAGEMENT FUNCTIONS */
516 static int check_management_access(struct handle_info *hi, struct hs_toplevel *tlfh, struct hs_secondlevel *slfh) {
519 if(hi->opserv_level >= hostserv_conf.toplevel_access)
521 struct hs_user *user = hs_get_user(hi, 0);
524 struct hs_manager *manager;
526 for(manager = user->managements; manager; manager = manager->next) {
527 if(manager->type == 2 && manager->object == slfh)
532 for(manager = user->managements; manager; manager = manager->next) {
533 if(manager->type == 1 && manager->object == tlfh)
541 static void cmd_view_toplevel_information(UNUSED_ARG(struct userNode *user), UNUSED_ARG(struct svccmd *cmd), struct hs_toplevel *tlfh) {
542 reply("HSMSG_TOPLEVEL_FAKEHOSTS", tlfh->fakehost);
543 struct hs_secondlevel *slfh;
544 if(!tlfh->secondlevel)
545 reply("HSMSG_ASSIGNED_NONE");
547 for(slfh = tlfh->secondlevel; slfh; slfh = slfh->next) {
548 struct hs_manager *cmanager;
550 for(cmanager = slfh->managers; cmanager; cmanager = cmanager->next)
552 struct hs_assignment *assignment;
554 for(assignment = slfh->assignments; assignment; assignment = assignment->next)
556 reply("HSMSG_TOPLEVEL_FAKEHOST", slfh->fakehost, tlfh->fakehost, assignments, managers);
558 reply("HSMSG_MANAGERS_TOPLEVEL", tlfh->fakehost);
559 struct hs_manager *cmanager;
561 reply("HSMSG_ASSIGNED_NONE");
563 char managerBuf[351];
565 for(cmanager = tlfh->managers; cmanager; cmanager = cmanager->next) {
566 if(managerPos + strlen(cmanager->user->hi->handle) + 2 >= 350) {
567 reply("HSMSG_MANAGERS_MANAGERS", managerBuf);
570 managerPos += sprintf(managerBuf + managerPos, (managerPos ? ", %s" : "%s"), cmanager->user->hi->handle);
572 reply("HSMSG_MANAGERS_MANAGERS", managerBuf);
576 static void cmd_view_secondlevel_information(UNUSED_ARG(struct userNode *user), UNUSED_ARG(struct svccmd *cmd), struct hs_secondlevel *slfh) {
577 reply("HSMSG_FAKEHOST_ASSIGNMENTS", slfh->fakehost, slfh->toplevel->fakehost);
578 struct hs_assignment *assignment;
579 for(assignment = slfh->assignments; assignment; assignment = assignment->next) {
580 reply((assignment->active ? "HSMSG_FAKEHOST_ASSIGNMENT_ACTIVE" : "HSMSG_FAKEHOST_ASSIGNMENT"), assignment->user->hi->handle, assignment->user->hi->handle, slfh->fakehost, slfh->toplevel->fakehost);
582 reply("HSMSG_MANAGERS_FAKEHOST", slfh->fakehost, slfh->toplevel->fakehost);
583 struct hs_manager *cmanager;
585 reply("HSMSG_ASSIGNED_NONE");
587 char managerBuf[351];
589 for(cmanager = slfh->managers; cmanager; cmanager = cmanager->next) {
590 if(managerPos + strlen(cmanager->user->hi->handle) + 2 >= 350) {
591 reply("HSMSG_MANAGERS_MANAGERS", managerBuf);
594 managerPos += sprintf(managerBuf + managerPos, (managerPos ? ", %s" : "%s"), cmanager->user->hi->handle);
596 reply("HSMSG_MANAGERS_MANAGERS", managerBuf);
600 static MODCMD_FUNC(cmd_addhost) {
601 struct handle_info *hi;
602 if (!(hi = user->handle_info)) {
603 reply("NSMSG_MUST_AUTH");
606 char *slfh_name = argv[1];
607 char *tlfh_name = strchr(argv[1], '.');
609 reply("HSMSG_TOPLEVEL_INVALID", slfh_name);
614 if(strchr(tlfh_name, '.')) {
615 reply("HSMSG_UNKNOWN_FAKEHOST", slfh_name, tlfh_name);
618 if(!irccasecmp(slfh_name, "*")) {
619 if(hi->opserv_level >= hostserv_conf.toplevel_access) {
620 struct hs_toplevel *tlfh;
621 for(tlfh = toplevels; tlfh; tlfh = tlfh->next) {
622 if(!irccasecmp(tlfh->fakehost, tlfh_name)) break;
625 reply("HSMSG_FAKEHOST_TOPLEVEL_ALREADY_EXISTS", slfh_name, tlfh_name);
628 hs_add_toplevel(tlfh_name);
629 reply("HSMSG_FAKEHOST_TOPLEVEL_ADDED", tlfh_name);
632 reply("HSMSG_UNKNOWN_FAKEHOST", slfh_name, tlfh_name);
635 struct hs_secondlevel *slfh;
636 struct hs_toplevel *tlfh;
637 for(tlfh = toplevels; tlfh; tlfh = tlfh->next) {
638 if(!irccasecmp(tlfh->fakehost, tlfh_name)) break;
641 reply("HSMSG_UNKNOWN_FAKEHOST", slfh_name, tlfh_name);
644 for(slfh = tlfh->secondlevel; slfh; slfh = slfh->next) {
645 if(!irccasecmp(slfh->fakehost, slfh_name)) break;
648 reply("HSMSG_UNKNOWN_FAKEHOST", slfh_name, tlfh_name);
651 if(!check_management_access(hi, tlfh, NULL)) {
652 reply("HSMSG_FAKEHOST_SECONDLEVEL_ALREADY_EXISTS", slfh_name, tlfh_name);
655 hs_add_secondlevel(tlfh, slfh_name);
656 reply("HSMSG_FAKEHOST_SECONDLEVEL_ADDED", slfh_name, tlfh_name);
661 static MODCMD_FUNC(cmd_delhost) {
662 struct handle_info *hi;
663 if (!(hi = user->handle_info)) {
664 reply("NSMSG_MUST_AUTH");
667 char *slfh_name = argv[1];
668 char *tlfh_name = strchr(argv[1], '.');
671 if(strchr(tlfh_name, '.')) {
672 reply("HSMSG_UNKNOWN_FAKEHOST", slfh_name, tlfh_name);
675 struct hs_toplevel *tlfh;
676 for(tlfh = toplevels; tlfh; tlfh = tlfh->next) {
677 if(!irccasecmp(tlfh->fakehost, tlfh_name)) break;
680 reply("HSMSG_UNKNOWN_FAKEHOST", slfh_name, tlfh_name);
683 if(!irccasecmp(slfh_name, "*")) {
684 if(hi->opserv_level < hostserv_conf.toplevel_access) {
685 reply("HSMSG_UNKNOWN_FAKEHOST", slfh_name, tlfh_name);
688 hs_del_toplevel(tlfh);
689 reply("HSMSG_FAKEHOST_TOPLEVEL_DELETED", tlfh_name);
692 struct hs_secondlevel *slfh;
693 for(slfh = tlfh->secondlevel; slfh; slfh = slfh->next) {
694 if(!irccasecmp(slfh->fakehost, slfh_name)) break;
696 if(!slfh || !check_management_access(hi, tlfh, NULL)) {
697 reply("HSMSG_UNKNOWN_FAKEHOST", slfh_name, tlfh_name);
700 hs_del_secondlevel(slfh, 1);
701 reply("HSMSG_FAKEHOST_SECONDLEVEL_DELETED", slfh_name, tlfh_name);
706 static MODCMD_FUNC(cmd_view) {
707 struct handle_info *hi;
708 if(argc >= 2 && !strchr(argv[1], '.')) {
709 if (!(hi = modcmd_get_handle_info(user, argv[1])))
711 } else if(argc >= 2) {
712 if (!(hi = user->handle_info)) {
713 reply("NSMSG_MUST_AUTH");
716 char *slfh_name = argv[1];
717 char *tlfh_name = strchr(argv[1], '.');
720 if(strchr(tlfh_name, '.')) {
721 reply("HSMSG_UNKNOWN_FAKEHOST", slfh_name, tlfh_name);
724 struct hs_toplevel *tlfh;
725 for(tlfh = toplevels; tlfh; tlfh = tlfh->next) {
726 if(!irccasecmp(tlfh->fakehost, tlfh_name)) break;
729 reply("HSMSG_UNKNOWN_FAKEHOST", slfh_name, tlfh_name);
732 if(!irccasecmp(slfh_name, "*")) {
733 if(!check_management_access(hi, tlfh, NULL)) {
734 reply("HSMSG_UNKNOWN_FAKEHOST", slfh_name, tlfh_name);
737 cmd_view_toplevel_information(user, cmd, tlfh);
740 struct hs_secondlevel *slfh;
741 for(slfh = tlfh->secondlevel; slfh; slfh = slfh->next) {
742 if(!irccasecmp(slfh->fakehost, slfh_name)) break;
744 if(!slfh || !check_management_access(hi, tlfh, slfh)) {
745 reply("HSMSG_UNKNOWN_FAKEHOST", slfh_name, tlfh_name);
748 cmd_view_secondlevel_information(user, cmd, slfh);
752 if (!(hi = user->handle_info)) {
753 reply("NSMSG_MUST_AUTH");
757 struct hs_user *huser = hs_get_user(hi, 0);
758 reply("HSMSG_ASSIGNED_FAKEHOSTS", hi->handle);
761 struct hs_assignment *assignment;
762 for(assignment = huser->assignments; assignment; assignment = assignment->unext) {
763 reply((assignment->active ? "HSMSG_ASSIGNED_FAKEHOST_ACTTIVE" : "HSMSG_ASSIGNED_FAKEHOST"), assignment->secondlevel->fakehost, assignment->secondlevel->toplevel->fakehost);
766 if(assigncount && huser->hi == user->handle_info)
767 reply("HSMSG_ASSIGN_HOWTO");
770 reply("HSMSG_ASSIGNED_NONE");
771 if(user->handle_info == hi && hi->opserv_level >= hostserv_conf.toplevel_access) {
772 struct hs_toplevel *tlfh;
773 for(tlfh = toplevels; tlfh; tlfh = tlfh->next) {
774 struct hs_secondlevel *slfh;
775 struct hs_assignment *assignment;
776 int slfhs = 0, assignments = 0;
777 for(slfh = tlfh->secondlevel; slfh; slfh = slfh->next) {
779 for(assignment = slfh->assignments; assignment; assignment = assignment->next)
782 reply("HSMSG_MANAGED_TOPLEVEL", tlfh->fakehost, slfhs, assignments);
784 reply("HSMSG_MANAGE_HOWTO");
785 } else if(huser && huser->managements) {
786 reply("HSMSG_MANAGED_FAKEHOSTS", hi->handle);
787 struct hs_manager *manager;
788 for(manager = huser->managements; manager; manager = manager->unext) {
789 if(manager->type == 1) {
790 struct hs_toplevel *tlfh = manager->object;
791 struct hs_secondlevel *slfh;
792 struct hs_assignment *assignment;
793 int slfhs = 0, assignments = 0;
794 for(slfh = tlfh->secondlevel; slfh; slfh = slfh->next) {
796 for(assignment = slfh->assignments; assignment; assignment = assignment->next)
799 reply("HSMSG_MANAGED_TOPLEVEL", tlfh->fakehost, slfhs, assignments);
802 for(manager = huser->managements; manager; manager = manager->next) {
803 if(manager->type == 2) {
804 struct hs_secondlevel *slfh = manager->object;
805 struct hs_toplevel *tlfh = slfh->toplevel;
806 //check if the user is already a manager of the tlfh
807 struct hs_manager *cmanager;
808 for(cmanager = tlfh->managers; cmanager; cmanager = cmanager->next) {
809 if(cmanager->user == huser) break;
811 if(cmanager) continue;
812 struct hs_assignment *assignment;
814 for(assignment = slfh->assignments; assignment; assignment = assignment->next)
816 reply("HSMSG_MANAGED_FAKEHOST", slfh->fakehost, tlfh->fakehost, assignments);
819 if(huser->hi == user->handle_info)
820 reply("HSMSG_MANAGE_HOWTO");
825 static MODCMD_FUNC(cmd_addmanager) {
826 struct handle_info *hi;
829 if(!strchr(argv[1], '.')) {
830 if (!(hi = modcmd_get_handle_info(user, argv[1])))
834 if (!(hi = modcmd_get_handle_info(user, argv[2])))
838 char *slfh_name = fakehost;
839 char *tlfh_name = strchr(fakehost, '.');
842 if(strchr(tlfh_name, '.')) {
843 reply("HSMSG_UNKNOWN_FAKEHOST", slfh_name, tlfh_name);
846 struct hs_toplevel *tlfh;
847 struct hs_secondlevel *slfh = NULL;
848 for(tlfh = toplevels; tlfh; tlfh = tlfh->next) {
849 if(!irccasecmp(tlfh->fakehost, tlfh_name)) break;
852 reply("HSMSG_UNKNOWN_FAKEHOST", slfh_name, tlfh_name);
855 if(!irccasecmp(slfh_name, "*")) {
856 if(!check_management_access(user->handle_info, tlfh, NULL)) {
857 reply("HSMSG_UNKNOWN_FAKEHOST", slfh_name, tlfh_name);
861 for(slfh = tlfh->secondlevel; slfh; slfh = slfh->next) {
862 if(!irccasecmp(slfh->fakehost, slfh_name)) break;
864 if(!slfh || !check_management_access(user->handle_info, tlfh, slfh)) {
865 reply("HSMSG_UNKNOWN_FAKEHOST", slfh_name, tlfh_name);
869 struct hs_user *huser = hs_get_user(hi, 1);
870 struct hs_manager *manager;
872 for(manager = huser->managements; manager; manager = manager->next) {
873 if(manager->type == 2 && manager->object == slfh) {
874 reply("HSMSG_MANAGER_ALREADY", hi->handle, slfh_name, tlfh_name);
879 for(manager = huser->managements; manager; manager = manager->next) {
880 if(manager->type == 1 && manager->object == tlfh) {
881 reply("HSMSG_MANAGER_ALREADY", hi->handle, "*", tlfh_name);
886 hs_add_manager_secondlevel(slfh, huser);
888 hs_add_manager_toplevel(tlfh, huser);
889 reply("HSMSG_MANAGER_ADDED", hi->handle, slfh_name, tlfh_name);
895 static MODCMD_FUNC(cmd_delmanager) {
896 struct handle_info *hi;
898 if(!strchr(argv[1], '.')) {
899 if (!(hi = modcmd_get_handle_info(user, argv[1])))
903 if (!(hi = modcmd_get_handle_info(user, argv[2])))
908 reply("HSMSG_ASSIGNED_NONE");
911 char *slfh_name = fakehost;
912 char *tlfh_name = strchr(fakehost, '.');
916 reply("HSMSG_ASSIGNED_NONE");
920 if(strchr(tlfh_name, '.')) {
921 reply("HSMSG_UNKNOWN_FAKEHOST", slfh_name, tlfh_name);
924 struct hs_toplevel *tlfh;
925 struct hs_secondlevel *slfh = NULL;
926 for(tlfh = toplevels; tlfh; tlfh = tlfh->next) {
927 if(!irccasecmp(tlfh->fakehost, tlfh_name)) break;
930 reply("HSMSG_UNKNOWN_FAKEHOST", slfh_name, tlfh_name);
933 if(!irccasecmp(slfh_name, "*")) {
934 if(!check_management_access(user->handle_info, tlfh, NULL)) {
935 reply("HSMSG_UNKNOWN_FAKEHOST", slfh_name, tlfh_name);
939 for(slfh = tlfh->secondlevel; slfh; slfh = slfh->next) {
940 if(!irccasecmp(slfh->fakehost, slfh_name)) break;
942 if(!slfh || !check_management_access(user->handle_info, tlfh, slfh)) {
943 reply("HSMSG_UNKNOWN_FAKEHOST", slfh_name, tlfh_name);
947 struct hs_user *huser = hs_get_user(hi, 0);
948 struct hs_manager *manager;
950 reply("HSMSG_MANAGER_NOT", hi->handle, slfh_name, tlfh_name);
954 for(manager = huser->managements; manager; manager = manager->next) {
955 if(manager->type == 2 && manager->object == slfh)
959 reply("HSMSG_MANAGER_NOT", hi->handle, slfh_name, tlfh_name);
963 for(manager = huser->managements; manager; manager = manager->next) {
964 if(manager->type == 1 && manager->object == tlfh)
968 reply("HSMSG_MANAGER_NOT", hi->handle, "*", tlfh_name);
972 hs_del_manager(manager, 1);
973 reply("HSMSG_MANAGER_DELETED", hi->handle, slfh_name, tlfh_name);
977 static MODCMD_FUNC(cmd_set) {
978 struct handle_info *hi;
979 struct hs_user *hs_user;
980 struct hs_assignment *assignment;
981 struct hs_assignment *assgn;
982 struct hs_toplevel *tlfh;
983 struct hs_secondlevel *slfh;
986 if (!(hi = user->handle_info)) {
987 reply("NSMSG_MUST_AUTH");
990 hs_user = hs_get_user(hi, 0);
991 if(!strcmp(argv[1], "*")) {
993 apply_fakehost(hi, NULL);
994 if(hs_user->assignments) {
995 for(assgn = hs_user->assignments; assgn; assgn = assgn->unext) {
1001 if(!strchr(argv[1], '.')) {
1005 char *slfh_name = fakehost;
1006 char *tlfh_name = strchr(fakehost, '.');
1009 if(strchr(tlfh_name, '.')) {
1010 reply("HSMSG_UNKNOWN_FAKEHOST", slfh_name, tlfh_name);
1013 for(assignment = hs_user->assignments; assignment; assignment = assignment->unext) {
1014 slfh = assignment->secondlevel;
1015 tlfh = slfh->toplevel;
1016 if(!irccasecmp(slfh_name, slfh->fakehost)) {
1017 if(!irccasecmp(tlfh_name, tlfh->fakehost)) {
1018 activateAssignment(assignment);
1019 reply("HSMSG_FAKEHOST_SET_SUCCESS", slfh->fakehost, tlfh->fakehost);
1024 reply("HSMSG_UNKNOWN_FAKEHOST", slfh_name, tlfh_name);
1029 static MODCMD_FUNC(cmd_assign) {
1030 struct handle_info *hi;
1031 struct handle_info *hiuser;
1033 if(!strchr(argv[1], '.')) {
1034 if (!(hi = modcmd_get_handle_info(user, argv[1])))
1038 if (!(hi = modcmd_get_handle_info(user, argv[2])))
1042 if (!(hiuser = user->handle_info)) {
1043 reply("NSMSG_MUST_AUTH");
1047 reply("HSMSG_ASSIGNED_NONE");
1050 char *slfh_name = fakehost;
1051 char *tlfh_name = strchr(fakehost, '.');
1055 reply("HSMSG_ASSIGNED_NONE");
1059 if(strchr(tlfh_name, '.')) {
1060 reply("HSMSG_UNKNOWN_FAKEHOST", slfh_name, tlfh_name);
1063 struct hs_toplevel *tlfh;;
1064 struct hs_secondlevel *slfh;
1065 struct hs_user *hs_user = hs_get_user(hi, 1);
1066 for(tlfh = toplevels; tlfh; tlfh = tlfh->next) {
1067 if(!irccasecmp(tlfh_name, tlfh->fakehost)) {
1068 for(slfh = tlfh->secondlevel; slfh; slfh = slfh->next) {
1069 if(!irccasecmp(slfh_name, slfh->fakehost)) {
1070 if(check_management_access(hiuser, tlfh, slfh)) {
1071 hs_add_assignment(slfh, hs_user);
1072 reply("HSMSG_FAKEHOST_ASSIGN_SUCCESS", slfh_name, tlfh_name);
1075 reply("HSMSG_UNKNOWN_FAKEHOST", slfh_name, tlfh_name);
1081 reply("HSMSG_UNKNOWN_FAKEHOST", slfh_name, tlfh_name);
1085 static MODCMD_FUNC(cmd_revoke) {
1086 struct handle_info *hi;
1087 struct handle_info *hiuser;
1089 if(!strchr(argv[1], '.')) {
1090 if (!(hi = modcmd_get_handle_info(user, argv[1])))
1094 if (!(hi = modcmd_get_handle_info(user, argv[2])))
1098 if (!(hiuser = user->handle_info)) {
1099 reply("NSMSG_MUST_AUTH");
1103 reply("HSMSG_ASSIGNED_NONE");
1106 char *slfh_name = fakehost;
1107 char *tlfh_name = strchr(fakehost, '.');
1111 reply("HSMSG_ASSIGNED_NONE");
1115 if(strchr(tlfh_name, '.')) {
1116 reply("HSMSG_UNKNOWN_FAKEHOST", slfh_name, tlfh_name);
1119 struct hs_assignment *assignment;
1120 struct hs_user *hs_user = hs_get_user(hi, 0);
1121 for(assignment = hs_user->assignments; assignment; assignment = assignment->unext) {
1122 if(!irccasecmp(slfh_name, assignment->secondlevel->fakehost)) {
1123 if(!irccasecmp(tlfh_name, assignment->secondlevel->toplevel->fakehost)) {
1124 if(check_management_access(hiuser, assignment->secondlevel->toplevel, assignment->secondlevel)) {
1125 hs_del_assignment(assignment, 1);
1126 reply("HSMSG_FAKEHOST_REVOKE_SUCCESS", slfh_name, tlfh_name);
1129 reply("HSMSG_UNKNOWN_FAKEHOST", slfh_name, tlfh_name);
1134 reply("HSMSG_UNKNOWN_FAKEHOST", slfh_name, tlfh_name);
1138 static void hostserv_conf_read(void)
1143 str = "modules/hostserv";
1144 if (!(conf_node = conf_get_data(str, RECDB_OBJECT))) {
1145 log_module(HS_LOG, LOG_ERROR, "config node `%s' is missing or has wrong type.", str);
1149 str = database_get_data(conf_node, "nick", RECDB_QSTRING);
1150 if(hostserv_conf.nick && strcmp(hostserv_conf.nick, str)) {
1153 hostserv_conf.nick = str;
1155 str = database_get_data(conf_node, "modes", RECDB_QSTRING);
1156 hostserv_conf.modes = (str ? str : NULL);
1158 str = database_get_data(conf_node, "toplevel_access", RECDB_QSTRING);
1159 unsigned int toplevel_access = atoi(str);
1160 hostserv_conf.toplevel_access = (toplevel_access ? toplevel_access : 600);
1162 /*str = database_get_data(conf_node, "description", RECDB_QSTRING);
1163 hostserv_conf.description = (str ? str : NULL);*/
1164 str = database_get_data(conf_node, KEY_TITLEHOST_SUFFIX, RECDB_QSTRING);
1165 title_suffix = str ? str : "example.net";
1168 static int hostserv_saxdb_read_secondlevel(const char *name, void *data, UNUSED_ARG(void *extra));
1169 static int hostserv_saxdb_read_assignments(const char *name, void *data, UNUSED_ARG(void *extra));
1171 static int hostserv_saxdb_read_toplevel(const char *name, void *data, UNUSED_ARG(void *extra)) {
1172 struct record_data *rd = data;
1173 struct hs_toplevel *tlfh;
1174 struct hs_manager *managerTL;
1175 struct hs_user *user;
1176 struct dict *object;
1178 if (rd->type == RECDB_OBJECT) {
1179 dict_t db = GET_RECORD_OBJECT(rd);
1182 tlfh = hs_add_toplevel(name);
1184 if ((object = database_get_data(db, KEY_MANAGERS, RECDB_OBJECT))) {
1185 for (it = dict_first(object); it; it = iter_next(it)) {
1186 user = hs_get_user(get_handle_info(iter_key(it)), 1);
1187 //rd = iter_data(it);
1188 /* nothing in here, yet */
1189 managerTL = hs_add_manager_toplevel(tlfh, user);
1190 if (database_get_data(db, KEY_ACTIVE, RECDB_QSTRING))
1191 managerTL->active = 1;
1193 managerTL->active = 0;
1197 if ((object = database_get_data(db, KEY_SECONDLEVEL, RECDB_OBJECT)))
1198 dict_foreach(object, hostserv_saxdb_read_secondlevel, tlfh);
1203 static int hostserv_saxdb_read_secondlevel(const char *name, void *data, UNUSED_ARG(void *extra)) {
1204 struct record_data *rd = data;
1205 struct hs_toplevel *tlfh = extra;
1206 struct hs_secondlevel *slfh;
1207 struct hs_manager *managerSL;
1208 struct hs_user *user;
1209 struct dict *object;
1211 if (rd->type == RECDB_OBJECT) {
1212 dict_t db = GET_RECORD_OBJECT(rd);
1215 slfh = hs_add_secondlevel(tlfh, name);
1217 if ((object = database_get_data(db, KEY_MANAGERS, RECDB_OBJECT))) {
1218 for (it = dict_first(object); it; it = iter_next(it)) {
1219 user = hs_get_user(get_handle_info(iter_key(it)), 1);
1220 //rd = iter_data(it);
1221 /* nothing in here, yet */
1222 managerSL = hs_add_manager_secondlevel(slfh, user);
1223 if (database_get_data(db, KEY_ACTIVE, RECDB_QSTRING))
1224 managerSL->active = 1;
1226 managerSL->active = 0;
1230 if ((object = database_get_data(db, KEY_ASSIGNMENTS, RECDB_OBJECT)))
1231 dict_foreach(object, hostserv_saxdb_read_assignments, slfh);
1236 static int hostserv_saxdb_read_assignments(const char *name, void *data, UNUSED_ARG(void *extra)) {
1237 struct record_data *rd = data;
1238 struct hs_secondlevel *slfh = extra;
1239 struct hs_user *user;
1240 struct hs_assignment *assng;
1242 if (rd->type == RECDB_OBJECT) {
1243 dict_t db = GET_RECORD_OBJECT(rd);
1245 user = hs_get_user(get_handle_info(name), 1);
1246 assng = hs_add_assignment(slfh, user);
1248 if (database_get_data(db, KEY_ACTIVE, RECDB_QSTRING))
1258 hostserv_saxdb_read(struct dict *db)
1260 struct dict *object;
1262 if ((object = database_get_data(db, KEY_TOPLEVEL, RECDB_OBJECT)))
1263 dict_foreach(object, hostserv_saxdb_read_toplevel, NULL);
1269 hostserv_saxdb_write(struct saxdb_context *ctx)
1271 struct hs_toplevel *tlfh;
1272 struct hs_secondlevel *slfh;
1273 struct hs_assignment *assng;
1274 struct hs_manager *manager;
1276 saxdb_start_record(ctx, KEY_TOPLEVEL, 1);
1277 for(tlfh = toplevels; tlfh; tlfh = tlfh->next) {
1278 saxdb_start_record(ctx, tlfh->fakehost, 1);
1280 saxdb_start_record(ctx, KEY_MANAGERS, 1);
1281 for(manager = tlfh->managers; manager; manager = manager->next) {
1282 saxdb_start_record(ctx, manager->user->hi->handle, 0);
1283 //additional manager information?
1285 saxdb_write_int(ctx, KEY_ACTIVE, manager->active);
1286 saxdb_end_record(ctx);
1288 saxdb_end_record(ctx);
1290 saxdb_start_record(ctx, KEY_SECONDLEVEL, 1);
1291 for(slfh = tlfh->secondlevel; slfh; slfh = slfh->next) {
1292 saxdb_start_record(ctx, slfh->fakehost, 1);
1294 saxdb_start_record(ctx, KEY_MANAGERS, 1);
1295 for(manager = slfh->managers; manager; manager = manager->next) {
1296 saxdb_start_record(ctx, manager->user->hi->handle, 0);
1297 //additional manager information?
1299 saxdb_write_int(ctx, KEY_ACTIVE, manager->active);
1300 saxdb_end_record(ctx);
1302 saxdb_end_record(ctx);
1304 saxdb_start_record(ctx, KEY_ASSIGNMENTS, 1);
1305 for(assng = slfh->assignments; assng; assng = assng->next) {
1306 saxdb_start_record(ctx, assng->user->hi->handle, 0);
1307 //additional assignment information?
1309 saxdb_write_int(ctx, KEY_ACTIVE, assng->active);
1310 saxdb_end_record(ctx);
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);
1326 static void hostserv_db_cleanup(void) {
1330 int hostserv_init() {
1331 HS_LOG = log_register_type("HostServ", "file:hostserv.log");
1333 const char *nick, *modes;
1334 if((nick = conf_get_data("modules/hostserv/nick", RECDB_QSTRING))) {
1335 modes = conf_get_data("modules/hostserv/modes", RECDB_QSTRING);
1336 hostserv = AddLocalUser(nick, nick, NULL, "Host Service", modes);
1337 hostserv_service = service_register(hostserv);
1338 hostserv_service->trigger = '*';
1341 conf_register_reload(hostserv_conf_read);
1342 reg_exit_func(hostserv_db_cleanup);
1343 saxdb_register("HostServ", hostserv_saxdb_read, hostserv_saxdb_write);
1344 hostserv_module = module_register("HostServ", HS_LOG, "mod-hostserv.help", NULL);
1345 modcmd_register(hostserv_module, "view", cmd_view, 0, MODCMD_REQUIRE_AUTHED, NULL);
1346 modcmd_register(hostserv_module, "addmanager", cmd_addmanager, 3, MODCMD_REQUIRE_AUTHED, NULL);
1347 modcmd_register(hostserv_module, "delmanager", cmd_delmanager, 3, MODCMD_REQUIRE_AUTHED, NULL);
1348 modcmd_register(hostserv_module, "set", cmd_set, 2, MODCMD_REQUIRE_AUTHED, NULL);
1349 modcmd_register(hostserv_module, "assign", cmd_assign, 3, MODCMD_REQUIRE_AUTHED, NULL);
1350 modcmd_register(hostserv_module, "revoke", cmd_revoke, 3, MODCMD_REQUIRE_AUTHED, NULL);
1351 modcmd_register(hostserv_module, "addhost", cmd_addhost, 2, MODCMD_REQUIRE_AUTHED, NULL);
1352 modcmd_register(hostserv_module, "delhost", cmd_delhost, 2, MODCMD_REQUIRE_AUTHED, NULL);
1353 message_register_table(msgtab);
1357 int hostserv_finalize(void) {
1361 str = "modules/hostserv";
1362 if (!(conf_node = conf_get_data(str, RECDB_OBJECT))) {
1363 log_module(HS_LOG, LOG_ERROR, "config node `%s' is missing or has wrong type.", str);
1367 str = database_get_data(conf_node, "nick", RECDB_QSTRING);
1368 if (str) hostserv_conf.nick = str;
1370 str = database_get_data(conf_node, "modes", RECDB_QSTRING);
1371 if (str) hostserv_conf.modes = str;