1 /* This file is part of the Project Athena Zephyr Notification System.
2 * It contains functions for the User Locator service.
4 * Created by: John T. Kohl
6 * $Id: uloc.c,v 1.60 2001/02/27 04:59:03 zacheiss Exp $
8 * Copyright (c) 1987,1988 by the Massachusetts Institute of Technology.
9 * For copying and distribution information, see the file
13 #include <zephyr/mit-copyright.h>
15 #include <sys/socket.h>
19 static const char rcsid_uloc_c[] =
20 "$Id: uloc.c,v 1.60 2001/02/27 04:59:03 zacheiss Exp $";
25 * The user locator functions.
29 * void ulocate_dispatch(notice, auth, who, server)
32 * struct sockaddr_in *who;
35 * void ulogin_dispatch(notice, auth, who, server)
38 * struct sockaddr_in *who;
41 * void uloc_hflush(addr)
42 * struct in_addr *addr;
44 * void uloc_flush_client(sin)
45 * struct sockaddr_in *sin;
47 * Code_t uloc_send_locations()
49 * void uloc_dump_locs(fp)
55 * We maintain an array of Location sorted by user (so we can do
56 * binary searches), growing and shrinking it as necessary.
59 /* WARNING: make sure this is the same as the number of strings you */
60 /* plan to hand back to the user in response to a locate request, */
61 /* else you will lose. See ulogin_locate() and uloc_send_locations() */
64 typedef enum _Exposure_type {
73 typedef struct _Location {
76 char *time; /* in ctime format */
78 struct sockaddr_in addr; /* IP address and port of location */
79 Exposure_type exposure;
86 static void ulogin_locate __P((ZNotice_t *notice, struct sockaddr_in *who,
88 ulogin_flush_user __P((ZNotice_t *notice));
89 static Location *ulogin_find __P((char *user, struct in_addr *host,
91 static Location *ulogin_find_user __P((char *user));
92 static int ulogin_setup __P((ZNotice_t *notice, Location *locs,
93 Exposure_type exposure, struct sockaddr_in *who)),
94 ulogin_add_user __P((ZNotice_t *notice, Exposure_type exposure,
95 struct sockaddr_in *who)),
96 ulogin_parse __P((ZNotice_t *notice, Location *locs));
97 static Exposure_type ulogin_remove_user __P((ZNotice_t *notice,
98 struct sockaddr_in *who,
100 static void login_sendit __P((ZNotice_t *notice, int auth,
101 struct sockaddr_in *who, int external));
102 static char **ulogin_marshal_locs __P((ZNotice_t *notice, int *found,
105 static int ul_equiv __P((Location *l1, Location *l2));
107 static void free_loc __P((Location *loc));
108 static void ulogin_locate_forward __P((ZNotice_t *notice,
109 struct sockaddr_in *who, Realm *realm));
111 static Location *locations = NULL; /* ptr to first in array */
112 static int num_locs = 0; /* number in array */
115 * Dispatch a LOGIN notice.
119 ulogin_dispatch(notice, auth, who, server)
122 struct sockaddr_in *who;
125 Exposure_type retval;
128 if (strcmp(notice->z_opcode, LOGIN_USER_LOGOUT) == 0) {
129 retval = ulogin_remove_user(notice, who, &err_ret);
132 if (err_ret == UNAUTH) {
133 if (server == me_server)
134 clt_ack(notice, who, AUTH_FAILED);
136 } else if (err_ret == NOLOC) {
137 if (server == me_server)
138 clt_ack(notice, who, NOT_FOUND);
141 syslog(LOG_ERR,"bogus location exposure NONE, %s",
146 /* he is not announced to people. Silently ack */
147 if (server == me_server)
152 if (server == me_server)
153 sendit(notice, 1, who, 0, 1);
156 /* currently no distinction between these.
158 /* we assume that if this user is at a certain
159 IP address, we can trust the logout to be
160 authentic. ulogin_remove_user checks the
162 if (server == me_server)
163 sendit(notice, 1, who, 1, 1);
166 syslog(LOG_ERR,"bogus location exposure %d/%s",
167 (int) retval, notice->z_sender);
170 if (server == me_server) /* tell the other servers */
171 server_forward(notice, auth, who);
175 (!auth || strcmp(notice->z_sender, notice->z_class_inst) != 0)) {
176 zdbug((LOG_DEBUG,"unauthentic ulogin: %d %s %s", auth,
177 notice->z_sender, notice->z_class_inst));
178 if (server == me_server)
179 clt_ack(notice, who, AUTH_FAILED);
182 if (strcmp(notice->z_opcode, LOGIN_USER_FLUSH) == 0) {
183 ulogin_flush_user(notice);
184 if (server == me_server)
186 } else if (strcmp(notice->z_opcode, EXPOSE_NONE) == 0) {
187 ulogin_remove_user(notice, who, &err_ret);
188 if (err_ret == UNAUTH) {
189 if (server == me_server)
190 clt_ack(notice, who, AUTH_FAILED);
192 } else if (err_ret == NOLOC) {
193 if (server == me_server)
194 clt_ack(notice, who, NOT_FOUND);
197 if (server == me_server) {
199 server_forward(notice, auth, who);
202 } else if (strcmp(notice->z_opcode, EXPOSE_OPSTAFF) == 0) {
203 err_ret = ulogin_add_user(notice, OPSTAFF_VIS, who);
204 if (server == me_server) {
210 } else if (strcmp(notice->z_opcode, EXPOSE_REALMVIS) == 0) {
211 err_ret = ulogin_add_user(notice, REALM_VIS, who);
212 if (server == me_server) { /* realm vis is not broadcast,
219 } else if (!strcmp(notice->z_opcode, EXPOSE_REALMANN)) {
220 err_ret = ulogin_add_user(notice, REALM_ANN, who);
221 if (server == me_server) { /* announce to the realm */
225 login_sendit(notice, auth, who, 0);
227 } else if (!strcmp(notice->z_opcode, EXPOSE_NETVIS)) {
228 err_ret = ulogin_add_user(notice, NET_VIS, who);
229 if (server == me_server) { /* announce to the realm */
233 login_sendit(notice, auth, who, 0);
235 } else if (!strcmp(notice->z_opcode, EXPOSE_NETANN)) {
236 err_ret = ulogin_add_user(notice, NET_ANN, who);
237 if (server == me_server) { /* tell the world */
241 login_sendit(notice, auth, who, 1);
244 syslog(LOG_ERR, "unknown ulog opcode %s", notice->z_opcode);
245 if (server == me_server)
249 if (server == me_server)
250 server_forward(notice, auth, who);
255 login_sendit(notice, auth, who, external)
258 struct sockaddr_in *who;
261 ZNotice_t log_notice;
263 /* we must copy the notice struct here because we need the original
264 for forwarding. We needn't copy the private data of the notice,
265 since that isn't modified by sendit and its subroutines. */
267 log_notice = *notice;
269 log_notice.z_opcode = LOGIN_USER_LOGIN;
270 sendit(&log_notice, auth, who, external, 1);
275 * Dispatch a LOCATE notice.
278 ulocate_dispatch(notice, auth, who, server)
281 struct sockaddr_in *who;
287 if (!strcmp(notice->z_opcode, LOCATE_LOCATE)) {
288 /* we are talking to a current-rev client; send an ack */
290 ulogin_locate(notice, who, auth);
293 syslog(LOG_ERR, "unknown uloc opcode %s", notice->z_opcode);
294 if (server == me_server)
301 * Flush all locations at the address.
306 struct in_addr *addr;
309 int i = 0, new_num = 0;
312 return; /* none to flush */
314 /* slightly inefficient, assume the worst, and allocate enough space */
315 loc = (Location *) malloc(num_locs *sizeof(Location));
317 syslog(LOG_CRIT, "uloc_flush alloc");
321 /* copy entries which don't match */
322 while (i < num_locs) {
323 if (locations[i].addr.sin_addr.s_addr != addr->s_addr)
324 loc[new_num++] = locations[i];
326 free_loc(&locations[i]);
348 uloc_flush_client(sin)
349 struct sockaddr_in *sin;
352 int i = 0, new_num = 0;
355 return; /* none to flush */
357 /* slightly inefficient, assume the worst, and allocate enough space */
358 loc = (Location *) malloc(num_locs *sizeof(Location));
360 syslog(LOG_CRIT, "uloc_flush_clt alloc");
364 /* copy entries which don't match */
365 while (i < num_locs) {
366 if ((locations[i].addr.sin_addr.s_addr != sin->sin_addr.s_addr)
367 || (locations[i].addr.sin_port != sin->sin_port)) {
368 loc[new_num++] = locations[i];
370 free_loc(&locations[i]);
392 for (i = 0; i < num_locs; i++) {
393 syslog(LOG_DEBUG, "%s/%d", locations[i].user->string,
394 (int) locations[i].exposure);
403 * Send the locations for host for a brain dump
408 uloc_send_locations()
412 char *lyst[NUM_FIELDS];
413 char *exposure_level;
416 for (i = 0, loc = locations; i < num_locs; i++, loc++) {
417 lyst[0] = (char *) loc->machine->string;
418 lyst[1] = (char *) loc->time;
419 lyst[2] = (char *) loc->tty->string;
421 switch (loc->exposure) {
423 exposure_level = EXPOSE_OPSTAFF;
426 exposure_level = EXPOSE_REALMVIS;
429 exposure_level = EXPOSE_REALMANN;
432 exposure_level = EXPOSE_NETVIS;
435 exposure_level = EXPOSE_NETANN;
438 syslog(LOG_ERR,"broken location state %s/%d",
439 loc->user->string, (int) loc->exposure);
442 retval = bdump_send_list_tcp(ACKED, &loc->addr, LOGIN_CLASS,
443 loc->user->string, exposure_level, myname,
444 "", lyst, NUM_FIELDS);
445 if (retval != ZERR_NONE) {
446 syslog(LOG_ERR, "uloc_send_locs: %s", error_message(retval));
454 * Add the user to the internal table of locations.
458 ulogin_add_user(notice, exposure, who)
460 Exposure_type exposure;
461 struct sockaddr_in *who;
463 Location *loc, *oldlocs, newloc;
466 loc = ulogin_find(notice->z_class_inst, &who->sin_addr, notice->z_port);
468 /* Update the time, tty, and exposure on the existing location. */
469 loc->exposure = exposure;
470 if (ulogin_parse(notice, &newloc) == 0) {
471 free_string(loc->tty);
472 loc->tty = dup_string(newloc.tty);
474 loc->time = strsave(newloc.time);
482 locations = (Location *) malloc((num_locs + 1) * sizeof(Location));
484 syslog(LOG_ERR, "zloc mem alloc");
489 if (num_locs == 0) { /* first one */
490 if (ulogin_setup(notice, locations, exposure, who)) {
499 /* not the first one, insert him */
501 if (ulogin_setup(notice, &newloc, exposure, who)) {
510 while ((i < num_locs-1) &&
511 (comp_string(oldlocs[i].user,newloc.user) < 0)) {
512 locations[i] = oldlocs[i];
516 /* add him in here */
517 locations[i++] = newloc;
520 while (i < num_locs) {
521 locations[i] = oldlocs[i - 1];
532 * Set up the location locs with the information in the notice.
536 ulogin_setup(notice, locs, exposure, who)
539 Exposure_type exposure;
540 struct sockaddr_in *who;
542 if (ulogin_parse(notice, locs))
545 locs->exposure = exposure;
546 locs->addr.sin_family = AF_INET;
547 locs->addr.sin_addr.s_addr = who->sin_addr.s_addr;
548 locs->addr.sin_port = notice->z_port;
553 * Parse the location information in the notice, and fill it into *locs
557 ulogin_parse(notice, locs)
564 if (!notice->z_message_len) {
565 syslog(LOG_ERR, "short ulogin");
569 base = notice->z_message;
570 for (cp = base; cp < base + notice->z_message_len; cp++) {
575 syslog(LOG_ERR, "zloc bad format from user %s (only %d fields)",
576 notice->z_sender, nulls);
580 locs->user = make_string(notice->z_class_inst,0);
583 locs->machine = make_string(cp,0);
585 cp += (strlen(cp) + 1);
586 locs->time = strsave(cp);
588 /* This field might not be null-terminated */
589 cp += (strlen(cp) + 1);
590 locs->tty = make_string(cp, 0);
597 ulogin_find(user, host, port)
599 struct in_addr *host;
605 /* Find the first location for this user. */
606 loc = ulogin_find_user(user);
610 /* Look for a location which matches the host and port. */
611 str = make_string(user, 0);
612 while (loc < locations + num_locs && loc->user == str) {
613 if (loc->addr.sin_addr.s_addr == host->s_addr
614 && loc->addr.sin_port == port) {
626 * Return a pointer to the first instance of this user@realm in the
631 ulogin_find_user(user)
641 str = make_string(user, 0);
643 /* i is the current midpoint location, rlo is the lowest we will
644 * still check, and rhi is the highest we will still check. */
650 while ((compar = comp_string(locations[i].user, str)) != 0) {
662 /* Back up to the first location for this user. */
663 while (i > 0 && locations[i - 1].user == str)
666 return &locations[i];
673 if (l1->machine != l2->machine)
675 if (l1->tty != l2->tty)
681 * remove the user specified in notice from the internal table
685 ulogin_remove_user(notice, who, err_return)
687 struct sockaddr_in *who;
690 Location *new_locs, *loc;
695 loc = ulogin_find(notice->z_class_inst, &who->sin_addr, notice->z_port);
701 quiet = loc->exposure;
703 if (--num_locs == 0) { /* last one */
710 new_locs = (Location *) malloc(num_locs * sizeof(Location));
712 syslog(LOG_CRIT, "ul_rem alloc");
716 /* copy old entries */
717 while (i < num_locs && &locations[i] < loc) {
718 new_locs[i] = locations[i];
722 /* free up this one */
723 free_loc(&locations[i]);
724 i++; /* skip over this one */
727 while (i <= num_locs) {
728 new_locs[i - 1] = locations[i];
734 locations = new_locs;
741 * remove all locs of the user specified in notice from the internal table
745 ulogin_flush_user(notice)
748 Location *loc, *loc2;
749 int i, j, num_match, num_left;
751 i = num_match = num_left = 0;
753 if (!(loc2 = ulogin_find_user(notice->z_class_inst)))
756 /* compute # locations left in the list, after loc2 (inclusive) */
757 num_left = num_locs - (loc2 - locations);
760 !strcasecmp(loc2[num_match].user->string,
761 notice->z_class_inst)) {
762 /* as long as we keep matching, march up the list */
766 if (num_locs == num_match) { /* no other locations left */
767 for (j = 0; j < num_match; j++)
768 free_loc(&locations[j]); /* free storage */
775 loc = (Location *) malloc((num_locs - num_match) * sizeof(Location));
777 syslog(LOG_CRIT, "ul_rem alloc");
781 /* copy old entries */
782 while (i < num_locs && &locations[i] < loc2) {
783 loc[i] = locations[i];
787 for(j = 0; j < num_match; j++) {
788 free_loc(&locations[i]);
793 while (i < num_locs) {
794 loc[i - num_match] = locations[i];
801 num_locs -= num_match;
807 for (i = 0; i < num_locs; i++) {
808 syslog(LOG_DEBUG, "%s/%d", locations[i].user->string,
809 (int) locations[i].exposure);
817 ulogin_locate(notice, who, auth)
819 struct sockaddr_in *who;
825 struct sockaddr_in send_to_who;
829 answer = ulogin_marshal_locs(notice, &found, auth);
831 /* XXX do more parsing, like in dispatch() */
834 cp = strrchr(notice->z_class_inst, '@');
835 if (cp && (realm = realm_get_realm_by_name(cp + 1))) {
840 inlhsat = strrchr(notice->z_class_inst, '@');
845 ulogin_locate_forward(notice, who, realm);
851 send_to_who.sin_port = notice->z_port;
853 retval = ZSetDestAddr(&send_to_who);
854 if (retval != ZERR_NONE) {
855 syslog(LOG_WARNING, "ulogin_locate set addr: %s",
856 error_message(retval));
862 notice->z_kind = ACKED;
864 /* use xmit_frag() to send each piece of the notice */
866 retval = ZSrvSendRawList(notice, answer, found * NUM_FIELDS, xmit_frag);
867 if (retval != ZERR_NONE)
868 syslog(LOG_WARNING, "ulog_locate xmit: %s", error_message(retval));
874 * Locate the user and collect the locations into an array. Return the # of
875 * locations in *found.
879 ulogin_marshal_locs(notice, found, auth)
884 Location **matches = (Location **) 0;
889 int local = (auth && realm_sender_in_realm(my_galaxy, notice->z_sender));
891 *found = 0; /* # of matches */
893 loc = ulogin_find_user(notice->z_class_inst);
899 inst = make_string(notice->z_class_inst,0);
900 while (i < num_locs && (inst == locations[i].user)) {
901 /* these locations match */
902 switch (locations[i].exposure) {
918 matches = (Location **) malloc(sizeof(Location *));
920 syslog(LOG_ERR, "ulog_loc: no mem");
921 break; /* from the while */
923 matches[0] = &locations[i];
926 matches = (Location **) realloc(matches,
927 ++(*found) * sizeof(Location *));
929 syslog(LOG_ERR, "ulog_loc: realloc no mem");
931 break; /* from the while */
933 matches[*found - 1] = &locations[i];
939 /* OK, now we have a list of user@host's to return to the client
944 for (i = 0; i < *found ; i++)
945 zdbug((LOG_DEBUG,"found %s",
946 matches[i]->user->string));
950 /* coalesce the location information into a list of char *'s */
951 answer = (char **) malloc((*found) * NUM_FIELDS * sizeof(char *));
953 syslog(LOG_ERR, "zloc no mem(answer)");
956 for (i = 0; i < *found ; i++) {
957 answer[i * NUM_FIELDS] = matches[i]->machine->string;
958 answer[i * NUM_FIELDS + 1] = matches[i]->time;
959 answer[i * NUM_FIELDS + 2] = matches[i]->tty->string;
973 for (i = 0; i < num_locs; i++) {
975 dump_quote(locations[i].user->string, fp);
977 dump_quote(locations[i].machine->string, fp);
979 dump_quote(locations[i].time, fp);
981 dump_quote(locations[i].tty->string, fp);
983 switch (locations[i].exposure) {
985 fputs("OPSTAFF", fp);
988 fputs("RLM_VIS", fp);
991 fputs("RLM_ANN", fp);
994 fputs("NET_VIS", fp);
997 fputs("NET_ANN", fp);
1000 fprintf(fp, "? %d ?", locations[i].exposure);
1003 fprintf(fp, " %s/%d\n", inet_ntoa(locations[i].addr.sin_addr),
1004 ntohs(locations[i].addr.sin_port));
1012 free_string(loc->user);
1013 free_string(loc->machine);
1014 free_string(loc->tty);
1020 ulogin_locate_forward(notice, who, realm)
1022 struct sockaddr_in *who;
1028 lnotice.z_opcode = REALM_REQ_LOCATE;
1030 realm_handoff(&lnotice, 1, who, realm, 0);
1034 ulogin_realm_locate(notice, who, realm)
1036 struct sockaddr_in *who;
1048 zdbug((LOG_DEBUG, "ulogin_realm_locate"));
1051 answer = ulogin_marshal_locs(notice, &found, 0/*AUTH*/);
1054 lnotice.z_opcode = REALM_ANS_LOCATE;
1056 if ((retval = ZFormatRawNoticeList(&lnotice, answer, found * NUM_FIELDS, &pack, &packlen)) != ZERR_NONE) {
1057 syslog(LOG_WARNING, "ulog_rlm_loc format: %s",
1058 error_message(retval));
1067 if ((retval = ZParseNotice(pack, packlen, &lnotice)) != ZERR_NONE) {
1068 syslog(LOG_WARNING, "subscr_rlm_sendit parse: %s",
1069 error_message(retval));
1074 realm_handoff(&lnotice, 1, who, realm, 0);
1081 ulogin_relay_locate(notice, who)
1083 struct sockaddr_in *who;
1087 struct sockaddr_in newwho;
1091 newwho.sin_addr.s_addr = notice->z_sender_addr.s_addr;
1092 newwho.sin_port = notice->z_port;
1093 newwho.sin_family = AF_INET;
1095 if ((retval = ZSetDestAddr(&newwho)) != ZERR_NONE) {
1096 syslog(LOG_WARNING, "uloc_relay_loc set addr: %s",
1097 error_message(retval));
1102 lnotice.z_opcode = LOCATE_LOCATE;
1103 lnotice.z_kind = ACKED;
1105 if ((retval = ZFormatRawNotice(&lnotice, &pack, &packlen)) != ZERR_NONE) {
1106 syslog(LOG_WARNING, "ulog_relay_loc format: %s",
1107 error_message(retval));
1111 if ((retval = ZSendPacket(pack, packlen, 0)) != ZERR_NONE) {
1112 syslog(LOG_WARNING, "ulog_relay_loc xmit: %s",
1113 error_message(retval));