Mercurial > pidgin.yaz
annotate src/protocols/oscar/service.c @ 7282:ad243bc63184
[gaim-migrate @ 7861]
Mostly this is my usual blah clean-up/changes.
I started merging that icq sms patch, but I'm not comfortable
with much of it...
I also made AIM have 6 login steps instead of 2. The first
few go pretty quickly though. I'll probably work on this
more later, but I'm going to sleep now.
committer: Tailor Script <tailor@pidgin.im>
author | Mark Doliner <mark@kingant.net> |
---|---|
date | Thu, 16 Oct 2003 06:12:43 +0000 |
parents | 6d3d8f11e765 |
children | 2bdacd38528c |
rev | line source |
---|---|
2703 | 1 /* |
3952 | 2 * Family 0x0001 - This is a very special group. All connections support |
2703 | 3 * this group, as it does some particularly good things (like rate limiting). |
4 */ | |
5 | |
6 #define FAIM_INTERNAL | |
2734
9fc65bb80596
[gaim-migrate @ 2747]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2703
diff
changeset
|
7 #define FAIM_NEED_CONN_INTERNAL |
2703 | 8 #include <aim.h> |
9 | |
10 #include "md5.h" | |
11 | |
3952 | 12 /* Subtype 0x0002 - Client Online */ |
2703 | 13 faim_export int aim_clientready(aim_session_t *sess, aim_conn_t *conn) |
14 { | |
15 aim_conn_inside_t *ins = (aim_conn_inside_t *)conn->inside; | |
16 struct snacgroup *sg; | |
17 aim_frame_t *fr; | |
18 aim_snacid_t snacid; | |
19 | |
20 if (!ins) | |
21 return -EINVAL; | |
22 | |
23 if (!(fr = aim_tx_new(sess, conn, AIM_FRAMETYPE_FLAP, 0x02, 1152))) | |
24 return -ENOMEM; | |
25 | |
26 snacid = aim_cachesnac(sess, 0x0001, 0x0002, 0x0000, NULL, 0); | |
27 aim_putsnac(&fr->data, 0x0001, 0x0002, 0x0000, snacid); | |
28 | |
29 /* | |
30 * Send only the tool versions that the server cares about (that it | |
31 * marked as supporting in the server ready SNAC). | |
32 */ | |
33 for (sg = ins->groups; sg; sg = sg->next) { | |
34 aim_module_t *mod; | |
35 | |
36 if ((mod = aim__findmodulebygroup(sess, sg->group))) { | |
37 aimbs_put16(&fr->data, mod->family); | |
38 aimbs_put16(&fr->data, mod->version); | |
39 aimbs_put16(&fr->data, mod->toolid); | |
40 aimbs_put16(&fr->data, mod->toolversion); | |
41 } else | |
42 faimdprintf(sess, 1, "aim_clientready: server supports group 0x%04x but we don't!\n", sg->group); | |
43 } | |
44 | |
45 aim_tx_enqueue(sess, fr); | |
46 | |
47 return 0; | |
48 } | |
49 | |
50 /* | |
3952 | 51 * Subtype 0x0003 - Host Online |
2703 | 52 * |
53 * See comments in conn.c about how the group associations are supposed | |
54 * to work, and how they really work. | |
55 * | |
56 * This info probably doesn't even need to make it to the client. | |
57 * | |
58 * We don't actually call the client here. This starts off the connection | |
59 * initialization routine required by all AIM connections. The next time | |
60 * the client is called is the CONNINITDONE callback, which should be | |
61 * shortly after the rate information is acknowledged. | |
62 * | |
63 */ | |
64 static int hostonline(aim_session_t *sess, aim_module_t *mod, aim_frame_t *rx, aim_modsnac_t *snac, aim_bstream_t *bs) | |
65 { | |
66 fu16_t *families; | |
67 int famcount; | |
68 | |
69 | |
70 if (!(families = malloc(aim_bstream_empty(bs)))) | |
71 return 0; | |
72 | |
73 for (famcount = 0; aim_bstream_empty(bs); famcount++) { | |
74 families[famcount] = aimbs_get16(bs); | |
75 aim_conn_addgroup(rx->conn, families[famcount]); | |
76 } | |
77 | |
78 free(families); | |
79 | |
80 | |
81 /* | |
82 * Next step is in the Host Versions handler. | |
83 * | |
84 * Note that we must send this before we request rates, since | |
85 * the format of the rate information depends on the versions we | |
86 * give it. | |
87 * | |
88 */ | |
89 aim_setversions(sess, rx->conn); | |
90 | |
91 return 1; | |
92 } | |
93 | |
3952 | 94 /* Subtype 0x0004 - Service request */ |
2703 | 95 faim_export int aim_reqservice(aim_session_t *sess, aim_conn_t *conn, fu16_t serviceid) |
96 { | |
97 return aim_genericreq_s(sess, conn, 0x0001, 0x0004, &serviceid); | |
98 } | |
99 | |
3952 | 100 /* Subtype 0x0005 - Redirect */ |
2703 | 101 static int redirect(aim_session_t *sess, aim_module_t *mod, aim_frame_t *rx, aim_modsnac_t *snac, aim_bstream_t *bs) |
102 { | |
2821
9467e4ee81be
[gaim-migrate @ 2834]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2734
diff
changeset
|
103 struct aim_redirect_data redir; |
2703 | 104 aim_rxcallback_t userfunc; |
105 aim_tlvlist_t *tlvlist; | |
2821
9467e4ee81be
[gaim-migrate @ 2834]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2734
diff
changeset
|
106 aim_snac_t *origsnac = NULL; |
2703 | 107 int ret = 0; |
108 | |
2821
9467e4ee81be
[gaim-migrate @ 2834]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2734
diff
changeset
|
109 memset(&redir, 0, sizeof(redir)); |
9467e4ee81be
[gaim-migrate @ 2834]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2734
diff
changeset
|
110 |
7167 | 111 tlvlist = aim_tlvlist_read(bs); |
2703 | 112 |
7167 | 113 if (!aim_tlv_gettlv(tlvlist, 0x000d, 1) || |
114 !aim_tlv_gettlv(tlvlist, 0x0005, 1) || | |
115 !aim_tlv_gettlv(tlvlist, 0x0006, 1)) { | |
116 aim_tlvlist_free(&tlvlist); | |
2703 | 117 return 0; |
118 } | |
119 | |
7167 | 120 redir.group = aim_tlv_get16(tlvlist, 0x000d, 1); |
121 redir.ip = aim_tlv_getstr(tlvlist, 0x0005, 1); | |
122 redir.cookielen = aim_tlv_gettlv(tlvlist, 0x0006, 1)->length; | |
123 redir.cookie = aim_tlv_getstr(tlvlist, 0x0006, 1); | |
2821
9467e4ee81be
[gaim-migrate @ 2834]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2734
diff
changeset
|
124 |
9467e4ee81be
[gaim-migrate @ 2834]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2734
diff
changeset
|
125 /* Fetch original SNAC so we can get csi if needed */ |
9467e4ee81be
[gaim-migrate @ 2834]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2734
diff
changeset
|
126 origsnac = aim_remsnac(sess, snac->id); |
2703 | 127 |
2821
9467e4ee81be
[gaim-migrate @ 2834]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2734
diff
changeset
|
128 if ((redir.group == AIM_CONN_TYPE_CHAT) && origsnac) { |
9467e4ee81be
[gaim-migrate @ 2834]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2734
diff
changeset
|
129 struct chatsnacinfo *csi = (struct chatsnacinfo *)origsnac->data; |
9467e4ee81be
[gaim-migrate @ 2834]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2734
diff
changeset
|
130 |
9467e4ee81be
[gaim-migrate @ 2834]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2734
diff
changeset
|
131 redir.chat.exchange = csi->exchange; |
9467e4ee81be
[gaim-migrate @ 2834]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2734
diff
changeset
|
132 redir.chat.room = csi->name; |
9467e4ee81be
[gaim-migrate @ 2834]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2734
diff
changeset
|
133 redir.chat.instance = csi->instance; |
2703 | 134 } |
135 | |
136 if ((userfunc = aim_callhandler(sess, rx->conn, snac->family, snac->subtype))) | |
2821
9467e4ee81be
[gaim-migrate @ 2834]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2734
diff
changeset
|
137 ret = userfunc(sess, rx, &redir); |
2703 | 138 |
2821
9467e4ee81be
[gaim-migrate @ 2834]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2734
diff
changeset
|
139 free((void *)redir.ip); |
9467e4ee81be
[gaim-migrate @ 2834]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2734
diff
changeset
|
140 free((void *)redir.cookie); |
9467e4ee81be
[gaim-migrate @ 2834]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2734
diff
changeset
|
141 |
9467e4ee81be
[gaim-migrate @ 2834]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2734
diff
changeset
|
142 if (origsnac) |
9467e4ee81be
[gaim-migrate @ 2834]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2734
diff
changeset
|
143 free(origsnac->data); |
9467e4ee81be
[gaim-migrate @ 2834]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2734
diff
changeset
|
144 free(origsnac); |
2703 | 145 |
7167 | 146 aim_tlvlist_free(&tlvlist); |
2703 | 147 |
148 return ret; | |
149 } | |
150 | |
3952 | 151 /* Subtype 0x0006 - Request Rate Information. */ |
2703 | 152 faim_internal int aim_reqrates(aim_session_t *sess, aim_conn_t *conn) |
153 { | |
7282 | 154 return aim_genericreq_n_snacid(sess, conn, 0x0001, 0x0006); |
2703 | 155 } |
156 | |
157 /* | |
158 * OSCAR defines several 'rate classes'. Each class has seperate | |
159 * rate limiting properties (limit level, alert level, disconnect | |
160 * level, etc), and a set of SNAC family/type pairs associated with | |
161 * it. The rate classes, their limiting properties, and the definitions | |
162 * of which SNACs are belong to which class, are defined in the | |
163 * Rate Response packet at login to each host. | |
164 * | |
165 * Logically, all rate offenses within one class count against further | |
166 * offenses for other SNACs in the same class (ie, sending messages | |
167 * too fast will limit the number of user info requests you can send, | |
168 * since those two SNACs are in the same rate class). | |
169 * | |
170 * Since the rate classes are defined dynamically at login, the values | |
171 * below may change. But they seem to be fairly constant. | |
172 * | |
173 * Currently, BOS defines five rate classes, with the commonly used | |
174 * members as follows... | |
175 * | |
176 * Rate class 0x0001: | |
177 * - Everything thats not in any of the other classes | |
178 * | |
179 * Rate class 0x0002: | |
180 * - Buddy list add/remove | |
181 * - Permit list add/remove | |
182 * - Deny list add/remove | |
183 * | |
184 * Rate class 0x0003: | |
185 * - User information requests | |
186 * - Outgoing ICBMs | |
187 * | |
188 * Rate class 0x0004: | |
189 * - A few unknowns: 2/9, 2/b, and f/2 | |
190 * | |
191 * Rate class 0x0005: | |
192 * - Chat room create | |
193 * - Outgoing chat ICBMs | |
194 * | |
195 * The only other thing of note is that class 5 (chat) has slightly looser | |
196 * limiting properties than class 3 (normal messages). But thats just a | |
197 * small bit of trivia for you. | |
198 * | |
199 * The last thing that needs to be learned about the rate limiting | |
200 * system is how the actual numbers relate to the passing of time. This | |
201 * seems to be a big mystery. | |
202 * | |
203 */ | |
204 | |
205 static void rc_addclass(struct rateclass **head, struct rateclass *inrc) | |
206 { | |
207 struct rateclass *rc, *rc2; | |
208 | |
209 if (!(rc = malloc(sizeof(struct rateclass)))) | |
210 return; | |
211 | |
212 memcpy(rc, inrc, sizeof(struct rateclass)); | |
213 rc->next = NULL; | |
214 | |
215 for (rc2 = *head; rc2 && rc2->next; rc2 = rc2->next) | |
216 ; | |
217 | |
218 if (!rc2) | |
219 *head = rc; | |
220 else | |
221 rc2->next = rc; | |
222 | |
223 return; | |
224 } | |
225 | |
226 static struct rateclass *rc_findclass(struct rateclass **head, fu16_t id) | |
227 { | |
228 struct rateclass *rc; | |
229 | |
230 for (rc = *head; rc; rc = rc->next) { | |
231 if (rc->classid == id) | |
232 return rc; | |
233 } | |
234 | |
235 return NULL; | |
236 } | |
237 | |
238 static void rc_addpair(struct rateclass *rc, fu16_t group, fu16_t type) | |
239 { | |
240 struct snacpair *sp, *sp2; | |
241 | |
242 if (!(sp = malloc(sizeof(struct snacpair)))) | |
243 return; | |
244 memset(sp, 0, sizeof(struct snacpair)); | |
245 | |
246 sp->group = group; | |
247 sp->subtype = type; | |
248 sp->next = NULL; | |
249 | |
250 for (sp2 = rc->members; sp2 && sp2->next; sp2 = sp2->next) | |
251 ; | |
252 | |
253 if (!sp2) | |
254 rc->members = sp; | |
255 else | |
256 sp2->next = sp; | |
257 | |
258 return; | |
259 } | |
260 | |
3952 | 261 /* Subtype 0x0007 - Rate Parameters */ |
2703 | 262 static int rateresp(aim_session_t *sess, aim_module_t *mod, aim_frame_t *rx, aim_modsnac_t *snac, aim_bstream_t *bs) |
263 { | |
264 aim_conn_inside_t *ins = (aim_conn_inside_t *)rx->conn->inside; | |
265 fu16_t numclasses, i; | |
266 aim_rxcallback_t userfunc; | |
267 | |
268 | |
269 /* | |
270 * First are the parameters for each rate class. | |
271 */ | |
272 numclasses = aimbs_get16(bs); | |
273 for (i = 0; i < numclasses; i++) { | |
274 struct rateclass rc; | |
275 | |
276 memset(&rc, 0, sizeof(struct rateclass)); | |
277 | |
278 rc.classid = aimbs_get16(bs); | |
279 rc.windowsize = aimbs_get32(bs); | |
280 rc.clear = aimbs_get32(bs); | |
281 rc.alert = aimbs_get32(bs); | |
282 rc.limit = aimbs_get32(bs); | |
283 rc.disconnect = aimbs_get32(bs); | |
284 rc.current = aimbs_get32(bs); | |
285 rc.max = aimbs_get32(bs); | |
286 | |
287 /* | |
288 * The server will send an extra five bytes of parameters | |
289 * depending on the version we advertised in 1/17. If we | |
290 * didn't send 1/17 (evil!), then this will crash and you | |
291 * die, as it will default to the old version but we have | |
292 * the new version hardcoded here. | |
293 */ | |
294 if (mod->version >= 3) | |
295 aimbs_getrawbuf(bs, rc.unknown, sizeof(rc.unknown)); | |
296 | |
2734
9fc65bb80596
[gaim-migrate @ 2747]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2703
diff
changeset
|
297 faimdprintf(sess, 1, "--- Adding rate class %d to connection type %d: window size = %ld, clear = %ld, alert = %ld, limit = %ld, disconnect = %ld, current = %ld, max = %ld\n", rx->conn->type, rc.classid, rc.windowsize, rc.clear, rc.alert, rc.limit, rc.disconnect, rc.current, rc.max); |
9fc65bb80596
[gaim-migrate @ 2747]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2703
diff
changeset
|
298 |
2703 | 299 rc_addclass(&ins->rates, &rc); |
300 } | |
301 | |
302 /* | |
303 * Then the members of each class. | |
304 */ | |
305 for (i = 0; i < numclasses; i++) { | |
306 fu16_t classid, count; | |
307 struct rateclass *rc; | |
308 int j; | |
309 | |
310 classid = aimbs_get16(bs); | |
311 count = aimbs_get16(bs); | |
312 | |
313 rc = rc_findclass(&ins->rates, classid); | |
314 | |
315 for (j = 0; j < count; j++) { | |
316 fu16_t group, subtype; | |
317 | |
318 group = aimbs_get16(bs); | |
319 subtype = aimbs_get16(bs); | |
320 | |
321 if (rc) | |
322 rc_addpair(rc, group, subtype); | |
323 } | |
324 } | |
325 | |
326 /* | |
327 * We don't pass the rate information up to the client, as it really | |
328 * doesn't care. The information is stored in the connection, however | |
329 * so that we can do more fun stuff later (not really). | |
330 */ | |
331 | |
332 /* | |
333 * Last step in the conn init procedure is to acknowledge that we | |
334 * agree to these draconian limitations. | |
335 */ | |
336 aim_rates_addparam(sess, rx->conn); | |
337 | |
338 /* | |
339 * Finally, tell the client it's ready to go... | |
340 */ | |
341 if ((userfunc = aim_callhandler(sess, rx->conn, AIM_CB_FAM_SPECIAL, AIM_CB_SPECIAL_CONNINITDONE))) | |
342 userfunc(sess, rx); | |
343 | |
344 | |
345 return 1; | |
346 } | |
347 | |
3952 | 348 /* Subtype 0x0008 - Add Rate Parameter */ |
2703 | 349 faim_internal int aim_rates_addparam(aim_session_t *sess, aim_conn_t *conn) |
350 { | |
351 aim_conn_inside_t *ins = (aim_conn_inside_t *)conn->inside; | |
352 aim_frame_t *fr; | |
353 aim_snacid_t snacid; | |
354 struct rateclass *rc; | |
355 | |
356 if (!(fr = aim_tx_new(sess, conn, AIM_FRAMETYPE_FLAP, 0x02, 512))) | |
357 return -ENOMEM; | |
358 | |
359 snacid = aim_cachesnac(sess, 0x0001, 0x0008, 0x0000, NULL, 0); | |
360 aim_putsnac(&fr->data, 0x0001, 0x0008, 0x0000, snacid); | |
361 | |
362 for (rc = ins->rates; rc; rc = rc->next) | |
363 aimbs_put16(&fr->data, rc->classid); | |
364 | |
365 aim_tx_enqueue(sess, fr); | |
366 | |
367 return 0; | |
368 } | |
369 | |
3952 | 370 /* Subtype 0x0009 - Delete Rate Parameter */ |
2703 | 371 faim_internal int aim_rates_delparam(aim_session_t *sess, aim_conn_t *conn) |
372 { | |
373 aim_conn_inside_t *ins = (aim_conn_inside_t *)conn->inside; | |
374 aim_frame_t *fr; | |
375 aim_snacid_t snacid; | |
376 struct rateclass *rc; | |
377 | |
378 if (!(fr = aim_tx_new(sess, conn, AIM_FRAMETYPE_FLAP, 0x02, 512))) | |
379 return -ENOMEM; | |
380 | |
381 snacid = aim_cachesnac(sess, 0x0001, 0x0009, 0x0000, NULL, 0); | |
382 aim_putsnac(&fr->data, 0x0001, 0x0009, 0x0000, snacid); | |
383 | |
384 for (rc = ins->rates; rc; rc = rc->next) | |
385 aimbs_put16(&fr->data, rc->classid); | |
386 | |
387 aim_tx_enqueue(sess, fr); | |
388 | |
389 return 0; | |
390 } | |
391 | |
3952 | 392 /* Subtype 0x000a - Rate Change */ |
2703 | 393 static int ratechange(aim_session_t *sess, aim_module_t *mod, aim_frame_t *rx, aim_modsnac_t *snac, aim_bstream_t *bs) |
394 { | |
4871 | 395 int ret = 0; |
2703 | 396 aim_rxcallback_t userfunc; |
397 fu16_t code, rateclass; | |
398 fu32_t currentavg, maxavg, windowsize, clear, alert, limit, disconnect; | |
399 | |
400 code = aimbs_get16(bs); | |
401 rateclass = aimbs_get16(bs); | |
402 | |
403 windowsize = aimbs_get32(bs); | |
404 clear = aimbs_get32(bs); | |
405 alert = aimbs_get32(bs); | |
406 limit = aimbs_get32(bs); | |
407 disconnect = aimbs_get32(bs); | |
408 currentavg = aimbs_get32(bs); | |
409 maxavg = aimbs_get32(bs); | |
410 | |
411 if ((userfunc = aim_callhandler(sess, rx->conn, snac->family, snac->subtype))) | |
4871 | 412 ret = userfunc(sess, rx, code, rateclass, windowsize, clear, alert, limit, disconnect, currentavg, maxavg); |
2703 | 413 |
4871 | 414 return ret; |
2703 | 415 } |
416 | |
417 /* | |
3952 | 418 * How Migrations work. |
2703 | 419 * |
420 * The server sends a Server Pause message, which the client should respond to | |
421 * with a Server Pause Ack, which contains the families it needs on this | |
422 * connection. The server will send a Migration Notice with an IP address, and | |
423 * then disconnect. Next the client should open the connection and send the | |
424 * cookie. Repeat the normal login process and pretend this never happened. | |
425 * | |
426 * The Server Pause contains no data. | |
427 * | |
428 */ | |
429 | |
3952 | 430 /* Subtype 0x000b - Service Pause */ |
2703 | 431 static int serverpause(aim_session_t *sess, aim_module_t *mod, aim_frame_t *rx, aim_modsnac_t *snac, aim_bstream_t *bs) |
432 { | |
4871 | 433 int ret = 0; |
2703 | 434 aim_rxcallback_t userfunc; |
435 | |
436 if ((userfunc = aim_callhandler(sess, rx->conn, snac->family, snac->subtype))) | |
4871 | 437 ret = userfunc(sess, rx); |
2703 | 438 |
4871 | 439 return ret; |
2703 | 440 } |
441 | |
442 /* | |
3952 | 443 * Subtype 0x000c - Service Pause Acknowledgement |
2703 | 444 * |
445 * It is rather important that aim_sendpauseack() gets called for the exact | |
446 * same connection that the Server Pause callback was called for, since | |
447 * libfaim extracts the data for the SNAC from the connection structure. | |
448 * | |
449 * Of course, if you don't do that, more bad things happen than just what | |
450 * libfaim can cause. | |
451 * | |
452 */ | |
453 faim_export int aim_sendpauseack(aim_session_t *sess, aim_conn_t *conn) | |
454 { | |
455 aim_frame_t *fr; | |
456 aim_snacid_t snacid; | |
457 aim_conn_inside_t *ins = (aim_conn_inside_t *)conn->inside; | |
458 struct snacgroup *sg; | |
459 | |
460 if (!(fr = aim_tx_new(sess, conn, AIM_FRAMETYPE_FLAP, 0x02, 1024))) | |
461 return -ENOMEM; | |
462 | |
463 snacid = aim_cachesnac(sess, 0x0001, 0x000c, 0x0000, NULL, 0); | |
464 aim_putsnac(&fr->data, 0x0001, 0x000c, 0x0000, snacid); | |
465 | |
466 /* | |
467 * This list should have all the groups that the original | |
468 * Host Online / Server Ready said this host supports. And | |
469 * we want them all back after the migration. | |
470 */ | |
471 for (sg = ins->groups; sg; sg = sg->next) | |
472 aimbs_put16(&fr->data, sg->group); | |
473 | |
474 aim_tx_enqueue(sess, fr); | |
475 | |
476 return 0; | |
477 } | |
478 | |
3952 | 479 /* Subtype 0x000d - Service Resume */ |
2703 | 480 static int serverresume(aim_session_t *sess, aim_module_t *mod, aim_frame_t *rx, aim_modsnac_t *snac, aim_bstream_t *bs) |
481 { | |
4871 | 482 int ret = 0; |
2703 | 483 aim_rxcallback_t userfunc; |
484 | |
485 if ((userfunc = aim_callhandler(sess, rx->conn, snac->family, snac->subtype))) | |
4871 | 486 ret = userfunc(sess, rx); |
2703 | 487 |
4871 | 488 return ret; |
2703 | 489 } |
490 | |
3952 | 491 /* Subtype 0x000e - Request self-info */ |
2703 | 492 faim_export int aim_reqpersonalinfo(aim_session_t *sess, aim_conn_t *conn) |
493 { | |
7282 | 494 return aim_genericreq_n_snacid(sess, conn, 0x0001, 0x000e); |
2703 | 495 } |
496 | |
3952 | 497 /* Subtype 0x000f - Self User Info */ |
2703 | 498 static int selfinfo(aim_session_t *sess, aim_module_t *mod, aim_frame_t *rx, aim_modsnac_t *snac, aim_bstream_t *bs) |
499 { | |
4871 | 500 int ret = 0; |
2703 | 501 aim_rxcallback_t userfunc; |
502 aim_userinfo_t userinfo; | |
503 | |
5836 | 504 aim_info_extract(sess, bs, &userinfo); |
2703 | 505 |
506 if ((userfunc = aim_callhandler(sess, rx->conn, snac->family, snac->subtype))) | |
4871 | 507 ret = userfunc(sess, rx, &userinfo); |
2703 | 508 |
5836 | 509 aim_info_free(&userinfo); |
510 | |
4871 | 511 return ret; |
2703 | 512 } |
513 | |
3952 | 514 /* Subtype 0x0010 - Evil Notification */ |
2703 | 515 static int evilnotify(aim_session_t *sess, aim_module_t *mod, aim_frame_t *rx, aim_modsnac_t *snac, aim_bstream_t *bs) |
516 { | |
4871 | 517 int ret = 0; |
2703 | 518 aim_rxcallback_t userfunc; |
519 fu16_t newevil; | |
520 aim_userinfo_t userinfo; | |
521 | |
522 memset(&userinfo, 0, sizeof(aim_userinfo_t)); | |
523 | |
524 newevil = aimbs_get16(bs); | |
525 | |
526 if (aim_bstream_empty(bs)) | |
5836 | 527 aim_info_extract(sess, bs, &userinfo); |
2703 | 528 |
529 if ((userfunc = aim_callhandler(sess, rx->conn, snac->family, snac->subtype))) | |
4871 | 530 ret = userfunc(sess, rx, newevil, &userinfo); |
2703 | 531 |
5836 | 532 aim_info_free(&userinfo); |
533 | |
4871 | 534 return ret; |
2703 | 535 } |
536 | |
537 /* | |
3952 | 538 * Subtype 0x0011 - Idle Notification |
2703 | 539 * |
540 * Should set your current idle time in seconds. Note that this should | |
541 * never be called consecutively with a non-zero idle time. That makes | |
542 * OSCAR do funny things. Instead, just set it once you go idle, and then | |
543 * call it again with zero when you're back. | |
544 * | |
545 */ | |
546 faim_export int aim_bos_setidle(aim_session_t *sess, aim_conn_t *conn, fu32_t idletime) | |
547 { | |
548 return aim_genericreq_l(sess, conn, 0x0001, 0x0011, &idletime); | |
549 } | |
550 | |
551 /* | |
3952 | 552 * Subtype 0x0012 - Service Migrate |
2703 | 553 * |
554 * This is the final SNAC sent on the original connection during a migration. | |
555 * It contains the IP and cookie used to connect to the new server, and | |
556 * optionally a list of the SNAC groups being migrated. | |
557 * | |
558 */ | |
559 static int migrate(aim_session_t *sess, aim_module_t *mod, aim_frame_t *rx, aim_modsnac_t *snac, aim_bstream_t *bs) | |
560 { | |
561 aim_rxcallback_t userfunc; | |
562 int ret = 0; | |
563 fu16_t groupcount, i; | |
564 aim_tlvlist_t *tl; | |
565 char *ip = NULL; | |
566 aim_tlv_t *cktlv; | |
567 | |
568 /* | |
569 * Apparently there's some fun stuff that can happen right here. The | |
570 * migration can actually be quite selective about what groups it | |
571 * moves to the new server. When not all the groups for a connection | |
572 * are migrated, or they are all migrated but some groups are moved | |
573 * to a different server than others, it is called a bifurcated | |
574 * migration. | |
575 * | |
576 * Let's play dumb and not support that. | |
577 * | |
578 */ | |
579 groupcount = aimbs_get16(bs); | |
580 for (i = 0; i < groupcount; i++) { | |
581 fu16_t group; | |
582 | |
583 group = aimbs_get16(bs); | |
584 | |
585 faimdprintf(sess, 0, "bifurcated migration unsupported -- group 0x%04x\n", group); | |
586 } | |
587 | |
7167 | 588 tl = aim_tlvlist_read(bs); |
2703 | 589 |
7167 | 590 if (aim_tlv_gettlv(tl, 0x0005, 1)) |
591 ip = aim_tlv_getstr(tl, 0x0005, 1); | |
2703 | 592 |
7167 | 593 cktlv = aim_tlv_gettlv(tl, 0x0006, 1); |
2703 | 594 |
595 if ((userfunc = aim_callhandler(sess, rx->conn, snac->family, snac->subtype))) | |
596 ret = userfunc(sess, rx, ip, cktlv ? cktlv->value : NULL); | |
597 | |
7167 | 598 aim_tlvlist_free(&tl); |
2703 | 599 free(ip); |
600 | |
601 return ret; | |
602 } | |
603 | |
3952 | 604 /* Subtype 0x0013 - Message of the Day */ |
2703 | 605 static int motd(aim_session_t *sess, aim_module_t *mod, aim_frame_t *rx, aim_modsnac_t *snac, aim_bstream_t *bs) |
606 { | |
607 aim_rxcallback_t userfunc; | |
608 char *msg = NULL; | |
609 int ret = 0; | |
610 aim_tlvlist_t *tlvlist; | |
611 fu16_t id; | |
612 | |
613 /* | |
614 * Code. | |
615 * | |
616 * Valid values: | |
617 * 1 Mandatory upgrade | |
618 * 2 Advisory upgrade | |
619 * 3 System bulletin | |
620 * 4 Nothing's wrong ("top o the world" -- normal) | |
621 * 5 Lets-break-something. | |
622 * | |
623 */ | |
624 id = aimbs_get16(bs); | |
625 | |
626 /* | |
627 * TLVs follow | |
628 */ | |
7167 | 629 tlvlist = aim_tlvlist_read(bs); |
2703 | 630 |
7167 | 631 msg = aim_tlv_getstr(tlvlist, 0x000b, 1); |
2703 | 632 |
633 if ((userfunc = aim_callhandler(sess, rx->conn, snac->family, snac->subtype))) | |
634 ret = userfunc(sess, rx, id, msg); | |
635 | |
636 free(msg); | |
637 | |
7167 | 638 aim_tlvlist_free(&tlvlist); |
2703 | 639 |
640 return ret; | |
641 } | |
642 | |
643 /* | |
3952 | 644 * Subtype 0x0014 - Set privacy flags |
2703 | 645 * |
646 * Normally 0x03. | |
647 * | |
648 * Bit 1: Allows other AIM users to see how long you've been idle. | |
649 * Bit 2: Allows other AIM users to see how long you've been a member. | |
650 * | |
651 */ | |
652 faim_export int aim_bos_setprivacyflags(aim_session_t *sess, aim_conn_t *conn, fu32_t flags) | |
653 { | |
654 return aim_genericreq_l(sess, conn, 0x0001, 0x0014, &flags); | |
655 } | |
656 | |
657 /* | |
3952 | 658 * Subtype 0x0016 - No-op |
2703 | 659 * |
660 * WinAIM sends these every 4min or so to keep the connection alive. Its not | |
3952 | 661 * really necessary. |
2703 | 662 * |
7282 | 663 * Wha? No? Since when? I think WinAIM sends an empty channel 3 |
664 * SNAC as a no-op... | |
2703 | 665 */ |
666 faim_export int aim_nop(aim_session_t *sess, aim_conn_t *conn) | |
667 { | |
668 return aim_genericreq_n(sess, conn, 0x0001, 0x0016); | |
669 } | |
670 | |
671 /* | |
3952 | 672 * Subtype 0x0017 - Set client versions |
2703 | 673 * |
674 * If you've seen the clientonline/clientready SNAC you're probably | |
675 * wondering what the point of this one is. And that point seems to be | |
676 * that the versions in the client online SNAC are sent too late for the | |
677 * server to be able to use them to change the protocol for the earlier | |
678 * login packets (client versions are sent right after Host Online is | |
679 * received, but client online versions aren't sent until quite a bit later). | |
680 * We can see them already making use of this by changing the format of | |
681 * the rate information based on what version of group 1 we advertise here. | |
682 * | |
683 */ | |
684 faim_internal int aim_setversions(aim_session_t *sess, aim_conn_t *conn) | |
685 { | |
686 aim_conn_inside_t *ins = (aim_conn_inside_t *)conn->inside; | |
687 struct snacgroup *sg; | |
688 aim_frame_t *fr; | |
689 aim_snacid_t snacid; | |
690 | |
691 if (!ins) | |
692 return -EINVAL; | |
693 | |
694 if (!(fr = aim_tx_new(sess, conn, AIM_FRAMETYPE_FLAP, 0x02, 1152))) | |
695 return -ENOMEM; | |
696 | |
697 snacid = aim_cachesnac(sess, 0x0001, 0x0017, 0x0000, NULL, 0); | |
698 aim_putsnac(&fr->data, 0x0001, 0x0017, 0x0000, snacid); | |
699 | |
700 /* | |
701 * Send only the versions that the server cares about (that it | |
702 * marked as supporting in the server ready SNAC). | |
703 */ | |
704 for (sg = ins->groups; sg; sg = sg->next) { | |
705 aim_module_t *mod; | |
706 | |
707 if ((mod = aim__findmodulebygroup(sess, sg->group))) { | |
708 aimbs_put16(&fr->data, mod->family); | |
709 aimbs_put16(&fr->data, mod->version); | |
710 } else | |
711 faimdprintf(sess, 1, "aim_setversions: server supports group 0x%04x but we don't!\n", sg->group); | |
712 } | |
713 | |
714 aim_tx_enqueue(sess, fr); | |
715 | |
716 return 0; | |
717 } | |
718 | |
3952 | 719 /* Subtype 0x0018 - Host versions */ |
2703 | 720 static int hostversions(aim_session_t *sess, aim_module_t *mod, aim_frame_t *rx, aim_modsnac_t *snac, aim_bstream_t *bs) |
721 { | |
722 int vercount; | |
723 fu8_t *versions; | |
724 | |
725 /* This is frivolous. (Thank you SmarterChild.) */ | |
726 vercount = aim_bstream_empty(bs)/4; | |
727 versions = aimbs_getraw(bs, aim_bstream_empty(bs)); | |
728 free(versions); | |
729 | |
730 /* | |
731 * Now request rates. | |
732 */ | |
733 aim_reqrates(sess, rx->conn); | |
734 | |
735 return 1; | |
736 } | |
737 | |
738 /* | |
5917 | 739 * Subtype 0x001e - Extended Status |
2703 | 740 * |
5917 | 741 * Sets your ICQ status (available, away, do not disturb, etc.) |
2703 | 742 * |
4342 | 743 * These are the same TLVs seen in user info. You can |
744 * also set 0x0008 and 0x000c. | |
2703 | 745 */ |
4901 | 746 faim_export int aim_setextstatus(aim_session_t *sess, fu32_t status) |
2703 | 747 { |
4901 | 748 aim_conn_t *conn; |
2703 | 749 aim_frame_t *fr; |
750 aim_snacid_t snacid; | |
751 aim_tlvlist_t *tl = NULL; | |
752 fu32_t data; | |
753 | |
4901 | 754 if (!sess || !(conn = aim_conn_findbygroup(sess, 0x0004))) |
755 return -EINVAL; | |
756 | |
4342 | 757 data = AIM_ICQ_STATE_HIDEIP | AIM_ICQ_STATE_WEBAWARE | status; /* yay for error checking ;^) */ |
2703 | 758 |
759 if (!(fr = aim_tx_new(sess, conn, AIM_FRAMETYPE_FLAP, 0x02, 10 + 8))) | |
760 return -ENOMEM; | |
761 | |
762 snacid = aim_cachesnac(sess, 0x0001, 0x001e, 0x0000, NULL, 0); | |
763 aim_putsnac(&fr->data, 0x0001, 0x001e, 0x0000, snacid); | |
764 | |
7167 | 765 aim_tlvlist_add_32(&tl, 0x0006, data); |
766 aim_tlvlist_write(&fr->data, &tl); | |
767 aim_tlvlist_free(&tl); | |
2703 | 768 |
769 aim_tx_enqueue(sess, fr); | |
770 | |
771 return 0; | |
772 } | |
773 | |
5917 | 774 /* |
775 * Subtype 0x001e - Extended Status. | |
776 * | |
777 * Sets your "available" message. This is currently only supported by iChat | |
778 * and Gaim. | |
779 * | |
780 * These are the same TLVs seen in user info. You can | |
781 * also set 0x0008 and 0x000c. | |
782 */ | |
783 faim_export int aim_srv_setavailmsg(aim_session_t *sess, char *msg) | |
784 { | |
785 aim_conn_t *conn; | |
786 aim_frame_t *fr; | |
787 aim_snacid_t snacid; | |
788 | |
789 if (!sess || !(conn = aim_conn_findbygroup(sess, 0x0001))) | |
790 return -EINVAL; | |
791 | |
7141 | 792 if (msg != NULL) { |
5948 | 793 if (!(fr = aim_tx_new(sess, conn, AIM_FRAMETYPE_FLAP, 0x02, 10 + 4 + strlen(msg) + 8))) |
5917 | 794 return -ENOMEM; |
795 | |
796 snacid = aim_cachesnac(sess, 0x0001, 0x001e, 0x0000, NULL, 0); | |
797 aim_putsnac(&fr->data, 0x0001, 0x001e, 0x0000, snacid); | |
798 | |
7141 | 799 aimbs_put16(&fr->data, 0x001d); /* userinfo TLV type */ |
800 aimbs_put16(&fr->data, strlen(msg)+8); /* total length of userinfo TLV data */ | |
5948 | 801 aimbs_put16(&fr->data, 0x0002); |
802 aimbs_put8(&fr->data, 0x04); | |
803 aimbs_put8(&fr->data, strlen(msg)+4); | |
804 aimbs_put16(&fr->data, strlen(msg)); | |
5917 | 805 aimbs_putraw(&fr->data, msg, strlen(msg)); |
806 aimbs_put16(&fr->data, 0x0000); | |
807 } else { | |
808 if (!(fr = aim_tx_new(sess, conn, AIM_FRAMETYPE_FLAP, 0x02, 10 + 4 + 8))) | |
809 return -ENOMEM; | |
810 | |
811 snacid = aim_cachesnac(sess, 0x0001, 0x001e, 0x0000, NULL, 0); | |
812 aim_putsnac(&fr->data, 0x0001, 0x001e, 0x0000, snacid); | |
813 | |
814 aimbs_put16(&fr->data, 0x001d); | |
815 aimbs_put16(&fr->data, 0x0008); | |
816 aimbs_put16(&fr->data, 0x0002); | |
817 aimbs_put16(&fr->data, 0x0404); | |
818 aimbs_put16(&fr->data, 0x0000); | |
819 aimbs_put16(&fr->data, 0x0000); | |
820 } | |
821 | |
822 aim_tx_enqueue(sess, fr); | |
823 | |
824 return 0; | |
825 } | |
826 | |
2703 | 827 /* |
828 * Starting this past week (26 Mar 2001, say), AOL has started sending | |
829 * this nice little extra SNAC. AFAIK, it has never been used until now. | |
830 * | |
831 * The request contains eight bytes. The first four are an offset, the | |
832 * second four are a length. | |
833 * | |
834 * The offset is an offset into aim.exe when it is mapped during execution | |
835 * on Win32. So far, AOL has only been requesting bytes in static regions | |
836 * of memory. (I won't put it past them to start requesting data in | |
837 * less static regions -- regions that are initialized at run time, but still | |
838 * before the client recieves this request.) | |
839 * | |
840 * When the client recieves the request, it adds it to the current ds | |
841 * (0x00400000) and dereferences it, copying the data into a buffer which | |
842 * it then runs directly through the MD5 hasher. The 16 byte output of | |
843 * the hash is then sent back to the server. | |
844 * | |
845 * If the client does not send any data back, or the data does not match | |
846 * the data that the specific client should have, the client will get the | |
847 * following message from "AOL Instant Messenger": | |
848 * "You have been disconnected from the AOL Instant Message Service (SM) | |
849 * for accessing the AOL network using unauthorized software. You can | |
850 * download a FREE, fully featured, and authorized client, here | |
851 * http://www.aol.com/aim/download2.html" | |
852 * The connection is then closed, recieving disconnect code 1, URL | |
853 * http://www.aim.aol.com/errors/USER_LOGGED_OFF_NEW_LOGIN.html. | |
854 * | |
855 * Note, however, that numerous inconsistencies can cause the above error, | |
856 * not just sending back a bad hash. Do not immediatly suspect this code | |
857 * if you get disconnected. AOL and the open/free software community have | |
858 * played this game for a couple years now, generating the above message | |
859 * on numerous ocassions. | |
860 * | |
861 * Anyway, neener. We win again. | |
862 * | |
863 */ | |
3952 | 864 /* Subtype 0x001f - Client verification */ |
2703 | 865 static int memrequest(aim_session_t *sess, aim_module_t *mod, aim_frame_t *rx, aim_modsnac_t *snac, aim_bstream_t *bs) |
866 { | |
4871 | 867 int ret = 0; |
2703 | 868 aim_rxcallback_t userfunc; |
869 fu32_t offset, len; | |
870 aim_tlvlist_t *list; | |
871 char *modname; | |
872 | |
873 offset = aimbs_get32(bs); | |
874 len = aimbs_get32(bs); | |
7167 | 875 list = aim_tlvlist_read(bs); |
2703 | 876 |
7167 | 877 modname = aim_tlv_getstr(list, 0x0001, 1); |
2703 | 878 |
879 faimdprintf(sess, 1, "data at 0x%08lx (%d bytes) of requested\n", offset, len, modname ? modname : "aim.exe"); | |
880 | |
881 if ((userfunc = aim_callhandler(sess, rx->conn, snac->family, snac->subtype))) | |
4871 | 882 ret = userfunc(sess, rx, offset, len, modname); |
2703 | 883 |
884 free(modname); | |
7167 | 885 aim_tlvlist_free(&list); |
2703 | 886 |
4871 | 887 return ret; |
2703 | 888 } |
889 | |
890 #if 0 | |
891 static void dumpbox(aim_session_t *sess, unsigned char *buf, int len) | |
892 { | |
893 int i; | |
894 | |
895 if (!sess || !buf || !len) | |
896 return; | |
897 | |
898 faimdprintf(sess, 1, "\nDump of %d bytes at %p:", len, buf); | |
899 | |
900 for (i = 0; i < len; i++) { | |
901 if ((i % 8) == 0) | |
902 faimdprintf(sess, 1, "\n\t"); | |
903 | |
904 faimdprintf(sess, 1, "0x%2x ", buf[i]); | |
905 } | |
906 | |
907 faimdprintf(sess, 1, "\n\n"); | |
908 | |
909 return; | |
910 } | |
911 #endif | |
912 | |
3952 | 913 /* Subtype 0x0020 - Client verification reply */ |
2703 | 914 faim_export int aim_sendmemblock(aim_session_t *sess, aim_conn_t *conn, fu32_t offset, fu32_t len, const fu8_t *buf, fu8_t flag) |
915 { | |
916 aim_frame_t *fr; | |
917 aim_snacid_t snacid; | |
918 | |
919 if (!sess || !conn) | |
920 return -EINVAL; | |
921 | |
922 if (!(fr = aim_tx_new(sess, conn, AIM_FRAMETYPE_FLAP, 0x02, 10+2+16))) | |
923 return -ENOMEM; | |
924 | |
925 snacid = aim_cachesnac(sess, 0x0001, 0x0020, 0x0000, NULL, 0); | |
926 | |
927 aim_putsnac(&fr->data, 0x0001, 0x0020, 0x0000, snacid); | |
928 aimbs_put16(&fr->data, 0x0010); /* md5 is always 16 bytes */ | |
929 | |
930 if ((flag == AIM_SENDMEMBLOCK_FLAG_ISHASH) && buf && (len == 0x10)) { /* we're getting a hash */ | |
931 | |
932 aimbs_putraw(&fr->data, buf, 0x10); | |
933 | |
934 } else if (buf && (len > 0)) { /* use input buffer */ | |
935 md5_state_t state; | |
936 md5_byte_t digest[0x10]; | |
937 | |
938 md5_init(&state); | |
939 md5_append(&state, (const md5_byte_t *)buf, len); | |
940 md5_finish(&state, digest); | |
941 | |
942 aimbs_putraw(&fr->data, (fu8_t *)digest, 0x10); | |
943 | |
944 } else if (len == 0) { /* no length, just hash NULL (buf is optional) */ | |
945 md5_state_t state; | |
946 fu8_t nil = '\0'; | |
947 md5_byte_t digest[0x10]; | |
948 | |
949 /* | |
950 * These MD5 routines are stupid in that you have to have | |
951 * at least one append. So thats why this doesn't look | |
952 * real logical. | |
953 */ | |
954 md5_init(&state); | |
955 md5_append(&state, (const md5_byte_t *)&nil, 0); | |
956 md5_finish(&state, digest); | |
957 | |
958 aimbs_putraw(&fr->data, (fu8_t *)digest, 0x10); | |
959 | |
960 } else { | |
961 | |
962 /* | |
963 * This data is correct for AIM 3.5.1670. | |
964 * | |
965 * Using these blocks is as close to "legal" as you can get | |
966 * without using an AIM binary. | |
967 * | |
968 */ | |
969 if ((offset == 0x03ffffff) && (len == 0x03ffffff)) { | |
970 | |
971 #if 1 /* with "AnrbnrAqhfzcd" */ | |
972 aimbs_put32(&fr->data, 0x44a95d26); | |
973 aimbs_put32(&fr->data, 0xd2490423); | |
974 aimbs_put32(&fr->data, 0x93b8821f); | |
975 aimbs_put32(&fr->data, 0x51c54b01); | |
976 #else /* no filename */ | |
977 aimbs_put32(&fr->data, 0x1df8cbae); | |
978 aimbs_put32(&fr->data, 0x5523b839); | |
979 aimbs_put32(&fr->data, 0xa0e10db3); | |
980 aimbs_put32(&fr->data, 0xa46d3b39); | |
981 #endif | |
982 | |
983 } else if ((offset == 0x00001000) && (len == 0x00000000)) { | |
984 | |
985 aimbs_put32(&fr->data, 0xd41d8cd9); | |
986 aimbs_put32(&fr->data, 0x8f00b204); | |
987 aimbs_put32(&fr->data, 0xe9800998); | |
988 aimbs_put32(&fr->data, 0xecf8427e); | |
989 | |
990 } else | |
991 faimdprintf(sess, 0, "sendmemblock: WARNING: unknown hash request\n"); | |
992 | |
993 } | |
994 | |
995 aim_tx_enqueue(sess, fr); | |
996 | |
997 return 0; | |
998 } | |
999 | |
5836 | 1000 /* |
1001 * Subtype 0x0021 - Receive our extended status | |
1002 * | |
5892 | 1003 * This is used for iChat's "available" messages, and maybe ICQ extended |
1004 * status messages? It's also used to tell the client whether or not it | |
1005 * needs to upload an SSI buddy icon... who engineers this stuff, anyway? | |
5836 | 1006 */ |
1007 static int aim_parse_extstatus(aim_session_t *sess, aim_module_t *mod, aim_frame_t *rx, aim_modsnac_t *snac, aim_bstream_t *bs) | |
1008 { | |
5892 | 1009 int ret = 0; |
5836 | 1010 aim_rxcallback_t userfunc; |
5837 | 1011 fu16_t type; |
5892 | 1012 fu8_t flags, length; |
5836 | 1013 |
5842 | 1014 type = aimbs_get16(bs); |
5892 | 1015 flags = aimbs_get8(bs); |
1016 length = aimbs_get8(bs); | |
1017 | |
5842 | 1018 if ((userfunc = aim_callhandler(sess, rx->conn, snac->family, snac->subtype))) { |
1019 switch (type) { | |
5892 | 1020 case 0x0000: |
6101 | 1021 case 0x0001: { /* buddy icon checksum */ |
1022 /* not sure what the difference between 1 and 0 is */ | |
5892 | 1023 fu8_t *md5 = aimbs_getraw(bs, length); |
1024 ret = userfunc(sess, rx, type, flags, length, md5); | |
5842 | 1025 free(md5); |
5892 | 1026 } break; |
6101 | 1027 case 0x0002: { /* available message */ |
5892 | 1028 /* there is a second length that is just for the message */ |
1029 char *msg = aimbs_getstr(bs, aimbs_get16(bs)); | |
5842 | 1030 ret = userfunc(sess, rx, msg); |
1031 free(msg); | |
5892 | 1032 } break; |
5842 | 1033 } |
5871 | 1034 } |
5917 | 1035 |
1036 return ret; | |
5836 | 1037 } |
1038 | |
2703 | 1039 static int snachandler(aim_session_t *sess, aim_module_t *mod, aim_frame_t *rx, aim_modsnac_t *snac, aim_bstream_t *bs) |
1040 { | |
1041 | |
1042 if (snac->subtype == 0x0003) | |
1043 return hostonline(sess, mod, rx, snac, bs); | |
1044 else if (snac->subtype == 0x0005) | |
1045 return redirect(sess, mod, rx, snac, bs); | |
1046 else if (snac->subtype == 0x0007) | |
1047 return rateresp(sess, mod, rx, snac, bs); | |
1048 else if (snac->subtype == 0x000a) | |
1049 return ratechange(sess, mod, rx, snac, bs); | |
1050 else if (snac->subtype == 0x000b) | |
1051 return serverpause(sess, mod, rx, snac, bs); | |
1052 else if (snac->subtype == 0x000d) | |
1053 return serverresume(sess, mod, rx, snac, bs); | |
1054 else if (snac->subtype == 0x000f) | |
1055 return selfinfo(sess, mod, rx, snac, bs); | |
1056 else if (snac->subtype == 0x0010) | |
1057 return evilnotify(sess, mod, rx, snac, bs); | |
1058 else if (snac->subtype == 0x0012) | |
1059 return migrate(sess, mod, rx, snac, bs); | |
1060 else if (snac->subtype == 0x0013) | |
1061 return motd(sess, mod, rx, snac, bs); | |
1062 else if (snac->subtype == 0x0018) | |
1063 return hostversions(sess, mod, rx, snac, bs); | |
1064 else if (snac->subtype == 0x001f) | |
1065 return memrequest(sess, mod, rx, snac, bs); | |
5836 | 1066 else if (snac->subtype == 0x0021) |
1067 return aim_parse_extstatus(sess, mod, rx, snac, bs); | |
2703 | 1068 |
1069 return 0; | |
1070 } | |
1071 | |
1072 faim_internal int general_modfirst(aim_session_t *sess, aim_module_t *mod) | |
1073 { | |
1074 | |
1075 mod->family = 0x0001; | |
1076 mod->version = 0x0003; | |
1077 mod->toolid = 0x0110; | |
4071 | 1078 mod->toolversion = 0x0629; |
2703 | 1079 mod->flags = 0; |
1080 strncpy(mod->name, "general", sizeof(mod->name)); | |
1081 mod->snachandler = snachandler; | |
1082 | |
1083 return 0; | |
1084 } |