libpurple/protocols/facebook/thrift.c

   1 /* purple
   2  *
   3  * Purple is the legal property of its developers, whose names are too numerous
   4  * to list here.  Please refer to the COPYRIGHT file distributed with this
   5  * source distribution.
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
  20  */
  21
  22 #include <string.h>
  23
  24 #include "thrift.h"
  25
  26 typedef struct
  27 {
  28         GByteArray *bytes;
  29         gboolean internal;
  30         guint offset;
  31         guint pos;
  32         guint lastbool;
  33 } FbThriftPrivate;
  34
  35 /**
  36  * FbThrift:
  37  *
  38  * Represents a reader/writer for compact Thrift data.
  39  */
  40 struct _FbThrift
  41 {
  42         GObject parent;
  43         FbThriftPrivate *priv;
  44 };
  45
  46 G_DEFINE_TYPE_WITH_PRIVATE(FbThrift, fb_thrift, G_TYPE_OBJECT);
  47
  48 static void
  49 fb_thrift_dispose(GObject *obj)
  50 {
  51         FbThriftPrivate *priv = FB_THRIFT(obj)->priv;
  52
  53         if (priv->internal) {
  54                 g_byte_array_free(priv->bytes, TRUE);
  55         }
  56 }
  57
  58 static void
  59 fb_thrift_class_init(FbThriftClass *klass)
  60 {
  61         GObjectClass *gklass = G_OBJECT_CLASS(klass);
  62
  63         gklass->dispose = fb_thrift_dispose;
  64 }
  65
  66 static void
  67 fb_thrift_init(FbThrift *thft)
  68 {
  69         FbThriftPrivate *priv = fb_thrift_get_instance_private(thft);
  70
  71         thft->priv = priv;
  72 }
  73
  74 FbThrift *
  75 fb_thrift_new(GByteArray *bytes, guint offset)
  76 {
  77         FbThrift *thft;
  78         FbThriftPrivate *priv;
  79
  80         thft = g_object_new(FB_TYPE_THRIFT, NULL);
  81         priv = thft->priv;
  82
  83         if (bytes != NULL) {
  84                 priv->bytes = bytes;
  85                 priv->offset = offset;
  86                 priv->pos = offset;
  87         } else {
  88                 priv->bytes = g_byte_array_new();
  89                 priv->internal = TRUE;
  90         }
  91
  92         return thft;
  93 }
  94
  95 const GByteArray *
  96 fb_thrift_get_bytes(FbThrift *thft)
  97 {
  98         FbThriftPrivate *priv;
  99
 100         g_return_val_if_fail(FB_IS_THRIFT(thft), NULL);
 101         priv = thft->priv;
 102         return priv->bytes;
 103 }
 104
 105 guint
 106 fb_thrift_get_pos(FbThrift *thft)
 107 {
 108         FbThriftPrivate *priv;
 109
 110         g_return_val_if_fail(FB_IS_THRIFT(thft), 0);
 111         priv = thft->priv;
 112         return priv->pos;
 113 }
 114
 115 void
 116 fb_thrift_set_pos(FbThrift *thft, guint pos)
 117 {
 118         FbThriftPrivate *priv;
 119
 120         g_return_if_fail(FB_IS_THRIFT(thft));
 121         priv = thft->priv;
 122         priv->pos = pos;
 123 }
 124
 125 void
 126 fb_thrift_reset(FbThrift *thft)
 127 {
 128         FbThriftPrivate *priv;
 129
 130         g_return_if_fail(FB_IS_THRIFT(thft));
 131         priv = thft->priv;
 132         priv->pos = priv->offset;
 133 }
 134
 135 gboolean
 136 fb_thrift_read(FbThrift *thft, gpointer data, guint size)
 137 {
 138         FbThriftPrivate *priv;
 139
 140         g_return_val_if_fail(FB_IS_THRIFT(thft), FALSE);
 141         priv = thft->priv;
 142
 143         if ((priv->pos + size) > priv->bytes->len) {
 144                 return FALSE;
 145         }
 146
 147         if ((data != NULL) && (size > 0)) {
 148                 memcpy(data, priv->bytes->data + priv->pos, size);
 149         }
 150
 151         priv->pos += size;
 152         return TRUE;
 153 }
 154
 155 gboolean
 156 fb_thrift_read_bool(FbThrift *thft, gboolean *value)
 157 {
 158         FbThriftPrivate *priv;
 159         guint8 byte;
 160
 161         g_return_val_if_fail(FB_IS_THRIFT(thft), FALSE);
 162         priv = thft->priv;
 163
 164         if ((priv->lastbool & 0x03) != 0x01) {
 165                 if (!fb_thrift_read_byte(thft, &byte)) {
 166                         return FALSE;
 167                 }
 168
 169                 if (value != NULL) {
 170                         *value = (byte & 0x0F) == 0x01;
 171                 }
 172
 173                 priv->lastbool = 0;
 174                 return TRUE;
 175         }
 176
 177         if (value != NULL) {
 178                 *value = ((priv->lastbool & 0x04) >> 2) != 0;
 179         }
 180
 181         priv->lastbool = 0;
 182         return TRUE;
 183 }
 184
 185 gboolean
 186 fb_thrift_read_byte(FbThrift *thft, guint8 *value)
 187 {
 188         return fb_thrift_read(thft, value, sizeof *value);
 189 }
 190
 191 gboolean
 192 fb_thrift_read_dbl(FbThrift *thft, gdouble *value)
 193 {
 194         gint64 i64;
 195
 196         /* Almost always 8, but check anyways */
 197         static const gsize size = MIN(sizeof value, sizeof i64);
 198
 199         if (!fb_thrift_read_i64(thft, &i64)) {
 200                 return FALSE;
 201         }
 202
 203         if (value != NULL) {
 204                 memcpy(value, &i64, size);
 205         }
 206
 207         return TRUE;
 208 }
 209
 210 gboolean
 211 fb_thrift_read_i16(FbThrift *thft, gint16 *value)
 212 {
 213         gint64 i64;
 214
 215         if (!fb_thrift_read_i64(thft, &i64)) {
 216                 return FALSE;
 217         }
 218
 219         if (value != NULL) {
 220                 *value = i64;
 221         }
 222
 223         return TRUE;
 224 }
 225
 226 gboolean
 227 fb_thrift_read_vi16(FbThrift *thft, guint16 *value)
 228 {
 229         guint64 u64;
 230
 231         if (!fb_thrift_read_vi64(thft, &u64)) {
 232                 return FALSE;
 233         }
 234
 235         if (value != NULL) {
 236                 *value = u64;
 237         }
 238
 239         return TRUE;
 240 }
 241
 242 gboolean
 243 fb_thrift_read_i32(FbThrift *thft, gint32 *value)
 244 {
 245         gint64 i64;
 246
 247         if (!fb_thrift_read_i64(thft, &i64)) {
 248                 return FALSE;
 249         }
 250
 251         if (value != NULL) {
 252                 *value = i64;
 253         }
 254
 255         return TRUE;
 256 }
 257
 258 gboolean
 259 fb_thrift_read_vi32(FbThrift *thft, guint32 *value)
 260 {
 261         guint64 u64;
 262
 263         if (!fb_thrift_read_vi64(thft, &u64)) {
 264                 return FALSE;
 265         }
 266
 267         if (value != NULL) {
 268                 *value = u64;
 269         }
 270
 271         return TRUE;
 272 }
 273
 274 gboolean
 275 fb_thrift_read_i64(FbThrift *thft, gint64 *value)
 276 {
 277         guint64 u64;
 278
 279         if (!fb_thrift_read_vi64(thft, &u64)) {
 280                 return FALSE;
 281         }
 282
 283         if (value != NULL) {
 284                 /* Convert from zigzag to integer */
 285                 *value = (u64 >> 0x01) ^ -(u64 & 0x01);
 286         }
 287
 288         return TRUE;
 289 }
 290
 291 gboolean
 292 fb_thrift_read_vi64(FbThrift *thft, guint64 *value)
 293 {
 294         guint i = 0;
 295         guint8 byte;
 296         guint64 u64 = 0;
 297
 298         do {
 299                 if (!fb_thrift_read_byte(thft, &byte)) {
 300                         return FALSE;
 301                 }
 302
 303                 u64 |= ((guint64) (byte & 0x7F)) << i;
 304                 i += 7;
 305         } while ((byte & 0x80) == 0x80);
 306
 307         if (value != NULL) {
 308                 *value = u64;
 309         }
 310
 311         return TRUE;
 312 }
 313
 314 gboolean
 315 fb_thrift_read_str(FbThrift *thft, gchar **value)
 316 {
 317         guint8 *data;
 318         guint32 size;
 319
 320         if (!fb_thrift_read_vi32(thft, &size)) {
 321                 return FALSE;
 322         }
 323
 324         if (value != NULL) {
 325                 data = g_new(guint8, size + 1);
 326                 data[size] = 0;
 327         } else {
 328                 data = NULL;
 329         }
 330
 331         if (!fb_thrift_read(thft, data, size)) {
 332                 g_free(data);
 333                 return FALSE;
 334         }
 335
 336         if (value != NULL) {
 337                 *value = (gchar *) data;
 338         }
 339
 340         return TRUE;
 341 }
 342
 343 gboolean
 344 fb_thrift_read_field(FbThrift *thft, FbThriftType *type, gint16 *id,
 345                                          gint16 lastid)
 346 {
 347         FbThriftPrivate *priv;
 348         gint16 i16;
 349         guint8 byte;
 350
 351         g_return_val_if_fail(FB_IS_THRIFT(thft), FALSE);
 352         g_return_val_if_fail(type != NULL, FALSE);
 353         g_return_val_if_fail(id != NULL, FALSE);
 354         priv = thft->priv;
 355
 356         if (!fb_thrift_read_byte(thft, &byte)) {
 357                 return FALSE;
 358         }
 359
 360         if (byte == FB_THRIFT_TYPE_STOP) {
 361                 *type = FB_THRIFT_TYPE_STOP;
 362                 return FALSE;
 363         }
 364
 365         *type = fb_thrift_ct2t(byte & 0x0F);
 366         i16 = (byte & 0xF0) >> 4;
 367
 368         if (i16 == 0) {
 369                 if (!fb_thrift_read_i16(thft, id)) {
 370                         return FALSE;
 371                 }
 372         } else {
 373                 *id = lastid + i16;
 374         }
 375
 376         if (*type == FB_THRIFT_TYPE_BOOL) {
 377                 priv->lastbool = 0x01;
 378
 379                 if ((byte & 0x0F) == 0x01) {
 380                         priv->lastbool |= 0x01 << 2;
 381                 }
 382         }
 383
 384         return TRUE;
 385 }
 386
 387 gboolean
 388 fb_thrift_read_stop(FbThrift *thft)
 389 {
 390         guint8 byte;
 391
 392         return fb_thrift_read_byte(thft, &byte) &&
 393                (byte == FB_THRIFT_TYPE_STOP);
 394 }
 395
 396 gboolean
 397 fb_thrift_read_isstop(FbThrift *thft)
 398 {
 399         FbThriftPrivate *priv;
 400         guint8 byte;
 401
 402         g_return_val_if_fail(FB_IS_THRIFT(thft), FALSE);
 403         priv = thft->priv;
 404
 405         if (!fb_thrift_read_byte(thft, &byte)) {
 406                 return FALSE;
 407         }
 408
 409         priv->pos--;
 410         return byte == FB_THRIFT_TYPE_STOP;
 411 }
 412
 413 gboolean
 414 fb_thrift_read_list(FbThrift *thft, FbThriftType *type, guint *size)
 415 {
 416         guint8 byte;
 417         guint32 u32;
 418
 419         g_return_val_if_fail(type != NULL, FALSE);
 420         g_return_val_if_fail(size != NULL, FALSE);
 421
 422         if (!fb_thrift_read_byte(thft, &byte)) {
 423                 return FALSE;
 424         }
 425
 426         *type = fb_thrift_ct2t(byte & 0x0F);
 427         *size = (byte & 0xF0) >> 4;
 428
 429         if (*size == 0x0F) {
 430                 if (!fb_thrift_read_vi32(thft, &u32)) {
 431                         return FALSE;
 432                 }
 433
 434                 *size = u32;
 435         }
 436
 437         return TRUE;
 438 }
 439
 440 gboolean
 441 fb_thrift_read_map(FbThrift *thft, FbThriftType *ktype, FbThriftType *vtype,
 442                    guint *size)
 443 {
 444         gint32 i32;
 445         guint8 byte;
 446
 447         g_return_val_if_fail(ktype != NULL, FALSE);
 448         g_return_val_if_fail(vtype != NULL, FALSE);
 449         g_return_val_if_fail(size != NULL, FALSE);
 450
 451         if (!fb_thrift_read_i32(thft, &i32)) {
 452                 return FALSE;
 453         }
 454
 455         if (i32 != 0) {
 456                 if (!fb_thrift_read_byte(thft, &byte)) {
 457                         return FALSE;
 458                 }
 459
 460                 *ktype = fb_thrift_ct2t((byte & 0xF0) >> 4);
 461                 *vtype = fb_thrift_ct2t(byte & 0x0F);
 462         } else {
 463                 *ktype = 0;
 464                 *vtype = 0;
 465         }
 466
 467         *size = i32;
 468         return TRUE;
 469 }
 470
 471 gboolean
 472 fb_thrift_read_set(FbThrift *thft, FbThriftType *type, guint *size)
 473 {
 474         return fb_thrift_read_list(thft, type, size);
 475 }
 476
 477 void
 478 fb_thrift_write(FbThrift *thft, gconstpointer data, guint size)
 479 {
 480         FbThriftPrivate *priv;
 481
 482         g_return_if_fail(FB_IS_THRIFT(thft));
 483         priv = thft->priv;
 484
 485         g_byte_array_append(priv->bytes, data, size);
 486         priv->pos += size;
 487 }
 488
 489 void
 490 fb_thrift_write_bool(FbThrift *thft, gboolean value)
 491 {
 492         FbThriftPrivate *priv;
 493         guint pos;
 494
 495         g_return_if_fail(FB_IS_THRIFT(thft));
 496         priv = thft->priv;
 497
 498         if ((priv->lastbool & 0x03) != 0x02) {
 499                 fb_thrift_write_byte(thft, value ? 0x01 : 0x02);
 500                 return;
 501         }
 502
 503         pos = priv->lastbool >> 3;
 504         priv->lastbool = 0;
 505
 506         if ((pos >= priv->offset) && (pos < priv->bytes->len)) {
 507                 priv->bytes->data[pos] &= ~0x0F;
 508                 priv->bytes->data[pos] |= value ? 0x01 : 0x02;
 509         }
 510 }
 511
 512 void
 513 fb_thrift_write_byte(FbThrift *thft, guint8 value)
 514 {
 515         fb_thrift_write(thft, &value, sizeof value);
 516 }
 517
 518 void
 519 fb_thrift_write_dbl(FbThrift *thft, gdouble value)
 520 {
 521         gint64 i64;
 522
 523         /* Almost always 8, but check anyways */
 524         static const gsize size = MIN(sizeof value, sizeof i64);
 525
 526         memcpy(&i64, &value, size);
 527         fb_thrift_write_i64(thft, i64);
 528 }
 529
 530 void
 531 fb_thrift_write_i16(FbThrift *thft, gint16 value)
 532 {
 533         fb_thrift_write_i64(thft, value);
 534 }
 535
 536 void
 537 fb_thrift_write_vi16(FbThrift *thft, guint16 value)
 538 {
 539         fb_thrift_write_vi64(thft, value);
 540 }
 541
 542 void
 543 fb_thrift_write_i32(FbThrift *thft, gint32 value)
 544 {
 545         value = (value << 1) ^ (value >> 31);
 546         fb_thrift_write_vi64(thft, value);
 547 }
 548
 549 void
 550 fb_thrift_write_vi32(FbThrift *thft, guint32 value)
 551 {
 552         fb_thrift_write_vi64(thft, value);
 553 }
 554
 555 void
 556 fb_thrift_write_i64(FbThrift *thft, gint64 value)
 557 {
 558         value = (value << 1) ^ (value >> 63);
 559         fb_thrift_write_vi64(thft, value);
 560 }
 561
 562 void
 563 fb_thrift_write_vi64(FbThrift *thft, guint64 value)
 564 {
 565         gboolean last;
 566         guint8 byte;
 567
 568         do {
 569                 last = (value & ~0x7F) == 0;
 570                 byte = value & 0x7F;
 571
 572                 if (!last) {
 573                         byte |= 0x80;
 574                         value >>= 7;
 575                 }
 576
 577                 fb_thrift_write_byte(thft, byte);
 578         } while (!last);
 579 }
 580
 581 void
 582 fb_thrift_write_str(FbThrift *thft, const gchar *value)
 583 {
 584         guint32 size;
 585
 586         g_return_if_fail(value != NULL);
 587
 588         size = strlen(value);
 589         fb_thrift_write_vi32(thft, size);
 590         fb_thrift_write(thft, value, size);
 591 }
 592
 593 void
 594 fb_thrift_write_field(FbThrift *thft, FbThriftType type, gint16 id,
 595                                           gint16 lastid)
 596 {
 597         FbThriftPrivate *priv;
 598         gint16 diff;
 599
 600         g_return_if_fail(FB_IS_THRIFT(thft));
 601         priv = thft->priv;
 602
 603         if (type == FB_THRIFT_TYPE_BOOL) {
 604                 priv->lastbool = (priv->pos << 3) | 0x02;
 605         }
 606
 607         type = fb_thrift_t2ct(type);
 608         diff = id - lastid;
 609
 610         if ((id <= lastid) || (diff > 0x0F)) {
 611                 fb_thrift_write_byte(thft, type);
 612                 fb_thrift_write_i16(thft, id);
 613         } else {
 614                 fb_thrift_write_byte(thft, (diff << 4) | type);
 615         }
 616 }
 617
 618 void
 619 fb_thrift_write_stop(FbThrift *thft)
 620 {
 621         fb_thrift_write_byte(thft, FB_THRIFT_TYPE_STOP);
 622 }
 623
 624 void
 625 fb_thrift_write_list(FbThrift *thft, FbThriftType type, guint size)
 626 {
 627         type = fb_thrift_t2ct(type);
 628
 629         if (size <= 14) {
 630                 fb_thrift_write_byte(thft, (size << 4) | type);
 631                 return;
 632         }
 633
 634         fb_thrift_write_vi32(thft, size);
 635         fb_thrift_write_byte(thft, 0xF0 | type);
 636 }
 637
 638 void
 639 fb_thrift_write_map(FbThrift *thft, FbThriftType ktype, FbThriftType vtype,
 640                     guint size)
 641 {
 642         if (size == 0) {
 643                 fb_thrift_write_byte(thft, 0);
 644                 return;
 645         }
 646
 647         ktype = fb_thrift_t2ct(ktype);
 648         vtype = fb_thrift_t2ct(vtype);
 649
 650         fb_thrift_write_vi32(thft, size);
 651         fb_thrift_write_byte(thft, (ktype << 4) | vtype);
 652 }
 653
 654 void
 655 fb_thrift_write_set(FbThrift *thft, FbThriftType type, guint size)
 656 {
 657         fb_thrift_write_list(thft, type, size);
 658 }
 659
 660 guint8
 661 fb_thrift_t2ct(FbThriftType type)
 662 {
 663         static const guint8 types[] = {
 664                 [FB_THRIFT_TYPE_STOP]   = 0,
 665                 [FB_THRIFT_TYPE_VOID]   = 0,
 666                 [FB_THRIFT_TYPE_BOOL]   = 2,
 667                 [FB_THRIFT_TYPE_BYTE]   = 3,
 668                 [FB_THRIFT_TYPE_DOUBLE] = 7,
 669                 [5]                     = 0,
 670                 [FB_THRIFT_TYPE_I16]    = 4,
 671                 [7]                     = 0,
 672                 [FB_THRIFT_TYPE_I32]    = 5,
 673                 [9]                     = 0,
 674                 [FB_THRIFT_TYPE_I64]    = 6,
 675                 [FB_THRIFT_TYPE_STRING] = 8,
 676                 [FB_THRIFT_TYPE_STRUCT] = 12,
 677                 [FB_THRIFT_TYPE_MAP]    = 11,
 678                 [FB_THRIFT_TYPE_SET]    = 10,
 679                 [FB_THRIFT_TYPE_LIST]   = 9
 680         };
 681
 682         g_return_val_if_fail(type < G_N_ELEMENTS(types), 0);
 683         return types[type];
 684 }
 685
 686 FbThriftType
 687 fb_thrift_ct2t(guint8 type)
 688 {
 689         static const guint8 types[] = {
 690                 [0]  = FB_THRIFT_TYPE_STOP,
 691                 [1]  = FB_THRIFT_TYPE_BOOL,
 692                 [2]  = FB_THRIFT_TYPE_BOOL,
 693                 [3]  = FB_THRIFT_TYPE_BYTE,
 694                 [4]  = FB_THRIFT_TYPE_I16,
 695                 [5]  = FB_THRIFT_TYPE_I32,
 696                 [6]  = FB_THRIFT_TYPE_I64,
 697                 [7]  = FB_THRIFT_TYPE_DOUBLE,
 698                 [8]  = FB_THRIFT_TYPE_STRING,
 699                 [9]  = FB_THRIFT_TYPE_LIST,
 700                 [10] = FB_THRIFT_TYPE_SET,
 701                 [11] = FB_THRIFT_TYPE_MAP,
 702                 [12] = FB_THRIFT_TYPE_STRUCT
 703         };
 704
 705         g_return_val_if_fail(type < G_N_ELEMENTS(types), 0);
 706         return types[type];
 707 }