irreco/trunk/src/webdb/irreco_webdb_client.c

   1 /*
   2  * irreco - Ir Remote Control
   3  * Copyright (C) 2007,2008  Arto Karppinen (arto.karppinen@iki.fi),
   4  * Joni Kokko (t5kojo01@students.oamk.fi),
   5  * Sami Mäki (t5masa02@students.oamk.fi),
   6  * Harri Vattulainen (t5vaha01@students.oamk.fi)
   7  *
   8  * This program is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU General Public License
  10  * as published by the Free Software Foundation; either version 2
  11  * of the License, or (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software Foundation,
  20  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  21  */
  22
  23 #include "irreco_webdb_client.h"
  24
  25 /* #define IRRECO_WEBDB_URL "http://mercury.wipsl.com/irreco/webdb/" */
  26 #define IRRECO_WEBDB_URL "http://127.0.0.1/irreco/webdb/"
  27
  28 /*
  29 for php files
  30 svn co svn+irreco:///irreco/irreco/database/trunk/php /var/www/irreco/webdb
  31 */
  32
  33
  34 /**
  35  * @typedef IrrecoWebdbClient
  36  *
  37  * Irreco Web Database API implementation. These functions connect to the
  38  * IrrecoWebdbClient trough XML-RPC connection, pass arguments, and decode return
  39  * values.
  40  */
  41
  42
  43
  44 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  45 /* Prototypes                                                                 */
  46 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  47
  48 static gboolean irreco_webdb_client_check_error();
  49 static void irreco_webdb_client_reset_env();
  50
  51
  52
  53 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  54 /* Construction & Destruction                                                 */
  55 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  56
  57 /**
  58  * Create new IrrecoWebdbClient Object
  59  */
  60 IrrecoWebdbClient *irreco_webdb_client_new()
  61 {
  62         IrrecoWebdbClient *self;
  63         IRRECO_ENTER
  64
  65         self = g_slice_new0(IrrecoWebdbClient);
  66         self->error_env = g_slice_new0(xmlrpc_env);
  67         xmlrpc_env_init(self->error_env);
  68         self->server = xmlrpc_server_info_new(self->error_env,
  69                                               IRRECO_WEBDB_URL);
  70         if (irreco_webdb_client_check_error(self)) {
  71                 self->server = NULL;
  72                 irreco_webdb_client_free(self);
  73                 IRRECO_RETURN_PTR(NULL);
  74         }
  75         IRRECO_RETURN_PTR(self);
  76 }
  77
  78 void irreco_webdb_client_free(IrrecoWebdbClient *self)
  79 {
  80         IRRECO_ENTER
  81
  82         g_assert(self != NULL);
  83
  84         if (self->server) xmlrpc_server_info_free(self->server);
  85         xmlrpc_env_clean(self->error_env);
  86
  87         g_slice_free(xmlrpc_env, self->error_env);
  88         self->error_env = NULL;
  89
  90         g_slice_free(IrrecoWebdbClient, self);
  91         self = NULL;
  92
  93         IRRECO_RETURN
  94 }
  95
  96
  97
  98 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  99 /* Private Functions                                                          */
 100 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
 101
 102 /**
 103  * Release of RPC results and errors.
 104  */
 105 static void irreco_webdb_client_reset_env(IrrecoWebdbClient *self)
 106 {
 107         IRRECO_ENTER
 108         if (irreco_webdb_client_check_error(self)) {
 109                 xmlrpc_env_clean(self->error_env);
 110                 xmlrpc_env_init(self->error_env);
 111         }
 112         IRRECO_RETURN
 113 }
 114
 115 /**
 116  * Check if the previous call to XMLRPC-C succeeded.
 117  *
 118  * @return TRUE if error occured, FALSE otherwise.
 119  */
 120 static gboolean irreco_webdb_client_check_error(IrrecoWebdbClient *self)
 121 {
 122         IRRECO_ENTER
 123         if(self->error_env->fault_occurred) {
 124                 IRRECO_ERROR("%d: %s\n", self->error_env->fault_code,
 125                              self->error_env->fault_string);
 126                 IRRECO_RETURN_BOOL(TRUE);
 127         }
 128         IRRECO_RETURN_BOOL(FALSE);
 129 }
 130
 131
 132
 133 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
 134 /* Functions                                                                  */
 135 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
 136
 137 /**
 138  * Get error message.
 139  *
 140  * @param msg GString object to recieve the error message.
 141  */
 142 void irreco_webdb_client_get_error_msg(IrrecoWebdbClient *self, GString *msg)
 143 {
 144         IRRECO_ENTER
 145         g_string_printf(msg, "%d: %s\n",
 146                         self->error_env->fault_code,
 147                         self->error_env->fault_string);
 148         IRRECO_RETURN
 149 }
 150
 151 /**
 152  * Ask WebDB to sum two numbers.
 153  *
 154  * @param num_a First number.
 155  * @param num_b Second number.
 156  * @param sum   Variable to recieve the result.
 157  * @return TRUE on successfull XML-RPC call, FALSE otherwise.
 158  */
 159 gboolean irreco_webdb_client_sum(IrrecoWebdbClient *self,
 160                                  gint num_a,
 161                                  gint num_b,
 162                                  gint *sum)
 163 {
 164         gboolean         rvalue         = FALSE;
 165         xmlrpc_value    *response       = NULL;
 166         IRRECO_ENTER
 167
 168         irreco_webdb_client_reset_env(self);
 169         response = xmlrpc_client_call_server(self->error_env, self->server,
 170                                              "sum", "(ii)",
 171                                              (xmlrpc_int32) num_a,
 172                                              (xmlrpc_int32) num_b);
 173         if (irreco_webdb_client_check_error(self)) {
 174                 response = NULL;
 175                 goto cleanup;
 176         }
 177
 178         xmlrpc_read_int(self->error_env, response, sum);
 179         if (irreco_webdb_client_check_error(self)) goto cleanup;
 180
 181         /* No error occured. */
 182         rvalue = TRUE;
 183
 184         cleanup:
 185         if (response) xmlrpc_DECREF(response);
 186         IRRECO_RETURN_BOOL(rvalue);
 187 }
 188
 189 /**
 190  *
 191  */
 192
 193 gboolean irreco_webdb_client_add_user(IrrecoWebdbClient *self,
 194                                       const gchar *name,
 195                                       const gchar *email,
 196                                       const gchar *passwd)
 197 {
 198         gboolean        rvalue                  = FALSE;
 199         xmlrpc_value    *response               = NULL;
 200
 201         IRRECO_ENTER
 202
 203         irreco_webdb_client_reset_env(self);
 204
 205         /* Execute XML-RPC call. */
 206         response = xmlrpc_client_call_server(self->error_env,
 207                                      self->server,
 208                                      "addUser",
 209                                      "(sss)",
 210                                      name,
 211                                      email,
 212                                      passwd);
 213
 214         if (irreco_webdb_client_check_error(self)) {
 215                 response = NULL;
 216                 if (response) xmlrpc_DECREF(response);
 217                 IRRECO_RETURN_BOOL(FALSE);
 218         }
 219
 220         /* Parse response and set to user_exists */
 221         xmlrpc_read_bool(self->error_env, response, &rvalue);
 222
 223         if (irreco_webdb_client_check_error(self)) {
 224                 response = NULL;
 225                 if (response) xmlrpc_DECREF(response);
 226                 IRRECO_RETURN_BOOL(FALSE);
 227         }
 228
 229         IRRECO_RETURN_BOOL(rvalue);
 230 }
 231
 232 gboolean irreco_webdb_client_upload_configuration(IrrecoWebdbClient *self,
 233                                                   const gchar *backend,
 234                                                   const gchar *category,
 235                                                   const gchar *file_hash,
 236                                                   const gchar *file_name,
 237                                                   const gchar *manufacturer,
 238                                                   const gchar *model,
 239                                                   const gchar *password,
 240                                                   const gchar *user,
 241                                                   const gchar *data)
 242 {
 243         gboolean        rvalue          = FALSE;
 244         xmlrpc_value    *response       = NULL;
 245         IRRECO_ENTER
 246
 247         irreco_webdb_client_reset_env(self);
 248
 249         /* Execute XML-RPC call. */
 250         response = xmlrpc_client_call_server(self->error_env,
 251                                      self->server,
 252                                      /* For testing purposes only */
 253                                      "uploadConfiguration",
 254                                      "(sssssssss)",
 255                                      backend,
 256                                      category,
 257                                      manufacturer,
 258                                      model,
 259                                      user,
 260                                      password,
 261                                      file_hash,
 262                                      file_name,
 263                                      data);
 264
 265         if (irreco_webdb_client_check_error(self)) {
 266                 response = NULL;
 267                 goto cleanup;
 268         }
 269
 270         /* No error occured. */
 271         rvalue = TRUE;
 272
 273         cleanup:
 274         if (response) xmlrpc_DECREF(response);
 275
 276         IRRECO_RETURN_BOOL(rvalue);
 277 }
 278
 279 gboolean irreco_webdb_client_get_categories(IrrecoWebdbClient *self,
 280                                             IrrecoStringTable **category_list)
 281 {
 282         gint            i               = 0;
 283         gint            array_size      = 0;
 284         gboolean        rvalue          = FALSE;
 285         xmlrpc_value    *response       = NULL;
 286         xmlrpc_value    *category_xml   = NULL;
 287         const gchar     *category_str   = NULL;
 288         IRRECO_ENTER
 289
 290         *category_list = NULL;
 291         irreco_webdb_client_reset_env(self);
 292
 293         /* Execute XML-RPC call. */
 294         response = xmlrpc_client_call_server(self->error_env, self->server,
 295                                              "getCategories", "()");
 296         if (irreco_webdb_client_check_error(self)) {
 297                 response = NULL;
 298                 goto cleanup;
 299         }
 300
 301         /* Get size responce of array. */
 302         array_size = xmlrpc_array_size(self->error_env, response);
 303         if (irreco_webdb_client_check_error(self)) goto cleanup;
 304
 305         /* Parse array. */
 306         *category_list = irreco_string_table_new(
 307                 (GDestroyNotify) irreco_string_table_free, NULL);
 308         for(i = 0; i < array_size; i++) {
 309                 xmlrpc_array_read_item(self->error_env, response,
 310                                        i, &category_xml);
 311                 if (irreco_webdb_client_check_error(self)) goto cleanup;
 312
 313                 xmlrpc_read_string(self->error_env, category_xml,
 314                                    &category_str);
 315                 if (irreco_webdb_client_check_error(self)) goto cleanup;
 316
 317                 IRRECO_DEBUG("Category: %s\n", category_str);
 318                 irreco_string_table_add(*category_list, category_str, NULL);
 319                 xmlrpc_DECREF(category_xml);
 320         }
 321
 322         /* No error occured. */
 323         rvalue = TRUE;
 324
 325         cleanup:
 326         if (response) xmlrpc_DECREF(response);
 327         if (category_xml) xmlrpc_DECREF(category_xml);
 328         if (rvalue == FALSE && *category_list != NULL) {
 329                 irreco_string_table_free(*category_list);
 330         }
 331         IRRECO_RETURN_BOOL(rvalue);
 332 }
 333
 334 gboolean irreco_webdb_client_get_all_categories(IrrecoWebdbClient *self,
 335                                             IrrecoStringTable **category_list)
 336 {
 337         gint            i               = 0;
 338         gint            array_size      = 0;
 339         gboolean        rvalue          = FALSE;
 340         xmlrpc_value    *response       = NULL;
 341         xmlrpc_value    *category_xml   = NULL;
 342         const gchar     *category_str   = NULL;
 343         IRRECO_ENTER
 344
 345         *category_list = NULL;
 346         irreco_webdb_client_reset_env(self);
 347
 348         /* Execute XML-RPC call. */
 349         response = xmlrpc_client_call_server(self->error_env, self->server,
 350                                              "getAllCategories", "()");
 351         if (irreco_webdb_client_check_error(self)) {
 352                 response = NULL;
 353                 goto cleanup;
 354         }
 355
 356         /* Get size responce of array. */
 357         array_size = xmlrpc_array_size(self->error_env, response);
 358         if (irreco_webdb_client_check_error(self)) goto cleanup;
 359
 360         /* Parse array. */
 361         *category_list = irreco_string_table_new(
 362                 (GDestroyNotify) irreco_string_table_free, NULL);
 363         for(i = 0; i < array_size; i++) {
 364                 xmlrpc_array_read_item(self->error_env, response,
 365                                        i, &category_xml);
 366                 if (irreco_webdb_client_check_error(self)) goto cleanup;
 367
 368                 xmlrpc_read_string(self->error_env, category_xml,
 369                                    &category_str);
 370                 if (irreco_webdb_client_check_error(self)) goto cleanup;
 371
 372                 IRRECO_DEBUG("Category: %s\n", category_str);
 373                 irreco_string_table_add(*category_list, category_str, NULL);
 374                 xmlrpc_DECREF(category_xml);
 375         }
 376
 377         /* No error occured. */
 378         rvalue = TRUE;
 379
 380         cleanup:
 381         if (response) xmlrpc_DECREF(response);
 382         if (category_xml) xmlrpc_DECREF(category_xml);
 383         if (rvalue == FALSE && *category_list != NULL) {
 384                 irreco_string_table_free(*category_list);
 385         }
 386         IRRECO_RETURN_BOOL(rvalue);
 387 }
 388 gboolean irreco_webdb_client_get_manufacturers(IrrecoWebdbClient *self,
 389                                         const gchar *category,
 390                                         IrrecoStringTable **manufacturer_list)
 391 {
 392         gint            i                       = 0;
 393         gint            array_size              = 0;
 394         gboolean        rvalue                  = FALSE;
 395         xmlrpc_value    *response               = NULL;
 396         xmlrpc_value    *manufacturer_xml       = NULL;
 397         const gchar     *manufacturer_str       = NULL;
 398         IRRECO_ENTER
 399
 400         *manufacturer_list = NULL;
 401         irreco_webdb_client_reset_env(self);
 402
 403         /* Execute XML-RPC call. */
 404         response = xmlrpc_client_call_server(self->error_env, self->server,
 405                                              "getManufacturers", "(s)",
 406                                              category);
 407         if (irreco_webdb_client_check_error(self)) {
 408                 response = NULL;
 409                 goto cleanup;
 410         }
 411
 412         /* Get size responce of array. */
 413         array_size = xmlrpc_array_size(self->error_env, response);
 414         if (irreco_webdb_client_check_error(self)) goto cleanup;
 415
 416         /* Parse array. */
 417         *manufacturer_list = irreco_string_table_new(
 418                 (GDestroyNotify) irreco_string_table_free, NULL);
 419         for(i = 0; i < array_size; i++) {
 420                 xmlrpc_array_read_item(self->error_env, response,
 421                                        i, &manufacturer_xml);
 422                 if (irreco_webdb_client_check_error(self)) goto cleanup;
 423
 424                 xmlrpc_read_string(self->error_env, manufacturer_xml,
 425                                    &manufacturer_str);
 426                 if (irreco_webdb_client_check_error(self)) goto cleanup;
 427
 428                 IRRECO_DEBUG("Manufacturer: %s\n", manufacturer_str);
 429                 irreco_string_table_add(*manufacturer_list,
 430                                          manufacturer_str, NULL);
 431                 xmlrpc_DECREF(manufacturer_xml);
 432         }
 433
 434         /* No error occured. */
 435         rvalue = TRUE;
 436
 437         cleanup:
 438         if (response) xmlrpc_DECREF(response);
 439         if (manufacturer_xml) xmlrpc_DECREF(manufacturer_xml);
 440         if (rvalue == FALSE && *manufacturer_list != NULL) {
 441                 irreco_string_table_free(*manufacturer_list);
 442         }
 443         IRRECO_RETURN_BOOL(rvalue);
 444 }
 445
 446 gboolean irreco_webdb_client_get_all_manufacturers(IrrecoWebdbClient *self,
 447                             IrrecoStringTable **manufacturer_list)
 448 {
 449         gint            i                       = 0;
 450         gint            array_size              = 0;
 451         gboolean        rvalue                  = FALSE;
 452         xmlrpc_value    *response               = NULL;
 453         xmlrpc_value    *manufacturer_xml       = NULL;
 454         const gchar     *manufacturer_str       = NULL;
 455         IRRECO_ENTER
 456
 457         *manufacturer_list = NULL;
 458         irreco_webdb_client_reset_env(self);
 459
 460         /* Execute XML-RPC call. */
 461         response = xmlrpc_client_call_server(self->error_env, self->server,
 462                                              "getAllManufacturers", "()");
 463         if (irreco_webdb_client_check_error(self)) {
 464                 response = NULL;
 465                 goto cleanup;
 466         }
 467
 468         /* Get size response of array. */
 469         array_size = xmlrpc_array_size(self->error_env, response);
 470         if (irreco_webdb_client_check_error(self)) goto cleanup;
 471
 472         /* Parse array. */
 473         *manufacturer_list = irreco_string_table_new(
 474                 (GDestroyNotify) irreco_string_table_free, NULL);
 475         for(i = 0; i < array_size; i++) {
 476                 xmlrpc_array_read_item(self->error_env, response,
 477                                        i, &manufacturer_xml);
 478                 if (irreco_webdb_client_check_error(self)) goto cleanup;
 479
 480                 xmlrpc_read_string(self->error_env, manufacturer_xml,
 481                                    &manufacturer_str);
 482                 if (irreco_webdb_client_check_error(self)) goto cleanup;
 483
 484                 IRRECO_DEBUG("Manufacturer: %s\n", manufacturer_str);
 485                 irreco_string_table_add(*manufacturer_list,
 486                                 manufacturer_str, NULL);
 487                 xmlrpc_DECREF(manufacturer_xml);
 488         }
 489
 490         /* No error occured. */
 491         rvalue = TRUE;
 492
 493         cleanup:
 494         if (response) xmlrpc_DECREF(response);
 495         if (manufacturer_xml) xmlrpc_DECREF(manufacturer_xml);
 496         if (rvalue == FALSE && *manufacturer_list != NULL) {
 497                 irreco_string_table_free(*manufacturer_list);
 498         }
 499         IRRECO_RETURN_BOOL(rvalue);
 500 }
 501
 502 gboolean irreco_webdb_client_get_models(IrrecoWebdbClient *self,
 503                                         const gchar *category,
 504                                         const gchar *manufacturer,
 505                                         IrrecoStringTable **model_list)
 506 {
 507         gint            i                       = 0;
 508         gint            array_size              = 0;
 509         gboolean        rvalue                  = FALSE;
 510         xmlrpc_value    *response               = NULL;
 511         xmlrpc_value    *model_xml              = NULL;
 512         const gchar     *model_str              = NULL;
 513         IRRECO_ENTER
 514
 515         *model_list = NULL;
 516         irreco_webdb_client_reset_env(self);
 517
 518         /* Execute XML-RPC call. */
 519         response = xmlrpc_client_call_server(self->error_env, self->server,
 520                                              "getModels", "(ss)",
 521                                              category,manufacturer);
 522         if (irreco_webdb_client_check_error(self)) {
 523                 response = NULL;
 524                 goto cleanup;
 525         }
 526
 527         /* Get size responce of array. */
 528         array_size = xmlrpc_array_size(self->error_env, response);
 529         if (irreco_webdb_client_check_error(self)) goto cleanup;
 530
 531         /* Parse array. */
 532         *model_list = irreco_string_table_new(
 533                 (GDestroyNotify) irreco_string_table_free, NULL);
 534         for(i = 0; i < array_size; i++) {
 535                 xmlrpc_array_read_item(self->error_env, response,
 536                                        i, &model_xml);
 537                 if (irreco_webdb_client_check_error(self)) goto cleanup;
 538
 539                 xmlrpc_read_string(self->error_env, model_xml,
 540                                    &model_str);
 541                 if (irreco_webdb_client_check_error(self)) goto cleanup;
 542
 543                 IRRECO_DEBUG("Model: %s\n", model_str);
 544                 irreco_string_table_add(*model_list,
 545                                          model_str, NULL);
 546                 xmlrpc_DECREF(model_xml);
 547         }
 548
 549         /* No error occured. */
 550         rvalue = TRUE;
 551
 552         cleanup:
 553         if (response) xmlrpc_DECREF(response);
 554         if (model_xml) xmlrpc_DECREF(model_xml);
 555         if (rvalue == FALSE && *model_list != NULL) {
 556                 irreco_string_table_free(*model_list);
 557         }
 558         IRRECO_RETURN_BOOL(rvalue);
 559 }
 560
 561
 562 gboolean irreco_webdb_client_get_configs(IrrecoWebdbClient *self,
 563                                          const gchar *category,
 564                                          const gchar *manufacturer,
 565                                          const gchar *model,
 566                                          IrrecoStringTable **config_list)
 567 {
 568         gint            i                       = 0;
 569         gint            array_size              = 0;
 570         gboolean        rvalue                  = FALSE;
 571         xmlrpc_value    *response               = NULL;
 572         xmlrpc_value    *config_xml             = NULL;
 573         const gchar     *config_str             = NULL;
 574         IRRECO_ENTER
 575
 576         *config_list = NULL;
 577         irreco_webdb_client_reset_env(self);
 578
 579         /* Execute XML-RPC call. */
 580         response = xmlrpc_client_call_server(self->error_env, self->server,
 581                                              "getConfigs", "(s)",
 582                                              model);
 583         if (irreco_webdb_client_check_error(self)) {
 584                 response = NULL;
 585                 goto cleanup;
 586         }
 587
 588         /* Get size responce of array. */
 589         array_size = xmlrpc_array_size(self->error_env, response);
 590         if (irreco_webdb_client_check_error(self)) goto cleanup;
 591
 592         /* Parse array. */
 593         *config_list = irreco_string_table_new(NULL, NULL);
 594         for(i = 0; i < array_size; i++) {
 595
 596                 xmlrpc_array_read_item(self->error_env, response,
 597                                        i, &config_xml);
 598                 if (irreco_webdb_client_check_error(self)) goto cleanup;
 599
 600                 xmlrpc_read_string(self->error_env, config_xml,
 601                                    &config_str);
 602
 603                 if (irreco_webdb_client_check_error(self)) goto cleanup;
 604
 605                 IRRECO_DEBUG("Config: %s\n", config_str);
 606                 irreco_string_table_add(*config_list, config_str, NULL);
 607                 xmlrpc_DECREF(config_xml);
 608         }
 609
 610         /* No error occured. */
 611         rvalue = TRUE;
 612
 613         cleanup:
 614         if (response) xmlrpc_DECREF(response);
 615         if (config_xml) xmlrpc_DECREF(config_xml);
 616         if (rvalue == FALSE && *config_list != NULL) {
 617                 irreco_string_table_free(*config_list);
 618         }
 619         IRRECO_RETURN_BOOL(rvalue);
 620 }
 621
 622
 623 gboolean irreco_webdb_client_get_configuration(IrrecoWebdbClient *self,
 624                                                const gchar *id,
 625                                                IrrecoWebdbConf **configuration)
 626 {
 627         gboolean        rvalue          = FALSE;
 628         xmlrpc_value    *response       = NULL;
 629         xmlrpc_value    *_xml           = NULL;
 630         const gchar     *user;
 631         const gchar     *backend;
 632         const gchar     *category;
 633         const gchar     *manufacturer;
 634         const gchar     *model;
 635         const gchar     *file_hash;
 636         const gchar     *file_name;
 637         const gchar     *uploaded;
 638         const gchar     *download_count;
 639
 640         IRRECO_ENTER
 641
 642         *configuration = irreco_webdb_conf_new();
 643
 644         irreco_webdb_client_reset_env(self);
 645
 646         /* Execute XML-RPC call. */
 647         response = xmlrpc_client_call_server(self->error_env, self->server,
 648                                              "getConfiguration", "(s)", id);
 649         if (irreco_webdb_client_check_error(self)) {
 650                 response = NULL;
 651                 goto cleanup;
 652         }
 653
 654         /* Get size responce of array. */
 655
 656         xmlrpc_struct_find_value(self->error_env, response, "user", &_xml);
 657         if (irreco_webdb_client_check_error(self)) goto cleanup;
 658         xmlrpc_read_string(self->error_env, _xml, &user);
 659         xmlrpc_DECREF(_xml);
 660
 661         xmlrpc_struct_find_value(self->error_env, response, "backend", &_xml);
 662         if (irreco_webdb_client_check_error(self)) goto cleanup;
 663         xmlrpc_read_string(self->error_env, _xml, &backend);
 664         xmlrpc_DECREF(_xml);
 665
 666         xmlrpc_struct_find_value(self->error_env, response, "category", &_xml);
 667         if (irreco_webdb_client_check_error(self)) goto cleanup;
 668         xmlrpc_read_string(self->error_env, _xml, &category);
 669         xmlrpc_DECREF(_xml);
 670
 671         xmlrpc_struct_find_value(self->error_env, response, "manufacturer",
 672                                  &_xml);
 673         if (irreco_webdb_client_check_error(self)) goto cleanup;
 674         xmlrpc_read_string(self->error_env, _xml, &manufacturer);
 675         xmlrpc_DECREF(_xml);
 676
 677         xmlrpc_struct_find_value(self->error_env, response, "model", &_xml);
 678         if (irreco_webdb_client_check_error(self)) goto cleanup;
 679         xmlrpc_read_string(self->error_env, _xml, &model);
 680         xmlrpc_DECREF(_xml);
 681
 682         xmlrpc_struct_find_value(self->error_env, response, "file_hash", &_xml);
 683         if (irreco_webdb_client_check_error(self)) goto cleanup;
 684         xmlrpc_read_string(self->error_env, _xml, &file_hash);
 685         xmlrpc_DECREF(_xml);
 686
 687         xmlrpc_struct_find_value(self->error_env, response, "file_name", &_xml);
 688         if (irreco_webdb_client_check_error(self)) goto cleanup;
 689         xmlrpc_read_string(self->error_env, _xml, &file_name);
 690         xmlrpc_DECREF(_xml);
 691
 692         xmlrpc_struct_find_value(self->error_env, response, "uploaded", &_xml);
 693         if (irreco_webdb_client_check_error(self)) goto cleanup;
 694         xmlrpc_read_string(self->error_env, _xml, &uploaded);
 695         xmlrpc_DECREF(_xml);
 696
 697         xmlrpc_struct_find_value(self->error_env, response,
 698                                  "download_count", &_xml);
 699         if (irreco_webdb_client_check_error(self)) goto cleanup;
 700         xmlrpc_read_string(self->error_env, _xml, &download_count);
 701         xmlrpc_DECREF(_xml);
 702
 703         if (irreco_webdb_client_check_error(self)) goto cleanup;
 704
 705         IRRECO_DEBUG("Configuration: %d %s %s %s %s %s %s %s %s %s\n",
 706                      (gint)id, user, backend, category, manufacturer,
 707                      model, file_hash, file_name, uploaded, download_count);
 708
 709         irreco_webdb_conf_set(*configuration, (gint)id, user, backend, category,
 710                               manufacturer, model, file_hash, file_name,
 711                               uploaded, download_count);
 712
 713         /* No error occured. */
 714         rvalue = TRUE;
 715
 716         cleanup:
 717         if (response) xmlrpc_DECREF(response);
 718         if (_xml) xmlrpc_DECREF(_xml);
 719
 720         IRRECO_RETURN_BOOL(rvalue);
 721 }
 722
 723 gboolean irreco_webdb_client_get_file(IrrecoWebdbClient *self,
 724                                       const gchar *file_hash,
 725                                       const gchar *file_name,
 726                                       GString **file_data)
 727 {
 728         gboolean        rvalue          = FALSE;
 729         xmlrpc_value    *response       = NULL;
 730         xmlrpc_value    *_xml           = NULL;
 731         const gchar     *data           = NULL;
 732
 733         IRRECO_ENTER
 734
 735         irreco_webdb_client_reset_env(self);
 736
 737         IRRECO_LINE
 738
 739         /* Execute XML-RPC call. */
 740         response = xmlrpc_client_call_server(self->error_env, self->server,
 741                                              "getFile", "(ss)",
 742                                              file_hash, file_name);
 743         if (irreco_webdb_client_check_error(self)) {
 744                 response = NULL;
 745                 goto cleanup;
 746         }
 747
 748         /* Get size responce of array. */
 749
 750         xmlrpc_struct_find_value(self->error_env, response, "data", &_xml);
 751         if (irreco_webdb_client_check_error(self)) goto cleanup;
 752         xmlrpc_read_string(self->error_env, _xml, &data);
 753         xmlrpc_DECREF(_xml);
 754
 755         if (irreco_webdb_client_check_error(self)) goto cleanup;
 756
 757         IRRECO_DEBUG("File: %s\n", data);
 758
 759         *file_data = g_string_new (data);
 760
 761         /* No error occured. */
 762         rvalue = TRUE;
 763
 764         cleanup:
 765         if (response) xmlrpc_DECREF(response);
 766         if (_xml) xmlrpc_DECREF(_xml);
 767
 768         IRRECO_RETURN_BOOL(rvalue);
 769 }
 770
 771 gboolean irreco_webdb_client_get_user_exists(IrrecoWebdbClient *self,
 772                                              const gchar *name,
 773                                              gboolean *user_exists)
 774 {
 775         gboolean         rvalue                 = FALSE;
 776         xmlrpc_value    *response               = NULL;
 777
 778         IRRECO_ENTER
 779
 780         irreco_webdb_client_reset_env(self);
 781
 782         /* Execute XML-RPC call. */
 783         response = xmlrpc_client_call_server(self->error_env,
 784                                              self->server,
 785                                              "getUserExists",
 786                                              "(s)",
 787                                              name);
 788
 789         if (irreco_webdb_client_check_error(self)) {
 790                 response = NULL;
 791                 goto cleanup;
 792         }
 793
 794         /* Parse response and set to user_exists */
 795         xmlrpc_read_bool(self->error_env, response, user_exists);
 796
 797         if (irreco_webdb_client_check_error(self)) goto cleanup;
 798
 799         rvalue = TRUE;
 800
 801         cleanup:
 802         if (response) xmlrpc_DECREF(response);
 803
 804         IRRECO_RETURN_BOOL(rvalue);
 805 }
 806
 807
 808 #if 0
 809 /**
 810  *
 811  */
 812 gboolean irreco_webdb_client_get_category_list(GHashTable **category_list)
 813 {
 814         gint i;
 815         IRRECO_ENTER
 816
 817         *category_list = NULL;
 818
 819         /* Execute XML-RPC call. */
 820         irreco_webdb_client_reset_env();
 821         self->result = xmlrpc_client_call_server(self->error_env, self->server,
 822                                                  "getCategoryList", "()");
 823         if (!irreco_webdb_client_is_ok()) IRRECO_RETURN_BOOL(FALSE);
 824
 825         /* Get structure size. */
 826         i = xmlrpc_struct_size(self->error_env, self->result);
 827         if (!irreco_webdb_client_is_ok()) IRRECO_RETURN_BOOL(FALSE);
 828
 829         /* Create hashtable. */
 830         *category_list = g_hash_table_new_full(g_int_hash, g_int_equal,
 831                                           NULL, g_free);
 832
 833         /* Parse structure. */
 834         while (i--) {
 835                 xmlrpc_value *xml_key;
 836                 xmlrpc_value *xml_value;
 837                 const gchar * str_key;
 838                 const gchar * str_value;
 839
 840                 xmlrpc_struct_read_member(self->error_env, self->result, i,
 841                                           &xml_key, &xml_value);
 842                 if (!irreco_webdb_client_is_ok()) goto error;
 843
 844                 xmlrpc_read_string(self->error_env, xml_key, &str_key);
 845                 if (!irreco_webdb_client_is_ok()) goto error;
 846
 847                 xmlrpc_read_string(self->error_env, xml_value, &str_value);
 848                 if (!irreco_webdb_client_is_ok()) goto error;
 849
 850                 IRRECO_PRINTF("Key: %s, Val: %s\n", str_key, str_value);
 851                 /*g_hash_table_add();*/
 852
 853                 xmlrpc_DECREF(xml_key);
 854                 xmlrpc_DECREF(xml_value);
 855         }
 856
 857         IRRECO_RETURN_BOOL(TRUE);
 858
 859         error:
 860         g_hash_table_destroy(*category_list);
 861         *category_list = NULL;
 862         IRRECO_RETURN_BOOL(FALSE);
 863 }
 864 #endif
 865
 866
 867 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
 868 /* Events and Callbacks                                                       */
 869 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
 870
 871
 872
 873
 874
 875
 876
 877
 878