]> andersk Git - libfaim.git/blame_incremental - aim_rxhandlers.c
andersk / libfaim.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
- Wed Nov 8 02:23:25 UTC 2000
[libfaim.git] / aim_rxhandlers.c
... / ...
CommitLineData
1/*
2 * aim_rxhandlers.c
3 *
4 * This file contains most all of the incoming packet handlers, along
5 * with aim_rxdispatch(), the Rx dispatcher. Queue/list management is
6 * actually done in aim_rxqueue.c.
7 *
8 */
9
10#include <faim/aim.h>
11
12/*
13 * Bleck functions get called when there's no non-bleck functions
14 * around to cleanup the mess...
15 */
16faim_internal int bleck(struct aim_session_t *sess,struct command_rx_struct *workingPtr, ...)
17{
18 u_short family;
19 u_short subtype;
20
21 u_short maxf;
22 u_short maxs;
23
24 /* XXX: this is ugly. and big just for debugging. */
25 char *literals[14][25] = {
26 {"Invalid",
27 NULL
28 },
29 {"General",
30 "Invalid",
31 "Error",
32 "Client Ready",
33 "Server Ready",
34 "Service Request",
35 "Redirect",
36 "Rate Information Request",
37 "Rate Information",
38 "Rate Information Ack",
39 NULL,
40 "Rate Information Change",
41 "Server Pause",
42 NULL,
43 "Server Resume",
44 "Request Personal User Information",
45 "Personal User Information",
46 "Evil Notification",
47 NULL,
48 "Migration notice",
49 "Message of the Day",
50 "Set Privacy Flags",
51 "Well Known URL",
52 "NOP"
53 },
54 {"Location",
55 "Invalid",
56 "Error",
57 "Request Rights",
58 "Rights Information",
59 "Set user information",
60 "Request User Information",
61 "User Information",
62 "Watcher Sub Request",
63 "Watcher Notification"
64 },
65 {"Buddy List Management",
66 "Invalid",
67 "Error",
68 "Request Rights",
69 "Rights Information",
70 "Add Buddy",
71 "Remove Buddy",
72 "Watcher List Query",
73 "Watcher List Response",
74 "Watcher SubRequest",
75 "Watcher Notification",
76 "Reject Notification",
77 "Oncoming Buddy",
78 "Offgoing Buddy"
79 },
80 {"Messeging",
81 "Invalid",
82 "Error",
83 "Add ICBM Parameter",
84 "Remove ICBM Parameter",
85 "Request Parameter Information",
86 "Parameter Information",
87 "Outgoing Message",
88 "Incoming Message",
89 "Evil Request",
90 "Evil Reply",
91 "Missed Calls",
92 "Message Error",
93 "Host Ack"
94 },
95 {"Advertisements",
96 "Invalid",
97 "Error",
98 "Request Ad",
99 "Ad Data (GIFs)"
100 },
101 {"Invitation / Client-to-Client",
102 "Invalid",
103 "Error",
104 "Invite a Friend",
105 "Invitation Ack"
106 },
107 {"Administrative",
108 "Invalid",
109 "Error",
110 "Information Request",
111 "Information Reply",
112 "Information Change Request",
113 "Information Chat Reply",
114 "Account Confirm Request",
115 "Account Confirm Reply",
116 "Account Delete Request",
117 "Account Delete Reply"
118 },
119 {"Popups",
120 "Invalid",
121 "Error",
122 "Display Popup"
123 },
124 {"BOS",
125 "Invalid",
126 "Error",
127 "Request Rights",
128 "Rights Response",
129 "Set group permission mask",
130 "Add permission list entries",
131 "Delete permission list entries",
132 "Add deny list entries",
133 "Delete deny list entries",
134 "Server Error"
135 },
136 {"User Lookup",
137 "Invalid",
138 "Error",
139 "Search Request",
140 "Search Response"
141 },
142 {"Stats",
143 "Invalid",
144 "Error",
145 "Set minimum report interval",
146 "Report Events"
147 },
148 {"Translate",
149 "Invalid",
150 "Error",
151 "Translate Request",
152 "Translate Reply",
153 },
154 {"Chat Navigation",
155 "Invalid",
156 "Error",
157 "Request rights",
158 "Request Exchange Information",
159 "Request Room Information",
160 "Request Occupant List",
161 "Search for Room",
162 "Outgoing Message",
163 "Incoming Message",
164 "Evil Request",
165 "Evil Reply",
166 "Chat Error",
167 }
168 };
169
170 maxf = sizeof(literals) / sizeof(literals[0]);
171 maxs = sizeof(literals[0]) / sizeof(literals[0][0]);
172
173 family = aimutil_get16(workingPtr->data+0);
174 subtype= aimutil_get16(workingPtr->data+2);
175
176 if((family < maxf) && (subtype+1 < maxs) && (literals[family][subtype] != NULL))
177 printf("bleck: null handler for %04x/%04x (%s)\n", family, subtype, literals[family][subtype+1]);
178 else
179 printf("bleck: null handler for %04x/%04x (no literal)\n",family,subtype);
180
181 return 1;
182}
183
184faim_export int aim_conn_addhandler(struct aim_session_t *sess,
185 struct aim_conn_t *conn,
186 u_short family,
187 u_short type,
188 rxcallback_t newhandler,
189 u_short flags)
190{
191 struct aim_rxcblist_t *newcb;
192
193 if (!conn)
194 return -1;
195
196 faimdprintf(1, "aim_conn_addhandler: adding for %04x/%04x\n", family, type);
197
198 if (!(newcb = (struct aim_rxcblist_t *)calloc(1, sizeof(struct aim_rxcblist_t))))
199 return -1;
200 newcb->family = family;
201 newcb->type = type;
202 newcb->flags = flags;
203 if (!newhandler)
204 newcb->handler = &bleck;
205 else
206 newcb->handler = newhandler;
207 newcb->next = NULL;
208
209 if (!conn->handlerlist)
210 conn->handlerlist = newcb;
211 else {
212 struct aim_rxcblist_t *cur;
213
214 cur = conn->handlerlist;
215
216 while (cur->next)
217 cur = cur->next;
218 cur->next = newcb;
219 }
220
221 return 0;
222}
223
224faim_export int aim_clearhandlers(struct aim_conn_t *conn)
225{
226 struct aim_rxcblist_t *cur;
227
228 if (!conn)
229 return -1;
230
231 cur = conn->handlerlist;
232 while(cur) {
233 struct aim_rxcblist_t *tmp;
234
235 tmp = cur->next;
236 free(cur);
237 cur = tmp;
238 }
239
240 return 0;
241}
242
243faim_internal rxcallback_t aim_callhandler(struct aim_conn_t *conn,
244 u_short family,
245 u_short type)
246{
247 struct aim_rxcblist_t *cur;
248
249 if (!conn)
250 return NULL;
251
252 faimdprintf(1, "aim_callhandler: calling for %04x/%04x\n", family, type);
253
254 cur = conn->handlerlist;
255 while(cur)
256 {
257 if ( (cur->family == family) && (cur->type == type) )
258 return cur->handler;
259 cur = cur->next;
260 }
261
262 if (type==0xffff)
263 return NULL;
264
265 return aim_callhandler(conn, family, 0xffff);
266}
267
268faim_internal int aim_callhandler_noparam(struct aim_session_t *sess,
269 struct aim_conn_t *conn,
270 u_short family,
271 u_short type,
272 struct command_rx_struct *ptr)
273{
274 rxcallback_t userfunc = NULL;
275 userfunc = aim_callhandler(conn, family, type);
276 if (userfunc)
277 return userfunc(sess, ptr);
278 return 1; /* XXX */
279}
280
281/*
282 aim_rxdispatch()
283
284 Basically, heres what this should do:
285 1) Determine correct packet handler for this packet
286 2) Mark the packet handled (so it can be dequeued in purge_queue())
287 3) Send the packet to the packet handler
288 4) Go to next packet in the queue and start over
289 5) When done, run purge_queue() to purge handled commands
290
291 Note that any unhandlable packets should probably be left in the
292 queue. This is the best way to prevent data loss. This means
293 that a single packet may get looked at by this function multiple
294 times. This is more good than bad! This behavior may change.
295
296 Aren't queue's fun?
297
298 TODO: Get rid of all the ugly if's.
299 TODO: Clean up.
300 TODO: More support for mid-level handlers.
301 TODO: Allow for NULL handlers.
302
303 */
304faim_export int aim_rxdispatch(struct aim_session_t *sess)
305{
306 int i = 0;
307 struct command_rx_struct *workingPtr = NULL;
308
309 if (sess->queue_incoming == NULL) {
310 faimdprintf(1, "parse_generic: incoming packet queue empty.\n");
311 return 0;
312 } else {
313 workingPtr = sess->queue_incoming;
314 for (i = 0; workingPtr != NULL; workingPtr = workingPtr->next, i++) {
315 /*
316 * XXX: This is still fairly ugly.
317 */
318 if (workingPtr->handled)
319 continue;
320
321 /*
322 * This is a debugging/sanity check only and probably could/should be removed
323 * for stable code.
324 */
325 if (((workingPtr->hdrtype == AIM_FRAMETYPE_OFT) &&
326 (workingPtr->conn->type != AIM_CONN_TYPE_RENDEZVOUS)) ||
327 ((workingPtr->hdrtype == AIM_FRAMETYPE_OSCAR) &&
328 (workingPtr->conn->type == AIM_CONN_TYPE_RENDEZVOUS))) {
329 printf("faim: rxhandlers: incompatible frame type %d on connection type 0x%04x\n", workingPtr->hdrtype, workingPtr->conn->type);
330 workingPtr->handled = 1;
331 continue;
332 }
333
334 switch(workingPtr->conn->type) {
335 case -1:
336 /*
337 * This can happen if we have a queued command
338 * that was recieved after a connection has
339 * been terminated. In which case, the handler
340 * list has been cleared, and there's nothing we
341 * can do for it. We can only cancel it.
342 */
343 workingPtr->handled = 1;
344 break;
345 case AIM_CONN_TYPE_AUTH: {
346 u_long head;
347
348 head = aimutil_get32(workingPtr->data);
349 if (head == 0x00000001) {
350 faimdprintf(1, "got connection ack on auth line\n");
351 workingPtr->handled = 1;
352 } else if (workingPtr->hdr.oscar.type == 0x0004) {
353 workingPtr->handled = aim_authparse(sess, workingPtr);
354 } else {
355 u_short family,subtype;
356
357 family = aimutil_get16(workingPtr->data);
358 subtype = aimutil_get16(workingPtr->data+2);
359
360 switch (family) {
361 /* New login protocol */
362 case 0x0017:
363 if (subtype == 0x0001)
364 workingPtr->handled = aim_callhandler_noparam(sess, workingPtr->conn, 0x0017, 0x0001, workingPtr);
365 else if (subtype == 0x0003)
366 workingPtr->handled = aim_authparse(sess, workingPtr);
367 else if (subtype == 0x0007)
368 workingPtr->handled = aim_authkeyparse(sess, workingPtr);
369 else
370 workingPtr->handled = aim_callhandler_noparam(sess, workingPtr->conn, 0x0017, 0xffff, workingPtr);
371 break;
372 case 0x0007:
373 if (subtype == 0x0005)
374 workingPtr->handled = aim_callhandler_noparam(sess, workingPtr->conn, AIM_CB_FAM_ADM, AIM_CB_ADM_INFOCHANGE_REPLY, workingPtr);
375 break;
376 case AIM_CB_FAM_SPECIAL:
377 if (subtype == AIM_CB_SPECIAL_DEBUGCONN_CONNECT) {
378 workingPtr->handled = aim_callhandler_noparam(sess, workingPtr->conn, family, subtype, workingPtr);
379 break;
380 } /* others fall through */
381 default:
382#if 0
383 /* Old login protocol */
384 /* any user callbacks will be called from here */
385 workingPtr->handled = aim_authparse(sess, workingPtr);
386#endif
387 break;
388 }
389 }
390 break;
391 }
392 case AIM_CONN_TYPE_BOS: {
393 u_short family;
394 u_short subtype;
395
396 if (workingPtr->hdr.oscar.type == 0x04) {
397 workingPtr->handled = aim_negchan_middle(sess, workingPtr);
398 break;
399 }
400
401 family = aimutil_get16(workingPtr->data);
402 subtype = aimutil_get16(workingPtr->data+2);
403
404 switch (family) {
405 case 0x0000: /* not really a family, but it works */
406 if (subtype == 0x0001)
407 workingPtr->handled = aim_callhandler_noparam(sess, workingPtr->conn, 0x0000, 0x0001, workingPtr);
408 else
409 workingPtr->handled = aim_callhandler_noparam(sess, workingPtr->conn, AIM_CB_FAM_SPECIAL, AIM_CB_SPECIAL_UNKNOWN, workingPtr);
410 break;
411 case 0x0001: /* Family: General */
412 switch (subtype) {
413 case 0x0001:
414 workingPtr->handled = aim_parse_generalerrs(sess, workingPtr);
415 break;
416 case 0x0003:
417 workingPtr->handled = aim_callhandler_noparam(sess, workingPtr->conn, 0x0001, 0x0003, workingPtr);
418 break;
419 case 0x0005:
420 workingPtr->handled = aim_handleredirect_middle(sess, workingPtr);
421 break;
422 case 0x0007:
423 workingPtr->handled = aim_callhandler_noparam(sess, workingPtr->conn, 0x0001, 0x0007, workingPtr);
424 break;
425 case 0x000a:
426 workingPtr->handled = aim_parse_ratechange_middle(sess, workingPtr);
427 break;
428 case 0x000f:
429 workingPtr->handled = aim_callhandler_noparam(sess, workingPtr->conn, 0x0001, 0x000f, workingPtr);
430 break;
431 case 0x0010:
432 workingPtr->handled = aim_parse_evilnotify_middle(sess, workingPtr);
433 break;
434 case 0x0013:
435 workingPtr->handled = aim_parsemotd_middle(sess, workingPtr);
436 break;
437 default:
438 workingPtr->handled = aim_callhandler_noparam(sess, workingPtr->conn, AIM_CB_FAM_GEN, AIM_CB_GEN_DEFAULT, workingPtr);
439 break;
440 }
441 break;
442 case 0x0002: /* Family: Location */
443 switch (subtype) {
444 case 0x0001:
445 workingPtr->handled = aim_parse_locateerr(sess, workingPtr);
446 break;
447 case 0x0003:
448 workingPtr->handled = aim_callhandler_noparam(sess, workingPtr->conn, 0x0002, 0x0003, workingPtr);
449 break;
450 case 0x0006:
451 workingPtr->handled = aim_parse_userinfo_middle(sess, workingPtr);
452 break;
453 default:
454 workingPtr->handled = aim_callhandler_noparam(sess, workingPtr->conn, AIM_CB_FAM_LOC, AIM_CB_LOC_DEFAULT, workingPtr);
455 break;
456 }
457 break;
458 case 0x0003: /* Family: Buddy List */
459 switch (subtype) {
460 case 0x0001:
461 workingPtr->handled = aim_parse_generalerrs(sess, workingPtr);
462 break;
463 case 0x0003:
464 workingPtr->handled = aim_parse_buddyrights(sess, workingPtr);
465 break;
466 case 0x000b: /* oncoming buddy */
467 workingPtr->handled = aim_parse_oncoming_middle(sess, workingPtr);
468 break;
469 case 0x000c: /* offgoing buddy */
470 workingPtr->handled = aim_parse_offgoing_middle(sess, workingPtr);
471 break;
472 default:
473 workingPtr->handled = aim_callhandler_noparam(sess, workingPtr->conn, AIM_CB_FAM_BUD, AIM_CB_BUD_DEFAULT, workingPtr);
474 }
475 break;
476 case 0x0004: /* Family: Messeging */
477 switch (subtype) {
478 case 0x0001:
479 workingPtr->handled = aim_parse_msgerror_middle(sess, workingPtr);
480 break;
481 case 0x0005:
482 workingPtr->handled = aim_callhandler_noparam(sess, workingPtr->conn, 0x0004, 0x0005, workingPtr);
483 break;
484 case 0x0006:
485 workingPtr->handled = aim_parse_outgoing_im_middle(sess, workingPtr);
486 break;
487 case 0x0007:
488 workingPtr->handled = aim_parse_incoming_im_middle(sess, workingPtr);
489 break;
490 case 0x000a:
491 workingPtr->handled = aim_parse_missedcall(sess, workingPtr);
492 break;
493 case 0x000c:
494 workingPtr->handled = aim_parse_msgack_middle(sess, workingPtr);
495 break;
496 default:
497 workingPtr->handled = aim_callhandler_noparam(sess, workingPtr->conn, AIM_CB_FAM_MSG, AIM_CB_MSG_DEFAULT, workingPtr);
498 }
499 break;
500 case 0x0009:
501 if (subtype == 0x0001)
502 workingPtr->handled = aim_parse_generalerrs(sess, workingPtr);
503 else if (subtype == 0x0003)
504 workingPtr->handled = aim_parse_bosrights(sess, workingPtr);
505 else
506 workingPtr->handled = aim_callhandler_noparam(sess, workingPtr->conn, AIM_CB_FAM_BOS, AIM_CB_BOS_DEFAULT, workingPtr);
507 break;
508 case 0x000a: /* Family: User lookup */
509 switch (subtype) {
510 case 0x0001:
511 workingPtr->handled = aim_callhandler_noparam(sess, workingPtr->conn, 0x000a, 0x0001, workingPtr);
512 break;
513 case 0x0003:
514 workingPtr->handled = aim_callhandler_noparam(sess, workingPtr->conn, 0x000a, 0x0003, workingPtr);
515 break;
516 default:
517 workingPtr->handled = aim_callhandler_noparam(sess, workingPtr->conn, AIM_CB_FAM_LOK, AIM_CB_LOK_DEFAULT, workingPtr);
518 }
519 break;
520 case 0x000b: {
521 if (subtype == 0x0001)
522 workingPtr->handled = aim_parse_generalerrs(sess, workingPtr);
523 else if (subtype == 0x0002)
524 workingPtr->handled = aim_callhandler_noparam(sess, workingPtr->conn, 0x000b, 0x0002, workingPtr);
525 else
526 workingPtr->handled = aim_callhandler_noparam(sess, workingPtr->conn, AIM_CB_FAM_STS, AIM_CB_STS_DEFAULT, workingPtr);
527 break;
528 }
529 case AIM_CB_FAM_SPECIAL:
530 workingPtr->handled = aim_callhandler_noparam(sess, workingPtr->conn, family, subtype, workingPtr);
531 break;
532 default:
533 workingPtr->handled = aim_callhandler_noparam(sess, workingPtr->conn, AIM_CB_FAM_SPECIAL, AIM_CB_SPECIAL_UNKNOWN, workingPtr);
534 break;
535 } /* switch(family) */
536 break;
537 } /* AIM_CONN_TYPE_BOS */
538 case AIM_CONN_TYPE_CHATNAV: {
539 u_short family;
540 u_short subtype;
541 family = aimutil_get16(workingPtr->data);
542 subtype= aimutil_get16(workingPtr->data+2);
543
544 if ((family == 0x0002) && (subtype == 0x0006)) {
545 workingPtr->handled = 1;
546 aim_conn_setstatus(workingPtr->conn, AIM_CONN_STATUS_READY);
547 } else if ((family == 0x000d) && (subtype == 0x0009)) {
548 workingPtr->handled = aim_chatnav_parse_info(sess, workingPtr);
549 } else {
550 workingPtr->handled = aim_callhandler_noparam(sess, workingPtr->conn, family, subtype, workingPtr);
551 }
552 break;
553 }
554 case AIM_CONN_TYPE_CHAT: {
555 u_short family, subtype;
556
557 family = aimutil_get16(workingPtr->data);
558 subtype= aimutil_get16(workingPtr->data+2);
559
560 if ((family == 0x0000) && (subtype == 0x00001))
561 workingPtr->handled = aim_callhandler_noparam(sess, workingPtr->conn, 0x0000, 0x0001, workingPtr);
562 else if (family == 0x0001) {
563 if (subtype == 0x0001)
564 workingPtr->handled = aim_callhandler_noparam(sess, workingPtr->conn, 0x0001, 0x0001, workingPtr);
565 else if (subtype == 0x0003)
566 workingPtr->handled = aim_callhandler_noparam(sess, workingPtr->conn, 0x0001, 0x0003, workingPtr);
567 else if (subtype == 0x0007)
568 workingPtr->handled = aim_callhandler_noparam(sess, workingPtr->conn, 0x0001, 0x0007, workingPtr);
569 else
570 workingPtr->handled = aim_callhandler_noparam(sess, workingPtr->conn, family, subtype, workingPtr);
571 } else if (family == 0x000e) {
572 if (subtype == 0x0002)
573 workingPtr->handled = aim_chat_parse_infoupdate(sess, workingPtr);
574 else if (subtype == 0x0003)
575 workingPtr->handled = aim_chat_parse_joined(sess, workingPtr);
576 else if (subtype == 0x0004)
577 workingPtr->handled = aim_chat_parse_leave(sess, workingPtr);
578 else if (subtype == 0x0006)
579 workingPtr->handled = aim_chat_parse_incoming(sess, workingPtr);
580 else
581 printf("Chat: unknown snac %04x/%04x\n", family, subtype);
582 } else {
583 printf("Chat: unknown snac %04x/%04x\n", family, subtype);
584 workingPtr->handled = aim_callhandler_noparam(sess, workingPtr->conn, AIM_CB_FAM_CHT, AIM_CB_CHT_DEFAULT, workingPtr);
585 }
586 break;
587 }
588 case AIM_CONN_TYPE_RENDEZVOUS: {
589 /* make sure that we only get OFT frames on these connections */
590 if (workingPtr->hdrtype != AIM_FRAMETYPE_OFT) {
591 printf("faim: internal error: non-OFT frames on OFT connection\n");
592 workingPtr->handled = 1; /* get rid of it */
593 break;
594 }
595
596 /* XXX: implement this */
597 printf("faim: OFT frame!\n");
598
599 break;
600 }
601 case AIM_CONN_TYPE_RENDEZVOUS_OUT: {
602 /* not possible */
603 break;
604 }
605 default:
606 printf("\ninternal error: unknown connection type (very bad.) (type = %d, fd = %d, commandlen = %02x)\n\n", workingPtr->conn->type, workingPtr->conn->fd, workingPtr->commandlen);
607 workingPtr->handled = aim_callhandler_noparam(sess, workingPtr->conn, AIM_CB_FAM_SPECIAL, AIM_CB_SPECIAL_UNKNOWN, workingPtr);
608 break;
609 }
610 }
611 }
612
613 /*
614 * This doesn't have to be called here. It could easily be done
615 * by a seperate thread or something. It's an administrative operation,
616 * and can take a while. Though the less you call it the less memory
617 * you'll have :)
618 */
619 aim_purge_rxqueue(sess);
620
621 return 0;
622}
623
624faim_internal int aim_parse_msgack_middle(struct aim_session_t *sess, struct command_rx_struct *command)
625{
626 rxcallback_t userfunc = NULL;
627 char sn[MAXSNLEN];
628 unsigned short type;
629 int i = 10+8; /* skip SNAC and cookie */
630 int ret = 1;
631 unsigned char snlen;
632
633 type = aimutil_get16(command->data+i);
634 i += 2;
635
636 snlen = aimutil_get8(command->data+i);
637 i++;
638
639 memset(sn, 0, sizeof(sn));
640 strncpy(sn, (char *)command->data+i, snlen);
641
642 if ((userfunc = aim_callhandler(command->conn, 0x0004, 0x000c)))
643 ret = userfunc(sess, command, type, sn);
644
645 return ret;
646}
647
648faim_internal int aim_parse_ratechange_middle(struct aim_session_t *sess, struct command_rx_struct *command)
649{
650 rxcallback_t userfunc = NULL;
651 int ret = 1;
652 unsigned long newrate;
653
654 if (command->commandlen != 0x2f) {
655 printf("faim: unknown rate change length 0x%04x\n", command->commandlen);
656 return 1;
657 }
658
659 newrate = aimutil_get32(command->data+34);
660
661 if ((userfunc = aim_callhandler(command->conn, 0x0001, 0x000a)))
662 ret = userfunc(sess, command, newrate);
663
664 return ret;
665}
666
667faim_internal int aim_parse_evilnotify_middle(struct aim_session_t *sess, struct command_rx_struct *command)
668{
669 rxcallback_t userfunc = NULL;
670 int ret = 1, pos;
671 char *sn = NULL;
672
673 if(command->commandlen < 12) /* a warning level dec sends this */
674 return 1;
675
676 if ((pos = aimutil_get8(command->data+ 12)) > MAXSNLEN)
677 return 1;
678
679 if(!(sn = (char *)calloc(1, pos+1)))
680 return 1;
681
682 memcpy(sn, command->data+13, pos);
683
684 if ((userfunc = aim_callhandler(command->conn, 0x0001, 0x0010)))
685 ret = userfunc(sess, command, sn);
686
687 free(sn);
688
689 return ret;
690}
691
692faim_internal int aim_parsemotd_middle(struct aim_session_t *sess,
693 struct command_rx_struct *command, ...)
694{
695 rxcallback_t userfunc = NULL;
696 char *msg;
697 int ret=1;
698 struct aim_tlvlist_t *tlvlist;
699 u_short id;
700
701 /*
702 * Code.
703 *
704 * Valid values:
705 * 1 Mandatory upgrade
706 * 2 Advisory upgrade
707 * 3 System bulletin
708 * 4 Nothing's wrong ("top o the world" -- normal)
709 *
710 */
711 id = aimutil_get16(command->data+10);
712
713 /*
714 * TLVs follow
715 */
716 if (!(tlvlist = aim_readtlvchain(command->data+12, command->commandlen-12)))
717 return ret;
718
719 if (!(msg = aim_gettlv_str(tlvlist, 0x000b, 1))) {
720 aim_freetlvchain(&tlvlist);
721 return ret;
722 }
723
724 userfunc = aim_callhandler(command->conn, 0x0001, 0x0013);
725 if (userfunc)
726 ret = userfunc(sess, command, id, msg);
727
728 aim_freetlvchain(&tlvlist);
729 free(msg);
730
731 return ret;
732}
733
734faim_internal int aim_handleredirect_middle(struct aim_session_t *sess,
735 struct command_rx_struct *command, ...)
736{
737 struct aim_tlv_t *tmptlv = NULL;
738 int serviceid = 0x00;
739 unsigned char cookie[AIM_COOKIELEN];
740 char *ip = NULL;
741 rxcallback_t userfunc = NULL;
742 struct aim_tlvlist_t *tlvlist;
743 int ret = 1;
744
745 if (!(tlvlist = aim_readtlvchain(command->data+10, command->commandlen-10)))
746 {
747 printf("libfaim: major bug: unable to read tlvchain from redirect\n");
748 return ret;
749 }
750
751 if (!(tmptlv = aim_gettlv(tlvlist, 0x000d, 1)))
752 {
753 printf("libfaim: major bug: no service ID in tlvchain from redirect\n");
754 aim_freetlvchain(&tlvlist);
755 return ret;
756 }
757 serviceid = aimutil_get16(tmptlv->value);
758
759 if (!(ip = aim_gettlv_str(tlvlist, 0x0005, 1)))
760 {
761 printf("libfaim: major bug: no IP in tlvchain from redirect (service 0x%02x)\n", serviceid);
762 free(ip);
763 aim_freetlvchain(&tlvlist);
764 return ret;
765 }
766
767 if (!(tmptlv = aim_gettlv(tlvlist, 0x0006, 1)))
768 {
769 printf("libfaim: major bug: no cookie in tlvchain from redirect (service 0x%02x)\n", serviceid);
770 free(ip);
771 aim_freetlvchain(&tlvlist);
772 return ret;
773 }
774 memcpy(cookie, tmptlv->value, AIM_COOKIELEN);
775
776 if (serviceid == AIM_CONN_TYPE_CHAT)
777 {
778 /*
779 * Chat hack.
780 *
781 */
782 userfunc = aim_callhandler(command->conn, 0x0001, 0x0005);
783 if (userfunc)
784 ret = userfunc(sess, command, serviceid, ip, cookie, sess->pendingjoin);
785 free(sess->pendingjoin);
786 sess->pendingjoin = NULL;
787 }
788 else
789 {
790 userfunc = aim_callhandler(command->conn, 0x0001, 0x0005);
791 if (userfunc)
792 ret = userfunc(sess, command, serviceid, ip, cookie);
793 }
794
795 free(ip);
796 aim_freetlvchain(&tlvlist);
797
798 return ret;
799}
800
801faim_internal int aim_parse_unknown(struct aim_session_t *sess,
802 struct command_rx_struct *command, ...)
803{
804 u_int i = 0;
805
806 faimdprintf(1, "\nRecieved unknown packet:");
807
808 for (i = 0; i < command->commandlen; i++)
809 {
810 if ((i % 8) == 0)
811 faimdprintf(1, "\n\t");
812
813 faimdprintf(1, "0x%2x ", command->data[i]);
814 }
815
816 faimdprintf(1, "\n\n");
817
818 return 1;
819}
820
821
822faim_internal int aim_negchan_middle(struct aim_session_t *sess,
823 struct command_rx_struct *command)
824{
825 struct aim_tlvlist_t *tlvlist;
826 char *msg = NULL;
827 unsigned short code = 0;
828 struct aim_tlv_t *tmptlv;
829 rxcallback_t userfunc = NULL;
830 int ret = 1;
831
832 tlvlist = aim_readtlvchain(command->data, command->commandlen);
833
834 if ((tmptlv = aim_gettlv(tlvlist, 0x0009, 1)))
835 code = aimutil_get16(tmptlv->value);
836
837 if ((tmptlv = aim_gettlv(tlvlist, 0x000b, 1)))
838 msg = aim_gettlv_str(tlvlist, 0x000b, 1);
839
840 userfunc = aim_callhandler(command->conn,
841 AIM_CB_FAM_SPECIAL, AIM_CB_SPECIAL_CONNERR);
842 if (userfunc)
843 ret = userfunc(sess, command, code, msg);
844
845 aim_freetlvchain(&tlvlist);
846 free(msg);
847
848 return ret;
849}
850
851/*
852 * aim_parse_generalerrs()
853 *
854 * Middle handler for 0x0001 snac of each family.
855 *
856 */
857faim_internal int aim_parse_generalerrs(struct aim_session_t *sess,
858 struct command_rx_struct *command, ...)
859{
860 u_short family;
861 u_short subtype;
862
863 family = aimutil_get16(command->data+0);
864 subtype= aimutil_get16(command->data+2);
865
866 switch(family)
867 {
868 default:
869 /* Unknown family */
870 return aim_callhandler_noparam(sess, command->conn, AIM_CB_FAM_SPECIAL, AIM_CB_SPECIAL_UNKNOWN, command);
871 }
872
873 return 1;
874}
875
876
877
git-cvsimport mirror of libfaim
This page took 0.042004 seconds and 5 git commands to generate.