Mercurial > pidgin3 / file comparison

comparison: libgaim/protocols/zephyr/Zinternal.c

libgaim/protocols/zephyr/Zinternal.c

branch
gaim
changeset 20470
77693555855f
parent 12424
af82a40f2488
parent 15018
7ce510403b58
child 20471
1966704b3e42
equal deleted inserted replaced
13071:b98e72d4089a 20470:77693555855f
1 /* This file is part of the Project Athena Zephyr Notification System.
2 * It contains source for the internal Zephyr routines.
3 *
4 * Created by: Robert French
5 *
6 * Copyright (c) 1987,1988,1991 by the Massachusetts Institute of
7 * Technology.
8 * For copying and distribution information, see the file
9 * "mit-copyright.h".
10 */
11
12 #include "internal.h"
13 #ifdef WIN32
14 #include <winsock2.h>
15
16 #ifndef ZEPHYR_USES_KERBEROS
17 int gettimeofday(struct timeval* p, struct timezone* tz ){
18 union {
19 long long ns100; /*time since 1 Jan 1601 in 100ns units */
20 FILETIME ft;
21 } _now;
22
23 GetSystemTimeAsFileTime( &(_now.ft) );
24 p->tv_usec=(long)((_now.ns100 / 10LL) % 1000000LL );
25 p->tv_sec= (long)((_now.ns100-(116444736000000000LL))/10000000LL);
26 return 0;
27 }
28 #endif
29
30 #else
31 #include <arpa/inet.h>
32 #include <sys/socket.h>
33 #include <utmp.h>
34 #endif
35
36 extern char *inet_ntoa ();
37
38 int __Zephyr_fd = -1;
39 int __Zephyr_open;
40 int __Zephyr_port = -1;
41 struct in_addr __My_addr;
42 int __Q_CompleteLength;
43 int __Q_Size;
44 struct _Z_InputQ *__Q_Head, *__Q_Tail;
45 struct sockaddr_in __HM_addr;
46 struct sockaddr_in __HM_addr_real;
47 int __HM_set;
48 int __Zephyr_server;
49 ZLocations_t *__locate_list;
50 int __locate_num;
51 int __locate_next;
52 ZSubscription_t *__subscriptions_list;
53 int __subscriptions_num;
54 int __subscriptions_next;
55 int Z_discarded_packets = 0;
56
57 #ifdef ZEPHYR_USES_KERBEROS
58 C_Block __Zephyr_session;
59 #endif
60 char __Zephyr_realm[REALM_SZ];
61
62 #ifdef Z_DEBUG
63 void (*__Z_debug_print) __P((const char *fmt, va_list args, void *closure));
64 void *__Z_debug_print_closure;
65 #endif
66
67 #define min(a,b) ((a)<(b)?(a):(b))
68
69 static int Z_AddField __P((char **ptr, const char *field, char *end));
70 static int find_or_insert_uid __P((ZUnique_Id_t *uid, ZNotice_Kind_t kind));
71
72 /* Find or insert uid in the old uids buffer. The buffer is a sorted
73 * circular queue. We make the assumption that most packets arrive in
74 * order, so we can usually search for a uid or insert it into the buffer
75 * by looking back just a few entries from the end. Since this code is
76 * only executed by the client, the implementation isn't microoptimized. */
77 static int find_or_insert_uid(uid, kind)
78 ZUnique_Id_t *uid;
79 ZNotice_Kind_t kind;
80 {
81 static struct _filter {
82 ZUnique_Id_t uid;
83 ZNotice_Kind_t kind;
84 time_t t;
85 } *buffer;
86 static long size;
87 static long start;
88 static long num;
89
90 time_t now;
91 struct _filter *new;
92 long i, j, new_size;
93 int result;
94
95 /* Initialize the uid buffer if it hasn't been done already. */
96 if (!buffer) {
97 size = Z_INITFILTERSIZE;
98 buffer = (struct _filter *) malloc(size * sizeof(*buffer));
99 if (!buffer)
100 return 0;
101 }
102
103 /* Age the uid buffer, discarding any uids older than the clock skew. */
104 time(&now);
105 while (num && (now - buffer[start % size].t) > CLOCK_SKEW)
106 start++, num--;
107 start %= size;
108
109 /* Make room for a new uid, since we'll probably have to insert one. */
110 if (num == size) {
111 new_size = size * 2 + 2;
112 new = (struct _filter *) malloc(new_size * sizeof(*new));
113 if (!new)
114 return 0;
115 for (i = 0; i < num; i++)
116 new[i] = buffer[(start + i) % size];
117 free(buffer);
118 buffer = new;
119 size = new_size;
120 start = 0;
121 }
122
123 /* Search for this uid in the buffer, starting from the end. */
124 for (i = start + num - 1; i >= start; i--) {
125 result = memcmp(uid, &buffer[i % size].uid, sizeof(*uid));
126 if (result == 0 && buffer[i % size].kind == kind)
127 return 1;
128 if (result > 0)
129 break;
130 }
131
132 /* We didn't find it; insert the uid into the buffer after i. */
133 i++;
134 for (j = start + num; j > i; j--)
135 buffer[j % size] = buffer[(j - 1) % size];
136 buffer[i % size].uid = *uid;
137 buffer[i % size].kind = kind;
138 buffer[i % size].t = now;
139 num++;
140
141 return 0;
142 }
143
144
145 /* Return 1 if there is a packet waiting, 0 otherwise */
146
147 static int Z_PacketWaiting()
148 {
149 struct timeval tv;
150 fd_set read;
151
152 tv.tv_sec = tv.tv_usec = 0;
153 FD_ZERO(&read);
154 FD_SET(ZGetFD(), &read);
155 return (select(ZGetFD() + 1, &read, NULL, NULL, &tv));
156 }
157
158
159 /* Wait for a complete notice to become available */
160
161 Code_t Z_WaitForComplete()
162 {
163 Code_t retval;
164
165 if (__Q_CompleteLength)
166 return (Z_ReadEnqueue());
167
168 while (!__Q_CompleteLength)
169 if ((retval = Z_ReadWait()) != ZERR_NONE)
170 return (retval);
171
172 return (ZERR_NONE);
173 }
174
175
176 /* Read any available packets and enqueue them */
177
178 Code_t Z_ReadEnqueue()
179 {
180 Code_t retval;
181
182 if (ZGetFD() < 0)
183 return (ZERR_NOPORT);
184
185 while (Z_PacketWaiting())
186 if ((retval = Z_ReadWait()) != ZERR_NONE)
187 return (retval);
188
189 return (ZERR_NONE);
190 }
191
192
193 /*
194 * Search the queue for a notice with the proper multiuid - remove any
195 * notices that haven't been touched in a while
196 */
197
198 static struct _Z_InputQ *Z_SearchQueue(uid, kind)
199 ZUnique_Id_t *uid;
200 ZNotice_Kind_t kind;
201 {
202 register struct _Z_InputQ *qptr;
203 struct _Z_InputQ *next;
204 struct timeval tv;
205
206 (void) gettimeofday(&tv, (struct timezone *)0);
207
208 qptr = __Q_Head;
209
210 while (qptr) {
211 if (ZCompareUID(uid, &qptr->uid) && qptr->kind == kind)
212 return (qptr);
213 next = qptr->next;
214 if (qptr->timep && (qptr->timep+Z_NOTICETIMELIMIT < tv.tv_sec))
215 Z_RemQueue(qptr);
216 qptr = next;
217 }
218 return (NULL);
219 }
220
221 /*
222 * Now we delve into really convoluted queue handling and
223 * fragmentation reassembly algorithms and other stuff you probably
224 * don't want to look at...
225 *
226 * This routine does NOT guarantee a complete packet will be ready when it
227 * returns.
228 */
229
230 Code_t Z_ReadWait()
231 {
232 register struct _Z_InputQ *qptr;
233 ZNotice_t notice;
234 ZPacket_t packet;
235 struct sockaddr_in olddest, from;
236 int packet_len, zvlen, part, partof;
237 socklen_t from_len;
238 char *slash;
239 Code_t retval;
240 fd_set fds;
241 struct timeval tv;
242
243 if (ZGetFD() < 0)
244 return (ZERR_NOPORT);
245
246 FD_ZERO(&fds);
247 FD_SET(ZGetFD(), &fds);
248 tv.tv_sec = 60;
249 tv.tv_usec = 0;
250
251 if (select(ZGetFD() + 1, &fds, NULL, NULL, &tv) < 0)
252 return (errno);
253 if (!FD_ISSET(ZGetFD(), &fds))
254 return ETIMEDOUT;
255
256 from_len = sizeof(struct sockaddr_in);
257
258 packet_len = recvfrom(ZGetFD(), packet, sizeof(packet), 0,
259 (struct sockaddr *)&from, &from_len);
260
261 if (packet_len < 0)
262 return (errno);
263
264 if (!packet_len)
265 return (ZERR_EOF);
266
267 /* Ignore obviously non-Zephyr packets. */
268 zvlen = sizeof(ZVERSIONHDR) - 1;
269 if (packet_len < zvlen || memcmp(packet, ZVERSIONHDR, zvlen) != 0) {
270 Z_discarded_packets++;
271 return (ZERR_NONE);
272 }
273
274 /* Parse the notice */
275 if ((retval = ZParseNotice(packet, packet_len, &notice)) != ZERR_NONE)
276 return (retval);
277
278 /*
279 * If we're not a server and the notice is of an appropriate kind,
280 * send back a CLIENTACK to whoever sent it to say we got it.
281 */
282 if (!__Zephyr_server) {
283 if (notice.z_kind != HMACK && notice.z_kind != SERVACK &&
284 notice.z_kind != SERVNAK && notice.z_kind != CLIENTACK) {
285 ZNotice_t tmpnotice;
286 ZPacket_t pkt;
287 int len;
288
289 tmpnotice = notice;
290 tmpnotice.z_kind = CLIENTACK;
291 tmpnotice.z_message_len = 0;
292 olddest = __HM_addr;
293 __HM_addr = from;
294 if ((retval = ZFormatSmallRawNotice(&tmpnotice, pkt, &len))
295 != ZERR_NONE)
296 return(retval);
297 if ((retval = ZSendPacket(pkt, len, 0)) != ZERR_NONE)
298 return (retval);
299 __HM_addr = olddest;
300 }
301 if (find_or_insert_uid(&notice.z_uid, notice.z_kind))
302 return(ZERR_NONE);
303
304 /* Check authentication on the notice. */
305 notice.z_checked_auth = ZCheckAuthentication(&notice, &from);
306 }
307
308
309 /*
310 * Parse apart the z_multinotice field - if the field is blank for
311 * some reason, assume this packet stands by itself.
312 */
313 slash = strchr(notice.z_multinotice, '/');
314 if (slash) {
315 part = atoi(notice.z_multinotice);
316 partof = atoi(slash+1);
317 if (part > partof || partof == 0) {
318 part = 0;
319 partof = notice.z_message_len;
320 }
321 }
322 else {
323 part = 0;
324 partof = notice.z_message_len;
325 }
326
327 /* Too big a packet...just ignore it! */
328 if (partof > Z_MAXNOTICESIZE)
329 return (ZERR_NONE);
330
331 /*
332 * If we aren't a server and we can find a notice in the queue
333 * with the same multiuid field, insert the current fragment as
334 * appropriate.
335 */
336 switch (notice.z_kind) {
337 case SERVACK:
338 case SERVNAK:
339 /* The SERVACK and SERVNAK replies shouldn't be reassembled
340 (they have no parts). Instead, we should hold on to the reply
341 ONLY if it's the first part of a fragmented message, i.e.
342 multi_uid == uid. This allows programs to wait for the uid
343 of the first packet, and get a response when that notice
344 arrives. Acknowledgements of the other fragments are discarded
345 (XXX we assume here that they all carry the same information
346 regarding failure/success)
347 */
348 if (!__Zephyr_server &&
349 !ZCompareUID(&notice.z_multiuid, &notice.z_uid))
350 /* they're not the same... throw away this packet. */
351 return(ZERR_NONE);
352 /* fall thru & process it */
353 default:
354 /* for HMACK types, we assume no packet loss (local loopback
355 connections). The other types can be fragmented and MUST
356 run through this code. */
357 if (!__Zephyr_server && (qptr = Z_SearchQueue(&notice.z_multiuid,
358 notice.z_kind))) {
359 /*
360 * If this is the first fragment, and we haven't already
361 * gotten a first fragment, grab the header from it.
362 */
363 if (part == 0 && !qptr->header) {
364 qptr->header_len = packet_len-notice.z_message_len;
365 qptr->header = (char *) malloc((unsigned) qptr->header_len);
366 if (!qptr->header)
367 return (ENOMEM);
368 (void) memcpy(qptr->header, packet, qptr->header_len);
369 }
370 return (Z_AddNoticeToEntry(qptr, &notice, part));
371 }
372 }
373
374 /*
375 * We'll have to create a new entry...make sure the queue isn't
376 * going to get too big.
377 */
378 if (__Q_Size+(__Zephyr_server ? notice.z_message_len : partof) > Z_MAXQUEUESIZE)
379 return (ZERR_NONE);
380
381 /*
382 * This is a notice we haven't heard of, so create a new queue
383 * entry for it and zero it out.
384 */
385 qptr = (struct _Z_InputQ *)malloc(sizeof(struct _Z_InputQ));
386 if (!qptr)
387 return (ENOMEM);
388 (void) memset((char *)qptr, 0, sizeof(struct _Z_InputQ));
389
390 /* Insert the entry at the end of the queue */
391 qptr->next = NULL;
392 qptr->prev = __Q_Tail;
393 if (__Q_Tail)
394 __Q_Tail->next = qptr;
395 __Q_Tail = qptr;
396
397 if (!__Q_Head)
398 __Q_Head = qptr;
399
400
401 /* Copy the from field, multiuid, kind, and checked authentication. */
402 qptr->from = from;
403 qptr->uid = notice.z_multiuid;
404 qptr->kind = notice.z_kind;
405 qptr->auth = notice.z_checked_auth;
406
407 /*
408 * If this is the first part of the notice, we take the header
409 * from it. We only take it if this is the first fragment so that
410 * the Unique ID's will be predictable.
411 *
412 * If a Zephyr Server, we always take the header.
413 */
414 if (__Zephyr_server || part == 0) {
415 qptr->header_len = packet_len-notice.z_message_len;
416 qptr->header = (char *) malloc((unsigned) qptr->header_len);
417 if (!qptr->header)
418 return ENOMEM;
419 (void) memcpy(qptr->header, packet, qptr->header_len);
420 }
421
422 /*
423 * If this is not a fragmented notice, then don't bother with a
424 * hole list.
425 * If we are a Zephyr server, all notices are treated as complete.
426 */
427 if (__Zephyr_server || (part == 0 && notice.z_message_len == partof)) {
428 __Q_CompleteLength++;
429 qptr->holelist = (struct _Z_Hole *) 0;
430 qptr->complete = 1;
431 /* allocate a msg buf for this piece */
432 if (notice.z_message_len == 0)
433 qptr->msg = 0;
434 else if (!(qptr->msg = (char *) malloc((unsigned) notice.z_message_len)))
435 return(ENOMEM);
436 else
437 (void) memcpy(qptr->msg, notice.z_message, notice.z_message_len);
438 qptr->msg_len = notice.z_message_len;
439 __Q_Size += notice.z_message_len;
440 qptr->packet_len = qptr->header_len+qptr->msg_len;
441 if (!(qptr->packet = (char *) malloc((unsigned) qptr->packet_len)))
442 return (ENOMEM);
443 (void) memcpy(qptr->packet, qptr->header, qptr->header_len);
444 if(qptr->msg)
445 (void) memcpy(qptr->packet+qptr->header_len, qptr->msg,
446 qptr->msg_len);
447 return (ZERR_NONE);
448 }
449
450 /*
451 * We know how long the message is going to be (this is better
452 * than IP fragmentation...), so go ahead and allocate it all.
453 */
454 if (!(qptr->msg = (char *) malloc((unsigned) partof)) && partof)
455 return (ENOMEM);
456 qptr->msg_len = partof;
457 __Q_Size += partof;
458
459 /*
460 * Well, it's a fragmented notice...allocate a hole list and
461 * initialize it to the full packet size. Then insert the
462 * current fragment.
463 */
464 if (!(qptr->holelist = (struct _Z_Hole *)
465 malloc(sizeof(struct _Z_Hole))))
466 return (ENOMEM);
467 qptr->holelist->next = (struct _Z_Hole *) 0;
468 qptr->holelist->first = 0;
469 qptr->holelist->last = partof-1;
470 return (Z_AddNoticeToEntry(qptr, &notice, part));
471 }
472
473
474 /* Fragment management routines - compliments, more or less, of RFC815 */
475
476 Code_t Z_AddNoticeToEntry(qptr, notice, part)
477 struct _Z_InputQ *qptr;
478 ZNotice_t *notice;
479 int part;
480 {
481 int last, oldfirst, oldlast;
482 struct _Z_Hole *hole, *lasthole;
483 struct timeval tv;
484
485 /* Incorporate this notice's checked authentication. */
486 if (notice->z_checked_auth == ZAUTH_FAILED)
487 qptr->auth = ZAUTH_FAILED;
488 else if (notice->z_checked_auth == ZAUTH_NO && qptr->auth != ZAUTH_FAILED)
489 qptr->auth = ZAUTH_NO;
490
491 (void) gettimeofday(&tv, (struct timezone *)0);
492 qptr->timep = tv.tv_sec;
493
494 last = part+notice->z_message_len-1;
495
496 hole = qptr->holelist;
497 lasthole = (struct _Z_Hole *) 0;
498
499 /* copy in the message body */
500 (void) memcpy(qptr->msg+part, notice->z_message, notice->z_message_len);
501
502 /* Search for a hole that overlaps with the current fragment */
503 while (hole) {
504 if (part <= hole->last && last >= hole->first)
505 break;
506 lasthole = hole;
507 hole = hole->next;
508 }
509
510 /* If we found one, delete it and reconstruct a new hole */
511 if (hole) {
512 oldfirst = hole->first;
513 oldlast = hole->last;
514 if (lasthole)
515 lasthole->next = hole->next;
516 else
517 qptr->holelist = hole->next;
518 free((char *)hole);
519 /*
520 * Now create a new hole that is the original hole without the
521 * current fragment.
522 */
523 if (part > oldfirst) {
524 /* Search for the end of the hole list */
525 hole = qptr->holelist;
526 lasthole = (struct _Z_Hole *) 0;
527 while (hole) {
528 lasthole = hole;
529 hole = hole->next;
530 }
531 if (lasthole) {
532 if (!(lasthole->next = (struct _Z_Hole *)
533 malloc(sizeof(struct _Z_InputQ))))
534 return (ENOMEM);
535 hole = lasthole->next;
536 }
537 else {
538 if (!(qptr->holelist = (struct _Z_Hole *)
539 malloc(sizeof(struct _Z_InputQ))))
540 return (ENOMEM);
541 hole = qptr->holelist;
542 }
543 hole->next = NULL;
544 hole->first = oldfirst;
545 hole->last = part-1;
546 }
547 if (last < oldlast) {
548 /* Search for the end of the hole list */
549 hole = qptr->holelist;
550 lasthole = (struct _Z_Hole *) 0;
551 while (hole) {
552 lasthole = hole;
553 hole = hole->next;
554 }
555 if (lasthole) {
556 if (!(lasthole->next = (struct _Z_Hole *)
557 malloc(sizeof(struct _Z_InputQ))))
558 return (ENOMEM);
559 hole = lasthole->next;
560 }
561 else {
562 if (!(qptr->holelist = (struct _Z_Hole *)
563 malloc(sizeof(struct _Z_InputQ))))
564 return (ENOMEM);
565 hole = qptr->holelist;
566 }
567 hole->next = (struct _Z_Hole *) 0;
568 hole->first = last+1;
569 hole->last = oldlast;
570 }
571 }
572
573 if (!qptr->holelist) {
574 if (!qptr->complete)
575 __Q_CompleteLength++;
576 qptr->complete = 1;
577 qptr->timep = 0; /* don't time out anymore */
578 qptr->packet_len = qptr->header_len+qptr->msg_len;
579 if (!(qptr->packet = (char *) malloc((unsigned) qptr->packet_len)))
580 return (ENOMEM);
581 (void) memcpy(qptr->packet, qptr->header, qptr->header_len);
582 (void) memcpy(qptr->packet+qptr->header_len, qptr->msg,
583 qptr->msg_len);
584 }
585
586 return (ZERR_NONE);
587 }
588
589 Code_t Z_FormatHeader(notice, buffer, buffer_len, len, cert_routine)
590 ZNotice_t *notice;
591 char *buffer;
592 int buffer_len;
593 int *len;
594 Z_AuthProc cert_routine;
595 {
596 Code_t retval;
597 static char version[BUFSIZ]; /* default init should be all \0 */
598 struct sockaddr_in name;
599 socklen_t namelen = sizeof(name);
600
601 if (!notice->z_sender)
602 notice->z_sender = ZGetSender();
603
604 if (notice->z_port == 0) {
605 if (ZGetFD() < 0) {
606 retval = ZOpenPort((unsigned short *)0);
607 if (retval != ZERR_NONE)
608 return (retval);
609 }
610 retval = getsockname(ZGetFD(), (struct sockaddr *) &name, &namelen);
611 if (retval != 0)
612 return (retval);
613 notice->z_port = name.sin_port;
614 }
615
616 notice->z_multinotice = "";
617
618 (void) gettimeofday(&notice->z_uid.tv, (struct timezone *)0);
619 notice->z_uid.tv.tv_sec = htonl((unsigned long) notice->z_uid.tv.tv_sec);
620 notice->z_uid.tv.tv_usec = htonl((unsigned long) notice->z_uid.tv.tv_usec);
621
622 (void) memcpy(&notice->z_uid.zuid_addr, &__My_addr, sizeof(__My_addr));
623
624 notice->z_multiuid = notice->z_uid;
625
626 if (!version[0])
627 (void) sprintf(version, "%s%d.%d", ZVERSIONHDR, ZVERSIONMAJOR,
628 ZVERSIONMINOR);
629 notice->z_version = version;
630
631 return Z_FormatAuthHeader(notice, buffer, buffer_len, len, cert_routine);
632 }
633
634 Code_t Z_FormatAuthHeader(notice, buffer, buffer_len, len, cert_routine)
635 ZNotice_t *notice;
636 char *buffer;
637 int buffer_len;
638 int *len;
639 Z_AuthProc cert_routine;
640 {
641 if (!cert_routine) {
642 notice->z_auth = 0;
643 notice->z_authent_len = 0;
644 notice->z_ascii_authent = "";
645 notice->z_checksum = 0;
646 return (Z_FormatRawHeader(notice, buffer, buffer_len,
647 len, NULL, NULL));
648 }
649
650 return ((*cert_routine)(notice, buffer, buffer_len, len));
651 }
652
653 Code_t Z_FormatRawHeader(notice, buffer, buffer_len, len, cstart, cend)
654 ZNotice_t *notice;
655 char *buffer;
656 int buffer_len;
657 int *len;
658 char **cstart, **cend;
659 {
660 char newrecip[BUFSIZ];
661 char *ptr, *end;
662 int i;
663
664 if (!notice->z_class)
665 notice->z_class = "";
666
667 if (!notice->z_class_inst)
668 notice->z_class_inst = "";
669
670 if (!notice->z_opcode)
671 notice->z_opcode = "";
672
673 if (!notice->z_recipient)
674 notice->z_recipient = "";
675
676 if (!notice->z_default_format)
677 notice->z_default_format = "";
678
679 ptr = buffer;
680 end = buffer+buffer_len;
681
682 if (buffer_len < strlen(notice->z_version)+1)
683 return (ZERR_HEADERLEN);
684
685 (void) strcpy(ptr, notice->z_version);
686 ptr += strlen(ptr)+1;
687
688 if (ZMakeAscii32(ptr, end-ptr, Z_NUMFIELDS + notice->z_num_other_fields)
689 == ZERR_FIELDLEN)
690 return (ZERR_HEADERLEN);
691 ptr += strlen(ptr)+1;
692
693 if (ZMakeAscii32(ptr, end-ptr, notice->z_kind) == ZERR_FIELDLEN)
694 return (ZERR_HEADERLEN);
695 ptr += strlen(ptr)+1;
696
697 if (ZMakeAscii(ptr, end-ptr, (unsigned char *)&notice->z_uid,
698 sizeof(ZUnique_Id_t)) == ZERR_FIELDLEN)
699 return (ZERR_HEADERLEN);
700 ptr += strlen(ptr)+1;
701
702 if (ZMakeAscii16(ptr, end-ptr, ntohs(notice->z_port)) == ZERR_FIELDLEN)
703 return (ZERR_HEADERLEN);
704 ptr += strlen(ptr)+1;
705
706 if (ZMakeAscii32(ptr, end-ptr, notice->z_auth) == ZERR_FIELDLEN)
707 return (ZERR_HEADERLEN);
708 ptr += strlen(ptr)+1;
709
710 if (ZMakeAscii32(ptr, end-ptr, notice->z_authent_len) == ZERR_FIELDLEN)
711 return (ZERR_HEADERLEN);
712 ptr += strlen(ptr)+1;
713
714 if (Z_AddField(&ptr, notice->z_ascii_authent, end))
715 return (ZERR_HEADERLEN);
716 if (Z_AddField(&ptr, notice->z_class, end))
717 return (ZERR_HEADERLEN);
718 if (Z_AddField(&ptr, notice->z_class_inst, end))
719 return (ZERR_HEADERLEN);
720 if (Z_AddField(&ptr, notice->z_opcode, end))
721 return (ZERR_HEADERLEN);
722 if (Z_AddField(&ptr, notice->z_sender, end))
723 return (ZERR_HEADERLEN);
724 if (strchr(notice->z_recipient, '@') || !*notice->z_recipient) {
725 if (Z_AddField(&ptr, notice->z_recipient, end))
726 return (ZERR_HEADERLEN);
727 }
728 else {
729 if (strlen(notice->z_recipient) + strlen(__Zephyr_realm) + 2 >
730 sizeof(newrecip))
731 return (ZERR_HEADERLEN);
732 (void) sprintf(newrecip, "%s@%s", notice->z_recipient, __Zephyr_realm);
733 if (Z_AddField(&ptr, newrecip, end))
734 return (ZERR_HEADERLEN);
735 }
736 if (Z_AddField(&ptr, notice->z_default_format, end))
737 return (ZERR_HEADERLEN);
738
739 /* copy back the end pointer location for crypto checksum */
740 if (cstart)
741 *cstart = ptr;
742 if (ZMakeAscii32(ptr, end-ptr, notice->z_checksum) == ZERR_FIELDLEN)
743 return (ZERR_HEADERLEN);
744 ptr += strlen(ptr)+1;
745 if (cend)
746 *cend = ptr;
747
748 if (Z_AddField(&ptr, notice->z_multinotice, end))
749 return (ZERR_HEADERLEN);
750
751 if (ZMakeAscii(ptr, end-ptr, (unsigned char *)&notice->z_multiuid,
752 sizeof(ZUnique_Id_t)) == ZERR_FIELDLEN)
753 return (ZERR_HEADERLEN);
754 ptr += strlen(ptr)+1;
755
756 for (i=0;i<notice->z_num_other_fields;i++)
757 if (Z_AddField(&ptr, notice->z_other_fields[i], end))
758 return (ZERR_HEADERLEN);
759
760 *len = ptr-buffer;
761
762 return (ZERR_NONE);
763 }
764
765 static int
766 Z_AddField(char **ptr, const char *field, char *end)
767 {
768 register int len;
769
770 len = field ? strlen (field) + 1 : 1;
771
772 if (*ptr+len > end)
773 return 1;
774 if (field)
775 (void) strcpy(*ptr, field);
776 else
777 **ptr = '\0';
778 *ptr += len;
779
780 return 0;
781 }
782
783 struct _Z_InputQ *Z_GetFirstComplete()
784 {
785 struct _Z_InputQ *qptr;
786
787 qptr = __Q_Head;
788
789 while (qptr) {
790 if (qptr->complete)
791 return (qptr);
792 qptr = qptr->next;
793 }
794
795 return ((struct _Z_InputQ *)0);
796 }
797
798 struct _Z_InputQ *Z_GetNextComplete(qptr)
799 struct _Z_InputQ *qptr;
800 {
801 qptr = qptr->next;
802 while (qptr) {
803 if (qptr->complete)
804 return (qptr);
805 qptr = qptr->next;
806 }
807
808 return ((struct _Z_InputQ *)0);
809 }
810
811 void Z_RemQueue(qptr)
812 struct _Z_InputQ *qptr;
813 {
814 struct _Z_Hole *hole, *nexthole;
815
816 if (qptr->complete)
817 __Q_CompleteLength--;
818
819 __Q_Size -= qptr->msg_len;
820
821 if (qptr->header)
822 free(qptr->header);
823 if (qptr->msg)
824 free(qptr->msg);
825 if (qptr->packet)
826 free(qptr->packet);
827
828 hole = qptr->holelist;
829 while (hole) {
830 nexthole = hole->next;
831 free((char *)hole);
832 hole = nexthole;
833 }
834
835 if (qptr == __Q_Head && __Q_Head == __Q_Tail) {
836 free ((char *)qptr);
837 __Q_Head = (struct _Z_InputQ *)0;
838 __Q_Tail = (struct _Z_InputQ *)0;
839 return;
840 }
841
842 if (qptr == __Q_Head) {
843 __Q_Head = qptr->next;
844 __Q_Head->prev = (struct _Z_InputQ *)0;
845 free ((char *)qptr);
846 return;
847 }
848 if (qptr == __Q_Tail) {
849 __Q_Tail = qptr->prev;
850 __Q_Tail->next = (struct _Z_InputQ *)0;
851 free ((char *)qptr);
852 return;
853 }
854 qptr->prev->next = qptr->next;
855 qptr->next->prev = qptr->prev;
856 free ((char *)qptr);
857 return;
858 }
859
860 Code_t Z_SendFragmentedNotice(notice, len, cert_func, send_func)
861 ZNotice_t *notice;
862 int len;
863 Z_AuthProc cert_func;
864 Z_SendProc send_func;
865 {
866 ZNotice_t partnotice;
867 ZPacket_t buffer;
868 char multi[64];
869 int offset, hdrsize, fragsize, ret_len, message_len, waitforack;
870 Code_t retval;
871
872 hdrsize = len-notice->z_message_len;
873 fragsize = Z_MAXPKTLEN-hdrsize-Z_FRAGFUDGE;
874
875 offset = 0;
876
877 waitforack = ((notice->z_kind == UNACKED || notice->z_kind == ACKED)
878 && !__Zephyr_server);
879
880 partnotice = *notice;
881
882 while (offset < notice->z_message_len || !notice->z_message_len) {
883 (void) sprintf(multi, "%d/%d", offset, notice->z_message_len);
884 partnotice.z_multinotice = multi;
885 if (offset > 0) {
886 (void) gettimeofday(&partnotice.z_uid.tv,
887 (struct timezone *)0);
888 partnotice.z_uid.tv.tv_sec =
889 htonl((unsigned long) partnotice.z_uid.tv.tv_sec);
890 partnotice.z_uid.tv.tv_usec =
891 htonl((unsigned long) partnotice.z_uid.tv.tv_usec);
892 (void) memcpy((char *)&partnotice.z_uid.zuid_addr, &__My_addr,
893 sizeof(__My_addr));
894 }
895 message_len = min(notice->z_message_len-offset, fragsize);
896 partnotice.z_message = (char*)notice->z_message+offset;
897 partnotice.z_message_len = message_len;
898 if ((retval = Z_FormatAuthHeader(&partnotice, buffer, Z_MAXHEADERLEN,
899 &ret_len, cert_func)) != ZERR_NONE) {
900 return (retval);
901 }
902 memcpy(buffer + ret_len, partnotice.z_message, message_len);
903 if ((retval = (*send_func)(&partnotice, buffer, ret_len+message_len,
904 waitforack)) != ZERR_NONE) {
905 return (retval);
906 }
907 offset += fragsize;
908 if (!notice->z_message_len)
909 break;
910 }
911
912 return (ZERR_NONE);
913 }
914
915 /*ARGSUSED*/
916 Code_t Z_XmitFragment(notice, buf, len, wait)
917 ZNotice_t *notice;
918 char *buf;
919 int len;
920 int wait;
921 {
922 return(ZSendPacket(buf, len, wait));
923 }
924
925 #ifdef Z_DEBUG
926 /* For debugging printing */
927 const char *const ZNoticeKinds[] = {
928 "UNSAFE", "UNACKED", "ACKED", "HMACK", "HMCTL", "SERVACK", "SERVNAK",
929 "CLIENTACK", "STAT"
930 };
931 #endif
932
933 #ifdef Z_DEBUG
934
935 #undef Z_debug
936 #ifdef HAVE_STDARG_H
937 void Z_debug (const char *format, ...)
938 {
939 va_list pvar;
940 if (!__Z_debug_print)
941 return;
942 va_start (pvar, format);
943 (*__Z_debug_print) (format, pvar, __Z_debug_print_closure);
944 va_end (pvar);
945 }
946 #else /* stdarg */
947 void Z_debug (va_alist) va_dcl
948 {
949 va_list pvar;
950 char *format;
951 if (!__Z_debug_print)
952 return;
953 va_start (pvar);
954 format = va_arg (pvar, char *);
955 (*__Z_debug_print) (format, pvar, __Z_debug_print_closure);
956 va_end (pvar);
957 }
958 #endif
959
960 void Z_debug_stderr (format, args, closure)
961 const char *format;
962 va_list args;
963 void *closure;
964 {
965 #ifdef HAVE_VPRINTF
966 vfprintf (stderr, format, args);
967 #else
968 _doprnt (format, args, stderr);
969 #endif
970 putc ('\n', stderr);
971 }
972
973 #undef ZGetFD
974 int ZGetFD () { return __Zephyr_fd; }
975
976 #undef ZQLength
977 int ZQLength () { return __Q_CompleteLength; }
978
979 #undef ZGetDestAddr
980 struct sockaddr_in ZGetDestAddr () { return __HM_addr; }
981
982 #undef ZGetRealm
983 Zconst char * ZGetRealm () { return __Zephyr_realm; }
984
985 #undef ZSetDebug
986 void ZSetDebug(proc, arg)
987 void (*proc) __P((const char *, va_list, void *));
988 char *arg;
989 {
990 __Z_debug_print = proc;
991 __Z_debug_print_closure = arg;
992 }
993 #endif /* Z_DEBUG */
994

Mercurial Repository: pidgin3

mercurial