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