libpurple/protocols/facebook/json.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 "internal.h"
  23
  24 #include <stdarg.h>
  25 #include <string.h>
  26
  27 #include "json.h"
  28 #include "util.h"
  29
  30 typedef struct _FbJsonValue FbJsonValue;
  31
  32 struct _FbJsonValue
  33 {
  34         const gchar *expr;
  35         FbJsonType type;
  36         gboolean required;
  37         GValue value;
  38 };
  39
  40 struct _FbJsonValuesPrivate
  41 {
  42         JsonNode *root;
  43         GQueue *queue;
  44         GList *next;
  45
  46         gboolean isarray;
  47         JsonArray *array;
  48         guint index;
  49
  50         GError *error;
  51 };
  52
  53 G_DEFINE_TYPE(FbJsonValues, fb_json_values, G_TYPE_OBJECT);
  54
  55 static void
  56 fb_json_values_dispose(GObject *obj)
  57 {
  58         FbJsonValue *value;
  59         FbJsonValuesPrivate *priv = FB_JSON_VALUES(obj)->priv;
  60
  61         while (!g_queue_is_empty(priv->queue)) {
  62                 value = g_queue_pop_head(priv->queue);
  63
  64                 if (G_IS_VALUE(&value->value)) {
  65                         g_value_unset(&value->value);
  66                 }
  67
  68                 g_free(value);
  69         }
  70
  71         if (priv->array != NULL) {
  72                 json_array_unref(priv->array);
  73         }
  74
  75         if (priv->error != NULL) {
  76                 g_error_free(priv->error);
  77         }
  78
  79         g_queue_free(priv->queue);
  80 }
  81
  82 static void
  83 fb_json_values_class_init(FbJsonValuesClass *klass)
  84 {
  85         GObjectClass *gklass = G_OBJECT_CLASS(klass);
  86
  87         gklass->dispose = fb_json_values_dispose;
  88         g_type_class_add_private(klass, sizeof (FbJsonValuesPrivate));
  89 }
  90
  91 static void
  92 fb_json_values_init(FbJsonValues *values)
  93 {
  94         FbJsonValuesPrivate *priv;
  95
  96         priv = G_TYPE_INSTANCE_GET_PRIVATE(values, FB_TYPE_JSON_VALUES,
  97                                            FbJsonValuesPrivate);
  98         values->priv = priv;
  99
 100         priv->queue = g_queue_new();
 101 }
 102
 103 GQuark
 104 fb_json_error_quark(void)
 105 {
 106         static GQuark q = 0;
 107
 108         if (G_UNLIKELY(q == 0)) {
 109                 q = g_quark_from_static_string("fb-json-error-quark");
 110         }
 111
 112         return q;
 113 }
 114
 115 JsonBuilder *
 116 fb_json_bldr_new(JsonNodeType type)
 117 {
 118         JsonBuilder *bldr;
 119
 120         bldr = json_builder_new();
 121
 122         switch (type) {
 123         case JSON_NODE_ARRAY:
 124                 fb_json_bldr_arr_begin(bldr, NULL);
 125                 break;
 126
 127         case JSON_NODE_OBJECT:
 128                 fb_json_bldr_obj_begin(bldr, NULL);
 129                 break;
 130
 131         default:
 132                 break;
 133         }
 134
 135         return bldr;
 136 }
 137
 138 gchar *
 139 fb_json_bldr_close(JsonBuilder *bldr, JsonNodeType type, gsize *size)
 140 {
 141         gchar *ret;
 142         JsonGenerator *genr;
 143         JsonNode *root;
 144
 145         switch (type) {
 146         case JSON_NODE_ARRAY:
 147                 fb_json_bldr_arr_end(bldr);
 148                 break;
 149
 150         case JSON_NODE_OBJECT:
 151                 fb_json_bldr_obj_end(bldr);
 152                 break;
 153
 154         default:
 155                 break;
 156         }
 157
 158         genr = json_generator_new();
 159         root = json_builder_get_root(bldr);
 160
 161         json_generator_set_root(genr, root);
 162         ret = json_generator_to_data(genr, size);
 163
 164         json_node_free(root);
 165         g_object_unref(genr);
 166         g_object_unref(bldr);
 167
 168         return ret;
 169 }
 170
 171 void
 172 fb_json_bldr_arr_begin(JsonBuilder *bldr, const gchar *name)
 173 {
 174         if (name != NULL) {
 175                 json_builder_set_member_name(bldr, name);
 176         }
 177
 178         json_builder_begin_array(bldr);
 179 }
 180
 181 void
 182 fb_json_bldr_arr_end(JsonBuilder *bldr)
 183 {
 184         json_builder_end_array(bldr);
 185 }
 186
 187 void
 188 fb_json_bldr_obj_begin(JsonBuilder *bldr, const gchar *name)
 189 {
 190         if (name != NULL) {
 191                 json_builder_set_member_name(bldr, name);
 192         }
 193
 194         json_builder_begin_object(bldr);
 195 }
 196
 197 void
 198 fb_json_bldr_obj_end(JsonBuilder *bldr)
 199 {
 200         json_builder_end_object(bldr);
 201 }
 202
 203 void
 204 fb_json_bldr_add_bool(JsonBuilder *bldr, const gchar *name, gboolean value)
 205 {
 206         if (name != NULL) {
 207                 json_builder_set_member_name(bldr, name);
 208         }
 209
 210         json_builder_add_boolean_value(bldr, value);
 211 }
 212
 213 void
 214 fb_json_bldr_add_dbl(JsonBuilder *bldr, const gchar *name, gdouble value)
 215 {
 216         if (name != NULL) {
 217                 json_builder_set_member_name(bldr, name);
 218         }
 219
 220         json_builder_add_double_value(bldr, value);
 221 }
 222
 223 void
 224 fb_json_bldr_add_int(JsonBuilder *bldr, const gchar *name, gint64 value)
 225 {
 226         if (name != NULL) {
 227                 json_builder_set_member_name(bldr, name);
 228         }
 229
 230         json_builder_add_int_value(bldr, value);
 231 }
 232
 233 void
 234 fb_json_bldr_add_str(JsonBuilder *bldr, const gchar *name, const gchar *value)
 235 {
 236         if (name != NULL) {
 237                 json_builder_set_member_name(bldr, name);
 238         }
 239
 240         json_builder_add_string_value(bldr, value);
 241 }
 242
 243 void
 244 fb_json_bldr_add_strf(JsonBuilder *bldr, const gchar *name,
 245                                           const gchar *format, ...)
 246 {
 247         gchar *value;
 248         va_list ap;
 249
 250         va_start(ap, format);
 251         value = g_strdup_vprintf(format, ap);
 252         va_end(ap);
 253
 254         fb_json_bldr_add_str(bldr, name, value);
 255         g_free(value);
 256 }
 257
 258 JsonNode *
 259 fb_json_node_new(const gchar *data, gssize size, GError **error)
 260 {
 261         gchar *slice;
 262         JsonNode *root;
 263         JsonParser *prsr;
 264
 265         g_return_val_if_fail(data != NULL, NULL);
 266
 267         if (size < 0) {
 268                 size = strlen(data);
 269         }
 270
 271         /* Ensure data is null terminated for json-glib < 1.0.2 */
 272         slice = g_strndup(data, size);
 273         prsr = json_parser_new();
 274
 275         if (!json_parser_load_from_data(prsr, slice, size, error)) {
 276                 g_object_unref(prsr);
 277                 g_free(slice);
 278                 return NULL;
 279         }
 280
 281         root = json_parser_get_root(prsr);
 282         root = json_node_copy(root);
 283
 284         g_object_unref(prsr);
 285         g_free(slice);
 286         return root;
 287 }
 288
 289 JsonNode *
 290 fb_json_node_get(JsonNode *root, const gchar *expr, GError **error)
 291 {
 292         GError *err = NULL;
 293         guint size;
 294         JsonArray *rslt;
 295         JsonNode *node;
 296         JsonNode *ret;
 297
 298         /* Special case for json-glib < 0.99.2 */
 299         if (purple_strequal(expr, "$")) {
 300                 return json_node_copy(root);
 301         }
 302
 303         node = json_path_query(expr, root, &err);
 304
 305         if (err != NULL) {
 306                 g_propagate_error(error, err);
 307                 json_node_free(node);
 308                 return NULL;
 309         }
 310
 311         rslt = json_node_get_array(node);
 312         size = json_array_get_length(rslt);
 313
 314         if (size < 1) {
 315                 g_set_error(error, FB_JSON_ERROR, FB_JSON_ERROR_NOMATCH,
 316                             _("No matches for %s"), expr);
 317                 json_node_free(node);
 318                 return NULL;
 319         }
 320
 321         if (size > 1) {
 322                 g_set_error(error, FB_JSON_ERROR, FB_JSON_ERROR_AMBIGUOUS,
 323                             _("Ambiguous matches for %s"), expr);
 324                 json_node_free(node);
 325                 return NULL;
 326         }
 327
 328         if (json_array_get_null_element(rslt, 0)) {
 329                 g_set_error(error, FB_JSON_ERROR, FB_JSON_ERROR_NULL,
 330                             _("Null value for %s"), expr);
 331                 json_node_free(node);
 332                 return NULL;
 333         }
 334
 335         ret = json_array_dup_element(rslt, 0);
 336         json_node_free(node);
 337         return ret;
 338 }
 339
 340 JsonNode *
 341 fb_json_node_get_nth(JsonNode *root, guint n)
 342 {
 343         GList *vals;
 344         JsonNode *ret;
 345         JsonObject *obj;
 346
 347         obj = json_node_get_object(root);
 348         vals = json_object_get_values(obj);
 349         ret = g_list_nth_data(vals, n);
 350
 351         g_list_free(vals);
 352         return ret;
 353 }
 354
 355 JsonArray *
 356 fb_json_node_get_arr(JsonNode *root, const gchar *expr, GError **error)
 357 {
 358         JsonArray *ret;
 359         JsonNode *rslt;
 360
 361         rslt = fb_json_node_get(root, expr, error);
 362
 363         if (rslt == NULL) {
 364                 return NULL;
 365         }
 366
 367         ret = json_node_dup_array(rslt);
 368         json_node_free(rslt);
 369         return ret;
 370 }
 371
 372 gboolean
 373 fb_json_node_get_bool(JsonNode *root, const gchar *expr, GError **error)
 374 {
 375         gboolean ret;
 376         JsonNode *rslt;
 377
 378         rslt = fb_json_node_get(root, expr, error);
 379
 380         if (rslt == NULL) {
 381                 return FALSE;
 382         }
 383
 384         ret = json_node_get_boolean(rslt);
 385         json_node_free(rslt);
 386         return ret;
 387 }
 388
 389 gdouble
 390 fb_json_node_get_dbl(JsonNode *root, const gchar *expr, GError **error)
 391 {
 392         gdouble ret;
 393         JsonNode *rslt;
 394
 395         rslt = fb_json_node_get(root, expr, error);
 396
 397         if (rslt == NULL) {
 398                 return 0.0;
 399         }
 400
 401         ret = json_node_get_double(rslt);
 402         json_node_free(rslt);
 403         return ret;
 404 }
 405
 406 gint64
 407 fb_json_node_get_int(JsonNode *root, const gchar *expr, GError **error)
 408 {
 409         gint64 ret;
 410         JsonNode *rslt;
 411
 412         rslt = fb_json_node_get(root, expr, error);
 413
 414         if (rslt == NULL) {
 415                 return 0;
 416         }
 417
 418         ret = json_node_get_int(rslt);
 419         json_node_free(rslt);
 420         return ret;
 421 }
 422
 423 gchar *
 424 fb_json_node_get_str(JsonNode *root, const gchar *expr, GError **error)
 425 {
 426         gchar *ret;
 427         JsonNode *rslt;
 428
 429         rslt = fb_json_node_get(root, expr, error);
 430
 431         if (rslt == NULL) {
 432                 return NULL;
 433         }
 434
 435         ret = json_node_dup_string(rslt);
 436         json_node_free(rslt);
 437         return ret;
 438 }
 439
 440 FbJsonValues *
 441 fb_json_values_new(JsonNode *root)
 442 {
 443         FbJsonValues *values;
 444         FbJsonValuesPrivate *priv;
 445
 446         g_return_val_if_fail(root != NULL, NULL);
 447
 448         values = g_object_new(FB_TYPE_JSON_VALUES, NULL);
 449         priv = values->priv;
 450         priv->root = root;
 451
 452         return values;
 453 }
 454
 455 void
 456 fb_json_values_add(FbJsonValues *values, FbJsonType type, gboolean required,
 457                    const gchar *expr)
 458 {
 459         FbJsonValue *value;
 460         FbJsonValuesPrivate *priv;
 461
 462         g_return_if_fail(values != NULL);
 463         g_return_if_fail(expr != NULL);
 464         priv = values->priv;
 465
 466         value = g_new0(FbJsonValue, 1);
 467         value->expr = expr;
 468         value->type = type;
 469         value->required = required;
 470
 471         g_queue_push_tail(priv->queue, value);
 472 }
 473
 474 JsonNode *
 475 fb_json_values_get_root(FbJsonValues *values)
 476 {
 477         FbJsonValuesPrivate *priv;
 478         guint index;
 479
 480         g_return_val_if_fail(values != NULL, NULL);
 481         priv = values->priv;
 482
 483         if (priv->array == NULL) {
 484                 return priv->root;
 485         }
 486
 487         g_return_val_if_fail(priv->index > 0, NULL);
 488         index = priv->index - 1;
 489
 490         if (json_array_get_length(priv->array) <= index) {
 491                 return NULL;
 492         }
 493
 494         return json_array_get_element(priv->array, index);
 495 }
 496
 497 void
 498 fb_json_values_set_array(FbJsonValues *values, gboolean required,
 499                          const gchar *expr)
 500 {
 501         FbJsonValuesPrivate *priv;
 502
 503         g_return_if_fail(values != NULL);
 504         priv = values->priv;
 505
 506         priv->array = fb_json_node_get_arr(priv->root, expr, &priv->error);
 507         priv->isarray = TRUE;
 508
 509         if ((priv->error != NULL) && !required) {
 510                 g_clear_error(&priv->error);
 511         }
 512 }
 513
 514 gboolean
 515 fb_json_values_update(FbJsonValues *values, GError **error)
 516 {
 517         FbJsonValue *value;
 518         FbJsonValuesPrivate *priv;
 519         GError *err = NULL;
 520         GList *l;
 521         GType type;
 522         JsonNode *root;
 523         JsonNode *node;
 524
 525         g_return_val_if_fail(values != NULL, FALSE);
 526         priv = values->priv;
 527
 528         if (G_UNLIKELY(priv->error != NULL)) {
 529                 g_propagate_error(error, priv->error);
 530                 priv->error = NULL;
 531                 return FALSE;
 532         }
 533
 534         if (priv->isarray) {
 535                 if ((priv->array == NULL) ||
 536                     (json_array_get_length(priv->array) <= priv->index))
 537                 {
 538                         return FALSE;
 539                 }
 540
 541                 root = json_array_get_element(priv->array, priv->index++);
 542         } else {
 543                 root = priv->root;
 544         }
 545
 546         g_return_val_if_fail(root != NULL, FALSE);
 547
 548         for (l = priv->queue->head; l != NULL; l = l->next) {
 549                 value = l->data;
 550                 node = fb_json_node_get(root, value->expr, &err);
 551
 552                 if (G_IS_VALUE(&value->value)) {
 553                         g_value_unset(&value->value);
 554                 }
 555
 556                 if (err != NULL) {
 557                         json_node_free(node);
 558
 559                         if (value->required) {
 560                                 g_propagate_error(error, err);
 561                                 return FALSE;
 562                         }
 563
 564                         g_clear_error(&err);
 565                         continue;
 566                 }
 567
 568                 type = json_node_get_value_type(node);
 569
 570                 if (G_UNLIKELY(type != value->type)) {
 571                         g_set_error(error, FB_JSON_ERROR, FB_JSON_ERROR_TYPE,
 572                                     _("Expected a %s but got a %s for %s"),
 573                                     g_type_name(value->type),
 574                                     g_type_name(type),
 575                                     value->expr);
 576                         json_node_free(node);
 577                         return FALSE;
 578                 }
 579
 580                 json_node_get_value(node, &value->value);
 581                 json_node_free(node);
 582         }
 583
 584         priv->next = priv->queue->head;
 585         return TRUE;
 586 }
 587
 588 const GValue *
 589 fb_json_values_next(FbJsonValues *values)
 590 {
 591         FbJsonValue *value;
 592         FbJsonValuesPrivate *priv;
 593
 594         g_return_val_if_fail(values != NULL, NULL);
 595         priv = values->priv;
 596
 597         g_return_val_if_fail(priv->next != NULL, NULL);
 598         value = priv->next->data;
 599         priv->next = priv->next->next;
 600
 601         if (!G_IS_VALUE(&value->value)) {
 602                 return NULL;
 603         }
 604
 605         return &value->value;
 606 }
 607
 608 gboolean
 609 fb_json_values_next_bool(FbJsonValues *values, gboolean defval)
 610 {
 611         const GValue *value;
 612
 613         value = fb_json_values_next(values);
 614
 615         if (G_UNLIKELY(value == NULL)) {
 616                 return defval;
 617         }
 618
 619         return g_value_get_boolean(value);
 620 }
 621
 622 gdouble
 623 fb_json_values_next_dbl(FbJsonValues *values, gdouble defval)
 624 {
 625         const GValue *value;
 626
 627         value = fb_json_values_next(values);
 628
 629         if (G_UNLIKELY(value == NULL)) {
 630                 return defval;
 631         }
 632
 633         return g_value_get_double(value);
 634 }
 635
 636 gint64
 637 fb_json_values_next_int(FbJsonValues *values, gint64 defval)
 638 {
 639         const GValue *value;
 640
 641         value = fb_json_values_next(values);
 642
 643         if (G_UNLIKELY(value == NULL)) {
 644                 return defval;
 645         }
 646
 647         return g_value_get_int64(value);
 648 }
 649
 650 const gchar *
 651 fb_json_values_next_str(FbJsonValues *values, const gchar *defval)
 652 {
 653         const GValue *value;
 654
 655         value = fb_json_values_next(values);
 656
 657         if (G_UNLIKELY(value == NULL)) {
 658                 return defval;
 659         }
 660
 661         return g_value_get_string(value);
 662 }
 663
 664 gchar *
 665 fb_json_values_next_str_dup(FbJsonValues *values, const gchar *defval)
 666 {
 667         const GValue *value;
 668
 669         value = fb_json_values_next(values);
 670
 671         if (G_UNLIKELY(value == NULL)) {
 672                 return g_strdup(defval);
 673         }
 674
 675         return g_value_dup_string(value);
 676 }