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