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
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[] =
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);
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);
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);
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 cp = strchr(notice->z_class_inst, '@');
291 if (cp && (realm = realm_get_realm_by_name(cp + 1)))
292 ulogin_locate_forward(notice, who, realm);
294 ulogin_locate(notice, who, auth);
297 syslog(LOG_ERR, "unknown uloc opcode %s", notice->z_opcode);
298 if (server == me_server)
305 * Flush all locations at the address.
310 struct in_addr *addr;
313 int i = 0, new_num = 0;
316 return; /* none to flush */
318 /* slightly inefficient, assume the worst, and allocate enough space */
319 loc = (Location *) malloc(num_locs *sizeof(Location));
321 syslog(LOG_CRIT, "uloc_flush alloc");
325 /* copy entries which don't match */
326 while (i < num_locs) {
327 if (locations[i].addr.sin_addr.s_addr != addr->s_addr)
328 loc[new_num++] = locations[i];
330 free_loc(&locations[i]);
352 uloc_flush_client(sin)
353 struct sockaddr_in *sin;
356 int i = 0, new_num = 0;
359 return; /* none to flush */
361 /* slightly inefficient, assume the worst, and allocate enough space */
362 loc = (Location *) malloc(num_locs *sizeof(Location));
364 syslog(LOG_CRIT, "uloc_flush_clt alloc");
368 /* copy entries which don't match */
369 while (i < num_locs) {
370 if ((locations[i].addr.sin_addr.s_addr != sin->sin_addr.s_addr)
371 || (locations[i].addr.sin_port != sin->sin_port)) {
372 loc[new_num++] = locations[i];
374 free_loc(&locations[i]);
396 for (i = 0; i < num_locs; i++) {
397 syslog(LOG_DEBUG, "%s/%d", locations[i].user->string,
398 (int) locations[i].exposure);
407 * Send the locations for host for a brain dump
412 uloc_send_locations()
416 char *lyst[NUM_FIELDS];
417 char *exposure_level;
420 for (i = 0, loc = locations; i < num_locs; i++, loc++) {
421 lyst[0] = (char *) loc->machine->string;
422 lyst[1] = (char *) loc->time;
423 lyst[2] = (char *) loc->tty->string;
425 switch (loc->exposure) {
427 exposure_level = EXPOSE_OPSTAFF;
430 exposure_level = EXPOSE_REALMVIS;
433 exposure_level = EXPOSE_REALMANN;
436 exposure_level = EXPOSE_NETVIS;
439 exposure_level = EXPOSE_NETANN;
442 syslog(LOG_ERR,"broken location state %s/%d",
443 loc->user->string, (int) loc->exposure);
446 retval = bdump_send_list_tcp(ACKED, &loc->addr, LOGIN_CLASS,
447 loc->user->string, exposure_level, myname,
448 "", lyst, NUM_FIELDS);
449 if (retval != ZERR_NONE) {
450 syslog(LOG_ERR, "uloc_send_locs: %s", error_message(retval));
458 * Add the user to the internal table of locations.
462 ulogin_add_user(notice, exposure, who)
464 Exposure_type exposure;
465 struct sockaddr_in *who;
467 Location *loc, *oldlocs, newloc;
470 loc = ulogin_find(notice->z_class_inst, &who->sin_addr, notice->z_port);
472 /* Update the time, tty, and exposure on the existing location. */
473 loc->exposure = exposure;
474 if (ulogin_parse(notice, &newloc) == 0) {
475 free_string(loc->tty);
476 loc->tty = dup_string(newloc.tty);
478 loc->time = strsave(newloc.time);
486 locations = (Location *) malloc((num_locs + 1) * sizeof(Location));
488 syslog(LOG_ERR, "zloc mem alloc");
493 if (num_locs == 0) { /* first one */
494 if (ulogin_setup(notice, locations, exposure, who)) {
503 /* not the first one, insert him */
505 if (ulogin_setup(notice, &newloc, exposure, who)) {
514 while ((i < num_locs-1) &&
515 (comp_string(oldlocs[i].user,newloc.user) < 0)) {
516 locations[i] = oldlocs[i];
520 /* add him in here */
521 locations[i++] = newloc;
524 while (i < num_locs) {
525 locations[i] = oldlocs[i - 1];
536 * Set up the location locs with the information in the notice.
540 ulogin_setup(notice, locs, exposure, who)
543 Exposure_type exposure;
544 struct sockaddr_in *who;
546 if (ulogin_parse(notice, locs))
549 locs->exposure = exposure;
550 locs->addr.sin_family = AF_INET;
551 locs->addr.sin_addr.s_addr = who->sin_addr.s_addr;
552 locs->addr.sin_port = notice->z_port;
557 * Parse the location information in the notice, and fill it into *locs
561 ulogin_parse(notice, locs)
568 if (!notice->z_message_len) {
569 syslog(LOG_ERR, "short ulogin");
573 base = notice->z_message;
574 for (cp = base; cp < base + notice->z_message_len; cp++) {
579 syslog(LOG_ERR, "zloc bad format from user %s (only %d fields)",
580 notice->z_sender, nulls);
584 locs->user = make_string(notice->z_class_inst,0);
587 locs->machine = make_string(cp,0);
589 cp += (strlen(cp) + 1);
590 locs->time = strsave(cp);
592 /* This field might not be null-terminated */
593 cp += (strlen(cp) + 1);
594 locs->tty = make_string(cp, 0);
601 ulogin_find(user, host, port)
603 struct in_addr *host;
609 /* Find the first location for this user. */
610 loc = ulogin_find_user(user);
614 /* Look for a location which matches the host and port. */
615 str = make_string(user, 0);
616 while (loc < locations + num_locs && loc->user == str) {
617 if (loc->addr.sin_addr.s_addr == host->s_addr
618 && loc->addr.sin_port == port) {
630 * Return a pointer to the first instance of this user@realm in the
635 ulogin_find_user(user)
645 str = make_string(user, 0);
647 /* i is the current midpoint location, rlo is the lowest we will
648 * still check, and rhi is the highest we will still check. */
654 while ((compar = comp_string(locations[i].user, str)) != 0) {
666 /* Back up to the first location for this user. */
667 while (i > 0 && locations[i - 1].user == str)
670 return &locations[i];
677 if (l1->machine != l2->machine)
679 if (l1->tty != l2->tty)
685 * remove the user specified in notice from the internal table
689 ulogin_remove_user(notice, who, err_return)
691 struct sockaddr_in *who;
694 Location *new_locs, *loc;
699 loc = ulogin_find(notice->z_class_inst, &who->sin_addr, notice->z_port);
705 quiet = loc->exposure;
707 if (--num_locs == 0) { /* last one */
714 new_locs = (Location *) malloc(num_locs * sizeof(Location));
716 syslog(LOG_CRIT, "ul_rem alloc");
720 /* copy old entries */
721 while (i < num_locs && &locations[i] < loc) {
722 new_locs[i] = locations[i];
726 /* free up this one */
727 free_loc(&locations[i]);
728 i++; /* skip over this one */
731 while (i <= num_locs) {
732 new_locs[i - 1] = locations[i];
738 locations = new_locs;
745 * remove all locs of the user specified in notice from the internal table
749 ulogin_flush_user(notice)
752 Location *loc, *loc2;
753 int i, j, num_match, num_left;
755 i = num_match = num_left = 0;
757 if (!(loc2 = ulogin_find_user(notice->z_class_inst)))
760 /* compute # locations left in the list, after loc2 (inclusive) */
761 num_left = num_locs - (loc2 - locations);
764 !strcasecmp(loc2[num_match].user->string,
765 notice->z_class_inst)) {
766 /* as long as we keep matching, march up the list */
770 if (num_locs == num_match) { /* no other locations left */
771 for (j = 0; j < num_match; j++)
772 free_loc(&locations[j]); /* free storage */
779 loc = (Location *) malloc((num_locs - num_match) * sizeof(Location));
781 syslog(LOG_CRIT, "ul_rem alloc");
785 /* copy old entries */
786 while (i < num_locs && &locations[i] < loc2) {
787 loc[i] = locations[i];
791 for(j = 0; j < num_match; j++) {
792 free_loc(&locations[i]);
797 while (i < num_locs) {
798 loc[i - num_match] = locations[i];
805 num_locs -= num_match;
811 for (i = 0; i < num_locs; i++) {
812 syslog(LOG_DEBUG, "%s/%d", locations[i].user->string,
813 (int) locations[i].exposure);
821 ulogin_locate(notice, who, auth)
823 struct sockaddr_in *who;
829 struct sockaddr_in send_to_who;
831 answer = ulogin_marshal_locs(notice, &found, auth);
834 send_to_who.sin_port = notice->z_port;
836 retval = ZSetDestAddr(&send_to_who);
837 if (retval != ZERR_NONE) {
838 syslog(LOG_WARNING, "ulogin_locate set addr: %s",
839 error_message(retval));
845 notice->z_kind = ACKED;
847 /* use xmit_frag() to send each piece of the notice */
849 retval = ZSrvSendRawList(notice, answer, found * NUM_FIELDS, xmit_frag);
850 if (retval != ZERR_NONE)
851 syslog(LOG_WARNING, "ulog_locate xmit: %s", error_message(retval));
857 * Locate the user and collect the locations into an array. Return the # of
858 * locations in *found.
862 ulogin_marshal_locs(notice, found, auth)
867 Location **matches = (Location **) 0;
872 int local = (auth && realm_sender_in_realm(ZGetRealm(), notice->z_sender));
874 *found = 0; /* # of matches */
876 loc = ulogin_find_user(notice->z_class_inst);
882 inst = make_string(notice->z_class_inst,0);
883 while (i < num_locs && (inst == locations[i].user)) {
884 /* these locations match */
885 switch (locations[i].exposure) {
901 matches = (Location **) malloc(sizeof(Location *));
903 syslog(LOG_ERR, "ulog_loc: no mem");
904 break; /* from the while */
906 matches[0] = &locations[i];
909 matches = (Location **) realloc(matches,
910 ++(*found) * sizeof(Location *));
912 syslog(LOG_ERR, "ulog_loc: realloc no mem");
914 break; /* from the while */
916 matches[*found - 1] = &locations[i];
922 /* OK, now we have a list of user@host's to return to the client
928 for (i = 0; i < *found ; i++)
929 zdbug((LOG_DEBUG,"found %s",
930 matches[i]->user->string));
934 /* coalesce the location information into a list of char *'s */
935 answer = (char **) malloc((*found) * NUM_FIELDS * sizeof(char *));
937 syslog(LOG_ERR, "zloc no mem(answer)");
940 for (i = 0; i < *found ; i++) {
941 answer[i * NUM_FIELDS] = matches[i]->machine->string;
942 answer[i * NUM_FIELDS + 1] = matches[i]->time;
943 answer[i * NUM_FIELDS + 2] = matches[i]->tty->string;
957 for (i = 0; i < num_locs; i++) {
959 dump_quote(locations[i].user->string, fp);
961 dump_quote(locations[i].machine->string, fp);
963 dump_quote(locations[i].time, fp);
965 dump_quote(locations[i].tty->string, fp);
967 switch (locations[i].exposure) {
969 fputs("OPSTAFF", fp);
972 fputs("RLM_VIS", fp);
975 fputs("RLM_ANN", fp);
978 fputs("NET_VIS", fp);
981 fputs("NET_ANN", fp);
984 fprintf(fp, "? %d ?", locations[i].exposure);
987 fprintf(fp, " %s/%d\n", inet_ntoa(locations[i].addr.sin_addr),
988 ntohs(locations[i].addr.sin_port));
996 free_string(loc->user);
997 free_string(loc->machine);
998 free_string(loc->tty);
1004 ulogin_locate_forward(notice, who, realm)
1006 struct sockaddr_in *who;
1012 lnotice.z_opcode = REALM_REQ_LOCATE;
1014 realm_handoff(&lnotice, 1, who, realm, 0);
1018 ulogin_realm_locate(notice, who, realm)
1020 struct sockaddr_in *who;
1032 zdbug((LOG_DEBUG, "ulogin_realm_locate"));
1035 answer = ulogin_marshal_locs(notice, &found, 0/*AUTH*/);
1038 lnotice.z_opcode = REALM_ANS_LOCATE;
1040 if ((retval = ZFormatRawNoticeList(&lnotice, answer, found * NUM_FIELDS, &pack, &packlen)) != ZERR_NONE) {
1041 syslog(LOG_WARNING, "ulog_rlm_loc format: %s",
1042 error_message(retval));
1051 if ((retval = ZParseNotice(pack, packlen, &lnotice)) != ZERR_NONE) {
1052 syslog(LOG_WARNING, "subscr_rlm_sendit parse: %s",
1053 error_message(retval));
1058 realm_handoff(&lnotice, 1, who, realm, 0);
1065 ulogin_relay_locate(notice, who)
1067 struct sockaddr_in *who;
1071 struct sockaddr_in newwho;
1075 newwho.sin_addr.s_addr = notice->z_sender_addr.s_addr;
1076 newwho.sin_port = notice->z_port;
1077 newwho.sin_family = AF_INET;
1079 if ((retval = ZSetDestAddr(&newwho)) != ZERR_NONE) {
1080 syslog(LOG_WARNING, "uloc_relay_loc set addr: %s",
1081 error_message(retval));
1086 lnotice.z_opcode = LOCATE_LOCATE;
1087 lnotice.z_kind = ACKED;
1089 if ((retval = ZFormatRawNotice(&lnotice, &pack, &packlen)) != ZERR_NONE) {
1090 syslog(LOG_WARNING, "ulog_relay_loc format: %s",
1091 error_message(retval));
1095 if ((retval = ZSendPacket(pack, packlen, 0)) != ZERR_NONE) {
1096 syslog(LOG_WARNING, "ulog_relay_loc xmit: %s",
1097 error_message(retval));