2672
|
1 /*
|
|
2 * Server-Side/Stored Information.
|
|
3 *
|
|
4 * Relatively new facility that allows storing of certain types of information,
|
|
5 * such as a users buddy list, permit/deny list, and permit/deny preferences,
|
|
6 * to be stored on the server, so that they can be accessed from any client.
|
|
7 *
|
|
8 * This is entirely too complicated.
|
2991
|
9 * You don't know the half of it.
|
|
10 *
|
|
11 * XXX - Make sure moving buddies from group to group moves the buddy in the server list also
|
|
12 * XXX - Test for memory leaks
|
|
13 * XXX - Better parsing of rights, and use the rights info to limit adds
|
2672
|
14 *
|
|
15 */
|
|
16
|
|
17 #define FAIM_INTERNAL
|
|
18 #include <aim.h>
|
|
19
|
|
20 /*
|
2991
|
21 * Checks if the given screen name is anywhere in our buddy list.
|
|
22 */
|
|
23 faim_export int aim_ssi_inlist(aim_session_t *sess, aim_conn_t *conn, char *name, fu16_t type)
|
|
24 {
|
|
25 struct aim_ssi_item *cur;
|
3017
|
26 if (!sess && !conn && !name)
|
|
27 return -EINVAL;
|
2991
|
28 for (cur=sess->ssi.items; cur; cur=cur->next)
|
|
29 if ((cur->type==type) && (cur->name) && (!aim_sncmp(cur->name, name)))
|
|
30 return 1;
|
|
31 return 0;
|
|
32 }
|
|
33
|
|
34 /*
|
3017
|
35 * Return the parent group of a given buddy.
|
|
36 */
|
|
37 faim_export char *aim_ssi_getparentgroup(aim_session_t *sess, aim_conn_t *conn, char *name)
|
|
38 {
|
|
39 fu16_t gid;
|
|
40 struct aim_ssi_item *cur;
|
|
41 if (!sess && !conn && !name)
|
|
42 return NULL;
|
|
43 for (cur=sess->ssi.items; cur && (cur->type!=AIM_SSI_TYPE_BUDDY || !cur->name || aim_sncmp(cur->name, name)); cur=cur->next)
|
|
44 if (!cur)
|
|
45 return NULL;
|
|
46 gid = cur->gid;
|
|
47 for (cur=sess->ssi.items; cur; cur=cur->next)
|
|
48 if ((cur->type == AIM_SSI_TYPE_GROUP) && (cur->gid == gid) && (cur->name))
|
|
49 return cur->name;
|
|
50 return 0;
|
|
51 }
|
|
52
|
|
53 /*
|
2991
|
54 * Returns a pointer to an item with the given name and type, or NULL if one does not exist.
|
|
55 */
|
|
56 static struct aim_ssi_item *get_ssi_item(struct aim_ssi_item *items, char *name, fu16_t type)
|
|
57 {
|
|
58 struct aim_ssi_item *cur;
|
|
59 if (name) {
|
|
60 for (cur=items; cur; cur=cur->next)
|
|
61 if ((cur->type == type) && (cur->name) && !(aim_sncmp(cur->name, name)))
|
|
62 return cur;
|
3109
|
63 } else { /* return the given type with gid 0 */
|
2991
|
64 for (cur=items; cur; cur=cur->next)
|
|
65 if ((cur->type == type) && (cur->gid == 0x0000))
|
|
66 return cur;
|
|
67 }
|
|
68 return NULL;
|
|
69 }
|
|
70
|
|
71 /*
|
3109
|
72 * Returns the permit/deny byte
|
|
73 */
|
|
74 faim_export int aim_ssi_getpermdeny(aim_session_t *sess, aim_conn_t *conn)
|
|
75 {
|
|
76 struct aim_ssi_item *cur = get_ssi_item(sess->ssi.items, NULL, AIM_SSI_TYPE_PDINFO);
|
|
77 if (cur) {
|
|
78 aim_tlvlist_t *tlvlist = cur->data;
|
|
79 if (tlvlist) {
|
|
80 aim_tlv_t *tlv = aim_gettlv(tlvlist, 0x00ca, 1);
|
|
81 if (tlv && tlv->value)
|
|
82 return aimutil_get8(tlv->value);
|
|
83 }
|
|
84 }
|
|
85
|
|
86 return 0;
|
|
87 }
|
|
88
|
|
89 /*
|
|
90 * Returns the presence flag
|
|
91 * I'm pretty sure this is a bitmask, but really have no evidence for that.
|
|
92 * 0x00000400 - Show up as visible to others
|
|
93 */
|
|
94 faim_export fu32_t aim_ssi_getpresence(aim_session_t *sess, aim_conn_t *conn)
|
|
95 {
|
|
96 struct aim_ssi_item *cur = get_ssi_item(sess->ssi.items, NULL, AIM_SSI_TYPE_PRESENCEPREFS);
|
|
97 if (cur) {
|
|
98 aim_tlvlist_t *tlvlist = cur->data;
|
|
99 if (tlvlist) {
|
|
100 aim_tlv_t *tlv = aim_gettlv(tlvlist, 0x00c9, 1);
|
|
101 if (tlv && tlv->length)
|
|
102 return aimutil_get32(tlv->value);
|
|
103 }
|
|
104 }
|
|
105
|
|
106 return 0xFFFFFFFF;
|
|
107 }
|
|
108
|
|
109 /*
|
2991
|
110 * Add the given packet to the holding queue.
|
|
111 */
|
|
112 static int aim_ssi_enqueue(aim_session_t *sess, aim_conn_t *conn, aim_frame_t *fr)
|
|
113 {
|
|
114 aim_frame_t *cur;
|
|
115
|
|
116 if (!sess || !conn || !fr)
|
|
117 return -EINVAL;
|
|
118
|
|
119 fr->next = NULL;
|
|
120 if (sess->ssi.holding_queue == NULL) {
|
|
121 sess->ssi.holding_queue = fr;
|
|
122 if (!sess->ssi.waiting_for_ack)
|
|
123 aim_ssi_modbegin(sess, conn);
|
|
124 } else {
|
|
125 for (cur = sess->ssi.holding_queue; cur->next; cur = cur->next) ;
|
|
126 cur->next = fr;
|
|
127 }
|
|
128
|
|
129 return 0;
|
|
130 }
|
|
131
|
|
132 /*
|
|
133 * Send the next SNAC from the holding queue.
|
|
134 */
|
|
135 static int aim_ssi_dispatch(aim_session_t *sess, aim_conn_t *conn)
|
|
136 {
|
|
137 aim_frame_t *cur;
|
|
138
|
|
139 if (!sess || !conn)
|
|
140 return -EINVAL;
|
|
141
|
|
142 if (!sess->ssi.waiting_for_ack) {
|
|
143 if (sess->ssi.holding_queue) {
|
|
144 sess->ssi.waiting_for_ack = 1;
|
|
145 cur = sess->ssi.holding_queue->next;
|
|
146 sess->ssi.holding_queue->next = NULL;
|
|
147 aim_tx_enqueue(sess, sess->ssi.holding_queue);
|
|
148 sess->ssi.holding_queue = cur;
|
|
149 } else
|
|
150 aim_ssi_modend(sess, conn);
|
|
151 }
|
|
152
|
|
153 return 0;
|
|
154 }
|
|
155
|
|
156 /*
|
|
157 * Rebuild the additional data for the given group(s).
|
|
158 */
|
|
159 static int aim_ssi_rebuildgroup(aim_session_t *sess, aim_conn_t *conn, struct aim_ssi_item *parentgroup)
|
|
160 {
|
|
161 int newlen;
|
|
162 struct aim_ssi_item *cur;
|
|
163
|
|
164 if (!sess || !conn || !parentgroup)
|
|
165 return -EINVAL;
|
|
166
|
|
167 /* Free the old additional data */
|
|
168 if (parentgroup->data) {
|
|
169 aim_freetlvchain((aim_tlvlist_t **)&parentgroup->data);
|
|
170 parentgroup->data = NULL;
|
|
171 }
|
|
172
|
|
173 /* Find the length for the new additional data */
|
|
174 newlen = 0;
|
|
175 if (parentgroup->gid == 0x0000) {
|
|
176 for (cur=sess->ssi.items; cur; cur=cur->next)
|
3017
|
177 if ((cur->gid != 0x0000) && (cur->type == AIM_SSI_TYPE_GROUP))
|
2991
|
178 newlen += 2;
|
|
179 } else {
|
|
180 for (cur=sess->ssi.items; cur; cur=cur->next)
|
3017
|
181 if ((cur->gid == parentgroup->gid) && (cur->type == AIM_SSI_TYPE_BUDDY))
|
2991
|
182 newlen += 2;
|
|
183 }
|
|
184
|
|
185 /* Rebuild the additional data */
|
|
186 if (newlen>0) {
|
|
187 aim_bstream_t tbs;
|
|
188 tbs.len = newlen+4;
|
|
189 tbs.offset = 0;
|
|
190 if (!(tbs.data = (fu8_t *)malloc((tbs.len)*sizeof(fu8_t))))
|
|
191 return -ENOMEM;
|
|
192 aimbs_put16(&tbs, 0x00c8);
|
|
193 aimbs_put16(&tbs, tbs.len-4);
|
|
194 if (parentgroup->gid == 0x0000) {
|
|
195 for (cur=sess->ssi.items; cur; cur=cur->next)
|
3017
|
196 if ((cur->gid != 0x0000) && (cur->type == AIM_SSI_TYPE_GROUP))
|
2991
|
197 aimbs_put16(&tbs, cur->gid);
|
|
198 } else {
|
|
199 for (cur=sess->ssi.items; cur; cur=cur->next)
|
3017
|
200 if ((cur->gid == parentgroup->gid) && (cur->type == AIM_SSI_TYPE_BUDDY))
|
2991
|
201 aimbs_put16(&tbs, cur->bid);
|
|
202 }
|
|
203 tbs.offset = 0;
|
|
204 parentgroup->data = (void *)aim_readtlvchain(&tbs);
|
|
205 free(tbs.data);
|
|
206
|
|
207 /* XXX - WHYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYY does this crash?
|
|
208 fu8_t *newdata;
|
|
209 if (!(newdata = (fu8_t *)malloc((newlen)*sizeof(fu8_t))))
|
|
210 return -ENOMEM;
|
|
211 newlen = 0;
|
|
212 if (parentgroup->gid == 0x0000) {
|
|
213 for (cur=sess->ssi.items; cur; cur=cur->next)
|
3017
|
214 if ((cur->gid != 0x0000) && (cur->type == AIM_SSI_TYPE_GROUP)) {
|
2991
|
215 memcpy(&newdata[newlen*2], &cur->gid, 2);
|
|
216 newlen += 2;
|
|
217 }
|
|
218 } else {
|
|
219 for (cur=sess->ssi.items; cur; cur=cur->next)
|
3017
|
220 if ((cur->gid == parentgroup->gid) && (cur->type == AIM_SSI_TYPE_BUDDY)) {
|
|
221 memcpy(&newdata[newlen*2], &cur->bid, 2);
|
2991
|
222 newlen += 2;
|
|
223 }
|
|
224 }
|
|
225 aim_addtlvtochain_raw((aim_tlvlist_t **)&parentgroup->data, 0x00c8, newlen, newdata);
|
|
226 free(newdata); */
|
|
227 }
|
|
228
|
|
229 return 0;
|
|
230 }
|
|
231
|
|
232 /*
|
|
233 * Clears all of our locally stored buddy list information.
|
|
234 */
|
|
235 static int aim_ssi_freelist(aim_session_t *sess)
|
|
236 {
|
|
237 struct aim_ssi_item *cur, *delitem;
|
|
238
|
|
239 cur = sess->ssi.items;
|
|
240 while (cur) {
|
|
241 if (cur->name) free(cur->name);
|
|
242 if (cur->data) aim_freetlvchain((aim_tlvlist_t **)&cur->data);
|
|
243 delitem = cur;
|
|
244 cur = cur->next;
|
|
245 free(delitem);
|
|
246 }
|
|
247
|
|
248 sess->ssi.revision = 0;
|
|
249 sess->ssi.items = NULL;
|
|
250 sess->ssi.timestamp = (time_t)0;
|
|
251
|
|
252 return 0;
|
|
253 }
|
|
254
|
|
255 /*
|
|
256 * This removes all ssi data from server and local copy.
|
|
257 */
|
|
258 faim_export int aim_ssi_deletelist(aim_session_t *sess, aim_conn_t *conn)
|
|
259 {
|
3000
|
260 int num;
|
2991
|
261 struct aim_ssi_item *cur, **items;
|
|
262
|
|
263 for (cur=sess->ssi.items, num=0; cur; cur=cur->next)
|
|
264 num++;
|
|
265
|
|
266 if (!(items = (struct aim_ssi_item **)malloc(num*sizeof(struct aim_ssi_item *))))
|
|
267 return -ENOMEM;
|
3017
|
268 memset(items, 0, num*sizeof(struct aim_ssi_item *));
|
2991
|
269 for (cur=sess->ssi.items, num=0; cur; cur=cur->next) {
|
|
270 items[num] = cur;
|
|
271 num++;
|
|
272 }
|
|
273
|
3017
|
274 aim_ssi_addmoddel(sess, conn, items, num, AIM_CB_SSI_DEL);
|
2995
|
275 free(items);
|
2991
|
276 aim_ssi_dispatch(sess, conn);
|
|
277 aim_ssi_freelist(sess);
|
|
278
|
|
279 return 0;
|
|
280 }
|
|
281
|
|
282 /*
|
|
283 * This "cleans" the ssi list. It makes sure all buddies are in a group, and
|
|
284 * all groups have additional data for the buddies that are in them. It does
|
|
285 * this by rebuilding the additional data for every group, sending mod SNACs
|
|
286 * as necessary.
|
|
287 */
|
|
288 faim_export int aim_ssi_cleanlist(aim_session_t *sess, aim_conn_t *conn)
|
|
289 {
|
|
290 unsigned int num_to_be_fixed;
|
|
291 struct aim_ssi_item *cur, *parentgroup;
|
|
292
|
|
293 /* Make sure we actually need to clean out the list */
|
|
294 for (cur=sess->ssi.items, num_to_be_fixed=0; cur; cur=cur->next) {
|
|
295 /* Any buddies directly in the master group */
|
3017
|
296 if ((cur->type == AIM_SSI_TYPE_BUDDY) && (cur->gid == 0x0000))
|
2991
|
297 num_to_be_fixed++;
|
|
298 }
|
|
299 if (!num_to_be_fixed)
|
|
300 return 0;
|
|
301
|
|
302 /* Remove all the additional data from all groups and buddies */
|
|
303 for (cur=sess->ssi.items; cur; cur=cur->next)
|
3017
|
304 if (cur->data && ((cur->type == AIM_SSI_TYPE_BUDDY) || (cur->type == AIM_SSI_TYPE_GROUP))) {
|
2991
|
305 aim_freetlvchain((aim_tlvlist_t **)&cur->data);
|
|
306 cur->data = NULL;
|
|
307 }
|
|
308
|
|
309 /* If there are buddies directly in the master group, make sure */
|
|
310 /* there is a group to put them in. Any group, any group at all. */
|
3017
|
311 for (cur=sess->ssi.items; ((cur) && ((cur->type != AIM_SSI_TYPE_BUDDY) || (cur->gid != 0x0000))); cur=cur->next);
|
2991
|
312 if (!cur) {
|
3017
|
313 for (parentgroup=sess->ssi.items; ((parentgroup) && ((parentgroup->type!=AIM_SSI_TYPE_GROUP) || (parentgroup->gid!=0x0000))); parentgroup=parentgroup->next);
|
2991
|
314 if (!parentgroup) {
|
|
315 char *newgroup;
|
|
316 newgroup = (char*)malloc(strlen("Unknown")*sizeof(char));
|
|
317 strcpy(newgroup, "Unknown");
|
|
318 aim_ssi_addgroups(sess, conn, &newgroup, 1);
|
|
319 }
|
|
320 }
|
|
321
|
|
322 /* Set parentgroup equal to any arbitray group */
|
3017
|
323 for (parentgroup=sess->ssi.items; parentgroup->gid==0x0000 || parentgroup->type!=AIM_SSI_TYPE_GROUP; parentgroup=parentgroup->next);
|
2991
|
324
|
|
325 /* If there are any buddies directly in the master group, put them in a real group */
|
|
326 for (cur=sess->ssi.items; cur; cur=cur->next)
|
3017
|
327 if ((cur->type == AIM_SSI_TYPE_BUDDY) && (cur->gid == 0x0000)) {
|
|
328 aim_ssi_addmoddel(sess, conn, &cur, 1, AIM_CB_SSI_DEL);
|
2991
|
329 cur->gid = parentgroup->gid;
|
3017
|
330 aim_ssi_addmoddel(sess, conn, &cur, 1, AIM_CB_SSI_ADD);
|
2991
|
331 }
|
|
332
|
|
333 /* Rebuild additional data for all groups */
|
|
334 for (parentgroup=sess->ssi.items; parentgroup; parentgroup=parentgroup->next)
|
3017
|
335 if (parentgroup->type == AIM_SSI_TYPE_GROUP)
|
2991
|
336 aim_ssi_rebuildgroup(sess, conn, parentgroup);
|
|
337
|
|
338 /* Send a mod snac for all groups */
|
|
339 for (cur=sess->ssi.items; cur; cur=cur->next)
|
3017
|
340 if (cur->type == AIM_SSI_TYPE_GROUP)
|
|
341 aim_ssi_addmoddel(sess, conn, &cur, 1, AIM_CB_SSI_MOD);
|
2991
|
342
|
|
343 /* Begin sending SSI SNACs */
|
|
344 aim_ssi_dispatch(sess, conn);
|
|
345
|
|
346 return 0;
|
|
347 }
|
|
348
|
|
349 /*
|
|
350 * The next few functions take data as screen names and groups,
|
|
351 * modifies the ssi item list, and calls the functions to
|
|
352 * add, mod, or del an item or items.
|
|
353 *
|
|
354 * These are what the client should call. The client should
|
|
355 * also make sure it's not adding a buddy that's already in
|
|
356 * the list (using aim_ssi_inlist).
|
|
357 */
|
|
358 faim_export int aim_ssi_addbuddies(aim_session_t *sess, aim_conn_t *conn, char *gn, char **sn, unsigned int num)
|
|
359 {
|
|
360 struct aim_ssi_item *cur, *parentgroup, **newitems;
|
|
361 fu16_t i, j;
|
|
362
|
|
363 if (!sess || !conn || !gn || !sn || !num)
|
|
364 return -EINVAL;
|
|
365
|
|
366 /* Look up the parent group */
|
3017
|
367 if (!(parentgroup = get_ssi_item(sess->ssi.items, gn, AIM_SSI_TYPE_GROUP))) {
|
2991
|
368 aim_ssi_addgroups(sess, conn, &gn, 1);
|
3017
|
369 if (!(parentgroup = get_ssi_item(sess->ssi.items, gn, AIM_SSI_TYPE_GROUP)))
|
2991
|
370 return -ENOMEM;
|
|
371 }
|
|
372
|
|
373 /* Allocate an array of pointers to each of the new items */
|
|
374 if (!(newitems = (struct aim_ssi_item **)malloc(num*sizeof(struct aim_ssi_item *))))
|
|
375 return -ENOMEM;
|
3017
|
376 memset(newitems, 0, num*sizeof(struct aim_ssi_item *));
|
2991
|
377
|
|
378 /* The following for loop iterates once per item that needs to be added. */
|
|
379 /* For each i, create an item and tack it onto the newitems array */
|
|
380 for (i=0; i<num; i++) {
|
|
381 if (!(newitems[i] = (struct aim_ssi_item *)malloc(sizeof(struct aim_ssi_item)))) {
|
|
382 for (j=0; j<(i-1); j++) {
|
|
383 free(newitems[j]->name);
|
|
384 free(newitems[j]);
|
|
385 }
|
|
386 free(newitems);
|
|
387 return -ENOMEM;
|
|
388 }
|
|
389 if (!(newitems[i]->name = (char *)malloc((strlen(sn[i])+1)*sizeof(char)))) {
|
|
390 for (j=0; j<(i-1); j++) {
|
|
391 free(newitems[j]->name);
|
|
392 free(newitems[j]);
|
|
393 }
|
|
394 free(newitems[i]);
|
|
395 free(newitems);
|
|
396 return -ENOMEM;
|
|
397 }
|
|
398 strcpy(newitems[i]->name, sn[i]);
|
|
399 newitems[i]->gid = parentgroup->gid;
|
|
400 newitems[i]->bid = i ? newitems[i-1]->bid : 0;
|
|
401 do {
|
|
402 newitems[i]->bid += 0x0001;
|
|
403 for (cur=sess->ssi.items, j=0; ((cur) && (!j)); cur=cur->next)
|
3017
|
404 if ((cur->bid == newitems[i]->bid) && (cur->gid == newitems[i]->gid) && (cur->type == AIM_SSI_TYPE_BUDDY))
|
2991
|
405 j=1;
|
|
406 } while (j);
|
3017
|
407 newitems[i]->type = AIM_SSI_TYPE_BUDDY;
|
2991
|
408 newitems[i]->data = NULL;
|
|
409 newitems[i]->next = i ? newitems[i-1] : NULL;
|
|
410 }
|
|
411
|
|
412 /* Add the items to our list */
|
|
413 newitems[0]->next = sess->ssi.items;
|
|
414 sess->ssi.items = newitems[num-1];
|
|
415
|
|
416 /* Send the add item SNAC */
|
3017
|
417 aim_ssi_addmoddel(sess, conn, newitems, num, AIM_CB_SSI_ADD);
|
2991
|
418
|
|
419 /* Free the array of pointers to each of the new items */
|
|
420 free(newitems);
|
|
421
|
|
422 /* Rebuild the additional data in the parent group */
|
|
423 aim_ssi_rebuildgroup(sess, conn, parentgroup);
|
|
424
|
|
425 /* Send the mod item SNAC */
|
3017
|
426 aim_ssi_addmoddel(sess, conn, &parentgroup, 1, AIM_CB_SSI_MOD);
|
|
427
|
|
428 /* Begin sending SSI SNACs */
|
|
429 aim_ssi_dispatch(sess, conn);
|
|
430
|
|
431 return 0;
|
|
432 }
|
|
433
|
|
434 /*
|
|
435 * This adds the master group (the group containing all groups) if it doesn't exist.
|
|
436 * It's called by aim_ssi_addgroups, if your list is empty.
|
|
437 */
|
|
438 faim_export int aim_ssi_addmastergroup(aim_session_t *sess, aim_conn_t *conn) {
|
|
439 struct aim_ssi_item *newitem;
|
|
440
|
|
441 if (!sess || !conn)
|
|
442 return -EINVAL;
|
|
443
|
|
444 /* Allocate an array of pointers to each of the new items */
|
|
445 if (!(newitem = (struct aim_ssi_item *)malloc(sizeof(struct aim_ssi_item))))
|
|
446 return -ENOMEM;
|
|
447 memset(newitem, 0, sizeof(struct aim_ssi_item));
|
|
448
|
|
449 /* memset to 0 sets most of the vars to what they should be */
|
|
450 newitem->type = AIM_SSI_TYPE_GROUP;
|
|
451
|
|
452 /* Add the item to our list */
|
|
453 newitem->next = sess->ssi.items;
|
|
454 sess->ssi.items = newitem;
|
|
455
|
|
456 /* If there are any existing groups (technically there shouldn't be, but */
|
|
457 /* just in case) then add their group ID#'s to the additional data */
|
|
458 if (sess->ssi.items)
|
|
459 aim_ssi_rebuildgroup(sess, conn, newitem);
|
|
460
|
|
461 /* Send the add item SNAC */
|
|
462 aim_ssi_addmoddel(sess, conn, &newitem, 1, AIM_CB_SSI_ADD);
|
2991
|
463
|
|
464 /* Begin sending SSI SNACs */
|
|
465 aim_ssi_dispatch(sess, conn);
|
|
466
|
|
467 return 0;
|
|
468 }
|
|
469
|
|
470 faim_export int aim_ssi_addgroups(aim_session_t *sess, aim_conn_t *conn, char **gn, unsigned int num)
|
|
471 {
|
|
472 struct aim_ssi_item *cur, *parentgroup, **newitems;
|
|
473 fu16_t i, j;
|
|
474
|
|
475 if (!sess || !conn || !gn || !num)
|
|
476 return -EINVAL;
|
|
477
|
|
478 /* Look up the parent group */
|
3017
|
479 if (!(parentgroup = get_ssi_item(sess->ssi.items, NULL, AIM_SSI_TYPE_GROUP))) {
|
2991
|
480 aim_ssi_addmastergroup(sess, conn);
|
3017
|
481 if (!(parentgroup = get_ssi_item(sess->ssi.items, NULL, AIM_SSI_TYPE_GROUP)))
|
2991
|
482 return -ENOMEM;
|
|
483 }
|
|
484
|
|
485 /* Allocate an array of pointers to each of the new items */
|
|
486 if (!(newitems = (struct aim_ssi_item **)malloc(num*sizeof(struct aim_ssi_item *))))
|
|
487 return -ENOMEM;
|
3017
|
488 memset(newitems, 0, num*sizeof(struct aim_ssi_item *));
|
2991
|
489
|
|
490 /* The following for loop iterates once per item that needs to be added. */
|
|
491 /* For each i, create an item and tack it onto the newitems array */
|
|
492 for (i=0; i<num; i++) {
|
|
493 if (!(newitems[i] = (struct aim_ssi_item *)malloc(sizeof(struct aim_ssi_item)))) {
|
|
494 for (j=0; j<(i-1); j++) {
|
|
495 free(newitems[j]->name);
|
|
496 free(newitems[j]);
|
|
497 }
|
|
498 free(newitems);
|
|
499 return -ENOMEM;
|
|
500 }
|
|
501 if (!(newitems[i]->name = (char *)malloc((strlen(gn[i])+1)*sizeof(char)))) {
|
|
502 for (j=0; j<(i-1); j++) {
|
|
503 free(newitems[j]->name);
|
|
504 free(newitems[j]);
|
|
505 }
|
|
506 free(newitems[i]);
|
|
507 free(newitems);
|
|
508 return -ENOMEM;
|
|
509 }
|
|
510 strcpy(newitems[i]->name, gn[i]);
|
|
511 newitems[i]->gid = i ? newitems[i-1]->gid : 0;
|
|
512 do {
|
|
513 newitems[i]->gid += 0x0001;
|
|
514 for (cur=sess->ssi.items, j=0; ((cur) && (!j)); cur=cur->next)
|
3017
|
515 if ((cur->gid == newitems[i]->gid) && (cur->type == AIM_SSI_TYPE_GROUP))
|
2991
|
516 j=1;
|
|
517 } while (j);
|
|
518 newitems[i]->bid = 0x0000;
|
3017
|
519 newitems[i]->type = AIM_SSI_TYPE_GROUP;
|
2991
|
520 newitems[i]->data = NULL;
|
|
521 newitems[i]->next = i ? newitems[i-1] : NULL;
|
|
522 }
|
|
523
|
|
524 /* Add the items to our list */
|
|
525 newitems[0]->next = sess->ssi.items;
|
|
526 sess->ssi.items = newitems[num-1];
|
|
527
|
|
528 /* Send the add item SNAC */
|
3017
|
529 aim_ssi_addmoddel(sess, conn, newitems, num, AIM_CB_SSI_ADD);
|
2991
|
530
|
|
531 /* Free the array of pointers to each of the new items */
|
|
532 free(newitems);
|
|
533
|
|
534 /* Rebuild the additional data in the parent group */
|
|
535 aim_ssi_rebuildgroup(sess, conn, parentgroup);
|
|
536
|
|
537 /* Send the mod item SNAC */
|
3017
|
538 aim_ssi_addmoddel(sess, conn, &parentgroup, 1, AIM_CB_SSI_MOD);
|
2991
|
539
|
|
540 /* Begin sending SSI SNACs */
|
|
541 aim_ssi_dispatch(sess, conn);
|
|
542
|
|
543 return 0;
|
|
544 }
|
|
545
|
3017
|
546 /*
|
|
547 * Add permit or deny buddies to the permit or deny list.
|
|
548 * The buddies are passed as an array of pointers to char strings.
|
|
549 */
|
|
550 faim_export int aim_ssi_addpord(aim_session_t *sess, aim_conn_t *conn, char **sn, unsigned int num, fu16_t type)
|
2991
|
551 {
|
|
552 struct aim_ssi_item *cur, **newitems;
|
|
553 fu16_t i, j;
|
|
554
|
3017
|
555 if (!sess || !conn || !sn || !num || (type!=AIM_SSI_TYPE_PERMIT && type!=AIM_SSI_TYPE_DENY))
|
2991
|
556 return -EINVAL;
|
|
557
|
|
558 /* Allocate an array of pointers to each of the new items */
|
|
559 if (!(newitems = (struct aim_ssi_item **)malloc(num*sizeof(struct aim_ssi_item *))))
|
|
560 return -ENOMEM;
|
3017
|
561 memset(newitems, 0, num*sizeof(struct aim_ssi_item *));
|
2991
|
562
|
|
563 /* The following for loop iterates once per item that needs to be added. */
|
|
564 /* For each i, create an item and tack it onto the newitems array */
|
|
565 for (i=0; i<num; i++) {
|
|
566 if (!(newitems[i] = (struct aim_ssi_item *)malloc(sizeof(struct aim_ssi_item)))) {
|
|
567 for (j=0; j<(i-1); j++) {
|
|
568 free(newitems[j]->name);
|
|
569 free(newitems[j]);
|
|
570 }
|
|
571 free(newitems);
|
|
572 return -ENOMEM;
|
|
573 }
|
|
574 if (!(newitems[i]->name = (char *)malloc((strlen(sn[i])+1)*sizeof(char)))) {
|
|
575 for (j=0; j<(i-1); j++) {
|
|
576 free(newitems[j]->name);
|
|
577 free(newitems[j]);
|
|
578 }
|
|
579 free(newitems[i]);
|
|
580 free(newitems);
|
|
581 return -ENOMEM;
|
|
582 }
|
|
583 strcpy(newitems[i]->name, sn[i]);
|
|
584 newitems[i]->gid = 0x0000;
|
|
585 newitems[i]->bid = i ? newitems[i-1]->bid : 0x0000;
|
|
586 do {
|
|
587 newitems[i]->bid += 0x0001;
|
|
588 for (cur=sess->ssi.items, j=0; ((cur) && (!j)); cur=cur->next)
|
3017
|
589 if ((cur->bid == newitems[i]->bid) && ((cur->type == AIM_SSI_TYPE_PERMIT) || (cur->type == AIM_SSI_TYPE_DENY)))
|
2991
|
590 j=1;
|
|
591 } while (j);
|
3017
|
592 newitems[i]->type = type;
|
2991
|
593 newitems[i]->data = NULL;
|
|
594 newitems[i]->next = i ? newitems[i-1] : NULL;
|
|
595 }
|
|
596
|
|
597 /* Add the items to our list */
|
|
598 newitems[0]->next = sess->ssi.items;
|
|
599 sess->ssi.items = newitems[num-1];
|
|
600
|
|
601 /* Send the add item SNAC */
|
3017
|
602 aim_ssi_addmoddel(sess, conn, newitems, num, AIM_CB_SSI_ADD);
|
2991
|
603
|
|
604 /* Free the array of pointers to each of the new items */
|
|
605 free(newitems);
|
|
606
|
|
607 /* Begin sending SSI SNACs */
|
|
608 aim_ssi_dispatch(sess, conn);
|
|
609
|
|
610 return 0;
|
|
611 }
|
|
612
|
|
613 faim_export int aim_ssi_delbuddies(aim_session_t *sess, aim_conn_t *conn, char *gn, char **sn, unsigned int num)
|
|
614 {
|
|
615 struct aim_ssi_item *cur, *parentgroup, **delitems;
|
|
616 int i;
|
|
617
|
|
618 if (!sess || !conn || !gn || !sn || !num)
|
|
619 return -EINVAL;
|
|
620
|
|
621 /* Look up the parent group */
|
3017
|
622 if (!(parentgroup = get_ssi_item(sess->ssi.items, gn, AIM_SSI_TYPE_GROUP)))
|
2991
|
623 return -EINVAL;
|
|
624
|
|
625 /* Allocate an array of pointers to each of the items to be deleted */
|
|
626 delitems = (struct aim_ssi_item **)malloc(num*sizeof(struct aim_ssi_item *));
|
3017
|
627 memset(delitems, 0, num*sizeof(struct aim_ssi_item *));
|
2991
|
628
|
|
629 /* Make the delitems array a pointer to the aim_ssi_item structs to be deleted */
|
|
630 for (i=0; i<num; i++) {
|
3017
|
631 if (!(delitems[i] = get_ssi_item(sess->ssi.items, sn[i], AIM_SSI_TYPE_BUDDY))) {
|
2991
|
632 free(delitems);
|
|
633 return -EINVAL;
|
|
634 }
|
|
635
|
|
636 /* Remove the delitems from the item list */
|
|
637 if (sess->ssi.items == delitems[i]) {
|
|
638 sess->ssi.items = sess->ssi.items->next;
|
|
639 } else {
|
|
640 for (cur=sess->ssi.items; (cur->next && (cur->next!=delitems[i])); cur=cur->next);
|
|
641 if (cur->next)
|
|
642 cur->next = cur->next->next;
|
|
643 }
|
|
644 }
|
|
645
|
|
646 /* Send the del item SNAC */
|
3017
|
647 aim_ssi_addmoddel(sess, conn, delitems, num, AIM_CB_SSI_DEL);
|
2991
|
648
|
|
649 /* Free the items */
|
|
650 for (i=0; i<num; i++) {
|
|
651 if (delitems[i]->name)
|
|
652 free(delitems[i]->name);
|
|
653 if (delitems[i]->data)
|
|
654 aim_freetlvchain((aim_tlvlist_t **)&delitems[i]->data);
|
|
655 free(delitems[i]);
|
|
656 }
|
|
657 free(delitems);
|
|
658
|
|
659 /* Rebuild the additional data in the parent group */
|
|
660 aim_ssi_rebuildgroup(sess, conn, parentgroup);
|
|
661
|
|
662 /* Send the mod item SNAC */
|
3017
|
663 aim_ssi_addmoddel(sess, conn, &parentgroup, 1, AIM_CB_SSI_MOD);
|
2991
|
664
|
|
665 /* Delete the group, but only if it's empty */
|
|
666 if (!parentgroup->data)
|
|
667 aim_ssi_delgroups(sess, conn, &parentgroup->name, 1);
|
|
668
|
|
669 /* Begin sending SSI SNACs */
|
|
670 aim_ssi_dispatch(sess, conn);
|
|
671
|
|
672 return 0;
|
|
673 }
|
|
674
|
3017
|
675 faim_export int aim_ssi_delmastergroup(aim_session_t *sess, aim_conn_t *conn) {
|
|
676 struct aim_ssi_item *cur, *delitem;
|
|
677
|
|
678 if (!sess || !conn)
|
|
679 return -EINVAL;
|
|
680
|
|
681 /* Make delitem a pointer to the aim_ssi_item to be deleted */
|
|
682 if (!(delitem = get_ssi_item(sess->ssi.items, NULL, AIM_SSI_TYPE_GROUP)))
|
|
683 return -EINVAL;
|
|
684
|
|
685 /* Remove delitem from the item list */
|
|
686 if (sess->ssi.items == delitem) {
|
|
687 sess->ssi.items = sess->ssi.items->next;
|
|
688 } else {
|
|
689 for (cur=sess->ssi.items; (cur->next && (cur->next!=delitem)); cur=cur->next);
|
|
690 if (cur->next)
|
|
691 cur->next = cur->next->next;
|
|
692 }
|
|
693
|
|
694 /* Send the del item SNAC */
|
|
695 aim_ssi_addmoddel(sess, conn, &delitem, 1, AIM_CB_SSI_DEL);
|
|
696
|
|
697 /* Free the item */
|
|
698 if (delitem->name)
|
|
699 free(delitem->name);
|
|
700 if (delitem->data)
|
|
701 aim_freetlvchain((aim_tlvlist_t **)&delitem->data);
|
|
702 free(delitem);
|
|
703
|
|
704 /* Begin sending SSI SNACs */
|
|
705 aim_ssi_dispatch(sess, conn);
|
|
706
|
|
707 return 0;
|
|
708 }
|
|
709
|
|
710 faim_export int aim_ssi_delgroups(aim_session_t *sess, aim_conn_t *conn, char **gn, unsigned int num) {
|
|
711 struct aim_ssi_item *cur, *parentgroup, **delitems;
|
2991
|
712 int i;
|
|
713
|
3017
|
714 if (!sess || !conn || !gn || !num)
|
|
715 return -EINVAL;
|
|
716
|
|
717 /* Look up the parent group */
|
|
718 if (!(parentgroup = get_ssi_item(sess->ssi.items, NULL, AIM_SSI_TYPE_GROUP)))
|
2991
|
719 return -EINVAL;
|
|
720
|
|
721 /* Allocate an array of pointers to each of the items to be deleted */
|
|
722 delitems = (struct aim_ssi_item **)malloc(num*sizeof(struct aim_ssi_item *));
|
3017
|
723 memset(delitems, 0, num*sizeof(struct aim_ssi_item *));
|
2991
|
724
|
|
725 /* Make the delitems array a pointer to the aim_ssi_item structs to be deleted */
|
|
726 for (i=0; i<num; i++) {
|
3017
|
727 if (!(delitems[i] = get_ssi_item(sess->ssi.items, gn[i], AIM_SSI_TYPE_GROUP))) {
|
2991
|
728 free(delitems);
|
|
729 return -EINVAL;
|
|
730 }
|
|
731
|
|
732 /* Remove the delitems from the item list */
|
|
733 if (sess->ssi.items == delitems[i]) {
|
|
734 sess->ssi.items = sess->ssi.items->next;
|
|
735 } else {
|
|
736 for (cur=sess->ssi.items; (cur->next && (cur->next!=delitems[i])); cur=cur->next);
|
|
737 if (cur->next)
|
|
738 cur->next = cur->next->next;
|
|
739 }
|
|
740 }
|
|
741
|
|
742 /* Send the del item SNAC */
|
3017
|
743 aim_ssi_addmoddel(sess, conn, delitems, num, AIM_CB_SSI_DEL);
|
2991
|
744
|
|
745 /* Free the items */
|
|
746 for (i=0; i<num; i++) {
|
|
747 if (delitems[i]->name)
|
|
748 free(delitems[i]->name);
|
|
749 if (delitems[i]->data)
|
|
750 aim_freetlvchain((aim_tlvlist_t **)&delitems[i]->data);
|
|
751 free(delitems[i]);
|
|
752 }
|
|
753 free(delitems);
|
|
754
|
3017
|
755 /* Rebuild the additional data in the parent group */
|
|
756 aim_ssi_rebuildgroup(sess, conn, parentgroup);
|
|
757
|
|
758 /* Send the mod item SNAC */
|
|
759 aim_ssi_addmoddel(sess, conn, &parentgroup, 1, AIM_CB_SSI_MOD);
|
|
760
|
|
761 /* Delete the group, but only if it's empty */
|
|
762 if (!parentgroup->data)
|
|
763 aim_ssi_delmastergroup(sess, conn);
|
|
764
|
2991
|
765 /* Begin sending SSI SNACs */
|
|
766 aim_ssi_dispatch(sess, conn);
|
|
767
|
|
768 return 0;
|
|
769 }
|
|
770
|
3017
|
771 faim_export int aim_ssi_delpord(aim_session_t *sess, aim_conn_t *conn, char **sn, unsigned int num, fu16_t type) {
|
2991
|
772 struct aim_ssi_item *cur, **delitems;
|
|
773 int i;
|
|
774
|
3017
|
775 if (!sess || !conn || !sn || !num || (type!=AIM_SSI_TYPE_PERMIT && type!=AIM_SSI_TYPE_DENY))
|
2991
|
776 return -EINVAL;
|
|
777
|
|
778 /* Allocate an array of pointers to each of the items to be deleted */
|
|
779 delitems = (struct aim_ssi_item **)malloc(num*sizeof(struct aim_ssi_item *));
|
3017
|
780 memset(delitems, 0, num*sizeof(struct aim_ssi_item *));
|
2991
|
781
|
|
782 /* Make the delitems array a pointer to the aim_ssi_item structs to be deleted */
|
|
783 for (i=0; i<num; i++) {
|
3017
|
784 if (!(delitems[i] = get_ssi_item(sess->ssi.items, sn[i], type))) {
|
2991
|
785 free(delitems);
|
|
786 return -EINVAL;
|
|
787 }
|
|
788
|
|
789 /* Remove the delitems from the item list */
|
|
790 if (sess->ssi.items == delitems[i]) {
|
|
791 sess->ssi.items = sess->ssi.items->next;
|
|
792 } else {
|
|
793 for (cur=sess->ssi.items; (cur->next && (cur->next!=delitems[i])); cur=cur->next);
|
|
794 if (cur->next)
|
|
795 cur->next = cur->next->next;
|
|
796 }
|
|
797 }
|
|
798
|
|
799 /* Send the del item SNAC */
|
3017
|
800 aim_ssi_addmoddel(sess, conn, delitems, num, AIM_CB_SSI_DEL);
|
2991
|
801
|
|
802 /* Free the items */
|
|
803 for (i=0; i<num; i++) {
|
|
804 if (delitems[i]->name)
|
|
805 free(delitems[i]->name);
|
|
806 if (delitems[i]->data)
|
|
807 aim_freetlvchain((aim_tlvlist_t **)&delitems[i]->data);
|
|
808 free(delitems[i]);
|
|
809 }
|
|
810 free(delitems);
|
|
811
|
|
812 /* Begin sending SSI SNACs */
|
|
813 aim_ssi_dispatch(sess, conn);
|
|
814
|
|
815 return 0;
|
|
816 }
|
|
817
|
|
818 /*
|
|
819 * Stores your permit/deny setting on the server, and starts using it.
|
|
820 * The permit/deny byte should be:
|
|
821 * 1 - Allow all users
|
|
822 * 2 - Block all users
|
|
823 * 3 - Allow only the users below
|
|
824 * 4 - Block the users below
|
|
825 * 5 - Allow only users on my buddy list
|
|
826 * To block AIM users, change the x00cb tlv from xffff to x0004
|
|
827 */
|
|
828 faim_export int aim_ssi_setpermdeny(aim_session_t *sess, aim_conn_t *conn, int permdeny) {
|
|
829 struct aim_ssi_item *cur, *tmp;
|
3000
|
830 fu16_t j;
|
2991
|
831 aim_tlv_t *tlv;
|
|
832
|
|
833 if (!sess || !conn)
|
|
834 return -EINVAL;
|
|
835
|
|
836 /* Look up the permit/deny settings item */
|
3109
|
837 cur = get_ssi_item(sess->ssi.items, NULL, AIM_SSI_TYPE_PDINFO);
|
2991
|
838
|
|
839 if (cur) {
|
|
840 /* The permit/deny item exists */
|
|
841 if (cur->data && (tlv = aim_gettlv(cur->data, 0x00ca, 1))) {
|
|
842 /* Just change the value of the x00ca TLV */
|
|
843 if (tlv->length != 1) {
|
|
844 tlv->length = 1;
|
|
845 free(tlv->value);
|
|
846 tlv->value = (fu8_t *)malloc(sizeof(fu8_t));
|
|
847 }
|
3090
|
848 tlv->value[0] = permdeny;
|
2991
|
849 } else {
|
|
850 /* Need to add the x00ca TLV to the TLV chain */
|
|
851 aim_addtlvtochain8((aim_tlvlist_t**)&cur->data, 0x00ca, permdeny);
|
|
852 }
|
|
853
|
|
854 /* Send the mod item SNAC */
|
3017
|
855 aim_ssi_addmoddel(sess, conn, &cur, 1, AIM_CB_SSI_MOD);
|
2991
|
856 } else {
|
|
857 /* Need to add the permit/deny item */
|
|
858 if (!(cur = (struct aim_ssi_item *)malloc(sizeof(struct aim_ssi_item))))
|
|
859 return -ENOMEM;
|
|
860 cur->name = NULL;
|
|
861 cur->gid = 0x0000;
|
|
862 cur->bid = 0x007a; /* XXX - Is this number significant? */
|
|
863 do {
|
|
864 cur->bid += 0x0001;
|
|
865 for (tmp=sess->ssi.items, j=0; ((tmp) && (!j)); tmp=tmp->next)
|
|
866 if (tmp->bid == cur->bid)
|
|
867 j=1;
|
|
868 } while (j);
|
3017
|
869 cur->type = AIM_SSI_TYPE_PDINFO;
|
2991
|
870 cur->data = NULL;
|
|
871 aim_addtlvtochain8((aim_tlvlist_t**)&cur->data, 0x00ca, permdeny);
|
|
872 aim_addtlvtochain32((aim_tlvlist_t**)&cur->data, 0x00cb, 0xffffffff);
|
|
873
|
|
874 /* Add the item to our list */
|
|
875 cur->next = sess->ssi.items;
|
|
876 sess->ssi.items = cur;
|
|
877
|
|
878 /* Send the add item SNAC */
|
3017
|
879 aim_ssi_addmoddel(sess, conn, &cur, 1, AIM_CB_SSI_ADD);
|
2991
|
880 }
|
|
881
|
|
882 /* Begin sending SSI SNACs */
|
|
883 aim_ssi_dispatch(sess, conn);
|
|
884
|
|
885 return 0;
|
|
886 }
|
|
887
|
|
888 /*
|
3109
|
889 * Stores your setting for whether you should show up as idle or not.
|
|
890 * presence is a bitmask (at least, I think so...)
|
|
891 * 0x00000400 if you want others to see your idle time
|
|
892 */
|
|
893 faim_export int aim_ssi_setpresence(aim_session_t *sess, aim_conn_t *conn, fu32_t presence) {
|
|
894 struct aim_ssi_item *cur, *tmp;
|
|
895 fu16_t j;
|
|
896 aim_tlv_t *tlv;
|
|
897
|
|
898 if (!sess || !conn)
|
|
899 return -EINVAL;
|
|
900
|
|
901 /* Look up the item */
|
|
902 cur = get_ssi_item(sess->ssi.items, NULL, AIM_SSI_TYPE_PRESENCEPREFS);
|
|
903
|
|
904 if (cur) {
|
|
905 /* The item exists */
|
|
906 if (cur->data && (tlv = aim_gettlv(cur->data, 0x00c9, 1))) {
|
|
907 /* Just change the value of the x00c9 TLV */
|
|
908 if (tlv->length != 4) {
|
|
909 tlv->length = 4;
|
|
910 free(tlv->value);
|
|
911 tlv->value = (fu8_t *)malloc(4*sizeof(fu8_t));
|
|
912 }
|
|
913 aimutil_put32(tlv->value, presence);
|
|
914 } else {
|
|
915 /* Need to add the x00c9 TLV to the TLV chain */
|
|
916 aim_addtlvtochain32((aim_tlvlist_t**)&cur->data, 0x00c9, presence);
|
|
917 }
|
|
918
|
|
919 /* Send the mod item SNAC */
|
|
920 aim_ssi_addmoddel(sess, conn, &cur, 1, AIM_CB_SSI_MOD);
|
|
921 } else {
|
|
922 /* Need to add the item */
|
|
923 if (!(cur = (struct aim_ssi_item *)malloc(sizeof(struct aim_ssi_item))))
|
|
924 return -ENOMEM;
|
|
925 cur->name = NULL;
|
|
926 cur->gid = 0x0000;
|
|
927 cur->bid = 0x007a; /* XXX - Is this number significant? */
|
|
928 do {
|
|
929 cur->bid += 0x0001;
|
|
930 for (tmp=sess->ssi.items, j=0; ((tmp) && (!j)); tmp=tmp->next)
|
|
931 if (tmp->bid == cur->bid)
|
|
932 j=1;
|
|
933 } while (j);
|
|
934 cur->type = AIM_SSI_TYPE_PRESENCEPREFS;
|
|
935 cur->data = NULL;
|
|
936 aim_addtlvtochain32((aim_tlvlist_t**)&cur->data, 0x00c9, presence);
|
|
937
|
|
938 /* Add the item to our list */
|
|
939 cur->next = sess->ssi.items;
|
|
940 sess->ssi.items = cur;
|
|
941
|
|
942 /* Send the add item SNAC */
|
|
943 aim_ssi_addmoddel(sess, conn, &cur, 1, AIM_CB_SSI_ADD);
|
|
944 }
|
|
945
|
|
946 /* Begin sending SSI SNACs */
|
|
947 aim_ssi_dispatch(sess, conn);
|
|
948
|
|
949 return 0;
|
|
950 }
|
|
951
|
|
952 /*
|
2672
|
953 * Request SSI Rights.
|
|
954 */
|
|
955 faim_export int aim_ssi_reqrights(aim_session_t *sess, aim_conn_t *conn)
|
|
956 {
|
3017
|
957 return aim_genericreq_n(sess, conn, AIM_CB_FAM_SSI, AIM_CB_SSI_REQRIGHTS);
|
2672
|
958 }
|
|
959
|
|
960 /*
|
|
961 * SSI Rights Information.
|
|
962 */
|
|
963 static int parserights(aim_session_t *sess, aim_module_t *mod, aim_frame_t *rx, aim_modsnac_t *snac, aim_bstream_t *bs)
|
|
964 {
|
|
965 int ret = 0;
|
|
966 aim_rxcallback_t userfunc;
|
|
967
|
|
968 if ((userfunc = aim_callhandler(sess, rx->conn, snac->family, snac->subtype)))
|
|
969 ret = userfunc(sess, rx);
|
|
970
|
|
971 return ret;
|
|
972 }
|
|
973
|
|
974 /*
|
|
975 * Request SSI Data.
|
|
976 *
|
|
977 * The data will only be sent if it is newer than the posted local
|
|
978 * timestamp and revision.
|
|
979 *
|
|
980 * Note that the client should never increment the revision, only the server.
|
|
981 *
|
|
982 */
|
|
983 faim_export int aim_ssi_reqdata(aim_session_t *sess, aim_conn_t *conn, time_t localstamp, fu16_t localrev)
|
|
984 {
|
|
985 aim_frame_t *fr;
|
|
986 aim_snacid_t snacid;
|
|
987
|
|
988 if (!sess || !conn)
|
|
989 return -EINVAL;
|
|
990
|
|
991 if (!(fr = aim_tx_new(sess, conn, AIM_FRAMETYPE_FLAP, 0x02, 10+4+2)))
|
|
992 return -ENOMEM;
|
|
993
|
3017
|
994 snacid = aim_cachesnac(sess, AIM_CB_FAM_SSI, AIM_CB_SSI_REQLIST, 0x0000, NULL, 0);
|
2672
|
995
|
3017
|
996 aim_putsnac(&fr->data, AIM_CB_FAM_SSI, AIM_CB_SSI_REQLIST, 0x0000, snacid);
|
2672
|
997 aimbs_put32(&fr->data, localstamp);
|
|
998 aimbs_put16(&fr->data, localrev);
|
|
999
|
|
1000 aim_tx_enqueue(sess, fr);
|
|
1001
|
|
1002 return 0;
|
|
1003 }
|
|
1004
|
|
1005 /*
|
|
1006 * SSI Data.
|
|
1007 */
|
|
1008 static int parsedata(aim_session_t *sess, aim_module_t *mod, aim_frame_t *rx, aim_modsnac_t *snac, aim_bstream_t *bs)
|
|
1009 {
|
|
1010 int ret = 0;
|
|
1011 aim_rxcallback_t userfunc;
|
2991
|
1012 struct aim_ssi_item *cur = NULL;
|
2672
|
1013 fu8_t fmtver; /* guess */
|
2991
|
1014 fu16_t revision;
|
|
1015 fu32_t timestamp;
|
2672
|
1016
|
2991
|
1017 fmtver = aimbs_get8(bs); /* Version of ssi data. Should be 0x00 */
|
|
1018 revision = aimbs_get16(bs); /* # of times ssi data has been modified */
|
|
1019 if (revision != 0)
|
|
1020 sess->ssi.revision = revision;
|
|
1021
|
|
1022 for (cur = sess->ssi.items; cur && cur->next; cur=cur->next) ;
|
2672
|
1023
|
|
1024 while (aim_bstream_empty(bs) > 4) { /* last four bytes are stamp */
|
|
1025 fu16_t namelen, tbslen;
|
|
1026
|
2991
|
1027 if (!sess->ssi.items) {
|
|
1028 if (!(sess->ssi.items = malloc(sizeof(struct aim_ssi_item))))
|
|
1029 return -ENOMEM;
|
|
1030 cur = sess->ssi.items;
|
|
1031 } else {
|
|
1032 if (!(cur->next = malloc(sizeof(struct aim_ssi_item))))
|
|
1033 return -ENOMEM;
|
|
1034 cur = cur->next;
|
|
1035 }
|
|
1036 memset(cur, 0, sizeof(struct aim_ssi_item));
|
2672
|
1037
|
|
1038 if ((namelen = aimbs_get16(bs)))
|
2991
|
1039 cur->name = aimbs_getstr(bs, namelen);
|
|
1040 cur->gid = aimbs_get16(bs);
|
|
1041 cur->bid = aimbs_get16(bs);
|
|
1042 cur->type = aimbs_get16(bs);
|
2672
|
1043
|
|
1044 if ((tbslen = aimbs_get16(bs))) {
|
|
1045 aim_bstream_t tbs;
|
|
1046
|
|
1047 aim_bstream_init(&tbs, bs->data + bs->offset /* XXX */, tbslen);
|
2991
|
1048 cur->data = (void *)aim_readtlvchain(&tbs);
|
2672
|
1049 aim_bstream_advance(bs, tbslen);
|
|
1050 }
|
|
1051 }
|
|
1052
|
2991
|
1053 timestamp = aimbs_get32(bs);
|
|
1054 if (timestamp != 0)
|
|
1055 sess->ssi.timestamp = timestamp;
|
|
1056 sess->ssi.received_data = 1;
|
2672
|
1057
|
|
1058 if ((userfunc = aim_callhandler(sess, rx->conn, snac->family, snac->subtype)))
|
2991
|
1059 ret = userfunc(sess, rx, fmtver, sess->ssi.revision, sess->ssi.timestamp, sess->ssi.items);
|
2672
|
1060
|
|
1061 return ret;
|
|
1062 }
|
|
1063
|
|
1064 /*
|
|
1065 * SSI Data Enable Presence.
|
|
1066 *
|
|
1067 * Should be sent after receiving 13/6 or 13/f to tell the server you
|
|
1068 * are ready to begin using the list. It will promptly give you the
|
|
1069 * presence information for everyone in your list and put your permit/deny
|
|
1070 * settings into effect.
|
|
1071 *
|
|
1072 */
|
|
1073 faim_export int aim_ssi_enable(aim_session_t *sess, aim_conn_t *conn)
|
|
1074 {
|
3017
|
1075 return aim_genericreq_n(sess, conn, AIM_CB_FAM_SSI, 0x0007);
|
2672
|
1076 }
|
|
1077
|
|
1078 /*
|
3017
|
1079 * SSI Add/Mod/Del Item(s).
|
2991
|
1080 *
|
3017
|
1081 * Sends the SNAC to add, modify, or delete an item from the server-stored
|
|
1082 * information. These 3 SNACs all have an identical structure. The only
|
|
1083 * difference is the subtype that is set for the SNAC.
|
2991
|
1084 *
|
|
1085 */
|
3017
|
1086 faim_export int aim_ssi_addmoddel(aim_session_t *sess, aim_conn_t *conn, struct aim_ssi_item **items, unsigned int num, fu16_t subtype)
|
2991
|
1087 {
|
|
1088 aim_frame_t *fr;
|
|
1089 aim_snacid_t snacid;
|
|
1090 int i, snaclen;
|
|
1091
|
|
1092 if (!sess || !conn || !items || !num)
|
|
1093 return -EINVAL;
|
|
1094
|
|
1095 snaclen = 10; /* For family, subtype, flags, and SNAC ID */
|
|
1096 for (i=0; i<num; i++) {
|
|
1097 snaclen += 10; /* For length, GID, BID, type, and length */
|
|
1098 if (items[i]->name)
|
|
1099 snaclen += strlen(items[i]->name);
|
|
1100 if (items[i]->data)
|
|
1101 snaclen += aim_sizetlvchain((aim_tlvlist_t **)&items[i]->data);
|
|
1102 }
|
|
1103
|
|
1104 if (!(fr = aim_tx_new(sess, conn, AIM_FRAMETYPE_FLAP, 0x02, snaclen)))
|
|
1105 return -ENOMEM;
|
|
1106
|
3017
|
1107 snacid = aim_cachesnac(sess, AIM_CB_FAM_SSI, subtype, 0x0000, NULL, 0);
|
|
1108 aim_putsnac(&fr->data, AIM_CB_FAM_SSI, subtype, 0x0000, snacid);
|
2991
|
1109
|
|
1110 for (i=0; i<num; i++) {
|
|
1111 aimbs_put16(&fr->data, items[i]->name ? strlen(items[i]->name) : 0);
|
|
1112 if (items[i]->name)
|
|
1113 aimbs_putraw(&fr->data, items[i]->name, strlen(items[i]->name));
|
|
1114 aimbs_put16(&fr->data, items[i]->gid);
|
|
1115 aimbs_put16(&fr->data, items[i]->bid);
|
|
1116 aimbs_put16(&fr->data, items[i]->type);
|
|
1117 aimbs_put16(&fr->data, items[i]->data ? aim_sizetlvchain((aim_tlvlist_t **)&items[i]->data) : 0);
|
|
1118 if (items[i]->data)
|
|
1119 aim_writetlvchain(&fr->data, (aim_tlvlist_t **)&items[i]->data);
|
|
1120 }
|
|
1121
|
|
1122 aim_ssi_enqueue(sess, conn, fr);
|
|
1123
|
|
1124 return 0;
|
|
1125 }
|
|
1126
|
|
1127 /*
|
|
1128 * SSI Add/Mod/Del Ack.
|
|
1129 *
|
3017
|
1130 * Response to add, modify, or delete SNAC (sent with aim_ssi_addmoddel).
|
2991
|
1131 *
|
|
1132 */
|
|
1133 static int parseack(aim_session_t *sess, aim_module_t *mod, aim_frame_t *rx, aim_modsnac_t *snac, aim_bstream_t *bs)
|
|
1134 {
|
|
1135 int ret = 0;
|
|
1136 aim_rxcallback_t userfunc;
|
|
1137
|
|
1138 sess->ssi.waiting_for_ack = 0;
|
|
1139 aim_ssi_dispatch(sess, rx->conn);
|
|
1140
|
|
1141 if ((userfunc = aim_callhandler(sess, rx->conn, snac->family, snac->subtype)))
|
|
1142 ret = userfunc(sess, rx);
|
|
1143
|
|
1144 return ret;
|
|
1145 }
|
|
1146
|
|
1147 /*
|
2672
|
1148 * SSI Begin Data Modification.
|
|
1149 *
|
|
1150 * Tells the server you're going to start modifying data.
|
|
1151 *
|
|
1152 */
|
|
1153 faim_export int aim_ssi_modbegin(aim_session_t *sess, aim_conn_t *conn)
|
|
1154 {
|
3017
|
1155 return aim_genericreq_n(sess, conn, AIM_CB_FAM_SSI, AIM_CB_SSI_EDITSTART);
|
2672
|
1156 }
|
|
1157
|
|
1158 /*
|
|
1159 * SSI End Data Modification.
|
|
1160 *
|
|
1161 * Tells the server you're done modifying data.
|
|
1162 *
|
|
1163 */
|
|
1164 faim_export int aim_ssi_modend(aim_session_t *sess, aim_conn_t *conn)
|
|
1165 {
|
3017
|
1166 return aim_genericreq_n(sess, conn, AIM_CB_FAM_SSI, AIM_CB_SSI_EDITSTOP);
|
2672
|
1167 }
|
|
1168
|
|
1169 /*
|
|
1170 * SSI Data Unchanged.
|
|
1171 *
|
|
1172 * Response to aim_ssi_reqdata() if the server-side data is not newer than
|
|
1173 * posted local stamp/revision.
|
|
1174 *
|
|
1175 */
|
|
1176 static int parsedataunchanged(aim_session_t *sess, aim_module_t *mod, aim_frame_t *rx, aim_modsnac_t *snac, aim_bstream_t *bs)
|
|
1177 {
|
|
1178 int ret = 0;
|
|
1179 aim_rxcallback_t userfunc;
|
|
1180
|
2991
|
1181 sess->ssi.received_data = 1;
|
|
1182
|
2672
|
1183 if ((userfunc = aim_callhandler(sess, rx->conn, snac->family, snac->subtype)))
|
|
1184 ret = userfunc(sess, rx);
|
|
1185
|
|
1186 return ret;
|
|
1187 }
|
|
1188
|
|
1189 static int snachandler(aim_session_t *sess, aim_module_t *mod, aim_frame_t *rx, aim_modsnac_t *snac, aim_bstream_t *bs)
|
|
1190 {
|
|
1191
|
3017
|
1192 if (snac->subtype == AIM_CB_SSI_RIGHTSINFO)
|
2672
|
1193 return parserights(sess, mod, rx, snac, bs);
|
3017
|
1194 else if (snac->subtype == AIM_CB_SSI_LIST)
|
2672
|
1195 return parsedata(sess, mod, rx, snac, bs);
|
2991
|
1196 else if (snac->subtype == AIM_CB_SSI_SRVACK)
|
|
1197 return parseack(sess, mod, rx, snac, bs);
|
3017
|
1198 else if (snac->subtype == AIM_CB_SSI_NOLIST)
|
2672
|
1199 return parsedataunchanged(sess, mod, rx, snac, bs);
|
|
1200
|
|
1201 return 0;
|
|
1202 }
|
|
1203
|
2991
|
1204 static void ssi_shutdown(aim_session_t *sess, aim_module_t *mod)
|
|
1205 {
|
|
1206 aim_ssi_freelist(sess);
|
|
1207
|
|
1208 return;
|
|
1209 }
|
|
1210
|
2672
|
1211 faim_internal int ssi_modfirst(aim_session_t *sess, aim_module_t *mod)
|
|
1212 {
|
|
1213
|
3017
|
1214 mod->family = AIM_CB_FAM_SSI;
|
2672
|
1215 mod->version = 0x0001;
|
|
1216 mod->toolid = 0x0110;
|
|
1217 mod->toolversion = 0x047b;
|
|
1218 mod->flags = 0;
|
|
1219 strncpy(mod->name, "ssi", sizeof(mod->name));
|
|
1220 mod->snachandler = snachandler;
|
2991
|
1221 mod->shutdown = ssi_shutdown;
|
2672
|
1222
|
|
1223 return 0;
|
|
1224 }
|