5 static aim_tlv_t *createtlv(void)
9 if (!(newtlv = (aim_tlv_t *)malloc(sizeof(aim_tlv_t))))
11 memset(newtlv, 0, sizeof(aim_tlv_t));
16 static void freetlv(aim_tlv_t **oldtlv)
19 if (!oldtlv || !*oldtlv)
22 free((*oldtlv)->value);
30 * aim_readtlvchain - Read a TLV chain from a buffer.
32 * @maxlen: Length of input buffer
34 * Reads and parses a series of TLV patterns from a data buffer; the
35 * returned structure is manipulatable with the rest of the TLV
36 * routines. When done with a TLV chain, aim_freetlvchain() should
37 * be called to free the dynamic substructures.
39 * XXX There should be a flag setable here to have the tlvlist contain
40 * bstream references, so that at least the ->value portion of each
41 * element doesn't need to be malloc/memcpy'd. This could prove to be
42 * just as effecient as the in-place TLV parsing used in a couple places
46 faim_internal aim_tlvlist_t *aim_readtlvchain(aim_bstream_t *bs)
48 aim_tlvlist_t *list = NULL, *cur;
51 while (aim_bstream_empty(bs)) {
53 type = aimbs_get16(bs);
54 length = aimbs_get16(bs);
56 #if 0 /* temporarily disabled until I know if they're still doing it or not */
58 * Okay, so now AOL has decided that any TLV of
59 * type 0x0013 can only be two bytes, despite
60 * what the actual given length is. So here
61 * we dump any invalid TLVs of that sort. Hopefully
62 * theres no special cases to this special case.
65 if ((type == 0x0013) && (length != 0x0002))
73 cur = (aim_tlvlist_t *)malloc(sizeof(aim_tlvlist_t));
74 memset(cur, 0, sizeof(aim_tlvlist_t));
76 cur->tlv = createtlv();
77 cur->tlv->type = type;
78 if ((cur->tlv->length = length))
79 cur->tlv->value = aimbs_getraw(bs, length);
90 * aim_freetlvchain - Free a TLV chain structure
91 * @list: Chain to be freed
93 * Walks the list of TLVs in the passed TLV chain and
94 * frees each one. Note that any references to this data
95 * should be removed before calling this.
98 faim_internal void aim_freetlvchain(aim_tlvlist_t **list)
105 for (cur = *list; cur; ) {
121 * aim_counttlvchain - Count the number of TLVs in a chain
122 * @list: Chain to be counted
124 * Returns the number of TLVs stored in the passed chain.
127 faim_internal int aim_counttlvchain(aim_tlvlist_t **list)
135 for (cur = *list, count = 0; cur; cur = cur->next)
142 * aim_sizetlvchain - Count the number of bytes in a TLV chain
143 * @list: Chain to be sized
145 * Returns the number of bytes that would be needed to
146 * write the passed TLV chain to a data buffer.
149 faim_internal int aim_sizetlvchain(aim_tlvlist_t **list)
157 for (cur = *list, size = 0; cur; cur = cur->next)
158 size += (4 + cur->tlv->length);
164 * aim_addtlvtochain_str - Add a string to a TLV chain
165 * @list: Desination chain (%NULL pointer if empty)
167 * @str: String to add
168 * @len: Length of string to add (not including %NULL)
170 * Adds the passed string as a TLV element of the passed type
174 faim_internal int aim_addtlvtochain_raw(aim_tlvlist_t **list, const fu16_t t, const fu16_t l, const fu8_t *v)
176 aim_tlvlist_t *newtlv, *cur;
181 if (!(newtlv = (aim_tlvlist_t *)malloc(sizeof(aim_tlvlist_t))))
183 memset(newtlv, 0x00, sizeof(aim_tlvlist_t));
185 if (!(newtlv->tlv = createtlv())) {
189 newtlv->tlv->type = t;
190 if ((newtlv->tlv->length = l)) {
191 newtlv->tlv->value = (fu8_t *)malloc(newtlv->tlv->length);
192 memcpy(newtlv->tlv->value, v, newtlv->tlv->length);
198 for(cur = *list; cur->next; cur = cur->next)
203 return newtlv->tlv->length;
207 * aim_addtlvtochain16 - Add a 16bit integer to a TLV chain
208 * @list: Destination chain
209 * @type: TLV type to add
212 * Adds a two-byte unsigned integer to a TLV chain.
215 faim_internal int aim_addtlvtochain16(aim_tlvlist_t **list, const fu16_t t, const fu16_t v)
219 aimutil_put16(v16, v);
221 return aim_addtlvtochain_raw(list, t, 2, v16);
225 * aim_addtlvtochain32 - Add a 32bit integer to a TLV chain
226 * @list: Destination chain
227 * @type: TLV type to add
230 * Adds a four-byte unsigned integer to a TLV chain.
233 faim_internal int aim_addtlvtochain32(aim_tlvlist_t **list, const fu16_t t, const fu32_t v)
237 aimutil_put32(v32, v);
239 return aim_addtlvtochain_raw(list, t, 4, v32);
243 * aim_addtlvtochain_caps - Add a capability block to a TLV chain
244 * @list: Destination chain
245 * @type: TLV type to add
246 * @caps: Bitfield of capability flags to send
248 * Adds a block of capability blocks to a TLV chain. The bitfield
249 * passed in should be a bitwise %OR of any of the %AIM_CAPS constants:
251 * %AIM_CAPS_BUDDYICON Supports Buddy Icons
253 * %AIM_CAPS_VOICE Supports Voice Chat
255 * %AIM_CAPS_IMIMAGE Supports DirectIM/IMImage
257 * %AIM_CAPS_CHAT Supports Chat
259 * %AIM_CAPS_GETFILE Supports Get File functions
261 * %AIM_CAPS_SENDFILE Supports Send File functions
264 faim_internal int aim_addtlvtochain_caps(aim_tlvlist_t **list, const fu16_t t, const fu16_t caps)
266 fu8_t buf[16*16]; /* icky fixed length buffer */
269 aim_bstream_init(&bs, buf, sizeof(buf));
271 aim_putcap(&bs, caps);
273 return aim_addtlvtochain_raw(list, t, aim_bstream_curpos(&bs), buf);
276 faim_internal int aim_addtlvtochain_userinfo(aim_tlvlist_t **list, fu16_t type, struct aim_userinfo_s *ui)
278 fu8_t buf[1024]; /* bleh */
281 aim_bstream_init(&bs, buf, sizeof(buf));
283 aim_putuserinfo(&bs, ui);
285 return aim_addtlvtochain_raw(list, type, aim_bstream_curpos(&bs), buf);
289 * aim_addtlvtochain_noval - Add a blank TLV to a TLV chain
290 * @list: Destination chain
291 * @type: TLV type to add
293 * Adds a TLV with a zero length to a TLV chain.
296 faim_internal int aim_addtlvtochain_noval(aim_tlvlist_t **list, const fu16_t t)
298 return aim_addtlvtochain_raw(list, t, 0, NULL);
302 * Note that the inner TLV chain will not be modifiable as a tlvchain once
303 * it is written using this. Or rather, it can be, but updates won't be
306 * XXX should probably support sublists for real.
311 faim_internal int aim_addtlvtochain_frozentlvlist(aim_tlvlist_t **list, fu16_t type, aim_tlvlist_t **tl)
317 buflen = aim_sizetlvchain(tl);
322 if (!(buf = malloc(buflen)))
325 aim_bstream_init(&bs, buf, buflen);
327 aim_writetlvchain(&bs, tl);
329 aim_addtlvtochain_raw(list, type, aim_bstream_curpos(&bs), buf);
337 * aim_writetlvchain - Write a TLV chain into a data buffer.
338 * @buf: Destination buffer
339 * @buflen: Maximum number of bytes that will be written to buffer
340 * @list: Source TLV chain
342 * Copies a TLV chain into a raw data buffer, writing only the number
343 * of bytes specified. This operation does not free the chain;
344 * aim_freetlvchain() must still be called to free up the memory used
345 * by the chain structures.
347 * XXX clean this up, make better use of bstreams
349 faim_internal int aim_writetlvchain(aim_bstream_t *bs, aim_tlvlist_t **list)
354 /* do an initial run to test total length */
355 for (cur = *list, goodbuflen = 0; cur; cur = cur->next) {
356 goodbuflen += 2 + 2; /* type + len */
357 goodbuflen += cur->tlv->length;
360 if (goodbuflen > aim_bstream_empty(bs))
361 return 0; /* not enough buffer */
363 /* do the real write-out */
364 for (cur = *list; cur; cur = cur->next) {
365 aimbs_put16(bs, cur->tlv->type);
366 aimbs_put16(bs, cur->tlv->length);
367 if (cur->tlv->length)
368 aimbs_putraw(bs, cur->tlv->value, cur->tlv->length);
371 return 1; /* XXX this is a nonsensical return */
376 * aim_gettlv - Grab the Nth TLV of type type in the TLV list list.
377 * @list: Source chain
378 * @type: Requested TLV type
379 * @nth: Index of TLV of type to get
381 * Returns a pointer to an aim_tlv_t of the specified type;
382 * %NULL on error. The @nth parameter is specified starting at %1.
383 * In most cases, there will be no more than one TLV of any type
387 faim_internal aim_tlv_t *aim_gettlv(aim_tlvlist_t *list, const fu16_t t, const int n)
392 for (cur = list, i = 0; cur; cur = cur->next) {
393 if (cur && cur->tlv) {
394 if (cur->tlv->type == t)
405 * aim_gettlv_str - Retrieve the Nth TLV in chain as a string.
406 * @list: Source TLV chain
407 * @type: TLV type to search for
408 * @nth: Index of TLV to return
410 * Same as aim_gettlv(), except that the return value is a %NULL-
411 * terminated string instead of an aim_tlv_t. This is a
412 * dynamic buffer and must be freed by the caller.
415 faim_internal char *aim_gettlv_str(aim_tlvlist_t *list, const fu16_t t, const int n)
420 if (!(tlv = aim_gettlv(list, t, n)))
423 newstr = (char *) malloc(tlv->length + 1);
424 memcpy(newstr, tlv->value, tlv->length);
425 *(newstr + tlv->length) = '\0';
431 * aim_gettlv8 - Retrieve the Nth TLV in chain as a 8bit integer.
432 * @list: Source TLV chain
433 * @type: TLV type to search for
434 * @nth: Index of TLV to return
436 * Same as aim_gettlv(), except that the return value is a
437 * 8bit integer instead of an aim_tlv_t.
440 faim_internal fu8_t aim_gettlv8(aim_tlvlist_t *list, const fu16_t t, const int n)
444 if (!(tlv = aim_gettlv(list, t, n)))
446 return aimutil_get8(tlv->value);
450 * aim_gettlv16 - Retrieve the Nth TLV in chain as a 16bit integer.
451 * @list: Source TLV chain
452 * @type: TLV type to search for
453 * @nth: Index of TLV to return
455 * Same as aim_gettlv(), except that the return value is a
456 * 16bit integer instead of an aim_tlv_t.
459 faim_internal fu16_t aim_gettlv16(aim_tlvlist_t *list, const fu16_t t, const int n)
463 if (!(tlv = aim_gettlv(list, t, n)))
465 return aimutil_get16(tlv->value);
469 * aim_gettlv32 - Retrieve the Nth TLV in chain as a 32bit integer.
470 * @list: Source TLV chain
471 * @type: TLV type to search for
472 * @nth: Index of TLV to return
474 * Same as aim_gettlv(), except that the return value is a
475 * 32bit integer instead of an aim_tlv_t.
478 faim_internal fu32_t aim_gettlv32(aim_tlvlist_t *list, const fu16_t t, const int n)
482 if (!(tlv = aim_gettlv(list, t, n)))
484 return aimutil_get32(tlv->value);
489 * aim_puttlv_8 - Write a one-byte TLV.
490 * @buf: Destination buffer
494 * Writes a TLV with a one-byte integer value portion.
497 faim_export int aim_puttlv_8(fu8_t *buf, const fu16_t t, const fu8_t v)
503 return aim_puttlv_raw(buf, t, 1, v8);
507 * aim_puttlv_16 - Write a two-byte TLV.
508 * @buf: Destination buffer
512 * Writes a TLV with a two-byte integer value portion.
515 faim_export int aim_puttlv_16(fu8_t *buf, const fu16_t t, const fu16_t v)
519 aimutil_put16(v16, v);
521 return aim_puttlv_raw(buf, t, 2, v16);
526 * aim_puttlv_32 - Write a four-byte TLV.
527 * @buf: Destination buffer
531 * Writes a TLV with a four-byte integer value portion.
534 faim_export int aim_puttlv_32(fu8_t *buf, const fu16_t t, const fu32_t v)
538 aimutil_put32(v32, v);
540 return aim_puttlv_raw(buf, t, 4, v32);
544 * aim_puttlv_raw - Write a raw TLV.
545 * @buf: Destination buffer
547 * @l: Length of string
548 * @v: String to write
550 * Writes a TLV with a raw value portion. (Only the first @l
551 * bytes of the passed buffer will be written, which should not
552 * include a terminating NULL.)
555 faim_export int aim_puttlv_raw(fu8_t *buf, const fu16_t t, const fu16_t l, const fu8_t *v)
559 i = aimutil_put16(buf, t);
560 i += aimutil_put16(buf+i, l);