static Code_t
Z_SendAndWaitForServer(ZNotice_t *notice,
char *buf, int len,
int waitforack)
{
Code_t retval;
ZNotice_t retnotice;
retval = ZSendPacket(buf, len, waitforack);
if (retval != ZERR_NONE)
return (retval);
/* Z_ReadWait drops non-initial SERVACKs and SERVNAKs on the floor. We
should never see a non-initial one here, but be defensive about bugs in the
sharding code above. */
if (!ZCompareUID(¬ice->z_multiuid, ¬ice->z_uid))
return (retval);
if ((retval = ZIfNotice(&retnotice, (struct sockaddr_in *)0,
ZCompareUIDPred, (char *)¬ice->z_uid)) !=
ZERR_NONE)
return (retval);
if (retnotice.z_kind == SERVNAK) {
ZFreeNotice(&retnotice);
return (ZERR_SERVNAK);
}
if (retnotice.z_kind != SERVACK) {
ZFreeNotice(&retnotice);
return (ZERR_INTERNAL);
}
ZFreeNotice(&retnotice);
return (ZERR_NONE);
}
int
hm_stat(char *host,
char *server)
{
struct in_addr inaddr;
Code_t code;
char *line[20],*mp;
unsigned int i,nf;
struct hostent *hp;
time_t runtime;
struct tm *tim;
ZNotice_t notice;
if ((inaddr.s_addr = inet_addr(host)) == (unsigned)(-1)) {
if ((hp = gethostbyname(host)) == NULL) {
fprintf(stderr,"Unknown host: %s\n",host);
exit(-1);
}
(void) memcpy((char *) &inaddr, hp->h_addr, hp->h_length);
printf("Hostmanager stats: %s\n", hp->h_name);
} else {
printf("Hostmanager stats: %s\n", host);
}
if ((code = ZhmStat(&inaddr, ¬ice)) != ZERR_NONE) {
com_err("zstat", code, "getting hostmanager status");
exit(-1);
}
mp = notice.z_message;
for (nf=0;mp<notice.z_message+notice.z_message_len;nf++) {
line[nf] = mp;
mp += strlen(mp)+1;
}
(void) strcpy(server,line[0]);
printf("HostManager protocol version = %s\n",notice.z_version);
for (i=0; (i < nf) && (i < HM_SIZE); i++) {
if (!strncmp("Time",hm_head[i],4)) {
runtime = atol(line[i]);
tim = gmtime(&runtime);
printf("%s %d days, %02d:%02d:%02d\n", hm_head[i],
tim->tm_yday,
tim->tm_hour,
tim->tm_min,
tim->tm_sec);
}
else
printf("%s %s\n",hm_head[i],line[i]);
}
printf("\n");
ZFreeNotice(¬ice);
return(0);
}
Code_t
ZFlushUserSubscriptions(char *recip)
{
register Code_t retval;
ZNotice_t notice, retnotice;
(void)memset((char *)¬ice, 0, sizeof(notice));
notice.z_kind = ACKED;
notice.z_class = ZEPHYR_CTL_CLASS;
notice.z_class_inst = ZEPHYR_CTL_CLIENT;
notice.z_opcode = CLIENT_FLUSHSUBS;
notice.z_recipient = "";
notice.z_default_format = "";
if (recip) {
notice.z_message = recip;
notice.z_message_len = strlen(recip) + 1;
} else {
notice.z_message_len = 0;
}
if ((retval = ZSendNotice(¬ice, ZAUTH)) != ZERR_NONE)
return (retval);
if ((retval = ZIfNotice(&retnotice, (struct sockaddr_in *)0,
ZCompareUIDPred, (char *)¬ice.z_uid)) !=
ZERR_NONE)
return (retval);
if (retnotice.z_kind == SERVNAK) {
ZFreeNotice(&retnotice);
return (ZERR_SERVNAK);
}
if (retnotice.z_kind != SERVACK) {
ZFreeNotice(&retnotice);
return (ZERR_INTERNAL);
}
ZFreeNotice(&retnotice);
return (ZERR_NONE);
}
int
srv_stat(char *host)
{
char *line[20],*mp;
int sock,i,nf,ret;
struct hostent *hp;
struct sockaddr_in sin;
ZNotice_t notice;
time_t runtime;
struct tm *tim;
#ifdef _POSIX_VERSION
struct sigaction sa;
#endif
(void) memset((char *) &sin, 0, sizeof(struct sockaddr_in));
sin.sin_port = srv_port;
if ((sock = socket(PF_INET, SOCK_DGRAM, 0)) < 0) {
perror("socket:");
exit(-1);
}
sin.sin_family = AF_INET;
if ((sin.sin_addr.s_addr = inet_addr(host)) == (unsigned)(-1)) {
if ((hp = gethostbyname(host)) == NULL) {
fprintf(stderr,"Unknown host: %s\n",host);
exit(-1);
}
(void) memcpy((char *) &sin.sin_addr, hp->h_addr, hp->h_length);
printf("Server stats: %s\n", hp->h_name);
} else {
printf("Server stats: %s\n", host);
}
(void) memset((char *)¬ice, 0, sizeof(notice));
notice.z_kind = UNSAFE;
notice.z_port = 0;
notice.z_charset = ZCHARSET_UNKNOWN;
notice.z_class = ZEPHYR_ADMIN_CLASS;
notice.z_class_inst = "";
notice.z_opcode = ADMIN_STATUS;
notice.z_sender = "";
notice.z_recipient = "";
notice.z_default_format = "";
notice.z_message_len = 0;
if ((ret = ZSetDestAddr(&sin)) != ZERR_NONE) {
com_err("zstat", ret, "setting destination");
exit(-1);
}
if ((ret = ZSendNotice(¬ice, ZNOAUTH)) != ZERR_NONE) {
com_err("zstat", ret, "sending notice");
exit(-1);
}
#ifdef _POSIX_VERSION
sigemptyset(&sa.sa_mask);
sa.sa_flags = 0;
sa.sa_handler = timeout;
(void) sigaction(SIGALRM, &sa, (struct sigaction *)0);
#else
(void) signal(SIGALRM,timeout);
#endif
outoftime = 0;
(void) alarm(10);
if (((ret = ZReceiveNotice(¬ice, (struct sockaddr_in *) 0))
!= ZERR_NONE) &&
ret != EINTR) {
com_err("zstat", ret, "receiving notice");
return (1);
}
(void) alarm(0);
if (outoftime) {
fprintf(stderr,"No response after 10 seconds.\n");
return (1);
}
mp = notice.z_message;
for (nf=0;mp<notice.z_message+notice.z_message_len;nf++) {
line[nf] = mp;
mp += strlen(mp)+1;
}
printf("Server protocol version = %s\n",notice.z_version);
for (i=0; i < nf; i++) {
if (i < 2)
printf("%s %s\n",srv_head[i],line[i]);
else if (i == 2) { /* uptime field */
runtime = atol(line[i]);
tim = gmtime(&runtime);
printf("%s %d days, %02d:%02d:%02d\n",
srv_head[i],
tim->tm_yday,
tim->tm_hour,
tim->tm_min,
tim->tm_sec);
} else if (i == 3) {
printf("%s\n",srv_head[i]);
printf("%s\n",line[i]);
} else printf("%s\n",line[i]);
}
printf("\n");
(void) close(sock);
ZFreeNotice(¬ice);
return(0);
}
Code_t ZInitialize()
{
struct servent *hmserv;
struct hostent *hostent;
char addr[4], hostname[MAXHOSTNAMELEN];
struct in_addr servaddr;
struct sockaddr_in sin;
int s;
socklen_t sinsize = sizeof(sin);
Code_t code;
ZNotice_t notice;
#ifdef ZEPHYR_USES_KERBEROS
char *krealm = NULL;
int krbval;
char d1[ANAME_SZ], d2[INST_SZ];
/* initialize_krb_error_table(); */
#endif
initialize_zeph_error_table();
(void) memset((char *)&__HM_addr, 0, sizeof(__HM_addr));
__HM_addr.sin_family = AF_INET;
/* Set up local loopback address for HostManager */
addr[0] = 127;
addr[1] = 0;
addr[2] = 0;
addr[3] = 1;
hmserv = (struct servent *)getservbyname(HM_SVCNAME, "udp");
__HM_addr.sin_port = (hmserv) ? hmserv->s_port : HM_SVC_FALLBACK;
(void) memcpy((char *)&__HM_addr.sin_addr, addr, 4);
__HM_set = 0;
/* Initialize the input queue */
__Q_Tail = NULL;
__Q_Head = NULL;
/* if the application is a server, there might not be a zhm. The
code will fall back to something which might not be "right",
but this is is ok, since none of the servers call krb_rd_req. */
servaddr.s_addr = INADDR_NONE;
if (! __Zephyr_server) {
if ((code = ZOpenPort(NULL)) != ZERR_NONE)
return(code);
if ((code = ZhmStat(NULL, ¬ice)) != ZERR_NONE)
return(code);
ZClosePort();
/* the first field, which is NUL-terminated, is the server name.
If this code ever support a multiplexing zhm, this will have to
be made smarter, and probably per-message */
#ifdef ZEPHYR_USES_KERBEROS
krealm = krb_realmofhost(notice.z_message);
#endif
hostent = gethostbyname(notice.z_message);
if (hostent && hostent->h_addrtype == AF_INET)
memcpy(&servaddr, hostent->h_addr, sizeof(servaddr));
ZFreeNotice(¬ice);
}
#ifdef ZEPHYR_USES_KERBEROS
if (krealm) {
g_strlcpy(__Zephyr_realm, krealm, REALM_SZ);
} else if ((krb_get_tf_fullname(TKT_FILE, d1, d2, __Zephyr_realm)
!= KSUCCESS) &&
((krbval = krb_get_lrealm(__Zephyr_realm, 1)) != KSUCCESS)) {
return (krbval);
}
#else
g_strlcpy(__Zephyr_realm, "local-realm", REALM_SZ);
#endif
__My_addr.s_addr = INADDR_NONE;
if (servaddr.s_addr != INADDR_NONE) {
/* Try to get the local interface address by connecting a UDP
* socket to the server address and getting the local address.
* Some broken operating systems (e.g. Solaris 2.0-2.5) yield
* INADDR_ANY (zero), so we have to check for that. */
s = socket(AF_INET, SOCK_DGRAM, 0);
if (s != -1) {
memset(&sin, 0, sizeof(sin));
sin.sin_family = AF_INET;
memcpy(&sin.sin_addr, &servaddr, sizeof(servaddr));
sin.sin_port = HM_SRV_SVC_FALLBACK;
if (connect(s, (struct sockaddr *) &sin, sizeof(sin)) == 0
&& getsockname(s, (struct sockaddr *) &sin, &sinsize) == 0
&& sin.sin_addr.s_addr != 0)
memcpy(&__My_addr, &sin.sin_addr, sizeof(__My_addr));
close(s);
}
}
if (__My_addr.s_addr == INADDR_NONE) {
/* We couldn't figure out the local interface address by the
* above method. Try by resolving the local hostname. (This
* is a pretty broken thing to do, and unfortunately what we
* always do on server machines.) */
if (gethostname(hostname, sizeof(hostname)) == 0) {
hostent = gethostbyname(hostname);
if (hostent && hostent->h_addrtype == AF_INET)
memcpy(&__My_addr, hostent->h_addr, sizeof(__My_addr));
}
}
/* If the above methods failed, zero out __My_addr so things will
* sort of kind of work. */
if (__My_addr.s_addr == INADDR_NONE)
__My_addr.s_addr = 0;
/* Get the sender so we can cache it */
(void) ZGetSender();
return (ZERR_NONE);
}
