Annotation of ChivanetAimPidgin/oscarprpl/src/c/tlv.c, revision 1.1.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: #include "oscar.h"
22:
23: static aim_tlv_t *
24: createtlv(guint16 type, guint16 length, guint8 *value)
25: {
26: aim_tlv_t *ret;
27:
28: ret = g_new(aim_tlv_t, 1);
29: ret->type = type;
30: ret->length = length;
31: ret->value = value;
32:
33: return ret;
34: }
35:
36: static void
37: freetlv(aim_tlv_t *oldtlv)
38: {
39: g_free(oldtlv->value);
40: g_free(oldtlv);
41: }
42:
43: static GSList *
44: aim_tlv_read(GSList *list, ByteStream *bs)
45: {
46: guint16 type, length;
47: aim_tlv_t *tlv;
48:
49: type = byte_stream_get16(bs);
50: length = byte_stream_get16(bs);
51:
52: if (length > byte_stream_bytes_left(bs)) {
53: aim_tlvlist_free(list);
54: return NULL;
55: }
56:
57: tlv = createtlv(type, length, NULL);
58: if (tlv->length > 0) {
59: tlv->value = byte_stream_getraw(bs, length);
60: if (!tlv->value) {
61: freetlv(tlv);
62: aim_tlvlist_free(list);
63: return NULL;
64: }
65: }
66:
67: return g_slist_prepend(list, tlv);
68: }
69:
70: /**
71: * Read a TLV chain from a buffer.
72: *
73: * Reads and parses a series of TLV patterns from a data buffer; the
74: * returned structure is manipulatable with the rest of the TLV
75: * routines. When done with a TLV chain, aim_tlvlist_free() should
76: * be called to free the dynamic substructures.
77: *
78: * TODO: There should be a flag setable here to have the tlvlist contain
79: * bstream references, so that at least the ->value portion of each
80: * element doesn't need to be malloc/memcpy'd. This could prove to be
81: * just as efficient as the in-place TLV parsing used in a couple places
82: * in libfaim.
83: *
84: * @param bs Input bstream
85: * @return Return the TLV chain read
86: */
87: GSList *aim_tlvlist_read(ByteStream *bs)
88: {
89: GSList *list = NULL;
90:
91: while (byte_stream_bytes_left(bs) > 0) {
92: list = aim_tlv_read(list, bs);
93: if (list == NULL)
94: return NULL;
95: }
96:
97: return g_slist_reverse(list);
98: }
99:
100: /**
101: * Read a TLV chain from a buffer.
102: *
103: * Reads and parses a series of TLV patterns from a data buffer; the
104: * returned structure is manipulatable with the rest of the TLV
105: * routines. When done with a TLV chain, aim_tlvlist_free() should
106: * be called to free the dynamic substructures.
107: *
108: * TODO: There should be a flag setable here to have the tlvlist contain
109: * bstream references, so that at least the ->value portion of each
110: * element doesn't need to be malloc/memcpy'd. This could prove to be
111: * just as efficient as the in-place TLV parsing used in a couple places
112: * in libfaim.
113: *
114: * @param bs Input bstream
115: * @param num The max number of TLVs that will be read, or -1 if unlimited.
116: * There are a number of places where you want to read in a tlvchain,
117: * but the chain is not at the end of the SNAC, and the chain is
118: * preceded by the number of TLVs. So you can limit that with this.
119: * @return Return the TLV chain read
120: */
121: GSList *aim_tlvlist_readnum(ByteStream *bs, guint16 num)
122: {
123: GSList *list = NULL;
124:
125: while ((byte_stream_bytes_left(bs) > 0) && (num != 0)) {
126: list = aim_tlv_read(list, bs);
127: if (list == NULL)
128: return NULL;
129: num--;
130: }
131:
132: return g_slist_reverse(list);
133: }
134:
135: /**
136: * Read a TLV chain from a buffer.
137: *
138: * Reads and parses a series of TLV patterns from a data buffer; the
139: * returned structure is manipulatable with the rest of the TLV
140: * routines. When done with a TLV chain, aim_tlvlist_free() should
141: * be called to free the dynamic substructures.
142: *
143: * TODO: There should be a flag setable here to have the tlvlist contain
144: * bstream references, so that at least the ->value portion of each
145: * element doesn't need to be malloc/memcpy'd. This could prove to be
146: * just as efficient as the in-place TLV parsing used in a couple places
147: * in libfaim.
148: *
149: * @param bs Input bstream
150: * @param len The max length in bytes that will be read.
151: * There are a number of places where you want to read in a tlvchain,
152: * but the chain is not at the end of the SNAC, and the chain is
153: * preceded by the length of the TLVs. So you can limit that with this.
154: * @return Return the TLV chain read
155: */
156: GSList *aim_tlvlist_readlen(ByteStream *bs, guint16 len)
157: {
158: GSList *list = NULL;
159:
160: while ((byte_stream_bytes_left(bs) > 0) && (len > 0)) {
161: list = aim_tlv_read(list, bs);
162: if (list == NULL)
163: return NULL;
164:
165: len -= 2 + 2 + ((aim_tlv_t *)list->data)->length;
166: }
167:
168: return g_slist_reverse(list);
169: }
170:
171: /**
172: * Duplicate a TLV chain.
173: * This is pretty self explanatory.
174: *
175: * @param orig The TLV chain you want to make a copy of.
176: * @return A newly allocated TLV chain.
177: */
178: GSList *aim_tlvlist_copy(GSList *orig)
179: {
180: GSList *new = NULL;
181: aim_tlv_t *tlv;
182:
183: while (orig != NULL) {
184: tlv = orig->data;
185: aim_tlvlist_add_raw(&new, tlv->type, tlv->length, tlv->value);
186: orig = orig->next;
187: }
188:
189: return new;
190: }
191:
192: /*
193: * Compare two TLV lists for equality. This probably is not the most
194: * efficient way to do this.
195: *
196: * @param one One of the TLV chains to compare.
197: * @param two The other TLV chain to compare.
198: * @return Return 0 if the lists are the same, return 1 if they are different.
199: */
200: int aim_tlvlist_cmp(GSList *one, GSList *two)
201: {
202: ByteStream bs1, bs2;
203:
204: if (aim_tlvlist_size(one) != aim_tlvlist_size(two))
205: return 1;
206:
207: byte_stream_new(&bs1, aim_tlvlist_size(one));
208: byte_stream_new(&bs2, aim_tlvlist_size(two));
209:
210: aim_tlvlist_write(&bs1, &one);
211: aim_tlvlist_write(&bs2, &two);
212:
213: if (memcmp(bs1.data, bs2.data, bs1.len)) {
214: byte_stream_destroy(&bs1);
215: byte_stream_destroy(&bs2);
216: return 1;
217: }
218:
219: byte_stream_destroy(&bs1);
220: byte_stream_destroy(&bs2);
221:
222: return 0;
223: }
224:
225: /**
226: * Free a TLV chain structure
227: *
228: * Walks the list of TLVs in the passed TLV chain and
229: * frees each one. Note that any references to this data
230: * should be removed before calling this.
231: *
232: * @param list Chain to be freed
233: */
234: void aim_tlvlist_free(GSList *list)
235: {
236: while (list != NULL)
237: {
238: freetlv(list->data);
239: list = g_slist_delete_link(list, list);
240: }
241: }
242:
243: /**
244: * Count the number of TLVs in a chain.
245: *
246: * @param list Chain to be counted.
247: * @return The number of TLVs stored in the passed chain.
248: */
249: int aim_tlvlist_count(GSList *list)
250: {
251: GSList *cur;
252: int count;
253:
254: if (list == NULL)
255: return 0;
256:
257: for (cur = list, count = 0; cur; cur = cur->next)
258: count++;
259:
260: return count;
261: }
262:
263: /**
264: * Count the number of bytes in a TLV chain.
265: *
266: * @param list Chain to be sized
267: * @return The number of bytes that would be needed to
268: * write the passed TLV chain to a data buffer.
269: */
270: int aim_tlvlist_size(GSList *list)
271: {
272: GSList *cur;
273: int size;
274:
275: if (list == NULL)
276: return 0;
277:
278: for (cur = list, size = 0; cur; cur = cur->next)
279: size += (4 + ((aim_tlv_t *)cur->data)->length);
280:
281: return size;
282: }
283:
284: /**
285: * Adds the passed string as a TLV element of the passed type
286: * to the TLV chain.
287: *
288: * @param list Desination chain (%NULL pointer if empty).
289: * @param type TLV type.
290: * @param length Length of string to add (not including %NULL).
291: * @param value String to add.
292: * @return The size of the value added.
293: */
294: int aim_tlvlist_add_raw(GSList **list, const guint16 type, const guint16 length, const guint8 *value)
295: {
296: aim_tlv_t *tlv;
297:
298: if (list == NULL)
299: return 0;
300:
301: tlv = createtlv(type, length, NULL);
302: if (tlv->length > 0)
303: tlv->value = g_memdup(value, length);
304:
305: *list = g_slist_append(*list, tlv);
306:
307: return tlv->length;
308: }
309:
310: /**
311: * Add a one byte integer to a TLV chain.
312: *
313: * @param list Destination chain.
314: * @param type TLV type to add.
315: * @param value Value to add.
316: * @return The size of the value added.
317: */
318: int aim_tlvlist_add_8(GSList **list, const guint16 type, const guint8 value)
319: {
320: guint8 v8[1];
321:
322: (void)aimutil_put8(v8, value);
323:
324: return aim_tlvlist_add_raw(list, type, 1, v8);
325: }
326:
327: /**
328: * Add a two byte integer to a TLV chain.
329: *
330: * @param list Destination chain.
331: * @param type TLV type to add.
332: * @param value Value to add.
333: * @return The size of the value added.
334: */
335: int aim_tlvlist_add_16(GSList **list, const guint16 type, const guint16 value)
336: {
337: guint8 v16[2];
338:
339: (void)aimutil_put16(v16, value);
340:
341: return aim_tlvlist_add_raw(list, type, 2, v16);
342: }
343:
344: /**
345: * Add a four byte integer to a TLV chain.
346: *
347: * @param list Destination chain.
348: * @param type TLV type to add.
349: * @param value Value to add.
350: * @return The size of the value added.
351: */
352: int aim_tlvlist_add_32(GSList **list, const guint16 type, const guint32 value)
353: {
354: guint8 v32[4];
355:
356: (void)aimutil_put32(v32, value);
357:
358: return aim_tlvlist_add_raw(list, type, 4, v32);
359: }
360:
361: /**
362: * Add a string to a TLV chain.
363: *
364: * @param list Destination chain.
365: * @param type TLV type to add.
366: * @param value Value to add.
367: * @return The size of the value added.
368: */
369: int aim_tlvlist_add_str(GSList **list, const guint16 type, const char *value)
370: {
371: return aim_tlvlist_add_raw(list, type, strlen(value), (guint8 *)value);
372: }
373:
374: static int
375: count_caps(guint64 caps)
376: {
377: int set_bits = 0;
378: while (caps) {
379: set_bits += caps & 1;
380: caps >>= 1;
381: }
382: return set_bits;
383: }
384:
385: /**
386: * Adds a block of capability blocks to a TLV chain. The bitfield
387: * passed in should be a bitwise %OR of any of the %AIM_CAPS constants:
388: *
389: * %OSCAR_CAPABILITY_BUDDYICON Supports Buddy Icons
390: * %OSCAR_CAPABILITY_TALK Supports Voice Chat
391: * %OSCAR_CAPABILITY_IMIMAGE Supports DirectIM/IMImage
392: * %OSCAR_CAPABILITY_CHAT Supports Chat
393: * %OSCAR_CAPABILITY_GETFILE Supports Get File functions
394: * %OSCAR_CAPABILITY_SENDFILE Supports Send File functions
395: *
396: * @param list Destination chain
397: * @param type TLV type to add
398: * @param caps Bitfield of capability flags to send
399: * @return The size of the value added.
400: */
401: int aim_tlvlist_add_caps(GSList **list, const guint16 type, const guint64 caps, const char *mood)
402: {
403: int len;
404: ByteStream bs;
405: guint32 bs_size;
406: guint8 *data;
407:
408: if (caps == 0)
409: return 0; /* nothing there anyway */
410:
411: data = icq_get_custom_icon_data(mood);
412: bs_size = 16*(count_caps(caps) + (data != NULL ? 1 : 0));
413:
414: byte_stream_new(&bs, bs_size);
415: byte_stream_putcaps(&bs, caps);
416:
417: /* adding of custom icon GUID */
418: if (data != NULL)
419: byte_stream_putraw(&bs, data, 16);
420:
421: len = aim_tlvlist_add_raw(list, type, byte_stream_curpos(&bs), bs.data);
422:
423: byte_stream_destroy(&bs);
424:
425: return len;
426: }
427:
428: /**
429: * Adds the given chatroom info to a TLV chain.
430: *
431: * @param list Destination chain.
432: * @param type TLV type to add.
433: * @param roomname The name of the chat.
434: * @param instance The instance.
435: * @return The size of the value added.
436: */
437: int aim_tlvlist_add_chatroom(GSList **list, guint16 type, guint16 exchange, const char *roomname, guint16 instance)
438: {
439: int len;
440: ByteStream bs;
441:
442: byte_stream_new(&bs, 2 + 1 + strlen(roomname) + 2);
443:
444: byte_stream_put16(&bs, exchange);
445: byte_stream_put8(&bs, strlen(roomname));
446: byte_stream_putstr(&bs, roomname);
447: byte_stream_put16(&bs, instance);
448:
449: len = aim_tlvlist_add_raw(list, type, byte_stream_curpos(&bs), bs.data);
450:
451: byte_stream_destroy(&bs);
452:
453: return len;
454: }
455:
456: /**
457: * Adds a TLV with a zero length to a TLV chain.
458: *
459: * @param list Destination chain.
460: * @param type TLV type to add.
461: * @return The size of the value added.
462: */
463: int aim_tlvlist_add_noval(GSList **list, const guint16 type)
464: {
465: return aim_tlvlist_add_raw(list, type, 0, NULL);
466: }
467:
468: /*
469: * Note that the inner TLV chain will not be modifiable as a tlvchain once
470: * it is written using this. Or rather, it can be, but updates won't be
471: * made to this.
472: *
473: * TODO: Should probably support sublists for real.
474: *
475: * This is so neat.
476: *
477: * @param list Destination chain.
478: * @param type TLV type to add.
479: * @param t1 The TLV chain you want to write.
480: * @return The number of bytes written to the destination TLV chain.
481: * 0 is returned if there was an error or if the destination
482: * TLV chain has length 0.
483: */
484: int aim_tlvlist_add_frozentlvlist(GSList **list, guint16 type, GSList **tlvlist)
485: {
486: int buflen;
487: ByteStream bs;
488:
489: buflen = aim_tlvlist_size(*tlvlist);
490:
491: if (buflen <= 0)
492: return 0;
493:
494: byte_stream_new(&bs, buflen);
495:
496: aim_tlvlist_write(&bs, tlvlist);
497:
498: aim_tlvlist_add_raw(list, type, byte_stream_curpos(&bs), bs.data);
499:
500: byte_stream_destroy(&bs);
501:
502: return buflen;
503: }
504:
505: /**
506: * Substitute a TLV of a given type with a new TLV of the same type. If
507: * you attempt to replace a TLV that does not exist, this function will
508: * just add a new TLV as if you called aim_tlvlist_add_raw().
509: *
510: * @param list Desination chain (%NULL pointer if empty).
511: * @param type TLV type.
512: * @param length Length of string to add (not including %NULL).
513: * @param value String to add.
514: * @return The length of the TLV.
515: */
516: int aim_tlvlist_replace_raw(GSList **list, const guint16 type, const guint16 length, const guint8 *value)
517: {
518: GSList *cur;
519: aim_tlv_t *tlv;
520:
521: if (list == NULL)
522: return 0;
523:
524: for (cur = *list; cur != NULL; cur = cur->next)
525: {
526: tlv = cur->data;
527: if (tlv->type == type)
528: break;
529: }
530:
531: if (cur == NULL)
532: /* TLV does not exist, so add a new one */
533: return aim_tlvlist_add_raw(list, type, length, value);
534:
535: g_free(tlv->value);
536: tlv->length = length;
537: if (tlv->length > 0) {
538: tlv->value = g_memdup(value, length);
539: } else
540: tlv->value = NULL;
541:
542: return tlv->length;
543: }
544:
545: /**
546: * Substitute a TLV of a given type with a new TLV of the same type. If
547: * you attempt to replace a TLV that does not exist, this function will
548: * just add a new TLV as if you called aim_tlvlist_add_str().
549: *
550: * @param list Desination chain (%NULL pointer if empty).
551: * @param type TLV type.
552: * @param str String to add.
553: * @return The length of the TLV.
554: */
555: int aim_tlvlist_replace_str(GSList **list, const guint16 type, const char *str)
556: {
557: return aim_tlvlist_replace_raw(list, type, strlen(str), (const guchar *)str);
558: }
559:
560: /**
561: * Substitute a TLV of a given type with a new TLV of the same type. If
562: * you attempt to replace a TLV that does not exist, this function will
563: * just add a new TLV as if you called aim_tlvlist_add_raw().
564: *
565: * @param list Desination chain (%NULL pointer if empty).
566: * @param type TLV type.
567: * @return The length of the TLV.
568: */
569: int aim_tlvlist_replace_noval(GSList **list, const guint16 type)
570: {
571: return aim_tlvlist_replace_raw(list, type, 0, NULL);
572: }
573:
574: /**
575: * Substitute a TLV of a given type with a new TLV of the same type. If
576: * you attempt to replace a TLV that does not exist, this function will
577: * just add a new TLV as if you called aim_tlvlist_add_raw().
578: *
579: * @param list Desination chain (%NULL pointer if empty).
580: * @param type TLV type.
581: * @param value 8 bit value to add.
582: * @return The length of the TLV.
583: */
584: int aim_tlvlist_replace_8(GSList **list, const guint16 type, const guint8 value)
585: {
586: guint8 v8[1];
587:
588: (void)aimutil_put8(v8, value);
589:
590: return aim_tlvlist_replace_raw(list, type, 1, v8);
591: }
592:
593: /**
594: * Substitute a TLV of a given type with a new TLV of the same type. If
595: * you attempt to replace a TLV that does not exist, this function will
596: * just add a new TLV as if you called aim_tlvlist_add_raw().
597: *
598: * @param list Desination chain (%NULL pointer if empty).
599: * @param type TLV type.
600: * @param value 32 bit value to add.
601: * @return The length of the TLV.
602: */
603: int aim_tlvlist_replace_32(GSList **list, const guint16 type, const guint32 value)
604: {
605: guint8 v32[4];
606:
607: (void)aimutil_put32(v32, value);
608:
609: return aim_tlvlist_replace_raw(list, type, 4, v32);
610: }
611:
612: /**
613: * Remove all TLVs of a given type. If you attempt to remove a TLV
614: * that does not exist, nothing happens.
615: *
616: * @param list Desination chain (%NULL pointer if empty).
617: * @param type TLV type.
618: */
619: void aim_tlvlist_remove(GSList **list, const guint16 type)
620: {
621: GSList *cur, *next;
622: aim_tlv_t *tlv;
623:
624: if (list == NULL || *list == NULL)
625: return;
626:
627: cur = *list;
628: while (cur != NULL)
629: {
630: tlv = cur->data;
631: next = cur->next;
632:
633: if (tlv->type == type)
634: {
635: /* Delete this TLV */
636: *list = g_slist_delete_link(*list, cur);
637: g_free(tlv->value);
638: g_free(tlv);
639: }
640:
641: cur = next;
642: }
643: }
644:
645: /**
646: * Write a TLV chain into a data buffer.
647: *
648: * Copies a TLV chain into a raw data buffer, writing only the number
649: * of bytes specified. This operation does not free the chain;
650: * aim_tlvlist_free() must still be called to free up the memory used
651: * by the chain structures.
652: *
653: * TODO: Clean this up, make better use of bstreams
654: *
655: * @param bs Input bstream
656: * @param list Source TLV chain
657: * @return Return 0 if the destination bstream is too small.
658: */
659: int aim_tlvlist_write(ByteStream *bs, GSList **list)
660: {
661: size_t goodbuflen;
662: GSList *cur;
663: aim_tlv_t *tlv;
664:
665: /* do an initial run to test total length */
666: goodbuflen = aim_tlvlist_size(*list);
667:
668: if (goodbuflen > byte_stream_bytes_left(bs))
669: return 0; /* not enough buffer */
670:
671: /* do the real write-out */
672: for (cur = *list; cur; cur = cur->next) {
673: tlv = cur->data;
674: byte_stream_put16(bs, tlv->type);
675: byte_stream_put16(bs, tlv->length);
676: if (tlv->length > 0)
677: byte_stream_putraw(bs, tlv->value, tlv->length);
678: }
679:
680: return 1; /* TODO: This is a nonsensical return */
681: }
682:
683:
684: /**
685: * Grab the Nth TLV of type type in the TLV list list.
686: *
687: * Returns a pointer to an aim_tlv_t of the specified type;
688: * %NULL on error. The @nth parameter is specified starting at %1.
689: * In most cases, there will be no more than one TLV of any type
690: * in a chain.
691: *
692: * @param list Source chain.
693: * @param type Requested TLV type.
694: * @param nth Index of TLV of type to get.
695: * @return The TLV you were looking for, or NULL if one could not be found.
696: */
697: aim_tlv_t *aim_tlv_gettlv(GSList *list, const guint16 type, const int nth)
698: {
699: GSList *cur;
700: aim_tlv_t *tlv;
701: int i;
702:
703: for (cur = list, i = 0; cur != NULL; cur = cur->next) {
704: tlv = cur->data;
705: if (tlv->type == type)
706: i++;
707: if (i >= nth)
708: return tlv;
709: }
710:
711: return NULL;
712: }
713:
714: /**
715: * Get the length of the data of the nth TLV in the given TLV chain.
716: *
717: * @param list Source chain.
718: * @param type Requested TLV type.
719: * @param nth Index of TLV of type to get.
720: * @return The length of the data in this TLV, or -1 if the TLV could not be
721: * found. Unless -1 is returned, this value will be 2 bytes.
722: */
723: int aim_tlv_getlength(GSList *list, const guint16 type, const int nth)
724: {
725: aim_tlv_t *tlv;
726:
727: tlv = aim_tlv_gettlv(list, type, nth);
728: if (tlv == NULL)
729: return -1;
730:
731: return tlv->length;
732: }
733:
734: char *
735: aim_tlv_getvalue_as_string(aim_tlv_t *tlv)
736: {
737: char *ret;
738:
739: ret = g_malloc(tlv->length + 1);
740: memcpy(ret, tlv->value, tlv->length);
741: ret[tlv->length] = '\0';
742:
743: return ret;
744: }
745:
746: /**
747: * Retrieve the data from the nth TLV in the given TLV chain as a string.
748: *
749: * @param list Source TLV chain.
750: * @param type TLV type to search for.
751: * @param nth Index of TLV to return.
752: * @return The value of the TLV you were looking for, or NULL if one could
753: * not be found. This is a dynamic buffer and must be freed by the
754: * caller.
755: */
756: char *aim_tlv_getstr(GSList *list, const guint16 type, const int nth)
757: {
758: aim_tlv_t *tlv;
759:
760: tlv = aim_tlv_gettlv(list, type, nth);
761: if (tlv == NULL)
762: return NULL;
763:
764: return aim_tlv_getvalue_as_string(tlv);
765: }
766:
767: /**
768: * Retrieve the data from the nth TLV in the given TLV chain as an 8bit
769: * integer.
770: *
771: * @param list Source TLV chain.
772: * @param type TLV type to search for.
773: * @param nth Index of TLV to return.
774: * @return The value the TLV you were looking for, or 0 if one could
775: * not be found.
776: */
777: guint8 aim_tlv_get8(GSList *list, const guint16 type, const int nth)
778: {
779: aim_tlv_t *tlv;
780:
781: tlv = aim_tlv_gettlv(list, type, nth);
782: if (tlv == NULL)
783: return 0; /* erm */
784:
785: return aimutil_get8(tlv->value);
786: }
787:
788: /**
789: * Retrieve the data from the nth TLV in the given TLV chain as a 16bit
790: * integer.
791: *
792: * @param list Source TLV chain.
793: * @param type TLV type to search for.
794: * @param nth Index of TLV to return.
795: * @return The value the TLV you were looking for, or 0 if one could
796: * not be found.
797: */
798: guint16 aim_tlv_get16(GSList *list, const guint16 type, const int nth)
799: {
800: aim_tlv_t *tlv;
801:
802: tlv = aim_tlv_gettlv(list, type, nth);
803: if (tlv == NULL)
804: return 0; /* erm */
805:
806: return aimutil_get16(tlv->value);
807: }
808:
809: /**
810: * Retrieve the data from the nth TLV in the given TLV chain as a 32bit
811: * integer.
812: *
813: * @param list Source TLV chain.
814: * @param type TLV type to search for.
815: * @param nth Index of TLV to return.
816: * @return The value the TLV you were looking for, or 0 if one could
817: * not be found.
818: */
819: guint32 aim_tlv_get32(GSList *list, const guint16 type, const int nth)
820: {
821: aim_tlv_t *tlv;
822:
823: tlv = aim_tlv_gettlv(list, type, nth);
824: if (tlv == NULL)
825: return 0; /* erm */
826:
827: return aimutil_get32(tlv->value);
828: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tlv.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