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