Annotation of ChivanetAimPidgin/oscarprpl/src/c/family_feedbag.c, revision 1.1
1.1 ! snw 1: /*
! 2: * Purple's oscar protocol plugin
! 3: * This file is the legal property of its developers.
! 4: * Please see the AUTHORS file distributed alongside this file.
! 5: *
! 6: * This library is free software; you can redistribute it and/or
! 7: * modify it under the terms of the GNU Lesser General Public
! 8: * License as published by the Free Software Foundation; either
! 9: * version 2 of the License, or (at your option) any later version.
! 10: *
! 11: * This library is distributed in the hope that it will be useful,
! 12: * but WITHOUT ANY WARRANTY; without even the implied warranty of
! 13: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
! 14: * Lesser General Public License for more details.
! 15: *
! 16: * You should have received a copy of the GNU Lesser General Public
! 17: * License along with this library; if not, write to the Free Software
! 18: * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
! 19: */
! 20:
! 21: /*
! 22: * Family 0x0013 - Server-Side/Stored Information.
! 23: *
! 24: * Relatively new facility that allows certain types of information, such as
! 25: * a user's buddy list, permit/deny list, and permit/deny preferences, to be
! 26: * stored on the server, so that they can be accessed from any client.
! 27: *
! 28: * We keep 2 copies of SSI data:
! 29: * 1) An exact copy of what is stored on the AIM servers.
! 30: * 2) A local copy that we make changes to, and then send diffs
! 31: * between this and the exact copy to keep them in sync.
! 32: *
! 33: * All the "aim_ssi_itemlist_bleh" functions near the top just modify the list
! 34: * that is given to them (i.e. they don't send SNACs).
! 35: *
! 36: * The SNAC sending and receiving functions are lower down in the file, and
! 37: * they're simpler. They are in the order of the subtypes they deal with,
! 38: * starting with the request rights function (subtype 0x0002), then parse
! 39: * rights (subtype 0x0003), then--well, you get the idea.
! 40: *
! 41: * This is entirely too complicated.
! 42: * You don't know the half of it.
! 43: *
! 44: */
! 45:
! 46: #include "oscar.h"
! 47: #include "debug.h"
! 48:
! 49: static int aim_ssi_addmoddel(OscarData *od);
! 50:
! 51: /**
! 52: * List types based on http://dev.aol.com/aim/oscar/#FEEDBAG (archive.org)
! 53: * and http://iserverd.khstu.ru/oscar/ssi_item.html
! 54: *
! 55: * @param type The type of a list item as integer number, as provided by an aim_ssi_item struct.
! 56: * @return Returns the name of the item type as a character string.
! 57: */
! 58: static const gchar*
! 59: aim_ssi_type_to_string(guint16 type)
! 60: {
! 61: struct TypeStringPair
! 62: {
! 63: guint16 type;
! 64: const gchar *string;
! 65: };
! 66: static const struct TypeStringPair type_strings[] = {
! 67: { 0x0000, "Buddy" },
! 68: { 0x0001, "Group" },
! 69: { 0x0002, "Permit/Visible" },
! 70: { 0x0003, "Deny/Invisible" },
! 71: { 0x0004, "PDInfo" },
! 72: { 0x0005, "PresencePrefs" },
! 73: { 0x0006, "Non-Buddy Info" },
! 74: { 0x0009, "ClientPrefs" },
! 75: { 0x000e, "ICQDeny/Ignore" },
! 76: { 0x0014, "Buddy Icon" },
! 77: { 0x0015, "Recent Buddies" },
! 78: { 0x0019, "Non-Buddy" },
! 79: { 0x001d, "Vanity Info" },
! 80: { 0x0020, "ICQ-MDir" },
! 81: { 0x0029, "Facebook" },
! 82: };
! 83: size_t i;
! 84: for (i = 0; i < G_N_ELEMENTS(type_strings); i++) {
! 85: if (type_strings[i].type == type) {
! 86: return type_strings[i].string;
! 87: }
! 88: }
! 89: return "unknown";
! 90: }
! 91:
! 92: /** For debug log output: Appends a line containing information about a given list item to a string.
! 93: *
! 94: * @param str String to which the line will be appended.
! 95: * @param prefix A string which will be prepended to the line.
! 96: * @param item List item from which information is extracted.
! 97: */
! 98: static void
! 99: aim_ssi_item_debug_append(GString *str, char *prefix, struct aim_ssi_item *item)
! 100: {
! 101: g_string_append_printf(str,
! 102: "%s gid=0x%04hx, bid=0x%04hx, list_type=0x%04hx [%s], name=%s.\n",
! 103: prefix, item->gid, item->bid, item->type, aim_ssi_type_to_string(item->type),
! 104: item->name ? item->name : "(null)");
! 105: }
! 106:
! 107: /**
! 108: * Locally rebuild the 0x00c8 TLV in the additional data of the given group.
! 109: *
! 110: * @param list A pointer to a pointer to the current list of items.
! 111: * @param name A null terminated string containing the group name, or NULL
! 112: * if you want to modify the master group.
! 113: * @return Return a pointer to the modified item.
! 114: */
! 115: static void
! 116: aim_ssi_itemlist_rebuildgroup(struct aim_ssi_item *list, const char *name)
! 117: {
! 118: int newlen;
! 119: struct aim_ssi_item *cur, *group;
! 120:
! 121: /* Find the group */
! 122: if (!(group = aim_ssi_itemlist_finditem(list, name, NULL, AIM_SSI_TYPE_GROUP)))
! 123: return;
! 124:
! 125: /* Find the length for the new additional data */
! 126: newlen = 0;
! 127: if (group->gid == 0x0000) {
! 128: for (cur=list; cur; cur=cur->next)
! 129: if ((cur->type == AIM_SSI_TYPE_GROUP) && (cur->gid != 0x0000))
! 130: newlen += 2;
! 131: } else {
! 132: for (cur=list; cur; cur=cur->next)
! 133: if ((cur->gid == group->gid) && (cur->type == AIM_SSI_TYPE_BUDDY))
! 134: newlen += 2;
! 135: }
! 136:
! 137: /* Build the new TLV list */
! 138: if (newlen > 0) {
! 139: guint8 *newdata;
! 140:
! 141: newdata = (guint8 *)g_malloc((newlen)*sizeof(guint8));
! 142: newlen = 0;
! 143: if (group->gid == 0x0000) {
! 144: for (cur=list; cur; cur=cur->next)
! 145: if ((cur->type == AIM_SSI_TYPE_GROUP) && (cur->gid != 0x0000))
! 146: newlen += aimutil_put16(newdata+newlen, cur->gid);
! 147: } else {
! 148: for (cur=list; cur; cur=cur->next)
! 149: if ((cur->gid == group->gid) && (cur->type == AIM_SSI_TYPE_BUDDY))
! 150: newlen += aimutil_put16(newdata+newlen, cur->bid);
! 151: }
! 152: aim_tlvlist_replace_raw(&group->data, 0x00c8, newlen, newdata);
! 153:
! 154: g_free(newdata);
! 155: }
! 156: }
! 157:
! 158: /**
! 159: * Locally add a new item to the given item list.
! 160: *
! 161: * @param list A pointer to a pointer to the current list of items.
! 162: * @param name A null terminated string of the name of the new item, or NULL if the
! 163: * item should have no name.
! 164: * @param gid The group ID# you want the new item to have, or 0xFFFF if we should pick something.
! 165: * @param bid The buddy ID# you want the new item to have, or 0xFFFF if we should pick something.
! 166: * @param type The type of the item, 0x0000 for a contact, 0x0001 for a group, etc.
! 167: * @param data The additional data for the new item.
! 168: * @return A pointer to the newly created item.
! 169: */
! 170: static struct aim_ssi_item *aim_ssi_itemlist_add(struct aim_ssi_item **list, const char *name, guint16 gid, guint16 bid, guint16 type, GSList *data)
! 171: {
! 172: gboolean exists;
! 173: struct aim_ssi_item *cur, *new;
! 174:
! 175: new = g_new(struct aim_ssi_item, 1);
! 176:
! 177: /* Set the name */
! 178: new->name = g_strdup(name);
! 179:
! 180: /* Set the group ID# and buddy ID# */
! 181: new->gid = gid;
! 182: new->bid = bid;
! 183: if (type == AIM_SSI_TYPE_GROUP) {
! 184: if ((new->gid == 0xFFFF) && name) {
! 185: do {
! 186: new->gid += 0x0001;
! 187: exists = FALSE;
! 188: for (cur = *list; cur != NULL; cur = cur->next)
! 189: if ((cur->type == AIM_SSI_TYPE_GROUP) && (cur->gid == new->gid)) {
! 190: exists = TRUE;
! 191: break;
! 192: }
! 193: } while (exists);
! 194: }
! 195: } else if (new->gid == 0x0000) {
! 196: /*
! 197: * This is weird, but apparently items in the root group can't
! 198: * have a buddy ID equal to any group ID. You'll get error
! 199: * 0x0003 when trying to add, which is "item already exists"
! 200: */
! 201: if (new->bid == 0xFFFF) {
! 202: do {
! 203: new->bid += 0x0001;
! 204: exists = FALSE;
! 205: for (cur = *list; cur != NULL; cur = cur->next)
! 206: if (cur->bid == new->bid || cur->gid == new->bid) {
! 207: exists = TRUE;
! 208: break;
! 209: }
! 210: } while (exists);
! 211: }
! 212: } else {
! 213: if (new->bid == 0xFFFF) {
! 214: do {
! 215: new->bid += 0x0001;
! 216: exists = FALSE;
! 217: for (cur = *list; cur != NULL; cur = cur->next)
! 218: if (cur->bid == new->bid && cur->gid == new->gid) {
! 219: exists = TRUE;
! 220: break;
! 221: }
! 222: } while (exists);
! 223: }
! 224: }
! 225:
! 226: /* Set the type */
! 227: new->type = type;
! 228:
! 229: /* Set the TLV list */
! 230: new->data = aim_tlvlist_copy(data);
! 231:
! 232: /* Add the item to the list in the correct numerical position. Fancy, eh? */
! 233: if (*list) {
! 234: if ((new->gid < (*list)->gid) || ((new->gid == (*list)->gid) && (new->bid < (*list)->bid))) {
! 235: new->next = *list;
! 236: *list = new;
! 237: } else {
! 238: struct aim_ssi_item *prev;
! 239: for ((prev=*list, cur=(*list)->next); (cur && ((new->gid > cur->gid) || ((new->gid == cur->gid) && (new->bid > cur->bid)))); prev=cur, cur=cur->next);
! 240: new->next = prev->next;
! 241: prev->next = new;
! 242: }
! 243: } else {
! 244: new->next = *list;
! 245: *list = new;
! 246: }
! 247:
! 248: return new;
! 249: }
! 250:
! 251: /**
! 252: * Locally delete an item from the given item list.
! 253: *
! 254: * @param list A pointer to a pointer to the current list of items.
! 255: * @param del A pointer to the item you want to remove from the list.
! 256: * @return Return 0 if no errors, otherwise return the error number.
! 257: */
! 258: static int aim_ssi_itemlist_del(struct aim_ssi_item **list, struct aim_ssi_item *del)
! 259: {
! 260: if (!(*list) || !del)
! 261: return -EINVAL;
! 262:
! 263: /* Remove the item from the list */
! 264: if (*list == del) {
! 265: *list = (*list)->next;
! 266: } else {
! 267: struct aim_ssi_item *cur;
! 268: for (cur=*list; (cur->next && (cur->next!=del)); cur=cur->next);
! 269: if (cur->next)
! 270: cur->next = del->next;
! 271: }
! 272:
! 273: /* Free the removed item */
! 274: g_free(del->name);
! 275: aim_tlvlist_free(del->data);
! 276: g_free(del);
! 277:
! 278: return 0;
! 279: }
! 280:
! 281: /**
! 282: * Compare two items to see if they have the same data.
! 283: *
! 284: * @param cur1 A pointer to a pointer to the first item.
! 285: * @param cur2 A pointer to a pointer to the second item.
! 286: * @return Return 0 if no differences, or a number if there are differences.
! 287: */
! 288: static int aim_ssi_itemlist_cmp(struct aim_ssi_item *cur1, struct aim_ssi_item *cur2)
! 289: {
! 290: if (!cur1 || !cur2)
! 291: return 1;
! 292:
! 293: if (cur1->data && !cur2->data)
! 294: return 2;
! 295:
! 296: if (!cur1->data && cur2->data)
! 297: return 3;
! 298:
! 299: if ((cur1->data && cur2->data) && (aim_tlvlist_cmp(cur1->data, cur2->data)))
! 300: return 4;
! 301:
! 302: if (cur1->name && !cur2->name)
! 303: return 5;
! 304:
! 305: if (!cur1->name && cur2->name)
! 306: return 6;
! 307:
! 308: if (cur1->name && cur2->name && oscar_util_name_compare(cur1->name, cur2->name))
! 309: return 7;
! 310:
! 311: if (cur1->gid != cur2->gid)
! 312: return 8;
! 313:
! 314: if (cur1->bid != cur2->bid)
! 315: return 9;
! 316:
! 317: if (cur1->type != cur2->type)
! 318: return 10;
! 319:
! 320: return 0;
! 321: }
! 322:
! 323: static gboolean aim_ssi_itemlist_valid(struct aim_ssi_item *list, struct aim_ssi_item *item)
! 324: {
! 325: struct aim_ssi_item *cur;
! 326: for (cur=list; cur; cur=cur->next)
! 327: if (cur == item)
! 328: return TRUE;
! 329: return FALSE;
! 330: }
! 331:
! 332: /**
! 333: * Locally find an item given a group ID# and a buddy ID#.
! 334: *
! 335: * @param list A pointer to the current list of items.
! 336: * @param gid The group ID# of the desired item.
! 337: * @param bid The buddy ID# of the desired item.
! 338: * @return Return a pointer to the item if found, else return NULL;
! 339: */
! 340: struct aim_ssi_item *aim_ssi_itemlist_find(struct aim_ssi_item *list, guint16 gid, guint16 bid)
! 341: {
! 342: struct aim_ssi_item *cur;
! 343: for (cur=list; cur; cur=cur->next)
! 344: if ((cur->gid == gid) && (cur->bid == bid))
! 345: return cur;
! 346: return NULL;
! 347: }
! 348:
! 349: /**
! 350: * Locally find an item given a group name, buddy name, and type. If group name
! 351: * and buddy name are null, then just return the first item of the given type.
! 352: *
! 353: * @param list A pointer to the current list of items.
! 354: * @param gn The group name of the desired item.
! 355: * @param bn The buddy name of the desired item.
! 356: * @param type The type of the desired item.
! 357: * @return Return a pointer to the item if found, else return NULL.
! 358: */
! 359: struct aim_ssi_item *aim_ssi_itemlist_finditem(struct aim_ssi_item *list, const char *gn, const char *bn, guint16 type)
! 360: {
! 361: struct aim_ssi_item *cur;
! 362: if (!list)
! 363: return NULL;
! 364:
! 365: if (gn && bn) { /* For finding buddies in groups */
! 366: for (cur=list; cur; cur=cur->next)
! 367: if ((cur->type == type) && (cur->name) && !(oscar_util_name_compare(cur->name, bn))) {
! 368: struct aim_ssi_item *curg;
! 369: for (curg=list; curg; curg=curg->next)
! 370: if ((curg->type == AIM_SSI_TYPE_GROUP) && (curg->gid == cur->gid) && (curg->name) && !(oscar_util_name_compare(curg->name, gn)))
! 371: return cur;
! 372: }
! 373:
! 374: } else if (gn) { /* For finding groups */
! 375: for (cur=list; cur; cur=cur->next) {
! 376: if ((cur->type == type) && (cur->bid == 0x0000) && (cur->name) && !(oscar_util_name_compare(cur->name, gn))) {
! 377: return cur;
! 378: }
! 379: }
! 380:
! 381: } else if (bn) { /* For finding permits, denies, and ignores */
! 382: for (cur=list; cur; cur=cur->next) {
! 383: if ((cur->type == type) && (cur->name) && !(oscar_util_name_compare(cur->name, bn))) {
! 384: return cur;
! 385: }
! 386: }
! 387:
! 388: /* For stuff without names--permit deny setting, visibility mask, etc. */
! 389: } else for (cur=list; cur; cur=cur->next) {
! 390: if ((cur->type == type) && (!cur->name))
! 391: return cur;
! 392: }
! 393:
! 394: return NULL;
! 395: }
! 396:
! 397: /**
! 398: * Check if the given buddy exists in any group in the buddy list.
! 399: *
! 400: * @param list A pointer to the current list of items.
! 401: * @param bn The group name of the desired item.
! 402: * @return Return a pointer to the name of the item if found, else return NULL;
! 403: */
! 404: struct aim_ssi_item *aim_ssi_itemlist_exists(struct aim_ssi_item *list, const char *bn)
! 405: {
! 406: if (!bn)
! 407: return NULL;
! 408: return aim_ssi_itemlist_finditem(list, NULL, bn, AIM_SSI_TYPE_BUDDY);
! 409: }
! 410:
! 411: /**
! 412: * Locally find the parent item of the given buddy name.
! 413: *
! 414: * @param list A pointer to the current list of items.
! 415: * @param bn The buddy name of the desired item.
! 416: * @return Return a pointer to the name of the item if found, else return NULL;
! 417: */
! 418: char *aim_ssi_itemlist_findparentname(struct aim_ssi_item *list, const char *bn)
! 419: {
! 420: struct aim_ssi_item *cur, *curg;
! 421: if (!list || !bn)
! 422: return NULL;
! 423: if (!(cur = aim_ssi_itemlist_exists(list, bn)))
! 424: return NULL;
! 425: if (!(curg = aim_ssi_itemlist_find(list, cur->gid, 0x0000)))
! 426: return NULL;
! 427: return curg->name;
! 428: }
! 429:
! 430: /**
! 431: * Locally find the permit/deny setting item, and return the setting.
! 432: *
! 433: * @param list A pointer to the current list of items.
! 434: * @return Return the current SSI permit deny setting, or 0 if no setting was found.
! 435: */
! 436: int aim_ssi_getpermdeny(struct aim_ssi_item *list)
! 437: {
! 438: struct aim_ssi_item *cur = aim_ssi_itemlist_finditem(list, NULL, NULL, AIM_SSI_TYPE_PDINFO);
! 439: if (cur) {
! 440: aim_tlv_t *tlv = aim_tlv_gettlv(cur->data, 0x00ca, 1);
! 441: if (tlv && tlv->value)
! 442: return aimutil_get8(tlv->value);
! 443: }
! 444: return 0;
! 445: }
! 446:
! 447: /**
! 448: * Locally find the presence flag item, and return the setting. The returned setting is a
! 449: * bitmask of the preferences. See the AIM_SSI_PRESENCE_FLAG_* #defines in oscar.h.
! 450: *
! 451: * @param list A pointer to the current list of items.
! 452: * @return Return the current set of preferences.
! 453: */
! 454: guint32 aim_ssi_getpresence(struct aim_ssi_item *list)
! 455: {
! 456: struct aim_ssi_item *cur = aim_ssi_itemlist_finditem(list, NULL, NULL, AIM_SSI_TYPE_PRESENCEPREFS);
! 457: if (cur) {
! 458: aim_tlv_t *tlv = aim_tlv_gettlv(cur->data, 0x00c9, 1);
! 459: if (tlv && tlv->length)
! 460: return aimutil_get32(tlv->value);
! 461: }
! 462: return 0xFFFFFFFF;
! 463: }
! 464:
! 465: /**
! 466: * Locally find the alias of the given buddy.
! 467: *
! 468: * @param list A pointer to the current list of items.
! 469: * @param gn The group of the buddy.
! 470: * @param bn The name of the buddy.
! 471: * @return A pointer to a NULL terminated string that is the buddy's
! 472: * alias, or NULL if the buddy has no alias. You should free
! 473: * this returned value!
! 474: */
! 475: char *aim_ssi_getalias(struct aim_ssi_item *list, const char *gn, const char *bn)
! 476: {
! 477: struct aim_ssi_item *cur = aim_ssi_itemlist_finditem(list, gn, bn, AIM_SSI_TYPE_BUDDY);
! 478: if (cur) {
! 479: aim_tlv_t *tlv = aim_tlv_gettlv(cur->data, 0x0131, 1);
! 480: if (tlv && tlv->length)
! 481: return g_strndup((const gchar *)tlv->value, tlv->length);
! 482: }
! 483: return NULL;
! 484: }
! 485:
! 486: /**
! 487: * Locally find the comment of the given buddy.
! 488: *
! 489: * @param list A pointer to the current list of items.
! 490: * @param gn The group of the buddy.
! 491: * @param bn The name of the buddy.
! 492: * @return A pointer to a NULL terminated string that is the buddy's
! 493: * comment, or NULL if the buddy has no comment. You should free
! 494: * this returned value!
! 495: */
! 496: char *aim_ssi_getcomment(struct aim_ssi_item *list, const char *gn, const char *bn)
! 497: {
! 498: struct aim_ssi_item *cur = aim_ssi_itemlist_finditem(list, gn, bn, AIM_SSI_TYPE_BUDDY);
! 499: if (cur) {
! 500: aim_tlv_t *tlv = aim_tlv_gettlv(cur->data, 0x013c, 1);
! 501: if (tlv && tlv->length) {
! 502: return g_strndup((const gchar *)tlv->value, tlv->length);
! 503: }
! 504: }
! 505: return NULL;
! 506: }
! 507:
! 508: /**
! 509: * Locally find if you are waiting for authorization for a buddy.
! 510: *
! 511: * @param list A pointer to the current list of items.
! 512: * @param gn The group of the buddy.
! 513: * @param bn The name of the buddy.
! 514: * @return 1 if you are waiting for authorization; 0 if you are not
! 515: */
! 516: gboolean aim_ssi_waitingforauth(struct aim_ssi_item *list, const char *gn, const char *bn)
! 517: {
! 518: struct aim_ssi_item *cur = aim_ssi_itemlist_finditem(list, gn, bn, AIM_SSI_TYPE_BUDDY);
! 519: if (cur) {
! 520: if (aim_tlv_gettlv(cur->data, 0x0066, 1))
! 521: return TRUE;
! 522: }
! 523: return FALSE;
! 524: }
! 525:
! 526: /**
! 527: * If there are changes, then create temporary items and
! 528: * call addmoddel.
! 529: *
! 530: * @param od The oscar session.
! 531: * @return Return 0 if no errors, otherwise return the error number.
! 532: */
! 533: static int aim_ssi_sync(OscarData *od)
! 534: {
! 535: struct aim_ssi_item *cur1, *cur2;
! 536: struct aim_ssi_tmp *cur, *new;
! 537: int n = 0;
! 538: GString *debugstr = g_string_new("");
! 539:
! 540: /*
! 541: * The variable "n" is used to limit the number of addmoddel's that
! 542: * are performed in a single SNAC. It will hopefully keep the size
! 543: * of the SNAC below the maximum SNAC size.
! 544: */
! 545:
! 546: if (!od)
! 547: return -EINVAL;
! 548:
! 549: /* If we're waiting for an ack, we shouldn't do anything else */
! 550: if (od->ssi.waiting_for_ack)
! 551: return 0;
! 552:
! 553: /*
! 554: * Compare the 2 lists and create an aim_ssi_tmp for each difference.
! 555: * We should only send either additions, modifications, or deletions
! 556: * before waiting for an acknowledgement. So first do deletions, then
! 557: * additions, then modifications. Also, both the official and the local
! 558: * list should be in ascending numerical order for the group ID#s and the
! 559: * buddy ID#s, which makes things more efficient. I think.
! 560: */
! 561:
! 562: /* Deletions */
! 563: if (!od->ssi.pending) {
! 564: for (cur1=od->ssi.official; cur1 && (n < 15); cur1=cur1->next) {
! 565: if (!aim_ssi_itemlist_find(od->ssi.local, cur1->gid, cur1->bid)) {
! 566: n++;
! 567: new = g_new(struct aim_ssi_tmp, 1);
! 568: new->action = SNAC_SUBTYPE_FEEDBAG_DEL;
! 569: new->ack = 0xffff;
! 570: new->name = NULL;
! 571: new->item = cur1;
! 572: new->next = NULL;
! 573: if (od->ssi.pending) {
! 574: for (cur=od->ssi.pending; cur->next; cur=cur->next);
! 575: cur->next = new;
! 576: } else
! 577: od->ssi.pending = new;
! 578: aim_ssi_item_debug_append(debugstr, "Deleting item ", cur1);
! 579: }
! 580: }
! 581: }
! 582:
! 583: /* Additions */
! 584: if (!od->ssi.pending) {
! 585: for (cur1=od->ssi.local; cur1 && (n < 15); cur1=cur1->next) {
! 586: if (!aim_ssi_itemlist_find(od->ssi.official, cur1->gid, cur1->bid)) {
! 587: n++;
! 588: new = g_new(struct aim_ssi_tmp, 1);
! 589: new->action = SNAC_SUBTYPE_FEEDBAG_ADD;
! 590: new->ack = 0xffff;
! 591: new->name = NULL;
! 592: new->item = cur1;
! 593: new->next = NULL;
! 594: if (od->ssi.pending) {
! 595: for (cur=od->ssi.pending; cur->next; cur=cur->next);
! 596: cur->next = new;
! 597: } else
! 598: od->ssi.pending = new;
! 599: aim_ssi_item_debug_append(debugstr, "Adding item ", cur1);
! 600: }
! 601: }
! 602: }
! 603:
! 604: /* Modifications */
! 605: if (!od->ssi.pending) {
! 606: for (cur1=od->ssi.local; cur1 && (n < 15); cur1=cur1->next) {
! 607: cur2 = aim_ssi_itemlist_find(od->ssi.official, cur1->gid, cur1->bid);
! 608: if (cur2 && (aim_ssi_itemlist_cmp(cur1, cur2))) {
! 609: n++;
! 610: new = g_new(struct aim_ssi_tmp, 1);
! 611: new->action = SNAC_SUBTYPE_FEEDBAG_MOD;
! 612: new->ack = 0xffff;
! 613: new->name = NULL;
! 614: new->item = cur1;
! 615: new->next = NULL;
! 616: if (od->ssi.pending) {
! 617: for (cur=od->ssi.pending; cur->next; cur=cur->next);
! 618: cur->next = new;
! 619: } else
! 620: od->ssi.pending = new;
! 621: aim_ssi_item_debug_append(debugstr, "Modifying item ", cur1);
! 622: }
! 623: }
! 624: }
! 625: if (debugstr->len > 0) {
! 626: purple_debug_info("oscar", "%s", debugstr->str);
! 627: if (purple_debug_is_verbose()) {
! 628: g_string_truncate(debugstr, 0);
! 629: for (cur1 = od->ssi.local; cur1; cur1 = cur1->next)
! 630: aim_ssi_item_debug_append(debugstr, "\t", cur1);
! 631: purple_debug_misc("oscar", "Dumping item list of account %s:\n%s",
! 632: purple_connection_get_account(od->gc)->username, debugstr->str);
! 633: }
! 634: }
! 635: g_string_free(debugstr, TRUE);
! 636:
! 637: /* We're out of stuff to do, so tell the AIM servers we're done and exit */
! 638: if (!od->ssi.pending) {
! 639: if (od->ssi.in_transaction) {
! 640: aim_ssi_modend(od);
! 641: od->ssi.in_transaction = FALSE;
! 642: }
! 643: return 0;
! 644: }
! 645:
! 646: /* If this is the first in a series of add/mod/del
! 647: * requests then send the "begin transaction" message. */
! 648: if (!od->ssi.in_transaction)
! 649: {
! 650: aim_ssi_modbegin(od);
! 651: od->ssi.in_transaction = TRUE;
! 652: }
! 653:
! 654: /* Make sure we don't send anything else between now
! 655: * and when we receive the ack for the following operation */
! 656: od->ssi.waiting_for_ack = TRUE;
! 657:
! 658: /* Now go mail off our data and wait 4 to 6 weeks */
! 659: return aim_ssi_addmoddel(od);;
! 660: }
! 661:
! 662: /**
! 663: * Free all SSI data.
! 664: *
! 665: * This doesn't remove it from the server, that's different.
! 666: *
! 667: * @param od The oscar odion.
! 668: * @return Return 0 if no errors, otherwise return the error number.
! 669: */
! 670: static void
! 671: aim_ssi_freelist(OscarData *od)
! 672: {
! 673: struct aim_ssi_item *cur, *del;
! 674: struct aim_ssi_tmp *curtmp, *deltmp;
! 675:
! 676: cur = od->ssi.official;
! 677: while (cur) {
! 678: del = cur;
! 679: cur = cur->next;
! 680: g_free(del->name);
! 681: aim_tlvlist_free(del->data);
! 682: g_free(del);
! 683: }
! 684:
! 685: cur = od->ssi.local;
! 686: while (cur) {
! 687: del = cur;
! 688: cur = cur->next;
! 689: g_free(del->name);
! 690: aim_tlvlist_free(del->data);
! 691: g_free(del);
! 692: }
! 693:
! 694: curtmp = od->ssi.pending;
! 695: while (curtmp) {
! 696: deltmp = curtmp;
! 697: curtmp = curtmp->next;
! 698: g_free(deltmp);
! 699: }
! 700:
! 701: od->ssi.numitems = 0;
! 702: od->ssi.official = NULL;
! 703: od->ssi.local = NULL;
! 704: od->ssi.pending = NULL;
! 705: od->ssi.timestamp = (time_t)0;
! 706: }
! 707:
! 708: /**
! 709: * This "cleans" the ssi list. It does the following:
! 710: * 1) Makes sure all buddies, permits, and denies have names.
! 711: * 2) Makes sure that all buddies are in a group that exist.
! 712: * 3) Deletes any empty groups
! 713: *
! 714: * @param od The oscar odion.
! 715: * @return Return 0 if no errors, otherwise return the error number.
! 716: */
! 717: int aim_ssi_cleanlist(OscarData *od)
! 718: {
! 719: struct aim_ssi_item *cur, *next;
! 720:
! 721: if (!od)
! 722: return -EINVAL;
! 723:
! 724: /* Delete any buddies, permits, or denies with empty names. */
! 725: /* If there are any buddies directly in the master group, add them to a real group. */
! 726: /* DESTROY any buddies that are directly in the master group. */
! 727: /* Do the same for buddies that are in a non-existant group. */
! 728: /* This will kind of mess up if you hit the item limit, but this function isn't too critical */
! 729: cur = od->ssi.local;
! 730: while (cur) {
! 731: next = cur->next;
! 732: if (!cur->name) {
! 733: if (cur->type == AIM_SSI_TYPE_BUDDY)
! 734: aim_ssi_delbuddy(od, NULL, NULL);
! 735: else if (cur->type == AIM_SSI_TYPE_PERMIT || cur->type == AIM_SSI_TYPE_DENY || cur->type == AIM_SSI_TYPE_ICQDENY)
! 736: aim_ssi_del_from_private_list(od, NULL, cur->type);
! 737: } else if ((cur->type == AIM_SSI_TYPE_BUDDY) && ((cur->gid == 0x0000) || (!aim_ssi_itemlist_find(od->ssi.local, cur->gid, 0x0000)))) {
! 738: char *alias = aim_ssi_getalias(od->ssi.local, NULL, cur->name);
! 739: aim_ssi_addbuddy(od, cur->name, "orphans", NULL, alias, NULL, NULL, FALSE);
! 740: aim_ssi_delbuddy(od, cur->name, NULL);
! 741: g_free(alias);
! 742: }
! 743: cur = next;
! 744: }
! 745:
! 746: /* Make sure there aren't any duplicate buddies in a group, or duplicate permits or denies */
! 747: cur = od->ssi.local;
! 748: while (cur) {
! 749: if ((cur->type == AIM_SSI_TYPE_BUDDY) || (cur->type == AIM_SSI_TYPE_PERMIT) || (cur->type == AIM_SSI_TYPE_DENY))
! 750: {
! 751: struct aim_ssi_item *cur2, *next2;
! 752: cur2 = cur->next;
! 753: while (cur2) {
! 754: next2 = cur2->next;
! 755: if ((cur->type == cur2->type) && (cur->gid == cur2->gid) && (cur->name != NULL) && (cur2->name != NULL) && (!oscar_util_name_compare(cur->name, cur2->name))) {
! 756: aim_ssi_itemlist_del(&od->ssi.local, cur2);
! 757: }
! 758: cur2 = next2;
! 759: }
! 760: }
! 761: cur = cur->next;
! 762: }
! 763:
! 764: /* If we've made any changes then sync our list with the server's */
! 765: return aim_ssi_sync(od);
! 766: }
! 767:
! 768: /**
! 769: * Add a buddy to the list.
! 770: *
! 771: * @param od The oscar odion.
! 772: * @param name The name of the item.
! 773: * @param group The group of the item.
! 774: * @param data A TLV list to use as the additional data for this item.
! 775: * @param alias The alias/nickname of the item, or NULL.
! 776: * @param comment The buddy comment for the item, or NULL.
! 777: * @param smsnum The locally assigned SMS number, or NULL.
! 778: * @return Return 0 if no errors, otherwise return the error number.
! 779: */
! 780: int aim_ssi_addbuddy(OscarData *od, const char *name, const char *group, GSList *data, const char *alias, const char *comment, const char *smsnum, gboolean needauth)
! 781: {
! 782: struct aim_ssi_item *parent;
! 783:
! 784: if (!od || !name || !group)
! 785: return -EINVAL;
! 786:
! 787: /* Find the parent */
! 788: if (!(parent = aim_ssi_itemlist_finditem(od->ssi.local, group, NULL, AIM_SSI_TYPE_GROUP))) {
! 789: /* Find the parent's parent (the master group) */
! 790: if (aim_ssi_itemlist_find(od->ssi.local, 0x0000, 0x0000) == NULL)
! 791: aim_ssi_itemlist_add(&od->ssi.local, NULL, 0x0000, 0x0000, AIM_SSI_TYPE_GROUP, NULL);
! 792:
! 793: /* Add the parent */
! 794: parent = aim_ssi_itemlist_add(&od->ssi.local, group, 0xFFFF, 0x0000, AIM_SSI_TYPE_GROUP, NULL);
! 795:
! 796: /* Modify the parent's parent (the master group) */
! 797: aim_ssi_itemlist_rebuildgroup(od->ssi.local, NULL);
! 798: }
! 799:
! 800: /* Create a TLV list for the new buddy */
! 801: if (needauth)
! 802: aim_tlvlist_add_noval(&data, 0x0066);
! 803: if (alias != NULL)
! 804: aim_tlvlist_add_str(&data, 0x0131, alias);
! 805: if (smsnum != NULL)
! 806: aim_tlvlist_add_str(&data, 0x013a, smsnum);
! 807: if (comment != NULL)
! 808: aim_tlvlist_add_str(&data, 0x013c, comment);
! 809:
! 810: /* Add that bad boy */
! 811: aim_ssi_itemlist_add(&od->ssi.local, name, parent->gid, 0xFFFF, AIM_SSI_TYPE_BUDDY, data);
! 812: aim_tlvlist_free(data);
! 813:
! 814: /* Modify the parent group */
! 815: aim_ssi_itemlist_rebuildgroup(od->ssi.local, group);
! 816:
! 817: /* Sync our local list with the server list */
! 818: return aim_ssi_sync(od);
! 819: }
! 820:
! 821: int
! 822: aim_ssi_add_to_private_list(OscarData *od, const char* name, guint16 list_type)
! 823: {
! 824: if (!od || !name || !od->ssi.received_data)
! 825: return -EINVAL;
! 826:
! 827: if (aim_ssi_itemlist_find(od->ssi.local, 0x0000, 0x0000) == NULL)
! 828: aim_ssi_itemlist_add(&od->ssi.local, NULL, 0x0000, 0x0000, AIM_SSI_TYPE_GROUP, NULL);
! 829:
! 830: aim_ssi_itemlist_add(&od->ssi.local, name, 0x0000, 0xFFFF, list_type, NULL);
! 831: return aim_ssi_sync(od);
! 832: }
! 833:
! 834: int
! 835: aim_ssi_del_from_private_list(OscarData* od, const char* name, guint16 list_type)
! 836: {
! 837: struct aim_ssi_item *del;
! 838:
! 839: if (!od)
! 840: return -EINVAL;
! 841:
! 842: if (!(del = aim_ssi_itemlist_finditem(od->ssi.local, NULL, name, list_type)))
! 843: return -EINVAL;
! 844:
! 845: aim_ssi_itemlist_del(&od->ssi.local, del);
! 846: return aim_ssi_sync(od);
! 847: }
! 848:
! 849: /**
! 850: * Deletes a buddy from the list.
! 851: *
! 852: * @param od The oscar odion.
! 853: * @param name The name of the item, or NULL.
! 854: * @param group The group of the item, or NULL.
! 855: * @return Return 0 if no errors, otherwise return the error number.
! 856: */
! 857: int aim_ssi_delbuddy(OscarData *od, const char *name, const char *group)
! 858: {
! 859: struct aim_ssi_item *del;
! 860:
! 861: if (!od)
! 862: return -EINVAL;
! 863:
! 864: /* Find the buddy */
! 865: if (!(del = aim_ssi_itemlist_finditem(od->ssi.local, group, name, AIM_SSI_TYPE_BUDDY)))
! 866: return -EINVAL;
! 867:
! 868: /* Remove the item from the list */
! 869: aim_ssi_itemlist_del(&od->ssi.local, del);
! 870:
! 871: /* Modify the parent group */
! 872: aim_ssi_itemlist_rebuildgroup(od->ssi.local, group);
! 873:
! 874: /* Sync our local list with the server list */
! 875: return aim_ssi_sync(od);
! 876: }
! 877:
! 878: /**
! 879: * Deletes a group from the list.
! 880: *
! 881: * @param od The oscar odion.
! 882: * @param group The name of the group.
! 883: * @return Return 0 if no errors, otherwise return the error number.
! 884: */
! 885: int aim_ssi_delgroup(OscarData *od, const char *group)
! 886: {
! 887: struct aim_ssi_item *del;
! 888: aim_tlv_t *tlv;
! 889:
! 890: if (!od)
! 891: return -EINVAL;
! 892:
! 893: /* Find the group */
! 894: if (!(del = aim_ssi_itemlist_finditem(od->ssi.local, group, NULL, AIM_SSI_TYPE_GROUP)))
! 895: return -EINVAL;
! 896:
! 897: /* Don't delete the group if it's not empty */
! 898: tlv = aim_tlv_gettlv(del->data, 0x00c8, 1);
! 899: if (tlv && tlv->length > 0)
! 900: return -EINVAL;
! 901:
! 902: /* Remove the item from the list */
! 903: aim_ssi_itemlist_del(&od->ssi.local, del);
! 904:
! 905: /* Modify the parent group */
! 906: aim_ssi_itemlist_rebuildgroup(od->ssi.local, group);
! 907:
! 908: /* Sync our local list with the server list */
! 909: return aim_ssi_sync(od);
! 910: }
! 911:
! 912: /**
! 913: * Move a buddy from one group to another group. This basically just deletes the
! 914: * buddy and re-adds it.
! 915: *
! 916: * @param od The oscar odion.
! 917: * @param oldgn The group that the buddy is currently in.
! 918: * @param newgn The group that the buddy should be moved in to.
! 919: * @param bn The name of the buddy to be moved.
! 920: * @return Return 0 if no errors, otherwise return the error number.
! 921: */
! 922: int aim_ssi_movebuddy(OscarData *od, const char *oldgn, const char *newgn, const char *bn)
! 923: {
! 924: struct aim_ssi_item *buddy;
! 925: GSList *data;
! 926:
! 927: /* Find the buddy */
! 928: buddy = aim_ssi_itemlist_finditem(od->ssi.local, oldgn, bn, AIM_SSI_TYPE_BUDDY);
! 929: if (buddy == NULL)
! 930: return -EINVAL;
! 931:
! 932: /* Make a copy of the buddy's TLV list */
! 933: data = aim_tlvlist_copy(buddy->data);
! 934:
! 935: /* Delete the old item */
! 936: aim_ssi_delbuddy(od, bn, oldgn);
! 937:
! 938: /* Add the new item using the EXACT SAME TLV list */
! 939: aim_ssi_addbuddy(od, bn, newgn, data, NULL, NULL, NULL, FALSE);
! 940:
! 941: return 0;
! 942: }
! 943:
! 944: /**
! 945: * Change the alias stored on the server for a given buddy.
! 946: *
! 947: * @param od The oscar odion.
! 948: * @param gn The group that the buddy is currently in.
! 949: * @param bn The name of the buddy.
! 950: * @param alias The new alias for the buddy, or NULL if you want to remove
! 951: * a buddy's comment.
! 952: * @return Return 0 if no errors, otherwise return the error number.
! 953: */
! 954: int aim_ssi_aliasbuddy(OscarData *od, const char *gn, const char *bn, const char *alias)
! 955: {
! 956: struct aim_ssi_item *tmp;
! 957:
! 958: if (!od || !gn || !bn)
! 959: return -EINVAL;
! 960:
! 961: if (!(tmp = aim_ssi_itemlist_finditem(od->ssi.local, gn, bn, AIM_SSI_TYPE_BUDDY)))
! 962: return -EINVAL;
! 963:
! 964: /* Either add or remove the 0x0131 TLV from the TLV chain */
! 965: if ((alias != NULL) && (strlen(alias) > 0))
! 966: aim_tlvlist_replace_str(&tmp->data, 0x0131, alias);
! 967: else
! 968: aim_tlvlist_remove(&tmp->data, 0x0131);
! 969:
! 970: /* Sync our local list with the server list */
! 971: return aim_ssi_sync(od);
! 972: }
! 973:
! 974: /**
! 975: * Change the comment stored on the server for a given buddy.
! 976: *
! 977: * @param od The oscar odion.
! 978: * @param gn The group that the buddy is currently in.
! 979: * @param bn The name of the buddy.
! 980: * @param alias The new comment for the buddy, or NULL if you want to remove
! 981: * a buddy's comment.
! 982: * @return Return 0 if no errors, otherwise return the error number.
! 983: */
! 984: int aim_ssi_editcomment(OscarData *od, const char *gn, const char *bn, const char *comment)
! 985: {
! 986: struct aim_ssi_item *tmp;
! 987:
! 988: if (!od || !gn || !bn)
! 989: return -EINVAL;
! 990:
! 991: if (!(tmp = aim_ssi_itemlist_finditem(od->ssi.local, gn, bn, AIM_SSI_TYPE_BUDDY)))
! 992: return -EINVAL;
! 993:
! 994: /* Either add or remove the 0x0131 TLV from the TLV chain */
! 995: if ((comment != NULL) && (strlen(comment) > 0))
! 996: aim_tlvlist_replace_str(&tmp->data, 0x013c, comment);
! 997: else
! 998: aim_tlvlist_remove(&tmp->data, 0x013c);
! 999:
! 1000: /* Sync our local list with the server list */
! 1001: return aim_ssi_sync(od);
! 1002: }
! 1003:
! 1004: /**
! 1005: * Rename a group.
! 1006: *
! 1007: * @param od The oscar odion.
! 1008: * @param oldgn The old group name.
! 1009: * @param newgn The new group name.
! 1010: * @return Return 0 if no errors, otherwise return the error number.
! 1011: */
! 1012: int aim_ssi_rename_group(OscarData *od, const char *oldgn, const char *newgn)
! 1013: {
! 1014: struct aim_ssi_item *group;
! 1015:
! 1016: if (!od || !oldgn || !newgn)
! 1017: return -EINVAL;
! 1018:
! 1019: if (!(group = aim_ssi_itemlist_finditem(od->ssi.local, oldgn, NULL, AIM_SSI_TYPE_GROUP)))
! 1020: return -EINVAL;
! 1021:
! 1022: g_free(group->name);
! 1023: group->name = g_strdup(newgn);
! 1024:
! 1025: /* Sync our local list with the server list */
! 1026: return aim_ssi_sync(od);
! 1027: }
! 1028:
! 1029: /**
! 1030: * Stores your permit/deny setting on the server, and starts using it.
! 1031: *
! 1032: * @param od The oscar odion.
! 1033: * @param permdeny Your permit/deny setting. For ICQ accounts, it actually affects your visibility
! 1034: * and has nothing to do with blocking. Can be one of the following:
! 1035: * 1 - Allow all users
! 1036: * 2 - Block all users
! 1037: * 3 - Allow only the users below
! 1038: * 4 - Block only the users below
! 1039: * 5 - Allow only users on my buddy list
! 1040: * @return Return 0 if no errors, otherwise return the error number.
! 1041: */
! 1042: int aim_ssi_setpermdeny(OscarData *od, guint8 permdeny)
! 1043: {
! 1044: struct aim_ssi_item *tmp;
! 1045:
! 1046: if (!od || !od->ssi.received_data)
! 1047: return -EINVAL;
! 1048:
! 1049: /* Find the PDINFO item, or add it if it does not exist */
! 1050: if (!(tmp = aim_ssi_itemlist_finditem(od->ssi.local, NULL, NULL, AIM_SSI_TYPE_PDINFO))) {
! 1051: /* Make sure the master group exists */
! 1052: if (aim_ssi_itemlist_find(od->ssi.local, 0x0000, 0x0000) == NULL)
! 1053: aim_ssi_itemlist_add(&od->ssi.local, NULL, 0x0000, 0x0000, AIM_SSI_TYPE_GROUP, NULL);
! 1054:
! 1055: tmp = aim_ssi_itemlist_add(&od->ssi.local, NULL, 0x0000, 0xFFFF, AIM_SSI_TYPE_PDINFO, NULL);
! 1056: }
! 1057:
! 1058: /* Need to add the 0x00ca TLV to the TLV chain */
! 1059: aim_tlvlist_replace_8(&tmp->data, 0x00ca, permdeny);
! 1060:
! 1061: /* Sync our local list with the server list */
! 1062: return aim_ssi_sync(od);
! 1063: }
! 1064:
! 1065: /**
! 1066: * Set buddy icon information
! 1067: *
! 1068: * @param od The oscar odion.
! 1069: * @param iconcsum The MD5 checksum of the icon you are using.
! 1070: * @param iconcsumlen Length of the MD5 checksum given above. Should be 0x10 bytes.
! 1071: * @return Return 0 if no errors, otherwise return the error number.
! 1072: */
! 1073: int aim_ssi_seticon(OscarData *od, const guint8 *iconsum, guint8 iconsumlen)
! 1074: {
! 1075: struct aim_ssi_item *tmp;
! 1076: guint8 *csumdata;
! 1077:
! 1078: if (!od || !iconsum || !iconsumlen || !od->ssi.received_data)
! 1079: return -EINVAL;
! 1080:
! 1081: /* Find the ICONINFO item, or add it if it does not exist */
! 1082: if (!(tmp = aim_ssi_itemlist_finditem(od->ssi.local, NULL, "1", AIM_SSI_TYPE_ICONINFO))) {
! 1083: /* Make sure the master group exists */
! 1084: if (aim_ssi_itemlist_find(od->ssi.local, 0x0000, 0x0000) == NULL)
! 1085: aim_ssi_itemlist_add(&od->ssi.local, NULL, 0x0000, 0x0000, AIM_SSI_TYPE_GROUP, NULL);
! 1086:
! 1087: tmp = aim_ssi_itemlist_add(&od->ssi.local, "1", 0x0000, 0xFFFF, AIM_SSI_TYPE_ICONINFO, NULL);
! 1088: }
! 1089:
! 1090: /* Need to add the 0x00d5 TLV to the TLV chain */
! 1091: csumdata = (guint8 *)g_malloc((iconsumlen+2)*sizeof(guint8));
! 1092: (void)aimutil_put8(&csumdata[0], 0x00);
! 1093: (void)aimutil_put8(&csumdata[1], iconsumlen);
! 1094: memcpy(&csumdata[2], iconsum, iconsumlen);
! 1095: aim_tlvlist_replace_raw(&tmp->data, 0x00d5, (iconsumlen+2) * sizeof(guint8), csumdata);
! 1096: g_free(csumdata);
! 1097:
! 1098: /* Need to add the 0x0131 TLV to the TLV chain, used to cache the icon */
! 1099: aim_tlvlist_replace_noval(&tmp->data, 0x0131);
! 1100:
! 1101: /* Sync our local list with the server list */
! 1102: aim_ssi_sync(od);
! 1103: return 0;
! 1104: }
! 1105:
! 1106: /**
! 1107: * Remove a reference to a server stored buddy icon. This will make your
! 1108: * icon stop showing up to other people.
! 1109: *
! 1110: * Really this function just sets the icon to a dummy value. It's weird...
! 1111: * but I think the dummy value basically means "I don't have an icon!"
! 1112: *
! 1113: * @param od The oscar session.
! 1114: * @return Return 0 if no errors, otherwise return the error number.
! 1115: */
! 1116: int aim_ssi_delicon(OscarData *od)
! 1117: {
! 1118: const guint8 csumdata[] = {0x02, 0x01, 0xd2, 0x04, 0x72};
! 1119:
! 1120: return aim_ssi_seticon(od, csumdata, 5);
! 1121: }
! 1122:
! 1123: /**
! 1124: * Stores your setting for various SSI settings. Whether you
! 1125: * should show up as idle or not, etc.
! 1126: *
! 1127: * @param od The oscar odion.
! 1128: * @param presence A bitmask of the first 32 entries [0-31] from
! 1129: * http://dev.aol.com/aim/oscar/#FEEDBAG__BUDDY_PREFS
! 1130: * 0x00000002 - Hide "eBuddy group" (whatever that is)
! 1131: * 0x00000400 - Allow others to see your idle time
! 1132: * 0x00020000 - Don't show Recent Buddies
! 1133: * @return Return 0 if no errors, otherwise return the error number.
! 1134: */
! 1135: int aim_ssi_setpresence(OscarData *od, guint32 presence) {
! 1136: struct aim_ssi_item *tmp;
! 1137:
! 1138: if (!od || !od->ssi.received_data)
! 1139: return -EINVAL;
! 1140:
! 1141: /* Find the PRESENCEPREFS item, or add it if it does not exist */
! 1142: if (!(tmp = aim_ssi_itemlist_finditem(od->ssi.local, NULL, NULL, AIM_SSI_TYPE_PRESENCEPREFS))) {
! 1143: /* Make sure the master group exists */
! 1144: if (aim_ssi_itemlist_find(od->ssi.local, 0x0000, 0x0000) == NULL)
! 1145: aim_ssi_itemlist_add(&od->ssi.local, NULL, 0x0000, 0x0000, AIM_SSI_TYPE_GROUP, NULL);
! 1146:
! 1147: tmp = aim_ssi_itemlist_add(&od->ssi.local, NULL, 0x0000, 0xFFFF, AIM_SSI_TYPE_PRESENCEPREFS, NULL);
! 1148: }
! 1149:
! 1150: /* Need to add the x00c9 TLV to the TLV chain */
! 1151: aim_tlvlist_replace_32(&tmp->data, 0x00c9, presence);
! 1152:
! 1153: /* Sync our local list with the server list */
! 1154: return aim_ssi_sync(od);
! 1155: }
! 1156:
! 1157: /*
! 1158: * Subtype 0x0002 - Request SSI Rights.
! 1159: */
! 1160: int aim_ssi_reqrights(OscarData *od)
! 1161: {
! 1162: FlapConnection *conn;
! 1163:
! 1164: if (!od || !(conn = flap_connection_findbygroup(od, SNAC_FAMILY_FEEDBAG)))
! 1165: return -EINVAL;
! 1166:
! 1167: aim_genericreq_n_snacid(od, conn, SNAC_FAMILY_FEEDBAG, SNAC_SUBTYPE_FEEDBAG_REQRIGHTS);
! 1168:
! 1169: return 0;
! 1170: }
! 1171:
! 1172: /*
! 1173: * Subtype 0x0003 - SSI Rights Information.
! 1174: */
! 1175: static int parserights(OscarData *od, FlapConnection *conn, aim_module_t *mod, FlapFrame *frame, aim_modsnac_t *snac, ByteStream *bs)
! 1176: {
! 1177: int ret = 0, i;
! 1178: aim_rxcallback_t userfunc;
! 1179: GSList *tlvlist;
! 1180: aim_tlv_t *tlv;
! 1181: ByteStream bstream;
! 1182: guint16 *maxitems;
! 1183:
! 1184: /* This SNAC is made up of a bunch of TLVs */
! 1185: tlvlist = aim_tlvlist_read(bs);
! 1186:
! 1187: /* TLV 0x0004 contains the maximum number of each item */
! 1188: if (!(tlv = aim_tlv_gettlv(tlvlist, 0x0004, 1))) {
! 1189: aim_tlvlist_free(tlvlist);
! 1190: return 0;
! 1191: }
! 1192:
! 1193: byte_stream_init(&bstream, tlv->value, tlv->length);
! 1194:
! 1195: maxitems = (guint16 *)g_malloc((tlv->length/2)*sizeof(guint16));
! 1196:
! 1197: for (i=0; i<(tlv->length/2); i++)
! 1198: maxitems[i] = byte_stream_get16(&bstream);
! 1199:
! 1200: if ((userfunc = aim_callhandler(od, snac->family, snac->subtype)))
! 1201: ret = userfunc(od, conn, frame, tlv->length/2, maxitems);
! 1202:
! 1203: aim_tlvlist_free(tlvlist);
! 1204: g_free(maxitems);
! 1205:
! 1206: return ret;
! 1207: }
! 1208:
! 1209: /*
! 1210: * Subtype 0x0004 - Request SSI Data when you don't have a timestamp and
! 1211: * revision number.
! 1212: *
! 1213: */
! 1214: int aim_ssi_reqdata(OscarData *od)
! 1215: {
! 1216: FlapConnection *conn;
! 1217:
! 1218: if (!od || !(conn = flap_connection_findbygroup(od, SNAC_FAMILY_FEEDBAG)))
! 1219: return -EINVAL;
! 1220:
! 1221: /* Free any current data, just in case */
! 1222: aim_ssi_freelist(od);
! 1223:
! 1224: aim_genericreq_n_snacid(od, conn, SNAC_FAMILY_FEEDBAG, SNAC_SUBTYPE_FEEDBAG_REQDATA);
! 1225:
! 1226: return 0;
! 1227: }
! 1228:
! 1229: /*
! 1230: * Subtype 0x0006 - SSI Data.
! 1231: */
! 1232: static int parsedata(OscarData *od, FlapConnection *conn, aim_module_t *mod, FlapFrame *frame, aim_modsnac_t *snac, ByteStream *bs)
! 1233: {
! 1234: int ret = 0;
! 1235: aim_rxcallback_t userfunc;
! 1236: guint8 fmtver; /* guess */
! 1237: guint16 namelen, gid, bid, type;
! 1238: char *name;
! 1239: GSList *data;
! 1240: GString *debugstr = g_string_new("");
! 1241:
! 1242: fmtver = byte_stream_get8(bs); /* Version of ssi data. Should be 0x00 */
! 1243: od->ssi.numitems += byte_stream_get16(bs); /* # of items in this SSI SNAC */
! 1244:
! 1245: /* Read in the list */
! 1246: while (byte_stream_bytes_left(bs) > 4) { /* last four bytes are timestamp */
! 1247: if ((namelen = byte_stream_get16(bs)))
! 1248: name = byte_stream_getstr(bs, namelen);
! 1249: else
! 1250: name = NULL;
! 1251: gid = byte_stream_get16(bs);
! 1252: bid = byte_stream_get16(bs);
! 1253: type = byte_stream_get16(bs);
! 1254: data = aim_tlvlist_readlen(bs, byte_stream_get16(bs));
! 1255: aim_ssi_item_debug_append(debugstr, "\t", aim_ssi_itemlist_add(&od->ssi.official, name, gid, bid, type, data));
! 1256: g_free(name);
! 1257: aim_tlvlist_free(data);
! 1258: }
! 1259: purple_debug_misc("oscar", "Reading items from tlvlist for account %s:\n%s",
! 1260: purple_connection_get_account(od->gc)->username, debugstr->str);
! 1261: g_string_free(debugstr, TRUE);
! 1262:
! 1263: /* Read in the timestamp */
! 1264: od->ssi.timestamp = byte_stream_get32(bs);
! 1265:
! 1266: if (!(snac->flags & 0x0001)) {
! 1267: /* Make a copy of the list */
! 1268: struct aim_ssi_item *cur;
! 1269: for (cur=od->ssi.official; cur; cur=cur->next)
! 1270: aim_ssi_itemlist_add(&od->ssi.local, cur->name, cur->gid, cur->bid, cur->type, cur->data);
! 1271:
! 1272: od->ssi.received_data = TRUE;
! 1273:
! 1274: if ((userfunc = aim_callhandler(od, snac->family, snac->subtype)))
! 1275: ret = userfunc(od, conn, frame, fmtver, od->ssi.numitems, od->ssi.timestamp);
! 1276: }
! 1277:
! 1278: return ret;
! 1279: }
! 1280:
! 1281: /*
! 1282: * Subtype 0x0007 - SSI Activate Data.
! 1283: *
! 1284: * Should be sent after receiving 13/6 or 13/f to tell the server you
! 1285: * are ready to begin using the list. It will promptly give you the
! 1286: * presence information for everyone in your list and put your permit/deny
! 1287: * settings into effect.
! 1288: *
! 1289: */
! 1290: int aim_ssi_enable(OscarData *od)
! 1291: {
! 1292: FlapConnection *conn;
! 1293:
! 1294: if (!od || !(conn = flap_connection_findbygroup(od, SNAC_FAMILY_FEEDBAG)))
! 1295: return -EINVAL;
! 1296:
! 1297: aim_genericreq_n(od, conn, SNAC_FAMILY_FEEDBAG, 0x0007);
! 1298:
! 1299: return 0;
! 1300: }
! 1301:
! 1302: /*
! 1303: * Subtype 0x0008/0x0009/0x000a - SSI Add/Mod/Del Item(s).
! 1304: *
! 1305: * Sends the SNAC to add, modify, or delete items from the server-stored
! 1306: * information. These 3 SNACs all have an identical structure. The only
! 1307: * difference is the subtype that is set for the SNAC.
! 1308: *
! 1309: */
! 1310: static int aim_ssi_addmoddel(OscarData *od)
! 1311: {
! 1312: FlapConnection *conn;
! 1313: ByteStream bs;
! 1314: aim_snacid_t snacid;
! 1315: int bslen;
! 1316: struct aim_ssi_tmp *cur;
! 1317:
! 1318: if (!od || !(conn = flap_connection_findbygroup(od, SNAC_FAMILY_FEEDBAG)) || !od->ssi.pending || !od->ssi.pending->item)
! 1319: return -EINVAL;
! 1320:
! 1321: /* Calculate total SNAC size */
! 1322: bslen = 0;
! 1323: for (cur=od->ssi.pending; cur; cur=cur->next) {
! 1324: bslen += 10; /* For length, GID, BID, type, and length */
! 1325: if (cur->item->name)
! 1326: bslen += strlen(cur->item->name);
! 1327: if (cur->item->data)
! 1328: bslen += aim_tlvlist_size(cur->item->data);
! 1329: }
! 1330:
! 1331: byte_stream_new(&bs, bslen);
! 1332:
! 1333: for (cur=od->ssi.pending; cur; cur=cur->next) {
! 1334: byte_stream_put16(&bs, cur->item->name ? strlen(cur->item->name) : 0);
! 1335: if (cur->item->name)
! 1336: byte_stream_putstr(&bs, cur->item->name);
! 1337: byte_stream_put16(&bs, cur->item->gid);
! 1338: byte_stream_put16(&bs, cur->item->bid);
! 1339: byte_stream_put16(&bs, cur->item->type);
! 1340: byte_stream_put16(&bs, cur->item->data ? aim_tlvlist_size(cur->item->data) : 0);
! 1341: if (cur->item->data)
! 1342: aim_tlvlist_write(&bs, &cur->item->data);
! 1343: }
! 1344:
! 1345: snacid = aim_cachesnac(od, SNAC_FAMILY_FEEDBAG, od->ssi.pending->action, 0x0000, NULL, 0);
! 1346: flap_connection_send_snac(od, conn, SNAC_FAMILY_FEEDBAG, od->ssi.pending->action, snacid, &bs);
! 1347:
! 1348: byte_stream_destroy(&bs);
! 1349:
! 1350: return 0;
! 1351: }
! 1352:
! 1353: /*
! 1354: * Subtype 0x0008 - Incoming SSI add.
! 1355: *
! 1356: * Sent by the server, for example, when someone is added to
! 1357: * your "Recent Buddies" group.
! 1358: */
! 1359: static int parseadd(OscarData *od, FlapConnection *conn, aim_module_t *mod, FlapFrame *frame, aim_modsnac_t *snac, ByteStream *bs)
! 1360: {
! 1361: int ret = 0;
! 1362: aim_rxcallback_t userfunc;
! 1363: char *name;
! 1364: guint16 len, gid, bid, type;
! 1365: GSList *data;
! 1366:
! 1367: while (byte_stream_bytes_left(bs)) {
! 1368: if ((len = byte_stream_get16(bs)))
! 1369: name = byte_stream_getstr(bs, len);
! 1370: else
! 1371: name = NULL;
! 1372: gid = byte_stream_get16(bs);
! 1373: bid = byte_stream_get16(bs);
! 1374: type = byte_stream_get16(bs);
! 1375: if ((len = byte_stream_get16(bs)))
! 1376: data = aim_tlvlist_readlen(bs, len);
! 1377: else
! 1378: data = NULL;
! 1379:
! 1380: aim_ssi_itemlist_add(&od->ssi.local, name, gid, bid, type, data);
! 1381: aim_ssi_itemlist_add(&od->ssi.official, name, gid, bid, type, data);
! 1382: aim_tlvlist_free(data);
! 1383:
! 1384: if ((userfunc = aim_callhandler(od, snac->family, snac->subtype)))
! 1385: ret = userfunc(od, conn, frame, snac->subtype, type, name);
! 1386:
! 1387: g_free(name);
! 1388: }
! 1389:
! 1390: return ret;
! 1391: }
! 1392:
! 1393: /*
! 1394: * Subtype 0x0009 - Incoming SSI mod.
! 1395: */
! 1396: static int parsemod(OscarData *od, FlapConnection *conn, aim_module_t *mod, FlapFrame *frame, aim_modsnac_t *snac, ByteStream *bs)
! 1397: {
! 1398: int ret = 0;
! 1399: aim_rxcallback_t userfunc;
! 1400: char *name;
! 1401: guint16 len, gid, bid, type;
! 1402: GSList *data;
! 1403: struct aim_ssi_item *item;
! 1404:
! 1405: while (byte_stream_bytes_left(bs)) {
! 1406: if ((len = byte_stream_get16(bs)))
! 1407: name = byte_stream_getstr(bs, len);
! 1408: else
! 1409: name = NULL;
! 1410: gid = byte_stream_get16(bs);
! 1411: bid = byte_stream_get16(bs);
! 1412: type = byte_stream_get16(bs);
! 1413: if ((len = byte_stream_get16(bs)))
! 1414: data = aim_tlvlist_readlen(bs, len);
! 1415: else
! 1416: data = NULL;
! 1417:
! 1418: /* Replace the 2 local items with the given one */
! 1419: if ((item = aim_ssi_itemlist_find(od->ssi.local, gid, bid))) {
! 1420: item->type = type;
! 1421: g_free(item->name);
! 1422: item->name = g_strdup(name);
! 1423: aim_tlvlist_free(item->data);
! 1424: item->data = aim_tlvlist_copy(data);
! 1425: }
! 1426:
! 1427: if ((item = aim_ssi_itemlist_find(od->ssi.official, gid, bid))) {
! 1428: item->type = type;
! 1429: g_free(item->name);
! 1430: item->name = g_strdup(name);
! 1431: aim_tlvlist_free(item->data);
! 1432: item->data = aim_tlvlist_copy(data);
! 1433: }
! 1434:
! 1435: if ((userfunc = aim_callhandler(od, snac->family, snac->subtype)))
! 1436: ret = userfunc(od, conn, frame, snac->subtype, type, name);
! 1437:
! 1438: g_free(name);
! 1439: aim_tlvlist_free(data);
! 1440: }
! 1441:
! 1442: return ret;
! 1443: }
! 1444:
! 1445: /*
! 1446: * Subtype 0x000a - Incoming SSI del.
! 1447: *
! 1448: * XXX - It would probably be good for the client to actually do something when it gets this.
! 1449: */
! 1450: static int parsedel(OscarData *od, FlapConnection *conn, aim_module_t *mod, FlapFrame *frame, aim_modsnac_t *snac, ByteStream *bs)
! 1451: {
! 1452: int ret = 0;
! 1453: aim_rxcallback_t userfunc;
! 1454: guint16 gid, bid;
! 1455: struct aim_ssi_item *del;
! 1456:
! 1457: while (byte_stream_bytes_left(bs)) {
! 1458: byte_stream_advance(bs, byte_stream_get16(bs));
! 1459: gid = byte_stream_get16(bs);
! 1460: bid = byte_stream_get16(bs);
! 1461: byte_stream_get16(bs);
! 1462: byte_stream_advance(bs, byte_stream_get16(bs));
! 1463:
! 1464: if ((del = aim_ssi_itemlist_find(od->ssi.local, gid, bid)))
! 1465: aim_ssi_itemlist_del(&od->ssi.local, del);
! 1466: if ((del = aim_ssi_itemlist_find(od->ssi.official, gid, bid)))
! 1467: aim_ssi_itemlist_del(&od->ssi.official, del);
! 1468:
! 1469: if ((userfunc = aim_callhandler(od, snac->family, snac->subtype)))
! 1470: ret = userfunc(od, conn, frame);
! 1471: }
! 1472:
! 1473: return ret;
! 1474: }
! 1475:
! 1476: /*
! 1477: * Subtype 0x000e - SSI Add/Mod/Del Ack.
! 1478: *
! 1479: * Response to add, modify, or delete SNAC (sent with aim_ssi_addmoddel).
! 1480: *
! 1481: */
! 1482: static int parseack(OscarData *od, FlapConnection *conn, aim_module_t *mod, FlapFrame *frame, aim_modsnac_t *snac, ByteStream *bs)
! 1483: {
! 1484: int ret = 0;
! 1485: aim_rxcallback_t userfunc;
! 1486: struct aim_ssi_tmp *cur, *del;
! 1487:
! 1488: /* Read in the success/failure flags from the ack SNAC */
! 1489: cur = od->ssi.pending;
! 1490: while (cur && (byte_stream_bytes_left(bs)>0)) {
! 1491: cur->ack = byte_stream_get16(bs);
! 1492: cur = cur->next;
! 1493: }
! 1494:
! 1495: /*
! 1496: * If outcome is 0, then add the item to the item list, or replace the other item,
! 1497: * or remove the old item. If outcome is non-zero, then remove the item from the
! 1498: * local list, or unmodify it, or add it.
! 1499: */
! 1500: for (cur=od->ssi.pending; (cur && (cur->ack != 0xffff)); cur=cur->next) {
! 1501: if (cur->item) {
! 1502: if (cur->ack) {
! 1503: /* Our action was unsuccessful, so change the local list back to how it was */
! 1504: if (cur->action == SNAC_SUBTYPE_FEEDBAG_ADD) {
! 1505: /* Remove the item from the local list */
! 1506: /* Make sure cur->item is still valid memory */
! 1507: if (aim_ssi_itemlist_valid(od->ssi.local, cur->item)) {
! 1508: cur->name = g_strdup(cur->item->name);
! 1509: aim_ssi_itemlist_del(&od->ssi.local, cur->item);
! 1510: }
! 1511: cur->item = NULL;
! 1512:
! 1513: } else if (cur->action == SNAC_SUBTYPE_FEEDBAG_MOD) {
! 1514: /* Replace the local item with the item from the official list */
! 1515: if (aim_ssi_itemlist_valid(od->ssi.local, cur->item)) {
! 1516: struct aim_ssi_item *cur1;
! 1517: if ((cur1 = aim_ssi_itemlist_find(od->ssi.official, cur->item->gid, cur->item->bid))) {
! 1518: g_free(cur->item->name);
! 1519: cur->item->name = g_strdup(cur1->name);
! 1520: aim_tlvlist_free(cur->item->data);
! 1521: cur->item->data = aim_tlvlist_copy(cur1->data);
! 1522: }
! 1523: } else
! 1524: cur->item = NULL;
! 1525:
! 1526: } else if (cur->action == SNAC_SUBTYPE_FEEDBAG_DEL) {
! 1527: /* Add the item back into the local list */
! 1528: if (aim_ssi_itemlist_valid(od->ssi.official, cur->item)) {
! 1529: aim_ssi_itemlist_add(&od->ssi.local, cur->item->name, cur->item->gid, cur->item->bid, cur->item->type, cur->item->data);
! 1530: } else
! 1531: cur->item = NULL;
! 1532: }
! 1533:
! 1534: } else {
! 1535: /* Do the exact opposite */
! 1536: if (cur->action == SNAC_SUBTYPE_FEEDBAG_ADD) {
! 1537: /* Add the local item to the official list */
! 1538: if (aim_ssi_itemlist_valid(od->ssi.local, cur->item)) {
! 1539: aim_ssi_itemlist_add(&od->ssi.official, cur->item->name, cur->item->gid, cur->item->bid, cur->item->type, cur->item->data);
! 1540: } else
! 1541: cur->item = NULL;
! 1542:
! 1543: } else if (cur->action == SNAC_SUBTYPE_FEEDBAG_MOD) {
! 1544: /* Replace the official item with the item from the local list */
! 1545: if (aim_ssi_itemlist_valid(od->ssi.local, cur->item)) {
! 1546: struct aim_ssi_item *cur1;
! 1547: if ((cur1 = aim_ssi_itemlist_find(od->ssi.official, cur->item->gid, cur->item->bid))) {
! 1548: g_free(cur1->name);
! 1549: cur1->name = g_strdup(cur->item->name);
! 1550: aim_tlvlist_free(cur1->data);
! 1551: cur1->data = aim_tlvlist_copy(cur->item->data);
! 1552: }
! 1553: } else
! 1554: cur->item = NULL;
! 1555:
! 1556: } else if (cur->action == SNAC_SUBTYPE_FEEDBAG_DEL) {
! 1557: /* Remove the item from the official list */
! 1558: if (aim_ssi_itemlist_valid(od->ssi.official, cur->item))
! 1559: aim_ssi_itemlist_del(&od->ssi.official, cur->item);
! 1560: cur->item = NULL;
! 1561: }
! 1562:
! 1563: }
! 1564: } /* End if (cur->item) */
! 1565: } /* End for loop */
! 1566:
! 1567: if ((userfunc = aim_callhandler(od, snac->family, snac->subtype)))
! 1568: ret = userfunc(od, conn, frame, od->ssi.pending);
! 1569:
! 1570: /* Free all aim_ssi_tmp's with an outcome */
! 1571: cur = od->ssi.pending;
! 1572: while (cur && (cur->ack != 0xffff)) {
! 1573: del = cur;
! 1574: cur = cur->next;
! 1575: g_free(del->name);
! 1576: g_free(del);
! 1577: }
! 1578: od->ssi.pending = cur;
! 1579:
! 1580: /* If we're not waiting for any more acks, then send more SNACs */
! 1581: if (!od->ssi.pending) {
! 1582: od->ssi.waiting_for_ack = FALSE;
! 1583: aim_ssi_sync(od);
! 1584: }
! 1585:
! 1586: return ret;
! 1587: }
! 1588:
! 1589: /*
! 1590: * Subtype 0x000f - SSI Data Unchanged.
! 1591: *
! 1592: * Response to aim_ssi_reqifchanged() if the server-side data is not newer than
! 1593: * posted local stamp/revision.
! 1594: *
! 1595: */
! 1596: static int parsedataunchanged(OscarData *od, FlapConnection *conn, aim_module_t *mod, FlapFrame *frame, aim_modsnac_t *snac, ByteStream *bs)
! 1597: {
! 1598: int ret = 0;
! 1599: aim_rxcallback_t userfunc;
! 1600:
! 1601: od->ssi.received_data = TRUE;
! 1602:
! 1603: if ((userfunc = aim_callhandler(od, snac->family, snac->subtype)))
! 1604: ret = userfunc(od, conn, frame);
! 1605:
! 1606: return ret;
! 1607: }
! 1608:
! 1609: /*
! 1610: * Subtype 0x0011 - SSI Begin Data Modification.
! 1611: *
! 1612: * Tell the server you're going to start modifying data. This marks
! 1613: * the beginning of a transaction.
! 1614: */
! 1615: int aim_ssi_modbegin(OscarData *od)
! 1616: {
! 1617: FlapConnection *conn;
! 1618:
! 1619: if (!od || !(conn = flap_connection_findbygroup(od, SNAC_FAMILY_FEEDBAG)))
! 1620: return -EINVAL;
! 1621:
! 1622: aim_genericreq_n(od, conn, SNAC_FAMILY_FEEDBAG, SNAC_SUBTYPE_FEEDBAG_EDITSTART);
! 1623:
! 1624: return 0;
! 1625: }
! 1626:
! 1627: /*
! 1628: * Subtype 0x0012 - SSI End Data Modification.
! 1629: *
! 1630: * Tell the server you're finished modifying data. The marks the end
! 1631: * of a transaction.
! 1632: */
! 1633: int aim_ssi_modend(OscarData *od)
! 1634: {
! 1635: FlapConnection *conn;
! 1636:
! 1637: if (!od || !(conn = flap_connection_findbygroup(od, SNAC_FAMILY_FEEDBAG)))
! 1638: return -EINVAL;
! 1639:
! 1640: aim_genericreq_n(od, conn, SNAC_FAMILY_FEEDBAG, SNAC_SUBTYPE_FEEDBAG_EDITSTOP);
! 1641:
! 1642: return 0;
! 1643: }
! 1644:
! 1645: /*
! 1646: * Subtype 0x0015 - Receive an authorization grant
! 1647: */
! 1648: static int receiveauthgrant(OscarData *od, FlapConnection *conn, aim_module_t *mod, FlapFrame *frame, aim_modsnac_t *snac, ByteStream *bs)
! 1649: {
! 1650: int ret = 0;
! 1651: aim_rxcallback_t userfunc;
! 1652: guint16 tmp;
! 1653: char *bn, *msg, *tmpstr;
! 1654:
! 1655: /* Read buddy name */
! 1656: tmp = byte_stream_get8(bs);
! 1657: if (!tmp) {
! 1658: purple_debug_warning("oscar", "Dropping auth grant SNAC "
! 1659: "because username was empty\n");
! 1660: return 0;
! 1661: }
! 1662: bn = byte_stream_getstr(bs, tmp);
! 1663: if (!g_utf8_validate(bn, -1, NULL)) {
! 1664: purple_debug_warning("oscar", "Dropping auth grant SNAC "
! 1665: "because the username was not valid UTF-8\n");
! 1666: g_free(bn);
! 1667: }
! 1668:
! 1669: /* Read message */
! 1670: tmp = byte_stream_get16(bs);
! 1671: if (tmp) {
! 1672: msg = byte_stream_getstr(bs, tmp);
! 1673: if (!g_utf8_validate(msg, -1, NULL)) {
! 1674: /* Ugh, msg isn't UTF8. Let's salvage. */
! 1675: purple_debug_warning("oscar", "Got non-UTF8 message in auth "
! 1676: "grant from %s\n", bn);
! 1677: tmpstr = purple_utf8_salvage(msg);
! 1678: g_free(msg);
! 1679: msg = tmpstr;
! 1680: }
! 1681: } else
! 1682: msg = NULL;
! 1683:
! 1684: /* Unknown */
! 1685: tmp = byte_stream_get16(bs);
! 1686:
! 1687: if ((userfunc = aim_callhandler(od, snac->family, snac->subtype)))
! 1688: ret = userfunc(od, conn, frame, bn, msg);
! 1689:
! 1690: g_free(bn);
! 1691: g_free(msg);
! 1692:
! 1693: return ret;
! 1694: }
! 1695:
! 1696: /*
! 1697: * Subtype 0x0018 - Send authorization request
! 1698: *
! 1699: * Sends a request for authorization to the given contact. The request will either be
! 1700: * granted, denied, or dropped.
! 1701: *
! 1702: */
! 1703: int aim_ssi_sendauthrequest(OscarData *od, const char *bn, const char *msg)
! 1704: {
! 1705: FlapConnection *conn;
! 1706: ByteStream bs;
! 1707: aim_snacid_t snacid;
! 1708:
! 1709: if (!od || !(conn = flap_connection_findbygroup(od, SNAC_FAMILY_FEEDBAG)) || !bn)
! 1710: return -EINVAL;
! 1711:
! 1712: byte_stream_new(&bs, 1+strlen(bn) + 2+(msg ? strlen(msg)+1 : 0) + 2);
! 1713:
! 1714: /* Username */
! 1715: byte_stream_put8(&bs, strlen(bn));
! 1716: byte_stream_putstr(&bs, bn);
! 1717:
! 1718: /* Message (null terminated) */
! 1719: byte_stream_put16(&bs, msg ? strlen(msg) : 0);
! 1720: if (msg) {
! 1721: byte_stream_putstr(&bs, msg);
! 1722: byte_stream_put8(&bs, 0x00);
! 1723: }
! 1724:
! 1725: /* Unknown */
! 1726: byte_stream_put16(&bs, 0x0000);
! 1727:
! 1728: snacid = aim_cachesnac(od, SNAC_FAMILY_FEEDBAG, SNAC_SUBTYPE_FEEDBAG_SENDAUTHREQ, 0x0000, NULL, 0);
! 1729: flap_connection_send_snac(od, conn, SNAC_FAMILY_FEEDBAG, SNAC_SUBTYPE_FEEDBAG_SENDAUTHREQ, snacid, &bs);
! 1730:
! 1731: byte_stream_destroy(&bs);
! 1732:
! 1733: return 0;
! 1734: }
! 1735:
! 1736: /*
! 1737: * Subtype 0x0019 - Receive an authorization request
! 1738: */
! 1739: static int receiveauthrequest(OscarData *od, FlapConnection *conn, aim_module_t *mod, FlapFrame *frame, aim_modsnac_t *snac, ByteStream *bs)
! 1740: {
! 1741: int ret = 0;
! 1742: aim_rxcallback_t userfunc;
! 1743: guint16 tmp;
! 1744: char *bn, *msg, *tmpstr;
! 1745:
! 1746: /* Read buddy name */
! 1747: tmp = byte_stream_get8(bs);
! 1748: if (!tmp) {
! 1749: purple_debug_warning("oscar", "Dropping auth request SNAC "
! 1750: "because username was empty\n");
! 1751: return 0;
! 1752: }
! 1753: bn = byte_stream_getstr(bs, tmp);
! 1754: if (!g_utf8_validate(bn, -1, NULL)) {
! 1755: purple_debug_warning("oscar", "Dropping auth request SNAC "
! 1756: "because the username was not valid UTF-8\n");
! 1757: g_free(bn);
! 1758: }
! 1759:
! 1760: /* Read message */
! 1761: tmp = byte_stream_get16(bs);
! 1762: if (tmp) {
! 1763: msg = byte_stream_getstr(bs, tmp);
! 1764: if (!g_utf8_validate(msg, -1, NULL)) {
! 1765: /* Ugh, msg isn't UTF8. Let's salvage. */
! 1766: purple_debug_warning("oscar", "Got non-UTF8 message in auth "
! 1767: "request from %s\n", bn);
! 1768: tmpstr = purple_utf8_salvage(msg);
! 1769: g_free(msg);
! 1770: msg = tmpstr;
! 1771: }
! 1772: } else
! 1773: msg = NULL;
! 1774:
! 1775: /* Unknown */
! 1776: tmp = byte_stream_get16(bs);
! 1777:
! 1778: if ((userfunc = aim_callhandler(od, snac->family, snac->subtype)))
! 1779: ret = userfunc(od, conn, frame, bn, msg);
! 1780:
! 1781: g_free(bn);
! 1782: g_free(msg);
! 1783:
! 1784: return ret;
! 1785: }
! 1786:
! 1787: /*
! 1788: * Subtype 0x001a - Send authorization reply
! 1789: *
! 1790: * Sends a reply to a request for authorization. The reply can either
! 1791: * grant authorization or deny authorization.
! 1792: *
! 1793: * if reply=0x00 then deny
! 1794: * if reply=0x01 then grant
! 1795: *
! 1796: */
! 1797: int aim_ssi_sendauthreply(OscarData *od, const char *bn, guint8 reply, const char *msg)
! 1798: {
! 1799: FlapConnection *conn;
! 1800: ByteStream bs;
! 1801: aim_snacid_t snacid;
! 1802:
! 1803: if (!od || !(conn = flap_connection_findbygroup(od, SNAC_FAMILY_FEEDBAG)) || !bn)
! 1804: return -EINVAL;
! 1805:
! 1806: byte_stream_new(&bs, 1+strlen(bn) + 1 + 2+(msg ? (strlen(msg)+1) : 0) + 2);
! 1807:
! 1808: /* Username */
! 1809: byte_stream_put8(&bs, strlen(bn));
! 1810: byte_stream_putstr(&bs, bn);
! 1811:
! 1812: /* Grant or deny */
! 1813: byte_stream_put8(&bs, reply);
! 1814:
! 1815: /* Message (null terminated) */
! 1816: byte_stream_put16(&bs, msg ? (strlen(msg)+1) : 0);
! 1817: if (msg) {
! 1818: byte_stream_putstr(&bs, msg);
! 1819: byte_stream_put8(&bs, 0x00);
! 1820: }
! 1821:
! 1822: /* Unknown */
! 1823: byte_stream_put16(&bs, 0x0000);
! 1824:
! 1825: snacid = aim_cachesnac(od, SNAC_FAMILY_FEEDBAG, SNAC_SUBTYPE_FEEDBAG_SENDAUTHREP, 0x0000, NULL, 0);
! 1826: flap_connection_send_snac(od, conn, SNAC_FAMILY_FEEDBAG, SNAC_SUBTYPE_FEEDBAG_SENDAUTHREP, snacid, &bs);
! 1827:
! 1828: byte_stream_destroy(&bs);
! 1829:
! 1830: return 0;
! 1831: }
! 1832:
! 1833: /*
! 1834: * Subtype 0x001b - Receive an authorization reply
! 1835: *
! 1836: * You get this bad boy when other people respond to the authorization
! 1837: * request that you have previously sent them.
! 1838: */
! 1839: static int receiveauthreply(OscarData *od, FlapConnection *conn, aim_module_t *mod, FlapFrame *frame, aim_modsnac_t *snac, ByteStream *bs)
! 1840: {
! 1841: int ret = 0;
! 1842: aim_rxcallback_t userfunc;
! 1843: guint16 tmp;
! 1844: guint8 reply;
! 1845: char *bn, *msg, *tmpstr;
! 1846:
! 1847: /* Read buddy name */
! 1848: tmp = byte_stream_get8(bs);
! 1849: if (!tmp) {
! 1850: purple_debug_warning("oscar", "Dropping auth reply SNAC "
! 1851: "because username was empty\n");
! 1852: return 0;
! 1853: }
! 1854: bn = byte_stream_getstr(bs, tmp);
! 1855: if (!g_utf8_validate(bn, -1, NULL)) {
! 1856: purple_debug_warning("oscar", "Dropping auth reply SNAC "
! 1857: "because the username was not valid UTF-8\n");
! 1858: g_free(bn);
! 1859: }
! 1860:
! 1861: /* Read reply */
! 1862: reply = byte_stream_get8(bs);
! 1863:
! 1864: /* Read message */
! 1865: tmp = byte_stream_get16(bs);
! 1866: if (tmp) {
! 1867: msg = byte_stream_getstr(bs, tmp);
! 1868: if (!g_utf8_validate(msg, -1, NULL)) {
! 1869: /* Ugh, msg isn't UTF8. Let's salvage. */
! 1870: purple_debug_warning("oscar", "Got non-UTF8 message in auth "
! 1871: "reply from %s\n", bn);
! 1872: tmpstr = purple_utf8_salvage(msg);
! 1873: g_free(msg);
! 1874: msg = tmpstr;
! 1875: }
! 1876: } else
! 1877: msg = NULL;
! 1878:
! 1879: /* Unknown */
! 1880: tmp = byte_stream_get16(bs);
! 1881:
! 1882: if ((userfunc = aim_callhandler(od, snac->family, snac->subtype)))
! 1883: ret = userfunc(od, conn, frame, bn, reply, msg);
! 1884:
! 1885: g_free(bn);
! 1886: g_free(msg);
! 1887:
! 1888: return ret;
! 1889: }
! 1890:
! 1891: /*
! 1892: * Subtype 0x001c - Receive a message telling you someone added you to their list.
! 1893: */
! 1894: static int receiveadded(OscarData *od, FlapConnection *conn, aim_module_t *mod, FlapFrame *frame, aim_modsnac_t *snac, ByteStream *bs)
! 1895: {
! 1896: int ret = 0;
! 1897: aim_rxcallback_t userfunc;
! 1898: guint16 tmp;
! 1899: char *bn;
! 1900:
! 1901: /* Read buddy name */
! 1902: tmp = byte_stream_get8(bs);
! 1903: if (!tmp) {
! 1904: purple_debug_warning("oscar", "Dropping 'you were added' SNAC "
! 1905: "because username was empty\n");
! 1906: return 0;
! 1907: }
! 1908: bn = byte_stream_getstr(bs, tmp);
! 1909: if (!g_utf8_validate(bn, -1, NULL)) {
! 1910: purple_debug_warning("oscar", "Dropping 'you were added' SNAC "
! 1911: "because the username was not valid UTF-8\n");
! 1912: g_free(bn);
! 1913: }
! 1914:
! 1915: if ((userfunc = aim_callhandler(od, snac->family, snac->subtype)))
! 1916: ret = userfunc(od, conn, frame, bn);
! 1917:
! 1918: g_free(bn);
! 1919:
! 1920: return ret;
! 1921: }
! 1922:
! 1923: /*
! 1924: * If we're on ICQ, then AIM_SSI_TYPE_DENY is used for the "permanently invisible" list.
! 1925: * AIM_SSI_TYPE_ICQDENY is used for blocking users instead.
! 1926: */
! 1927: guint16
! 1928: aim_ssi_getdenyentrytype(OscarData* od)
! 1929: {
! 1930: return od->icq ? AIM_SSI_TYPE_ICQDENY : AIM_SSI_TYPE_DENY;
! 1931: }
! 1932:
! 1933: static int
! 1934: snachandler(OscarData *od, FlapConnection *conn, aim_module_t *mod, FlapFrame *frame, aim_modsnac_t *snac, ByteStream *bs)
! 1935: {
! 1936: if (snac->subtype == SNAC_SUBTYPE_FEEDBAG_RIGHTSINFO)
! 1937: return parserights(od, conn, mod, frame, snac, bs);
! 1938: else if (snac->subtype == SNAC_SUBTYPE_FEEDBAG_LIST)
! 1939: return parsedata(od, conn, mod, frame, snac, bs);
! 1940: else if (snac->subtype == SNAC_SUBTYPE_FEEDBAG_ADD)
! 1941: return parseadd(od, conn, mod, frame, snac, bs);
! 1942: else if (snac->subtype == SNAC_SUBTYPE_FEEDBAG_MOD)
! 1943: return parsemod(od, conn, mod, frame, snac, bs);
! 1944: else if (snac->subtype == SNAC_SUBTYPE_FEEDBAG_DEL)
! 1945: return parsedel(od, conn, mod, frame, snac, bs);
! 1946: else if (snac->subtype == SNAC_SUBTYPE_FEEDBAG_SRVACK)
! 1947: return parseack(od, conn, mod, frame, snac, bs);
! 1948: else if (snac->subtype == SNAC_SUBTYPE_FEEDBAG_NOLIST)
! 1949: return parsedataunchanged(od, conn, mod, frame, snac, bs);
! 1950: else if (snac->subtype == SNAC_SUBTYPE_FEEDBAG_RECVAUTH)
! 1951: return receiveauthgrant(od, conn, mod, frame, snac, bs);
! 1952: else if (snac->subtype == SNAC_SUBTYPE_FEEDBAG_RECVAUTHREQ)
! 1953: return receiveauthrequest(od, conn, mod, frame, snac, bs);
! 1954: else if (snac->subtype == SNAC_SUBTYPE_FEEDBAG_RECVAUTHREP)
! 1955: return receiveauthreply(od, conn, mod, frame, snac, bs);
! 1956: else if (snac->subtype == SNAC_SUBTYPE_FEEDBAG_ADDED)
! 1957: return receiveadded(od, conn, mod, frame, snac, bs);
! 1958:
! 1959: return 0;
! 1960: }
! 1961:
! 1962: static void
! 1963: ssi_shutdown(OscarData *od, aim_module_t *mod)
! 1964: {
! 1965: aim_ssi_freelist(od);
! 1966: }
! 1967:
! 1968: int
! 1969: ssi_modfirst(OscarData *od, aim_module_t *mod)
! 1970: {
! 1971: mod->family = SNAC_FAMILY_FEEDBAG;
! 1972: mod->version = 0x0004;
! 1973: mod->toolid = 0x0110;
! 1974: mod->toolversion = 0x0629;
! 1975: mod->flags = 0;
! 1976: strncpy(mod->name, "feedbag", sizeof(mod->name));
! 1977: mod->snachandler = snachandler;
! 1978: mod->shutdown = ssi_shutdown;
! 1979:
! 1980: return 0;
! 1981: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to family_feedbag.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Coherent Logic Development] / ChivanetAimPidgin / oscarprpl / src / c