From a2c13d5a06ec1bc136b848d304117cd16099a3cd Mon Sep 17 00:00:00 2001 From: Kenneth G Raeburn Date: Thu, 21 Mar 1991 07:35:31 +0000 Subject: Remove name `_exposure_type'. `ZLocation_t' is now a class with ZString members and equality comparison defined. Compatibility code deleted. Location array is now array of pointers to ZLocation_t objects. In dumping location database, use temporary strings to optimize. --- server/uloc.c | 671 +++++++++++++++++++++++----------------------------------- 1 file changed, 260 insertions(+), 411 deletions(-) (limited to 'server/uloc.c') diff --git a/server/uloc.c b/server/uloc.c index 69bc508..f8a37c3 100644 --- a/server/uloc.c +++ b/server/uloc.c @@ -14,8 +14,9 @@ #include #ifndef lint -static char rcsid_uloc_c[] = "$Id$"; -#endif lint +static char rcsid_uloc_c[] = + "$Id$"; +#endif #include "zserver.h" @@ -61,67 +62,66 @@ static char rcsid_uloc_c[] = "$Id$"; /* else you will lose. See ulogin_locate() and uloc_send_locations() */ #define NUM_FIELDS 3 - -typedef enum _exposure_type { +enum exposure_type { NONE, OPSTAFF_VIS, REALM_VIS, REALM_ANN, NET_VIS, NET_ANN -} exposure_type; +}; -typedef struct _ZLocation_t { - char *zlt_user; - char *zlt_machine; - char *zlt_time; /* in ctime format */ - char *zlt_tty; - exposure_type zlt_exposure; +struct ZLocation_t { + ZString zlt_user; + ZString zlt_machine; + ZString zlt_time; /* in ctime format */ + ZString zlt_tty; struct in_addr zlt_addr; /* IP addr of this loc */ unsigned short zlt_port; /* port of registering client-- - for removing old entries */ -} ZLocation_t; + for removing old entries */ +#if defined(__GNUC__) || defined(__GNUG__) + exposure_type zlt_exposure : 16; +#else + exposure_type zlt_exposure; +#endif + +#if !defined(__GNUG__) || defined(FIXED_GXX) + void *operator new (unsigned int sz) { return zalloc (sz); } + void operator delete (void *ptr) { zfree (ptr, sizeof (ZLocation_t)); } +#endif +}; + +inline int operator == (const ZLocation_t &l1, const ZLocation_t &l2) { + return (!strcasecmp (l1.zlt_machine.value(), l2.zlt_machine.value()) + && l1.zlt_tty == l2.zlt_tty); +} +inline int operator != (const ZLocation_t &l1, const ZLocation_t &l2) { + return !(l1 == l2); +} static ZLocation_t* const NULLZLT = 0; static const int NOLOC = 1; static const int QUIET = -1; static const int UNAUTH = -2; -#ifdef OLD_COMPAT -#define OLD_ZEPHYR_VERSION "ZEPH0.0" -#define LOGIN_QUIET_LOGIN "QUIET_LOGIN" -extern int old_compat_count_ulocate; /* counter of old use */ -extern int old_compat_count_uloc; /* counter of old use */ -#endif /* OLD_COMPAT */ -#ifdef NEW_COMPAT -#define NEW_OLD_ZEPHYR_VERSION "ZEPH0.1" -extern int new_compat_count_uloc; /* counter of old use */ -#endif NEW_COMPAT -#if defined(OLD_COMPAT) || defined(NEW_COMPAT) -static void old_compat_ulogin_locate(ZNotice_t *notice, - struct sockaddr_in *who); -#endif /* OLD_COMPAT || NEW_COMPAT */ - static void ulogin_locate(ZNotice_t *, struct sockaddr_in *who, int auth), ulogin_add_user(ZNotice_t *notice, exposure_type exposure, struct sockaddr_in *who), ulogin_flush_user(ZNotice_t *notice); static ZLocation_t *ulogin_find(ZNotice_t *notice, int strict); -static int ulogin_setup(ZNotice_t *notice, ZLocation_t *locs, +static int ulogin_setup(ZNotice_t *notice, ZLocation_t **locs, exposure_type exposure, struct sockaddr_in *who), - ulogin_parse(ZNotice_t *notice, ZLocation_t *locs), - ul_equiv(ZLocation_t *l1, ZLocation_t *l2), + ulogin_parse(ZNotice_t *notice, ZLocation_t **locs), ulogin_expose_user(ZNotice_t *notice, exposure_type exposure); static exposure_type ulogin_remove_user(ZNotice_t *notice, int auth, struct sockaddr_in *who, int *err_return); static void login_sendit(ZNotice_t *notice, int auth, struct sockaddr_in *who), - sense_logout(ZNotice_t *notice, struct sockaddr_in *who), - free_loc(ZLocation_t *loc); + sense_logout(ZNotice_t *notice, struct sockaddr_in *who); static char **ulogin_marshal_locs(ZNotice_t *notice, int *found, int auth); -static ZLocation_t *locations = NULLZLT; /* ptr to first in array */ -static int num_locs = 0; /* number in array */ +static ZLocation_t **locations = 0; /* ptr to first in array */ +static int num_locs = 0; /* number in array */ /* * Dispatch a LOGIN notice. @@ -136,7 +136,10 @@ ulogin_dispatch(ZNotice_t *notice, int auth, struct sockaddr_in *who, ZHostList_t *host; #if 1 - zdbug((LOG_DEBUG,"ulogin_dispatch")); + zdbug((LOG_DEBUG, + "ulogin_dispatch: opc=%s from=%s/%d auth=%d who=%s/%d", + notice->z_opcode, notice->z_sender, ntohs (notice->z_port), + auth, inet_ntoa (who->sin_addr), ntohs (who->sin_port))); #endif host = hostm_find_host(&who->sin_addr); @@ -207,23 +210,6 @@ ulogin_dispatch(ZNotice_t *notice, int auth, struct sockaddr_in *who, if (!bdumping /* XXX: inter-server and tcp */) return(ZERR_NONE); } -#ifdef OLD_COMPAT - if (!strcmp(notice->z_opcode, LOGIN_USER_LOGIN)) { - syslog(LOG_INFO, "old login, %s", inet_ntoa(who->sin_addr)); - old_compat_count_uloc++; - /* map LOGIN's to realm-announced */ - ulogin_add_user(notice, REALM_ANN, who); - if (server == me_server) /* announce to the realm */ - sendit(notice, auth, who); - } else if (!strcmp(notice->z_opcode, LOGIN_QUIET_LOGIN)) { - syslog(LOG_INFO, "old hide, %s", inet_ntoa(who->sin_addr)); - old_compat_count_uloc++; - /* map LOGIN's to realm-announced */ - ulogin_add_user(notice, OPSTAFF_VIS, who); - if (server == me_server) /* announce to the realm */ - ack(notice, who); - } else -#endif /* OLD_COMPAT */ if (!strcmp(notice->z_opcode, LOGIN_USER_FLUSH)) { #if 0 zdbug((LOG_DEBUG, "user flush")); @@ -356,7 +342,7 @@ sense_logout(ZNotice_t *notice, struct sockaddr_in *who) sense_notice.z_class_inst = "URGENT"; sense_notice.z_opcode = ""; sense_notice.z_sender = "Zephyr Server"; - sense_notice.z_recipient = loc->zlt_user; + sense_notice.z_recipient = (char *) loc->zlt_user.value (); sense_notice.z_default_format = "Urgent Message from $sender at $time:\n\n$1"; (void) sprintf(message, "Someone at host %s tried an unauthorized \nchange to your login information", @@ -388,17 +374,6 @@ ulocate_dispatch(ZNotice_t *notice, int auth, struct sockaddr_in *who, ZServerDe zdbug((LOG_DEBUG,"ulocate_disp")); #endif -#ifdef OLD_COMPAT - if (!strcmp(notice->z_version, OLD_ZEPHYR_VERSION) && - !strcmp(notice->z_opcode, LOCATE_LOCATE)) { - /* we support locates on the old version */ - syslog(LOG_INFO, "old locate, %s", inet_ntoa(who->sin_addr)); - old_compat_count_ulocate++; - ulogin_locate(notice, who, auth); - /* does xmit and ack itself, so return */ - return(ZERR_NONE); - } -#endif /* OLD_COMPAT */ #if 0 /* Now we support unauthentic locate for net-visible. */ if (!auth) { #if 0 @@ -409,41 +384,10 @@ ulocate_dispatch(ZNotice_t *notice, int auth, struct sockaddr_in *who, ZServerDe return(ZERR_NONE); } #endif -#ifdef OLD_COMPAT - if (!strcmp(notice->z_version, OLD_ZEPHYR_VERSION)) { - ZHostList_t *host = hostm_find_host(&who->sin_addr); - if (host && host->zh_locked) /* process later if locked */ - return(ZSRV_REQUEUE); - - old_compat_count_ulocate++; - - if (!strcmp(notice->z_opcode, LOCATE_HIDE)) { - syslog(LOG_INFO, "old hide, %s", - inet_ntoa(who->sin_addr)); - if (ulogin_expose_user(notice, OPSTAFF_VIS)) { - if (server == me_server) - clt_ack(notice, who, NOT_FOUND); - return(ZERR_NONE); - } - } else if (!strcmp(notice->z_opcode, LOCATE_UNHIDE)) { - syslog(LOG_INFO, "old unhide, %s", - inet_ntoa(who->sin_addr)); - if (ulogin_expose_user(notice, REALM_VIS)) { - if (server == me_server) - clt_ack(notice, who, NOT_FOUND); - return(ZERR_NONE); - } - } - } else -#endif /* OLD_COMPAT */ if (!strcmp(notice->z_opcode, LOCATE_LOCATE)) { #if 0 zdbug((LOG_DEBUG,"locate")); #endif -#if defined(NEW_COMPAT) || defined(OLD_COMPAT) - if (strcmp(notice->z_version, NEW_OLD_ZEPHYR_VERSION) && - strcmp(notice->z_version, OLD_ZEPHYR_VERSION)) -#endif /* NEW_COMPAT || OLD_COMPAT */ /* we are talking to a current-rev client; send an acknowledgement-message */ ack(notice, who); @@ -468,48 +412,48 @@ ulocate_dispatch(ZNotice_t *notice, int auth, struct sockaddr_in *who, ZServerDe void uloc_hflush(struct in_addr *addr) { - ZLocation_t *loc; + ZLocation_t **loc; register int i = 0, new_num = 0; int omask; - if (!locations) + if (num_locs == 0) return; /* none to flush */ omask = sigblock(sigmask(SIGFPE)); /* don't do ascii dumps */ /* slightly inefficient, assume the worst, and allocate enough space */ - if (!(loc = (ZLocation_t *) xmalloc(num_locs * sizeof(ZLocation_t)))) { - syslog(LOG_CRIT, "uloc_flush malloc"); + loc = new ZLocation_t* [num_locs]; + if (!loc) { + syslog(LOG_CRIT, "uloc_flush alloc"); abort(); /*NOTREACHED*/ } /* copy entries which don't match */ while (i < num_locs) { - if (locations[i].zlt_addr.s_addr != addr->s_addr) + if (locations[i]->zlt_addr.s_addr != addr->s_addr) loc[new_num++] = locations[i]; else { #if 0 if (zdebug) syslog(LOG_DEBUG, "uloc hflushing %s/%s/%s", - locations[i].zlt_user, - locations[i].zlt_machine, - locations[i].zlt_tty); + locations[i]->zlt_user.value (), + locations[i]->zlt_machine.value(), + locations[i]->zlt_tty.value()); #endif - free_loc(&locations[i]); + delete locations[i]; } i++; } - xfree(locations); + delete locations; if (!new_num) { #if 0 zdbug((LOG_DEBUG,"no more locs")); #endif - xfree(loc); - locations = NULLZLT; - num_locs = new_num; + delete loc; + loc = 0; (void) sigsetmask(omask); return; } @@ -523,10 +467,10 @@ uloc_hflush(struct in_addr *addr) for (i = 0; i < num_locs; i++) syslog(LOG_DEBUG, "%s/%d", - locations[i].zlt_user, - (int) locations[i].zlt_exposure); + locations[i]->zlt_user.value (), + (int) locations[i]->zlt_exposure); } -#endif DEBUG +#endif /* all done */ return; } @@ -534,51 +478,49 @@ uloc_hflush(struct in_addr *addr) void uloc_flush_client(struct sockaddr_in *sin) { - ZLocation_t *loc; + ZLocation_t **loc; register int i = 0, new_num = 0; int omask; - if (!locations) + if (num_locs == 0) return; /* none to flush */ omask = sigblock(sigmask(SIGFPE)); /* don't do ascii dumps */ /* slightly inefficient, assume the worst, and allocate enough space */ - if (!(loc = (ZLocation_t *) xmalloc(num_locs * sizeof(ZLocation_t)))) { - syslog(LOG_CRIT, "uloc_flush_clt malloc"); + loc = new ZLocation_t* [num_locs]; + if (!loc) { + syslog(LOG_CRIT, "uloc_flush_clt alloc"); abort(); /*NOTREACHED*/ } /* copy entries which don't match */ while (i < num_locs) { - if ((locations[i].zlt_addr.s_addr != sin->sin_addr.s_addr) - || (locations[i].zlt_port != sin->sin_port)) + if ((locations[i]->zlt_addr.s_addr != sin->sin_addr.s_addr) + || (locations[i]->zlt_port != sin->sin_port)) loc[new_num++] = locations[i]; else { #if 0 if (zdebug) syslog(LOG_DEBUG, "uloc cflushing %s/%s/%s", - locations[i].zlt_user, - locations[i].zlt_machine, - locations[i].zlt_tty); + locations[i]->zlt_user.value (), + locations[i]->zlt_machine.value(), + locations[i]->zlt_tty.value()); #endif - free_loc(&locations[i]); + delete locations[i]; } i++; } - xfree(locations); + delete locations; if (!new_num) { #if 0 zdbug((LOG_DEBUG,"no more locs")); #endif - xfree(loc); - locations = NULLZLT; - num_locs = new_num; - (void) sigsetmask(omask); - return; + delete loc; + loc = 0; } locations = loc; num_locs = new_num; @@ -590,10 +532,10 @@ uloc_flush_client(struct sockaddr_in *sin) for (i = 0; i < num_locs; i++) syslog(LOG_DEBUG, "%s/%d", - locations[i].zlt_user, - (int) locations[i].zlt_exposure); + locations[i]->zlt_user.value (), + (int) locations[i]->zlt_exposure); } -#endif DEBUG +#endif /* all done */ return; } @@ -613,36 +555,14 @@ uloc_send_locations(ZHostList_t *host, char *vers) char *exposure_level; Code_t retval; - for (i = 0, loc = locations; i < num_locs; i++, loc++) { + for (i = 0; i < num_locs; i++) { + loc = locations[i]; if (loc->zlt_addr.s_addr != haddr->s_addr) continue; - lyst[0] = loc->zlt_machine; - lyst[1] = loc->zlt_time; - lyst[2] = loc->zlt_tty; - - -#ifdef OLD_COMPAT - if (!strcmp(vers, OLD_ZEPHYR_VERSION)) - /* the other server is using the old - protocol version; send old-style - location/login information */ - switch(loc->zlt_exposure) { - case OPSTAFF_VIS: - exposure_level = LOGIN_QUIET_LOGIN; - break; - case REALM_VIS: - case REALM_ANN: - case NET_VIS: - case NET_ANN: - exposure_level = LOGIN_USER_LOGIN; - break; - default: - syslog(LOG_ERR,"broken location state %s/%d", - loc->zlt_user, (int) loc->zlt_exposure); - break; - } - else -#endif /* OLD_COMPAT */ + lyst[0] = (char *) loc->zlt_machine.value(); + lyst[1] = (char *) loc->zlt_time.value(); + lyst[2] = (char *) loc->zlt_tty.value (); + switch (loc->zlt_exposure) { case OPSTAFF_VIS: exposure_level = EXPOSE_OPSTAFF; @@ -661,14 +581,17 @@ uloc_send_locations(ZHostList_t *host, char *vers) break; default: syslog(LOG_ERR,"broken location state %s/%d", - loc->zlt_user, (int) loc->zlt_exposure); + loc->zlt_user.value (), + (int) loc->zlt_exposure); break; } - if ((retval = bdump_send_list_tcp(ACKED, loc->zlt_port, - LOGIN_CLASS, loc->zlt_user, - exposure_level, - myname, "", lyst, - NUM_FIELDS)) != ZERR_NONE) { + retval = bdump_send_list_tcp(ACKED, loc->zlt_port, + LOGIN_CLASS, + (char *) loc->zlt_user.value (), /* XXX */ + exposure_level, + myname, "", lyst, + NUM_FIELDS); + if (retval != ZERR_NONE) { syslog(LOG_ERR, "uloc_send_locs: %s", error_message(retval)); return(retval); @@ -682,9 +605,9 @@ uloc_send_locations(ZHostList_t *host, char *vers) */ static void -ulogin_add_user(ZNotice_t *notice, exposure_type exposure, struct sockaddr_in *who) +ulogin_add_user(ZNotice_t *notice, exposure_type exposure, sockaddr_in *who) { - ZLocation_t *oldlocs, newloc; + ZLocation_t **oldlocs, *newloc; register int i = 0; int omask; @@ -693,7 +616,7 @@ ulogin_add_user(ZNotice_t *notice, exposure_type exposure, struct sockaddr_in *w (int) exposure)); #endif - if ((oldlocs = ulogin_find(notice, 1))) { + if ((newloc = ulogin_find(notice, 1))) { #if 1 zdbug((LOG_DEBUG,"ul_add: already here")); #endif @@ -704,7 +627,8 @@ ulogin_add_user(ZNotice_t *notice, exposure_type exposure, struct sockaddr_in *w oldlocs = locations; omask = sigblock(sigmask(SIGFPE)); /* don't do ascii dumps */ - if (!(locations = (ZLocation_t *) xmalloc((num_locs + 1) * sizeof(ZLocation_t)))) { + locations = new ZLocation_t* [num_locs + 1]; + if (!locations) { syslog(LOG_ERR, "zloc mem alloc"); locations = oldlocs; return; @@ -712,18 +636,12 @@ ulogin_add_user(ZNotice_t *notice, exposure_type exposure, struct sockaddr_in *w if (num_locs == 0) { /* first one */ if (ulogin_setup(notice, locations, exposure, who)) { - xfree(locations); - locations = NULLZLT; - (void) sigsetmask(omask); - return; + delete locations; + locations = 0; } - num_locs = 1; - (void) sigsetmask(omask); -#ifdef DEBUG + else + num_locs = 1; goto dprnt; -#else - return; -#endif DEBUG } /* not the first one, insert him */ @@ -735,34 +653,34 @@ ulogin_add_user(ZNotice_t *notice, exposure_type exposure, struct sockaddr_in *w num_locs++; /* copy old locs */ - while ((i < (num_locs - 1)) && strcmp(oldlocs[i].zlt_user, newloc.zlt_user) < 0) { + while ((i < (num_locs - 1)) && oldlocs[i]->zlt_user < newloc->zlt_user) { locations[i] = oldlocs[i]; i++; } /* add him in here */ locations[i++] = newloc; - + /* copy the rest */ while (i < num_locs) { locations[i] = oldlocs[i - 1]; i++; } if (oldlocs) - xfree(oldlocs); - + delete oldlocs; + + dprnt: (void) sigsetmask(omask); #ifdef DEBUG - dprnt: if (zdebug) { register int i; for (i = 0; i < num_locs; i++) syslog(LOG_DEBUG, "%s/%d", - locations[i].zlt_user, - (int) locations[i].zlt_exposure); + locations[i]->zlt_user.value (), + (int) locations[i]->zlt_exposure); } -#endif DEBUG +#endif return; } @@ -771,40 +689,34 @@ ulogin_add_user(ZNotice_t *notice, exposure_type exposure, struct sockaddr_in *w */ static int -ulogin_setup(ZNotice_t *notice, register ZLocation_t *locs, exposure_type exposure, struct sockaddr_in *who) +ulogin_setup(ZNotice_t *notice, ZLocation_t **locs, exposure_type exposure, sockaddr_in *who) { if (ulogin_parse(notice, locs)) return(1); - if (!locs->zlt_user) { + ZLocation_t *loc = *locs; + if (!loc->zlt_user) { + ret1: syslog(LOG_ERR, "zloc bad format"); - return(1); + return 1; } - locs->zlt_user = strsave (locs->zlt_user); - if (!locs->zlt_machine) { - syslog(LOG_ERR, "zloc bad format"); - xfree(locs->zlt_user); - return(1); + if (!loc->zlt_machine) { + ret2: + loc->zlt_user = 0; + goto ret1; } - locs->zlt_machine = strsave (locs->zlt_machine); - if (!locs->zlt_tty) { - syslog(LOG_ERR, "zloc bad format"); - xfree(locs->zlt_user); - xfree(locs->zlt_machine); - return(1); + if (!loc->zlt_tty) { + ret3: + loc->zlt_machine = 0; + goto ret2; } - locs->zlt_tty = strsave(locs->zlt_tty); - if (!locs->zlt_time) { - syslog(LOG_ERR, "zloc bad format"); - xfree(locs->zlt_user); - xfree(locs->zlt_machine); - xfree(locs->zlt_tty); - return(1); + if (!loc->zlt_time) { + loc->zlt_tty = 0; + goto ret3; } - locs->zlt_time = strsave (locs->zlt_time); - locs->zlt_exposure = exposure; - locs->zlt_addr = who->sin_addr; - locs->zlt_port = notice->z_port; - return(0); + loc->zlt_exposure = exposure; + loc->zlt_addr = who->sin_addr; + loc->zlt_port = notice->z_port; + return 0; } /* @@ -812,23 +724,25 @@ ulogin_setup(ZNotice_t *notice, register ZLocation_t *locs, exposure_type exposu */ static int -ulogin_parse(register ZNotice_t *notice, register ZLocation_t *locs) +ulogin_parse(ZNotice_t *notice, ZLocation_t **locs) { register char *cp, *base; + ZLocation_t *loc = new ZLocation_t; + *locs = 0; if (!notice->z_message_len) { syslog(LOG_ERR, "short ulogin"); return(1); } - locs->zlt_user = notice->z_class_inst; + loc->zlt_user = notice->z_class_inst; cp = base = notice->z_message; #if 0 zdbug((LOG_DEBUG,"user %s",notice->z_class_inst)); #endif - locs->zlt_machine = cp; + loc->zlt_machine = cp; #if 0 zdbug((LOG_DEBUG,"mach %s",cp)); #endif @@ -838,36 +752,28 @@ ulogin_parse(register ZNotice_t *notice, register ZLocation_t *locs) syslog(LOG_ERR, "zloc bad format 1"); return(1); } - locs->zlt_time = cp; + loc->zlt_time = cp; #if 0 zdbug((LOG_DEBUG,"time %s",cp)); #endif cp += (strlen(cp) + 1); -#ifdef OLD_COMPAT - if (cp == base + notice->z_message_len) { - /* no tty--for backwards compat, we allow this */ -#if 0 - zdbug((LOG_DEBUG, "no tty")); -#endif - locs->zlt_tty = ""; - } else -#endif OLD_COMPAT if (cp > base + notice->z_message_len) { syslog(LOG_ERR, "zloc bad format 2"); return(1); } else { - locs->zlt_tty = cp; + loc->zlt_tty = cp; #if 0 zdbug((LOG_DEBUG,"tty %s",cp)); #endif - cp += (strlen(cp) + 1); + cp += loc->zlt_tty.length () + 1; } if (cp > base + notice->z_message_len) { syslog(LOG_ERR, "zloc bad format 3"); return(1); } + *locs = loc; return(0); } @@ -883,11 +789,13 @@ ulogin_find(ZNotice_t *notice, int strict) { register int i, rlo, rhi; int compar; - ZLocation_t tmploc; + ZLocation_t *tmploc = 0; - if (!locations) + if (num_locs == 0) return(NULLZLT); + ZString inst (notice->z_class_inst); + /* i is the current loc we are checking */ /* rlo is the lowest we will still check, rhi is the highest we will still check */ @@ -896,13 +804,20 @@ ulogin_find(ZNotice_t *notice, int strict) rlo = 0; rhi = num_locs - 1; /* first index is 0 */ - while (compar = strcmp(locations[i].zlt_user,notice->z_class_inst)) { - if (compar < 0) + while (locations[i]->zlt_user != inst) { +#if 1 + zdbug ((LOG_DEBUG, "ulogin_find: comparing %s %s %s %d %d", + notice->z_class_inst, + locations[i]->zlt_user.value (), + locations[i]->zlt_tty.value (), + rlo, rhi)); +#endif + if (locations[i]->zlt_user < inst) rlo = i + 1; else rhi = i - 1; if (rhi - rlo < 0) { -#if 0 +#if 1 zdbug((LOG_DEBUG,"ul_find not found")); #endif return(NULLZLT); @@ -910,43 +825,44 @@ ulogin_find(ZNotice_t *notice, int strict) i = (rhi + rlo) >> 1; /* split the diff */ } if (strict && ulogin_parse(notice, &tmploc)) { -#if 0 +#if 1 zdbug((LOG_DEBUG,"ul_find bad fmt")); #endif - return(NULLZLT); + return NULLZLT; } /* back up to the first of this guy */ if (i) { - while (i > 0 && !strcmp(locations[--i].zlt_user, notice->z_class_inst)); - if (i || strcmp(locations[i].zlt_user, notice->z_class_inst)) - i++; + while (i > 0 && locations[--i]->zlt_user == inst) { + ; +#if 1 + zdbug ((LOG_DEBUG, + "ulogin_find: backing up: %s %d %s %s", + inst.value (), i, + locations[i]->zlt_user.value (), + locations[i]->zlt_tty.value ())); +#endif + } + if (i || locations[i]->zlt_user != inst) + i++; } if (strict) - while (i < num_locs && !ul_equiv(&tmploc, &locations[i]) && - !strcmp(locations[i].zlt_user, notice->z_class_inst)) + while (i < num_locs + && *tmploc != *locations[i] + && locations[i]->zlt_user == inst) { i++; + } - if ((i == num_locs) || strcmp(locations[i].zlt_user, notice->z_class_inst)) { -#if 0 + if ((i == num_locs) || locations[i]->zlt_user != inst) { +#if 1 zdbug((LOG_DEBUG,"ul_find final match loss")); #endif - return(NULLZLT); + if (tmploc) + delete tmploc; + return NULLZLT; } - return(&locations[i]); -} - -/* - * are the locations of this user equivalent? 1 = yes, 0 = no - */ - -static int -ul_equiv(register ZLocation_t *l1, register ZLocation_t *l2) -{ - if (strcasecmp(l1->zlt_machine, l2->zlt_machine)) - return(0); - if (strcmp(l1->zlt_tty, l2->zlt_tty)) - return(0); - return(1); + if (tmploc) + delete tmploc; + return locations[i]; } /* @@ -954,9 +870,9 @@ ul_equiv(register ZLocation_t *l1, register ZLocation_t *l2) */ static exposure_type -ulogin_remove_user(ZNotice_t *notice, int auth, struct sockaddr_in *who, int *err_return) +ulogin_remove_user(ZNotice_t *notice, int auth, sockaddr_in *who, int *err_return) { - ZLocation_t *loc, *loc2; + ZLocation_t **loc, *loc2; register int i = 0; exposure_type quiet; int omask; @@ -972,10 +888,9 @@ ulogin_remove_user(ZNotice_t *notice, int auth, struct sockaddr_in *who, int *er /* if unauthentic, the sender MUST be the same IP addr that registered */ - if (!auth && loc2->zlt_addr.s_addr != who->sin_addr.s_addr) { *err_return = UNAUTH; - return(NONE); + return NONE; } quiet = loc2->zlt_exposure; @@ -985,26 +900,27 @@ ulogin_remove_user(ZNotice_t *notice, int auth, struct sockaddr_in *who, int *er #if 0 zdbug((LOG_DEBUG,"last loc")); #endif - xfree(locations); - locations = NULLZLT; + delete locations; + locations = 0; (void) sigsetmask(omask); return(quiet); } - if (!(loc = (ZLocation_t *) xmalloc(num_locs * sizeof(ZLocation_t)))) { - syslog(LOG_CRIT, "ul_rem malloc"); + loc = new ZLocation_t* [num_locs]; + if (!loc) { + syslog(LOG_CRIT, "ul_rem alloc"); abort(); /*NOTREACHED*/ } /* copy old entries */ - while (i < num_locs && &locations[i] < loc2) { + while (i < num_locs && locations[i] != loc2) { loc[i] = locations[i]; i++; } /* free up this one */ - free_loc(&locations[i]); + delete locations[i]; i++; /* skip over this one */ /* copy the rest */ @@ -1013,21 +929,21 @@ ulogin_remove_user(ZNotice_t *notice, int auth, struct sockaddr_in *who, int *er i++; } - xfree(locations); + delete locations; locations = loc; (void) sigsetmask(omask); -#ifdef DEBUG +#if defined(DEBUG) && 0 if (zdebug) { register int i; for (i = 0; i < num_locs; i++) syslog(LOG_DEBUG, "%s/%d", - locations[i].zlt_user, - (int) locations[i].zlt_exposure); + locations[i]->zlt_user.value(), + (int) locations[i]->zlt_exposure); } -#endif DEBUG +#endif /* all done */ return(quiet); } @@ -1039,7 +955,7 @@ ulogin_remove_user(ZNotice_t *notice, int auth, struct sockaddr_in *who, int *er static void ulogin_flush_user(ZNotice_t *notice) { - register ZLocation_t *loc, *loc2; + register ZLocation_t **loc, *loc2; register int i, j, num_match, num_left; int omask; @@ -1053,11 +969,16 @@ ulogin_flush_user(ZNotice_t *notice) } /* compute # locations left in the list, after loc2 (inclusive) */ - num_left = num_locs - (loc2 - locations); + { + int k; + for (k = 0; locations[k] != loc2; k++) + ; + num_left = num_locs - k; + } omask = sigblock(sigmask(SIGFPE)); /* don't let disk db dumps start */ while (num_left && - !strcmp(loc2[num_match].zlt_user, notice->z_class_inst)) { + !strcmp(loc2[num_match].zlt_user.value(), notice->z_class_inst)) { /* as long as we keep matching, march up the list */ num_match++; num_left--; @@ -1067,32 +988,30 @@ ulogin_flush_user(ZNotice_t *notice) zdbug((LOG_DEBUG,"last loc")); #endif for (j = 0; j < num_match; j++) - free_loc(&loc2[j]); /* free storage */ - xfree(locations); - locations = NULLZLT; + delete locations[j]; /* free storage */ + delete locations; + locations = 0; num_locs = 0; (void) sigsetmask(omask); return; } - if (!(loc = (ZLocation_t *) xmalloc((num_locs - num_match) * - sizeof(ZLocation_t)))) { - syslog(LOG_CRIT, "ul_rem malloc"); + loc = new ZLocation_t* [num_locs - num_match]; + if (!loc) { + syslog(LOG_CRIT, "ul_rem alloc"); abort(); /*NOTREACHED*/ } /* copy old entries */ - while (i < num_locs && &locations[i] < loc2) { + while (i < num_locs && locations[i] != loc2) { /* XXX should bcopy */ loc[i] = locations[i]; i++; } - for (j = 0; j < num_match; j++) { - free_loc(&locations[i]); - i++; /* skip over the matches */ - } + for (j = 0; j < num_match; j++) + delete locations[i++]; /* skip over the matches */ /* copy the rest */ while (i < num_locs) { @@ -1101,7 +1020,7 @@ ulogin_flush_user(ZNotice_t *notice) i++; } - xfree(locations); + delete locations; locations = loc; num_locs -= num_match; @@ -1113,10 +1032,10 @@ ulogin_flush_user(ZNotice_t *notice) for (i = 0; i < num_locs; i++) syslog(LOG_DEBUG, "%s/%d", - locations[i].zlt_user, - (int) locations[i].zlt_exposure); + locations[i]->zlt_user.value(), + (int) locations[i]->zlt_exposure); } -#endif DEBUG +#endif /* all done */ return; } @@ -1128,7 +1047,7 @@ ulogin_flush_user(ZNotice_t *notice) static int ulogin_expose_user(ZNotice_t *notice, exposure_type exposure) { - ZLocation_t *loc, loc2; + ZLocation_t *loc, *loc2; int idx, notfound = 1; #if 0 @@ -1145,47 +1064,38 @@ ulogin_expose_user(ZNotice_t *notice, exposure_type exposure) #endif return(1); } - idx = loc - locations; + for (idx = 0; locations[idx] != loc; idx++) + ; while ((idx < num_locs) && - !strcmp(locations[idx].zlt_user, loc2.zlt_user)) { + locations[idx]->zlt_user != loc2->zlt_user) { /* change exposure and owner for each loc on that host */ - if (!strcasecmp(locations[idx].zlt_machine, loc2.zlt_machine)) { + if (!strcasecmp(locations[idx]->zlt_machine.value(), loc2->zlt_machine.value())) { notfound = 0; - locations[idx].zlt_exposure = exposure; - locations[idx].zlt_port = notice->z_port; + locations[idx]->zlt_exposure = exposure; + locations[idx]->zlt_port = notice->z_port; /* change time for the specific loc */ - if (!strcmp(locations[idx].zlt_tty, loc2.zlt_tty)) { - xfree(locations[idx].zlt_time); - locations[idx].zlt_time = - strsave(loc2.zlt_time); + if (locations[idx]->zlt_tty == loc2->zlt_tty) { + locations[idx]->zlt_time = loc2->zlt_time; } } idx++; } + delete loc2; return(notfound); } static void -ulogin_locate(ZNotice_t *notice, struct sockaddr_in *who, int auth) +ulogin_locate(ZNotice_t *notice, sockaddr_in *who, int auth) { char **answer; int found; Code_t retval; struct sockaddr_in send_to_who; -#if defined(NEW_COMPAT) || defined(OLD_COMPAT) - if (!strcmp(notice->z_version, NEW_OLD_ZEPHYR_VERSION) || - !strcmp(notice->z_version, OLD_ZEPHYR_VERSION)) { - /* we are talking to a new old client; use the new-old-style - acknowledgement-message */ - old_compat_ulogin_locate(notice, who, auth); - return; - } -#endif /* NEW_COMPAT || OLD_COMPAT */ answer = ulogin_marshal_locs(notice, &found, auth); send_to_who = *who; @@ -1233,14 +1143,15 @@ ulogin_marshal_locs(ZNotice_t *notice, register int *found, int auth) /* not here anywhere */ return((char **)0); - i = loc - locations; - while ((i < num_locs) && - !strcmp(notice->z_class_inst, locations[i].zlt_user)) { + for (i = 0; locations[i] != loc; i++) + ; + ZString inst (notice->z_class_inst); + while (i < num_locs && inst == locations[i]->zlt_user) { /* these locations match */ #if 0 - zdbug((LOG_DEBUG,"match %s", locations[i].zlt_user)); + zdbug((LOG_DEBUG,"match %s", locations[i]->zlt_user.value())); #endif - switch (locations[i].zlt_exposure) { + switch (locations[i]->zlt_exposure) { case OPSTAFF_VIS: i++; continue; @@ -1260,7 +1171,7 @@ ulogin_marshal_locs(ZNotice_t *notice, register int *found, int auth) syslog(LOG_ERR, "ulog_loc: no mem"); break; /* from the while */ } - matches[0] = &locations[i]; + matches[0] = locations[i]; (*found)++; } else { if ((matches = (ZLocation_t **) realloc((caddr_t) matches, (unsigned) ++(*found) * sizeof(ZLocation_t *))) == (ZLocation_t **) 0) { @@ -1268,7 +1179,7 @@ ulogin_marshal_locs(ZNotice_t *notice, register int *found, int auth) *found = 0; break; /* from the while */ } - matches[*found - 1] = &locations[i]; + matches[*found - 1] = locations[i]; } i++; } @@ -1277,13 +1188,13 @@ ulogin_marshal_locs(ZNotice_t *notice, register int *found, int auth) in matches */ - #ifdef DEBUG if (zdebug) { for (i = 0; i < *found ; i++) - zdbug((LOG_DEBUG,"found %s", matches[i]->zlt_user)); + zdbug((LOG_DEBUG,"found %s", + matches[i]->zlt_user.value())); } -#endif DEBUG +#endif /* coalesce the location information into a list of char *'s */ if ((answer = (char **)xmalloc((*found) * NUM_FIELDS * sizeof(char *))) == (char **) 0) { @@ -1291,9 +1202,9 @@ ulogin_marshal_locs(ZNotice_t *notice, register int *found, int auth) *found = 0; } else for (i = 0; i < *found ; i++) { - answer[i*NUM_FIELDS] = matches[i]->zlt_machine; - answer[i*NUM_FIELDS + 1] = matches[i]->zlt_time; - answer[i*NUM_FIELDS + 2] = matches[i]->zlt_tty; + answer[i*NUM_FIELDS] = (char *) matches[i]->zlt_machine.value (); + answer[i*NUM_FIELDS + 1] = (char *) matches[i]->zlt_time.value(); + answer[i*NUM_FIELDS + 2] = (char *) matches[i]->zlt_tty.value(); } if (matches) @@ -1301,113 +1212,51 @@ ulogin_marshal_locs(ZNotice_t *notice, register int *found, int auth) return(answer); } -#if defined(OLD_COMPAT) || defined(NEW_COMPAT) -static void -old_compat_ulogin_locate(ZNotice_t *notice, struct sockaddr_in *who, int auth) -{ - char **answer; - int found; - int packlen; - ZPacket_t reppacket; - ZNotice_t reply; - Code_t retval; - -#ifdef NEW_COMPAT - if (!strcmp(notice->z_version, NEW_OLD_ZEPHYR_VERSION)) { - new_compat_count_uloc++; - syslog(LOG_INFO, "new old locate, %s", inet_ntoa(who->sin_addr)); - } -#endif - answer = ulogin_marshal_locs(notice, &found, auth); - - reply = *notice; - reply.z_kind = SERVACK; - - while ((retval = ZFormatSmallRawNoticeList(&reply, - answer, - found * NUM_FIELDS, - reppacket, - &packlen)) == ZERR_PKTLEN) - found--; - - if (retval != ZERR_NONE) { - syslog(LOG_ERR, "old_ulog_locate format: %s", - error_message(retval)); - if (answer) - xfree(answer); - return; - } - if ((retval = ZSetDestAddr(who)) != ZERR_NONE) { - syslog(LOG_WARNING, "old_ulog_locate set addr: %s", - error_message(retval)); - if (answer) - xfree(answer); - return; - } - if ((retval = ZSendPacket(reppacket, packlen, 0)) != ZERR_NONE) { - syslog(LOG_WARNING, "old_ulog_locate xmit: %s", - error_message(retval)); - if (answer) - xfree(answer); - return; - } -#if 0 - zdbug((LOG_DEBUG,"ulog_loc acked")); -#endif - if (answer) - xfree(answer); - return; -} -#endif /* OLD_COMPAT || NEW_COMPAT */ - void uloc_dump_locs(register FILE *fp) { register int i; + char buf[BUFSIZ], *bufp = buf; + const char *cp; - /* avoid using printf so that we can run FAST! */ + /* delay using stdio so that we can run FAST! */ for (i = 0; i < num_locs; i++) { - fputs(locations[i].zlt_user, fp); - fputs("/", fp); - fputs(locations[i].zlt_machine, fp); - fputs("/",fp); - fputs(locations[i].zlt_time, fp); - fputs("/", fp); - fputs(locations[i].zlt_tty, fp); - switch (locations[i].zlt_exposure) { +#define cpy(str) do{cp=(str);while(*cp){*bufp++=*cp++;}}while(0) + cpy (locations[i]->zlt_user.value ()); + *bufp++ = '/'; + cpy (locations[i]->zlt_machine.value()); + *bufp++ = '/'; + cpy (locations[i]->zlt_time.value()); + *bufp++ = '/'; + cpy (locations[i]->zlt_tty.value()); + switch (locations[i]->zlt_exposure) { case OPSTAFF_VIS: - fputs("/OPSTAFF/", fp); + cpy ("/OPSTAFF/"); break; case REALM_VIS: - fputs("/RLM_VIS/", fp); + cpy ("/RLM_VIS/"); break; case REALM_ANN: - fputs("/RLM_ANN/", fp); + cpy ("/RLM_ANN/"); break; case NET_VIS: - fputs("/NET_VIS/", fp); + cpy ("/NET_VIS/"); break; case NET_ANN: - fputs("/NET_ANN/", fp); + cpy ("/NET_ANN/"); break; default: - fprintf(fp, "/? %d ?/", locations[i].zlt_exposure); + sprintf (bufp, "/? %d ?/", locations[i]->zlt_exposure); + while (*bufp) + *bufp++; break; } - fputs(inet_ntoa(locations[i].zlt_addr), fp); - fputs("/", fp); - fprintf(fp, "%d", ntohs(locations[i].zlt_port)); + cpy (inet_ntoa (locations[i]->zlt_addr)); + *bufp++ = '/'; + sprintf(bufp, "%d", ntohs(locations[i]->zlt_port)); + fputs(buf, fp); (void) putc('\n', fp); +#undef cpy } return; } - -static void -free_loc(register ZLocation_t *loc) -{ - xfree(loc->zlt_user); - xfree(loc->zlt_machine); - xfree(loc->zlt_tty); - xfree(loc->zlt_time); - return; -} -- cgit v1.2.3