Mercurial > pidgin.yaz
view src/protocols/zephyr/Zinternal.c @ 6160:7416a43dc786
[gaim-migrate @ 6635]
Hold it.. Nobody said anything about _three_ books. Oh that stinkin' wise
man. He was so busy filling me full of his secret little workds and his
phrases and his BALONEY that he never said anything about this...
committer: Tailor Script <tailor@pidgin.im>
author | Christian Hammond <chipx86@chipx86.com> |
---|---|
date | Wed, 16 Jul 2003 22:43:27 +0000 |
parents | 381da05cb5ed |
children | 08ce2a94d9c7 |
line wrap: on
line source
/* This file is part of the Project Athena Zephyr Notification System. * It contains source for the internal Zephyr routines. * * Created by: Robert French * * $Source$ * $Author: faceprint $ * * Copyright (c) 1987,1988,1991 by the Massachusetts Institute of * Technology. * For copying and distribution information, see the file * "mit-copyright.h". */ /* $Header$ */ #include <internal.h> #include <arpa/inet.h> #include <sys/socket.h> #include <utmp.h> #ifndef lint static const char rcsid_Zinternal_c[] = "$Id: Zinternal.c 5500 2003-04-15 04:18:00Z faceprint $"; static const char copyright[] = "Copyright (c) 1987,1988,1991 by the Massachusetts Institute of Technology."; #endif extern char *inet_ntoa (); int __Zephyr_fd = -1; int __Zephyr_open; int __Zephyr_port = -1; struct in_addr __My_addr; int __Q_CompleteLength; int __Q_Size; struct _Z_InputQ *__Q_Head, *__Q_Tail; struct sockaddr_in __HM_addr; struct sockaddr_in __HM_addr_real; int __HM_set; int __Zephyr_server; ZLocations_t *__locate_list; int __locate_num; int __locate_next; ZSubscription_t *__subscriptions_list; int __subscriptions_num; int __subscriptions_next; int Z_discarded_packets = 0; #ifdef ZEPHYR_USES_KERBEROS C_Block __Zephyr_session; #endif char __Zephyr_realm[REALM_SZ]; #ifdef Z_DEBUG void (*__Z_debug_print) __P((const char *fmt, va_list args, void *closure)); void *__Z_debug_print_closure; #endif #define min(a,b) ((a)<(b)?(a):(b)) static int Z_AddField __P((char **ptr, const char *field, char *end)); static int find_or_insert_uid __P((ZUnique_Id_t *uid, ZNotice_Kind_t kind)); /* Find or insert uid in the old uids buffer. The buffer is a sorted * circular queue. We make the assumption that most packets arrive in * order, so we can usually search for a uid or insert it into the buffer * by looking back just a few entries from the end. Since this code is * only executed by the client, the implementation isn't microoptimized. */ static int find_or_insert_uid(uid, kind) ZUnique_Id_t *uid; ZNotice_Kind_t kind; { static struct _filter { ZUnique_Id_t uid; ZNotice_Kind_t kind; time_t t; } *buffer; static long size; static long start; static long num; time_t now; struct _filter *new; long i, j, new_size; int result; /* Initialize the uid buffer if it hasn't been done already. */ if (!buffer) { size = Z_INITFILTERSIZE; buffer = (struct _filter *) malloc(size * sizeof(*buffer)); if (!buffer) return 0; } /* Age the uid buffer, discarding any uids older than the clock skew. */ time(&now); while (num && (now - buffer[start % size].t) > CLOCK_SKEW) start++, num--; start %= size; /* Make room for a new uid, since we'll probably have to insert one. */ if (num == size) { new_size = size * 2 + 2; new = (struct _filter *) malloc(new_size * sizeof(*new)); if (!new) return 0; for (i = 0; i < num; i++) new[i] = buffer[(start + i) % size]; free(buffer); buffer = new; size = new_size; start = 0; } /* Search for this uid in the buffer, starting from the end. */ for (i = start + num - 1; i >= start; i--) { result = memcmp(uid, &buffer[i % size].uid, sizeof(*uid)); if (result == 0 && buffer[i % size].kind == kind) return 1; if (result > 0) break; } /* We didn't find it; insert the uid into the buffer after i. */ i++; for (j = start + num; j > i; j--) buffer[j % size] = buffer[(j - 1) % size]; buffer[i % size].uid = *uid; buffer[i % size].kind = kind; buffer[i % size].t = now; num++; return 0; } /* Return 1 if there is a packet waiting, 0 otherwise */ int Z_PacketWaiting() { struct timeval tv; fd_set read; tv.tv_sec = tv.tv_usec = 0; FD_ZERO(&read); FD_SET(ZGetFD(), &read); return (select(ZGetFD() + 1, &read, NULL, NULL, &tv)); } /* Wait for a complete notice to become available */ Code_t Z_WaitForComplete() { Code_t retval; if (__Q_CompleteLength) return (Z_ReadEnqueue()); while (!__Q_CompleteLength) if ((retval = Z_ReadWait()) != ZERR_NONE) return (retval); return (ZERR_NONE); } /* Read any available packets and enqueue them */ Code_t Z_ReadEnqueue() { Code_t retval; if (ZGetFD() < 0) return (ZERR_NOPORT); while (Z_PacketWaiting()) if ((retval = Z_ReadWait()) != ZERR_NONE) return (retval); return (ZERR_NONE); } /* * Search the queue for a notice with the proper multiuid - remove any * notices that haven't been touched in a while */ struct _Z_InputQ *Z_SearchQueue(uid, kind) ZUnique_Id_t *uid; ZNotice_Kind_t kind; { register struct _Z_InputQ *qptr; struct _Z_InputQ *next; struct timeval tv; (void) gettimeofday(&tv, (struct timezone *)0); qptr = __Q_Head; while (qptr) { if (ZCompareUID(uid, &qptr->uid) && qptr->kind == kind) return (qptr); next = qptr->next; if (qptr->timep && (qptr->timep+Z_NOTICETIMELIMIT < tv.tv_sec)) Z_RemQueue(qptr); qptr = next; } return (NULL); } /* * Now we delve into really convoluted queue handling and * fragmentation reassembly algorithms and other stuff you probably * don't want to look at... * * This routine does NOT guarantee a complete packet will be ready when it * returns. */ Code_t Z_ReadWait() { register struct _Z_InputQ *qptr; ZNotice_t notice; ZPacket_t packet; struct sockaddr_in olddest, from; int from_len, packet_len, zvlen, part, partof; char *slash; Code_t retval; fd_set fds; struct timeval tv; if (ZGetFD() < 0) return (ZERR_NOPORT); FD_ZERO(&fds); FD_SET(ZGetFD(), &fds); tv.tv_sec = 60; tv.tv_usec = 0; if (select(ZGetFD() + 1, &fds, NULL, NULL, &tv) < 0) return (errno); if (!FD_ISSET(ZGetFD(), &fds)) return ETIMEDOUT; from_len = sizeof(struct sockaddr_in); packet_len = recvfrom(ZGetFD(), packet, sizeof(packet), 0, (struct sockaddr *)&from, &from_len); if (packet_len < 0) return (errno); if (!packet_len) return (ZERR_EOF); /* Ignore obviously non-Zephyr packets. */ zvlen = sizeof(ZVERSIONHDR) - 1; if (packet_len < zvlen || memcmp(packet, ZVERSIONHDR, zvlen) != 0) { Z_discarded_packets++; return (ZERR_NONE); } /* Parse the notice */ if ((retval = ZParseNotice(packet, packet_len, ¬ice)) != ZERR_NONE) return (retval); /* * If we're not a server and the notice is of an appropriate kind, * send back a CLIENTACK to whoever sent it to say we got it. */ if (!__Zephyr_server) { if (notice.z_kind != HMACK && notice.z_kind != SERVACK && notice.z_kind != SERVNAK && notice.z_kind != CLIENTACK) { ZNotice_t tmpnotice; ZPacket_t pkt; int len; tmpnotice = notice; tmpnotice.z_kind = CLIENTACK; tmpnotice.z_message_len = 0; olddest = __HM_addr; __HM_addr = from; if ((retval = ZFormatSmallRawNotice(&tmpnotice, pkt, &len)) != ZERR_NONE) return(retval); if ((retval = ZSendPacket(pkt, len, 0)) != ZERR_NONE) return (retval); __HM_addr = olddest; } if (find_or_insert_uid(¬ice.z_uid, notice.z_kind)) return(ZERR_NONE); /* Check authentication on the notice. */ notice.z_checked_auth = ZCheckAuthentication(¬ice, &from); } /* * Parse apart the z_multinotice field - if the field is blank for * some reason, assume this packet stands by itself. */ slash = strchr(notice.z_multinotice, '/'); if (slash) { part = atoi(notice.z_multinotice); partof = atoi(slash+1); if (part > partof || partof == 0) { part = 0; partof = notice.z_message_len; } } else { part = 0; partof = notice.z_message_len; } /* Too big a packet...just ignore it! */ if (partof > Z_MAXNOTICESIZE) return (ZERR_NONE); /* * If we aren't a server and we can find a notice in the queue * with the same multiuid field, insert the current fragment as * appropriate. */ switch (notice.z_kind) { case SERVACK: case SERVNAK: /* The SERVACK and SERVNAK replies shouldn't be reassembled (they have no parts). Instead, we should hold on to the reply ONLY if it's the first part of a fragmented message, i.e. multi_uid == uid. This allows programs to wait for the uid of the first packet, and get a response when that notice arrives. Acknowledgements of the other fragments are discarded (XXX we assume here that they all carry the same information regarding failure/success) */ if (!__Zephyr_server && !ZCompareUID(¬ice.z_multiuid, ¬ice.z_uid)) /* they're not the same... throw away this packet. */ return(ZERR_NONE); /* fall thru & process it */ default: /* for HMACK types, we assume no packet loss (local loopback connections). The other types can be fragmented and MUST run through this code. */ if (!__Zephyr_server && (qptr = Z_SearchQueue(¬ice.z_multiuid, notice.z_kind))) { /* * If this is the first fragment, and we haven't already * gotten a first fragment, grab the header from it. */ if (part == 0 && !qptr->header) { qptr->header_len = packet_len-notice.z_message_len; qptr->header = (char *) malloc((unsigned) qptr->header_len); if (!qptr->header) return (ENOMEM); (void) memcpy(qptr->header, packet, qptr->header_len); } return (Z_AddNoticeToEntry(qptr, ¬ice, part)); } } /* * We'll have to create a new entry...make sure the queue isn't * going to get too big. */ if (__Q_Size+(__Zephyr_server ? notice.z_message_len : partof) > Z_MAXQUEUESIZE) return (ZERR_NONE); /* * This is a notice we haven't heard of, so create a new queue * entry for it and zero it out. */ qptr = (struct _Z_InputQ *)malloc(sizeof(struct _Z_InputQ)); if (!qptr) return (ENOMEM); (void) memset((char *)qptr, 0, sizeof(struct _Z_InputQ)); /* Insert the entry at the end of the queue */ qptr->next = NULL; qptr->prev = __Q_Tail; if (__Q_Tail) __Q_Tail->next = qptr; __Q_Tail = qptr; if (!__Q_Head) __Q_Head = qptr; /* Copy the from field, multiuid, kind, and checked authentication. */ qptr->from = from; qptr->uid = notice.z_multiuid; qptr->kind = notice.z_kind; qptr->auth = notice.z_checked_auth; /* * If this is the first part of the notice, we take the header * from it. We only take it if this is the first fragment so that * the Unique ID's will be predictable. * * If a Zephyr Server, we always take the header. */ if (__Zephyr_server || part == 0) { qptr->header_len = packet_len-notice.z_message_len; qptr->header = (char *) malloc((unsigned) qptr->header_len); if (!qptr->header) return ENOMEM; (void) memcpy(qptr->header, packet, qptr->header_len); } /* * If this is not a fragmented notice, then don't bother with a * hole list. * If we are a Zephyr server, all notices are treated as complete. */ if (__Zephyr_server || (part == 0 && notice.z_message_len == partof)) { __Q_CompleteLength++; qptr->holelist = (struct _Z_Hole *) 0; qptr->complete = 1; /* allocate a msg buf for this piece */ if (notice.z_message_len == 0) qptr->msg = 0; else if (!(qptr->msg = (char *) malloc((unsigned) notice.z_message_len))) return(ENOMEM); else (void) memcpy(qptr->msg, notice.z_message, notice.z_message_len); qptr->msg_len = notice.z_message_len; __Q_Size += notice.z_message_len; qptr->packet_len = qptr->header_len+qptr->msg_len; if (!(qptr->packet = (char *) malloc((unsigned) qptr->packet_len))) return (ENOMEM); (void) memcpy(qptr->packet, qptr->header, qptr->header_len); if(qptr->msg) (void) memcpy(qptr->packet+qptr->header_len, qptr->msg, qptr->msg_len); return (ZERR_NONE); } /* * We know how long the message is going to be (this is better * than IP fragmentation...), so go ahead and allocate it all. */ if (!(qptr->msg = (char *) malloc((unsigned) partof)) && partof) return (ENOMEM); qptr->msg_len = partof; __Q_Size += partof; /* * Well, it's a fragmented notice...allocate a hole list and * initialize it to the full packet size. Then insert the * current fragment. */ if (!(qptr->holelist = (struct _Z_Hole *) malloc(sizeof(struct _Z_Hole)))) return (ENOMEM); qptr->holelist->next = (struct _Z_Hole *) 0; qptr->holelist->first = 0; qptr->holelist->last = partof-1; return (Z_AddNoticeToEntry(qptr, ¬ice, part)); } /* Fragment management routines - compliments, more or less, of RFC815 */ Code_t Z_AddNoticeToEntry(qptr, notice, part) struct _Z_InputQ *qptr; ZNotice_t *notice; int part; { int last, oldfirst, oldlast; struct _Z_Hole *hole, *lasthole; struct timeval tv; /* Incorporate this notice's checked authentication. */ if (notice->z_checked_auth == ZAUTH_FAILED) qptr->auth = ZAUTH_FAILED; else if (notice->z_checked_auth == ZAUTH_NO && qptr->auth != ZAUTH_FAILED) qptr->auth = ZAUTH_NO; (void) gettimeofday(&tv, (struct timezone *)0); qptr->timep = tv.tv_sec; last = part+notice->z_message_len-1; hole = qptr->holelist; lasthole = (struct _Z_Hole *) 0; /* copy in the message body */ (void) memcpy(qptr->msg+part, notice->z_message, notice->z_message_len); /* Search for a hole that overlaps with the current fragment */ while (hole) { if (part <= hole->last && last >= hole->first) break; lasthole = hole; hole = hole->next; } /* If we found one, delete it and reconstruct a new hole */ if (hole) { oldfirst = hole->first; oldlast = hole->last; if (lasthole) lasthole->next = hole->next; else qptr->holelist = hole->next; free((char *)hole); /* * Now create a new hole that is the original hole without the * current fragment. */ if (part > oldfirst) { /* Search for the end of the hole list */ hole = qptr->holelist; lasthole = (struct _Z_Hole *) 0; while (hole) { lasthole = hole; hole = hole->next; } if (lasthole) { if (!(lasthole->next = (struct _Z_Hole *) malloc(sizeof(struct _Z_InputQ)))) return (ENOMEM); hole = lasthole->next; } else { if (!(qptr->holelist = (struct _Z_Hole *) malloc(sizeof(struct _Z_InputQ)))) return (ENOMEM); hole = qptr->holelist; } hole->next = NULL; hole->first = oldfirst; hole->last = part-1; } if (last < oldlast) { /* Search for the end of the hole list */ hole = qptr->holelist; lasthole = (struct _Z_Hole *) 0; while (hole) { lasthole = hole; hole = hole->next; } if (lasthole) { if (!(lasthole->next = (struct _Z_Hole *) malloc(sizeof(struct _Z_InputQ)))) return (ENOMEM); hole = lasthole->next; } else { if (!(qptr->holelist = (struct _Z_Hole *) malloc(sizeof(struct _Z_InputQ)))) return (ENOMEM); hole = qptr->holelist; } hole->next = (struct _Z_Hole *) 0; hole->first = last+1; hole->last = oldlast; } } if (!qptr->holelist) { if (!qptr->complete) __Q_CompleteLength++; qptr->complete = 1; qptr->timep = 0; /* don't time out anymore */ qptr->packet_len = qptr->header_len+qptr->msg_len; if (!(qptr->packet = (char *) malloc((unsigned) qptr->packet_len))) return (ENOMEM); (void) memcpy(qptr->packet, qptr->header, qptr->header_len); (void) memcpy(qptr->packet+qptr->header_len, qptr->msg, qptr->msg_len); } return (ZERR_NONE); } Code_t Z_FormatHeader(notice, buffer, buffer_len, len, cert_routine) ZNotice_t *notice; char *buffer; int buffer_len; int *len; Z_AuthProc cert_routine; { Code_t retval; static char version[BUFSIZ]; /* default init should be all \0 */ struct sockaddr_in name; int namelen = sizeof(name); if (!notice->z_sender) notice->z_sender = ZGetSender(); if (notice->z_port == 0) { if (ZGetFD() < 0) { retval = ZOpenPort((u_short *)0); if (retval != ZERR_NONE) return (retval); } retval = getsockname(ZGetFD(), (struct sockaddr *) &name, &namelen); if (retval != 0) return (retval); notice->z_port = name.sin_port; } notice->z_multinotice = ""; (void) gettimeofday(¬ice->z_uid.tv, (struct timezone *)0); notice->z_uid.tv.tv_sec = htonl((u_long) notice->z_uid.tv.tv_sec); notice->z_uid.tv.tv_usec = htonl((u_long) notice->z_uid.tv.tv_usec); (void) memcpy(¬ice->z_uid.zuid_addr, &__My_addr, sizeof(__My_addr)); notice->z_multiuid = notice->z_uid; if (!version[0]) (void) sprintf(version, "%s%d.%d", ZVERSIONHDR, ZVERSIONMAJOR, ZVERSIONMINOR); notice->z_version = version; return Z_FormatAuthHeader(notice, buffer, buffer_len, len, cert_routine); } Code_t Z_FormatAuthHeader(notice, buffer, buffer_len, len, cert_routine) ZNotice_t *notice; char *buffer; int buffer_len; int *len; Z_AuthProc cert_routine; { if (!cert_routine) { notice->z_auth = 0; notice->z_authent_len = 0; notice->z_ascii_authent = ""; notice->z_checksum = 0; return (Z_FormatRawHeader(notice, buffer, buffer_len, len, NULL, NULL)); } return ((*cert_routine)(notice, buffer, buffer_len, len)); } Code_t Z_FormatRawHeader(notice, buffer, buffer_len, len, cstart, cend) ZNotice_t *notice; char *buffer; int buffer_len; int *len; char **cstart, **cend; { char newrecip[BUFSIZ]; char *ptr, *end; int i; if (!notice->z_class) notice->z_class = ""; if (!notice->z_class_inst) notice->z_class_inst = ""; if (!notice->z_opcode) notice->z_opcode = ""; if (!notice->z_recipient) notice->z_recipient = ""; if (!notice->z_default_format) notice->z_default_format = ""; ptr = buffer; end = buffer+buffer_len; if (buffer_len < strlen(notice->z_version)+1) return (ZERR_HEADERLEN); (void) strcpy(ptr, notice->z_version); ptr += strlen(ptr)+1; if (ZMakeAscii32(ptr, end-ptr, Z_NUMFIELDS + notice->z_num_other_fields) == ZERR_FIELDLEN) return (ZERR_HEADERLEN); ptr += strlen(ptr)+1; if (ZMakeAscii32(ptr, end-ptr, notice->z_kind) == ZERR_FIELDLEN) return (ZERR_HEADERLEN); ptr += strlen(ptr)+1; if (ZMakeAscii(ptr, end-ptr, (unsigned char *)¬ice->z_uid, sizeof(ZUnique_Id_t)) == ZERR_FIELDLEN) return (ZERR_HEADERLEN); ptr += strlen(ptr)+1; if (ZMakeAscii16(ptr, end-ptr, ntohs(notice->z_port)) == ZERR_FIELDLEN) return (ZERR_HEADERLEN); ptr += strlen(ptr)+1; if (ZMakeAscii32(ptr, end-ptr, notice->z_auth) == ZERR_FIELDLEN) return (ZERR_HEADERLEN); ptr += strlen(ptr)+1; if (ZMakeAscii32(ptr, end-ptr, notice->z_authent_len) == ZERR_FIELDLEN) return (ZERR_HEADERLEN); ptr += strlen(ptr)+1; if (Z_AddField(&ptr, notice->z_ascii_authent, end)) return (ZERR_HEADERLEN); if (Z_AddField(&ptr, notice->z_class, end)) return (ZERR_HEADERLEN); if (Z_AddField(&ptr, notice->z_class_inst, end)) return (ZERR_HEADERLEN); if (Z_AddField(&ptr, notice->z_opcode, end)) return (ZERR_HEADERLEN); if (Z_AddField(&ptr, notice->z_sender, end)) return (ZERR_HEADERLEN); if (strchr(notice->z_recipient, '@') || !*notice->z_recipient) { if (Z_AddField(&ptr, notice->z_recipient, end)) return (ZERR_HEADERLEN); } else { if (strlen(notice->z_recipient) + strlen(__Zephyr_realm) + 2 > sizeof(newrecip)) return (ZERR_HEADERLEN); (void) sprintf(newrecip, "%s@%s", notice->z_recipient, __Zephyr_realm); if (Z_AddField(&ptr, newrecip, end)) return (ZERR_HEADERLEN); } if (Z_AddField(&ptr, notice->z_default_format, end)) return (ZERR_HEADERLEN); /* copy back the end pointer location for crypto checksum */ if (cstart) *cstart = ptr; if (ZMakeAscii32(ptr, end-ptr, notice->z_checksum) == ZERR_FIELDLEN) return (ZERR_HEADERLEN); ptr += strlen(ptr)+1; if (cend) *cend = ptr; if (Z_AddField(&ptr, notice->z_multinotice, end)) return (ZERR_HEADERLEN); if (ZMakeAscii(ptr, end-ptr, (unsigned char *)¬ice->z_multiuid, sizeof(ZUnique_Id_t)) == ZERR_FIELDLEN) return (ZERR_HEADERLEN); ptr += strlen(ptr)+1; for (i=0;i<notice->z_num_other_fields;i++) if (Z_AddField(&ptr, notice->z_other_fields[i], end)) return (ZERR_HEADERLEN); *len = ptr-buffer; return (ZERR_NONE); } static int Z_AddField(char **ptr, const char *field, char *end) { register int len; len = field ? strlen (field) + 1 : 1; if (*ptr+len > end) return 1; if (field) (void) strcpy(*ptr, field); else **ptr = '\0'; *ptr += len; return 0; } struct _Z_InputQ *Z_GetFirstComplete() { struct _Z_InputQ *qptr; qptr = __Q_Head; while (qptr) { if (qptr->complete) return (qptr); qptr = qptr->next; } return ((struct _Z_InputQ *)0); } struct _Z_InputQ *Z_GetNextComplete(qptr) struct _Z_InputQ *qptr; { qptr = qptr->next; while (qptr) { if (qptr->complete) return (qptr); qptr = qptr->next; } return ((struct _Z_InputQ *)0); } void Z_RemQueue(qptr) struct _Z_InputQ *qptr; { struct _Z_Hole *hole, *nexthole; if (qptr->complete) __Q_CompleteLength--; __Q_Size -= qptr->msg_len; if (qptr->header) free(qptr->header); if (qptr->msg) free(qptr->msg); if (qptr->packet) free(qptr->packet); hole = qptr->holelist; while (hole) { nexthole = hole->next; free((char *)hole); hole = nexthole; } if (qptr == __Q_Head && __Q_Head == __Q_Tail) { free ((char *)qptr); __Q_Head = (struct _Z_InputQ *)0; __Q_Tail = (struct _Z_InputQ *)0; return; } if (qptr == __Q_Head) { __Q_Head = qptr->next; __Q_Head->prev = (struct _Z_InputQ *)0; free ((char *)qptr); return; } if (qptr == __Q_Tail) { __Q_Tail = qptr->prev; __Q_Tail->next = (struct _Z_InputQ *)0; free ((char *)qptr); return; } qptr->prev->next = qptr->next; qptr->next->prev = qptr->prev; free ((char *)qptr); return; } Code_t Z_SendFragmentedNotice(notice, len, cert_func, send_func) ZNotice_t *notice; int len; Z_AuthProc cert_func; Z_SendProc send_func; { ZNotice_t partnotice; ZPacket_t buffer; char multi[64]; int offset, hdrsize, fragsize, ret_len, message_len, waitforack; Code_t retval; hdrsize = len-notice->z_message_len; fragsize = Z_MAXPKTLEN-hdrsize-Z_FRAGFUDGE; offset = 0; waitforack = ((notice->z_kind == UNACKED || notice->z_kind == ACKED) && !__Zephyr_server); partnotice = *notice; while (offset < notice->z_message_len || !notice->z_message_len) { (void) sprintf(multi, "%d/%d", offset, notice->z_message_len); partnotice.z_multinotice = multi; if (offset > 0) { (void) gettimeofday(&partnotice.z_uid.tv, (struct timezone *)0); partnotice.z_uid.tv.tv_sec = htonl((u_long) partnotice.z_uid.tv.tv_sec); partnotice.z_uid.tv.tv_usec = htonl((u_long) partnotice.z_uid.tv.tv_usec); (void) memcpy((char *)&partnotice.z_uid.zuid_addr, &__My_addr, sizeof(__My_addr)); } message_len = min(notice->z_message_len-offset, fragsize); partnotice.z_message = notice->z_message+offset; partnotice.z_message_len = message_len; if ((retval = Z_FormatAuthHeader(&partnotice, buffer, Z_MAXHEADERLEN, &ret_len, cert_func)) != ZERR_NONE) { return (retval); } memcpy(buffer + ret_len, partnotice.z_message, message_len); if ((retval = (*send_func)(&partnotice, buffer, ret_len+message_len, waitforack)) != ZERR_NONE) { return (retval); } offset += fragsize; if (!notice->z_message_len) break; } return (ZERR_NONE); } /*ARGSUSED*/ Code_t Z_XmitFragment(notice, buf, len, wait) ZNotice_t *notice; char *buf; int len; int wait; { return(ZSendPacket(buf, len, wait)); } #ifdef Z_DEBUG /* For debugging printing */ const char *const ZNoticeKinds[] = { "UNSAFE", "UNACKED", "ACKED", "HMACK", "HMCTL", "SERVACK", "SERVNAK", "CLIENTACK", "STAT" }; #endif #ifdef Z_DEBUG #undef Z_debug #ifdef HAVE_STDARG_H void Z_debug (const char *format, ...) { va_list pvar; if (!__Z_debug_print) return; va_start (pvar, format); (*__Z_debug_print) (format, pvar, __Z_debug_print_closure); va_end (pvar); } #else /* stdarg */ void Z_debug (va_alist) va_dcl { va_list pvar; char *format; if (!__Z_debug_print) return; va_start (pvar); format = va_arg (pvar, char *); (*__Z_debug_print) (format, pvar, __Z_debug_print_closure); va_end (pvar); } #endif void Z_debug_stderr (format, args, closure) const char *format; va_list args; void *closure; { #ifdef HAVE_VPRINTF vfprintf (stderr, format, args); #else _doprnt (format, args, stderr); #endif putc ('\n', stderr); } #undef ZGetFD int ZGetFD () { return __Zephyr_fd; } #undef ZQLength int ZQLength () { return __Q_CompleteLength; } #undef ZGetDestAddr struct sockaddr_in ZGetDestAddr () { return __HM_addr; } #undef ZGetRealm Zconst char * ZGetRealm () { return __Zephyr_realm; } #undef ZSetDebug void ZSetDebug(proc, arg) void (*proc) __P((const char *, va_list, void *)); char *arg; { __Z_debug_print = proc; __Z_debug_print_closure = arg; } #endif /* Z_DEBUG */