const char *owl_zephyr_get_sender(void)
{
#ifdef HAVE_LIBZEPHYR
if (owl_global_is_havezephyr(&g))
return(ZGetSender());
#endif
return "";
}
char *owl_zephyr_get_sender()
{
#ifdef HAVE_LIBZEPHYR
return(ZGetSender());
#else
return("");
#endif
}
Code_t
ZSubscriptions(register ZSubscription_t *sublist,
int nitems,
unsigned int port,
char *opcode,
Code_t (*send_routine)(ZNotice_t *, char *, int, int))
{
register int i, j;
int retval;
ZNotice_t notice;
char header[Z_MAXHEADERLEN];
char **list;
char *recip;
int hdrlen;
/* Space available for data, adjusted below. Take off Z_FRAGFUDGE twice.
The first is to account for Z_SendFragmentedNotice's space. The second
to account for hdrlen not being constant. Zcode escapes bytes 0x00 and
0xFF, so some bytes are encoded as two bytes. */
int size_avail = Z_MAXPKTLEN-Z_FRAGFUDGE-Z_FRAGFUDGE;
int size, start, numok;
Z_AuthProc cert_routine;
/* nitems = 0 means cancel all subscriptions; still need to allocate a */
/* array for one item so we can cancel, however. */
list = (char **)malloc((unsigned)((nitems==0)?1:nitems)*3*sizeof(char *));
if (!list)
return (ENOMEM);
(void) memset((char *)¬ice, 0, sizeof(notice));
notice.z_kind = ACKED;
notice.z_port = port;
notice.z_class = ZEPHYR_CTL_CLASS;
notice.z_class_inst = ZEPHYR_CTL_CLIENT;
notice.z_opcode = opcode;
notice.z_sender = 0;
notice.z_recipient = "";
notice.z_default_format = "";
notice.z_message_len = 0;
/* format the header to figure out how long it is */
retval = Z_FormatHeader(¬ice, header, sizeof(header), &hdrlen, ZAUTH);
if (retval != ZERR_NONE) {
free((char *)list);
return(retval);
}
/* if a subscription request, we save the key */
if (strcmp(opcode, CLIENT_SUBSCRIBE) == 0 ||
strcmp(opcode, CLIENT_SUBSCRIBE_NODEFS) == 0) {
cert_routine = ZSUBAUTH;
} else {
cert_routine = ZAUTH;
}
/* compute amount of room left */
size_avail -= hdrlen;
size = size_avail;
/* assemble subs into an array of pointers */
for (i=0;i<nitems;i++) {
list[i*3] = sublist[i].zsub_class;
list[i*3+1] = sublist[i].zsub_classinst;
recip = sublist[i].zsub_recipient;
if (recip && *recip == '*')
recip++;
if (!recip || (*recip != 0 && *recip != '@'))
recip = ZGetSender();
list[i*3+2] = recip;
}
start = -1;
i = 0;
numok = 0;
if (!nitems) {
/* there aren't really any, but we need to xmit anyway */
retval = ZSrvSendList(¬ice, list, 0, cert_routine, send_routine);
free((char *)list);
return(retval);
}
while(i < nitems) {
if (start == -1) {
size = size_avail;
start = i;
numok = 0;
}
if ((j = strlen(list[i*3])
+ strlen(list[i*3+1])
+ strlen(list[i*3+2]) + 3) <= size) {
/* it will fit in this packet */
size -= j;
numok++;
i++;
continue;
}
if (!numok) { /* a single subscription won't
fit into one packet */
free((char *)list);
return(ZERR_FIELDLEN);
}
retval = ZSrvSendList(¬ice, &list[start*3], numok * 3,
cert_routine, send_routine);
if (retval) {
free((char *)list);
return(retval);
}
start = -1;
}
if (numok)
retval = ZSrvSendList(¬ice, &list[start*3], numok * 3,
cert_routine, send_routine);
free((char *)list);
return(retval);
}
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);
}
