?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Removed Soup testing stuff.
[irreco.git] / irreco / trunk / src / webdb / irreco_webdb_client.c
blob1c0636d0c0ff636008ca1b38a1ee4193d62c5b1c
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 /* Private Functions */
99 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
100
101 /**
102 * Release of RPC results and errors.
103 */
104 static void irreco_webdb_client_reset_env(IrrecoWebdbClient *self)
105 {
106 IRRECO_ENTER
107 if (irreco_webdb_client_check_error(self)) {
108 xmlrpc_env_clean(self->error_env);
109 xmlrpc_env_init(self->error_env);
110 }
111 IRRECO_RETURN
112 }
113
114 /**
115 * Check if the previous call to XMLRPC-C succeeded.
116 *
117 * @return TRUE if error occured, FALSE otherwise.
118 */
119 static gboolean irreco_webdb_client_check_error(IrrecoWebdbClient *self)
120 {
121 IRRECO_ENTER
122 if(self->error_env->fault_occurred) {
123 IRRECO_ERROR("%d: %s\n", self->error_env->fault_code,
124 self->error_env->fault_string);
125 IRRECO_RETURN_BOOL(TRUE);
126 }
127 IRRECO_RETURN_BOOL(FALSE);
128 }
129
130
131
132 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
133 /* Functions */
134 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
135
136 /**
137 * Get error message.
138 *
139 * @param msg GString object to recieve the error message.
140 */
141 void irreco_webdb_client_get_error_msg(IrrecoWebdbClient *self, GString *msg)
142 {
143 IRRECO_ENTER
144 g_string_printf(msg, "%d: %s\n",
145 self->error_env->fault_code,
146 self->error_env->fault_string);
147 IRRECO_RETURN
148 }
149
150 /**
151 * Ask WebDB to sum two numbers.
152 *
153 * @param num_a First number.
154 * @param num_b Second number.
155 * @param sum Variable to recieve the result.
156 * @return TRUE on successfull XML-RPC call, FALSE otherwise.
157 */
158 gboolean irreco_webdb_client_sum(IrrecoWebdbClient *self,
159 gint num_a,
160 gint num_b,
161 gint *sum)
162 {
163 gboolean rvalue = FALSE;
164 xmlrpc_value *response = NULL;
165 IRRECO_ENTER
166
167 irreco_webdb_client_reset_env(self);
168 response = xmlrpc_client_call_server(self->error_env, self->server,
169 "sum", "(ii)",
170 (xmlrpc_int32) num_a,
171 (xmlrpc_int32) num_b);
172 if (irreco_webdb_client_check_error(self)) {
173 response = NULL;
174 goto cleanup;
175 }
176
177 xmlrpc_read_int(self->error_env, response, sum);
178 if (irreco_webdb_client_check_error(self)) goto cleanup;
179
180 /* No error occured. */
181 rvalue = TRUE;
182
183 cleanup:
184 if (response) xmlrpc_DECREF(response);
185 IRRECO_RETURN_BOOL(rvalue);
186 }
187
188 /**
189 *
190 */
191
192 gboolean irreco_webdb_client_add_user(IrrecoWebdbClient *self,
193 const gchar *name,
194 const gchar *email,
195 const gchar *passwd)
196 {
197 gboolean rvalue = TRUE;
198 xmlrpc_value *response = NULL;
199
200 IRRECO_ENTER
201
202 irreco_webdb_client_reset_env(self);
203
204 /* Execute XML-RPC call. */
205 response = xmlrpc_client_call_server(self->error_env,
206 self->server,
207 "addUser",
208 "(sss)",
209 name,
210 email,
211 passwd);
212
213 if (irreco_webdb_client_check_error(self)) {
214 rvalue = FALSE;
215 goto cleanup;
216 }
217
218 /* Parse response and set to user_exists */
219 xmlrpc_read_bool(self->error_env, response, &rvalue);
220
221 if (irreco_webdb_client_check_error(self)) {
222 rvalue = FALSE;
223 goto cleanup;
224 }
225
226 cleanup:
227 if (response) xmlrpc_DECREF(response);
228 IRRECO_RETURN_BOOL(rvalue);
229 }
230
231 gboolean irreco_webdb_client_upload_configuration(IrrecoWebdbClient *self,
232 const gchar *backend,
233 const gchar *category,
234 const gchar *file_hash,
235 const gchar *file_name,
236 const gchar *manufacturer,
237 const gchar *model,
238 const gchar *password,
239 const gchar *user,
240 const gchar *data)
241 {
242 gboolean rvalue = FALSE;
243 xmlrpc_value *response = NULL;
244 IRRECO_ENTER
245
246 irreco_webdb_client_reset_env(self);
247
248 /* Execute XML-RPC call. */
249 response = xmlrpc_client_call_server(self->error_env,
250 self->server,
251 /* For testing purposes only */
252 "uploadConfiguration",
253 "(sssssssss)",
254 backend,
255 category,
256 manufacturer,
257 model,
258 user,
259 password,
260 file_hash,
261 file_name,
262 data);
263
264 if (irreco_webdb_client_check_error(self)) {
265 response = NULL;
266 goto cleanup;
267 }
268
269 /* No error occured. */
270 rvalue = TRUE;
271
272 cleanup:
273 if (response) xmlrpc_DECREF(response);
274
275 IRRECO_RETURN_BOOL(rvalue);
276 }
277
278 gboolean irreco_webdb_client_get_categories(IrrecoWebdbClient *self,
279 IrrecoStringTable **category_list)
280 {
281 gint i = 0;
282 gint array_size = 0;
283 gboolean rvalue = FALSE;
284 xmlrpc_value *response = NULL;
285 xmlrpc_value *category_xml = NULL;
286 const gchar *category_str = NULL;
287 IRRECO_ENTER
288
289 *category_list = NULL;
290 irreco_webdb_client_reset_env(self);
291
292 /* Execute XML-RPC call. */
293 response = xmlrpc_client_call_server(self->error_env, self->server,
294 "getCategories", "()");
295 if (irreco_webdb_client_check_error(self)) {
296 response = NULL;
297 goto cleanup;
298 }
299
300 /* Get size responce of array. */
301 array_size = xmlrpc_array_size(self->error_env, response);
302 if (irreco_webdb_client_check_error(self)) goto cleanup;
303
304 /* Parse array. */
305 *category_list = irreco_string_table_new(
306 (GDestroyNotify) irreco_string_table_free, NULL);
307 for(i = 0; i < array_size; i++) {
308 xmlrpc_array_read_item(self->error_env, response,
309 i, &category_xml);
310 if (irreco_webdb_client_check_error(self)) goto cleanup;
311
312 xmlrpc_read_string(self->error_env, category_xml,
313 &category_str);
314 if (irreco_webdb_client_check_error(self)) goto cleanup;
315
316 IRRECO_DEBUG("Category: %s\n", category_str);
317 irreco_string_table_add(*category_list, category_str, NULL);
318 xmlrpc_DECREF(category_xml);
319 }
320
321 /* No error occured. */
322 rvalue = TRUE;
323
324 cleanup:
325 if (response) xmlrpc_DECREF(response);
326 if (category_xml) xmlrpc_DECREF(category_xml);
327 if (rvalue == FALSE && *category_list != NULL) {
328 irreco_string_table_free(*category_list);
329 }
330 IRRECO_RETURN_BOOL(rvalue);
331 }
332
333 gboolean irreco_webdb_client_get_all_categories(IrrecoWebdbClient *self,
334 IrrecoStringTable **category_list)
335 {
336 gint i = 0;
337 gint array_size = 0;
338 gboolean rvalue = FALSE;
339 xmlrpc_value *response = NULL;
340 xmlrpc_value *category_xml = NULL;
341 const gchar *category_str = NULL;
342 IRRECO_ENTER
343
344 *category_list = NULL;
345 irreco_webdb_client_reset_env(self);
346
347 /* Execute XML-RPC call. */
348 response = xmlrpc_client_call_server(self->error_env, self->server,
349 "getAllCategories", "()");
350 if (irreco_webdb_client_check_error(self)) {
351 response = NULL;
352 goto cleanup;
353 }
354
355 /* Get size responce of array. */
356 array_size = xmlrpc_array_size(self->error_env, response);
357 if (irreco_webdb_client_check_error(self)) goto cleanup;
358
359 /* Parse array. */
360 *category_list = irreco_string_table_new(
361 (GDestroyNotify) irreco_string_table_free, NULL);
362 for(i = 0; i < array_size; i++) {
363 xmlrpc_array_read_item(self->error_env, response,
364 i, &category_xml);
365 if (irreco_webdb_client_check_error(self)) goto cleanup;
366
367 xmlrpc_read_string(self->error_env, category_xml,
368 &category_str);
369 if (irreco_webdb_client_check_error(self)) goto cleanup;
370
371 IRRECO_DEBUG("Category: %s\n", category_str);
372 irreco_string_table_add(*category_list, category_str, NULL);
373 xmlrpc_DECREF(category_xml);
374 }
375
376 /* No error occured. */
377 rvalue = TRUE;
378
379 cleanup:
380 if (response) xmlrpc_DECREF(response);
381 if (category_xml) xmlrpc_DECREF(category_xml);
382 if (rvalue == FALSE && *category_list != NULL) {
383 irreco_string_table_free(*category_list);
384 }
385 IRRECO_RETURN_BOOL(rvalue);
386 }
387 gboolean irreco_webdb_client_get_manufacturers(IrrecoWebdbClient *self,
388 const gchar *category,
389 IrrecoStringTable **manufacturer_list)
390 {
391 gint i = 0;
392 gint array_size = 0;
393 gboolean rvalue = FALSE;
394 xmlrpc_value *response = NULL;
395 xmlrpc_value *manufacturer_xml = NULL;
396 const gchar *manufacturer_str = NULL;
397 IRRECO_ENTER
398
399 *manufacturer_list = NULL;
400 irreco_webdb_client_reset_env(self);
401
402 /* Execute XML-RPC call. */
403 response = xmlrpc_client_call_server(self->error_env, self->server,
404 "getManufacturers", "(s)",
405 category);
406 if (irreco_webdb_client_check_error(self)) {
407 response = NULL;
408 goto cleanup;
409 }
410
411 /* Get size responce of array. */
412 array_size = xmlrpc_array_size(self->error_env, response);
413 if (irreco_webdb_client_check_error(self)) goto cleanup;
414
415 /* Parse array. */
416 *manufacturer_list = irreco_string_table_new(
417 (GDestroyNotify) irreco_string_table_free, NULL);
418 for(i = 0; i < array_size; i++) {
419 xmlrpc_array_read_item(self->error_env, response,
420 i, &manufacturer_xml);
421 if (irreco_webdb_client_check_error(self)) goto cleanup;
422
423 xmlrpc_read_string(self->error_env, manufacturer_xml,
424 &manufacturer_str);
425 if (irreco_webdb_client_check_error(self)) goto cleanup;
426
427 IRRECO_DEBUG("Manufacturer: %s\n", manufacturer_str);
428 irreco_string_table_add(*manufacturer_list,
429 manufacturer_str, NULL);
430 xmlrpc_DECREF(manufacturer_xml);
431 }
432
433 /* No error occured. */
434 rvalue = TRUE;
435
436 cleanup:
437 if (response) xmlrpc_DECREF(response);
438 if (manufacturer_xml) xmlrpc_DECREF(manufacturer_xml);
439 if (rvalue == FALSE && *manufacturer_list != NULL) {
440 irreco_string_table_free(*manufacturer_list);
441 }
442 IRRECO_RETURN_BOOL(rvalue);
443 }
444
445 gboolean irreco_webdb_client_get_all_manufacturers(IrrecoWebdbClient *self,
446 IrrecoStringTable **manufacturer_list)
447 {
448 gint i = 0;
449 gint array_size = 0;
450 gboolean rvalue = FALSE;
451 xmlrpc_value *response = NULL;
452 xmlrpc_value *manufacturer_xml = NULL;
453 const gchar *manufacturer_str = NULL;
454 IRRECO_ENTER
455
456 *manufacturer_list = NULL;
457 irreco_webdb_client_reset_env(self);
458
459 /* Execute XML-RPC call. */
460 response = xmlrpc_client_call_server(self->error_env, self->server,
461 "getAllManufacturers", "()");
462 if (irreco_webdb_client_check_error(self)) {
463 response = NULL;
464 goto cleanup;
465 }
466
467 /* Get size response of array. */
468 array_size = xmlrpc_array_size(self->error_env, response);
469 if (irreco_webdb_client_check_error(self)) goto cleanup;
470
471 /* Parse array. */
472 *manufacturer_list = irreco_string_table_new(
473 (GDestroyNotify) irreco_string_table_free, NULL);
474 for(i = 0; i < array_size; i++) {
475 xmlrpc_array_read_item(self->error_env, response,
476 i, &manufacturer_xml);
477 if (irreco_webdb_client_check_error(self)) goto cleanup;
478
479 xmlrpc_read_string(self->error_env, manufacturer_xml,
480 &manufacturer_str);
481 if (irreco_webdb_client_check_error(self)) goto cleanup;
482
483 IRRECO_DEBUG("Manufacturer: %s\n", manufacturer_str);
484 irreco_string_table_add(*manufacturer_list,
485 manufacturer_str, NULL);
486 xmlrpc_DECREF(manufacturer_xml);
487 }
488
489 /* No error occured. */
490 rvalue = TRUE;
491
492 cleanup:
493 if (response) xmlrpc_DECREF(response);
494 if (manufacturer_xml) xmlrpc_DECREF(manufacturer_xml);
495 if (rvalue == FALSE && *manufacturer_list != NULL) {
496 irreco_string_table_free(*manufacturer_list);
497 }
498 IRRECO_RETURN_BOOL(rvalue);
499 }
500
501 gboolean irreco_webdb_client_get_models(IrrecoWebdbClient *self,
502 const gchar *category,
503 const gchar *manufacturer,
504 IrrecoStringTable **model_list)
505 {
506 gint i = 0;
507 gint array_size = 0;
508 gboolean rvalue = FALSE;
509 xmlrpc_value *response = NULL;
510 xmlrpc_value *model_xml = NULL;
511 const gchar *model_str = NULL;
512 IRRECO_ENTER
513
514 *model_list = NULL;
515 irreco_webdb_client_reset_env(self);
516
517 /* Execute XML-RPC call. */
518 response = xmlrpc_client_call_server(self->error_env, self->server,
519 "getModels", "(ss)",
520 category,manufacturer);
521 if (irreco_webdb_client_check_error(self)) {
522 response = NULL;
523 goto cleanup;
524 }
525
526 /* Get size responce of array. */
527 array_size = xmlrpc_array_size(self->error_env, response);
528 if (irreco_webdb_client_check_error(self)) goto cleanup;
529
530 /* Parse array. */
531 *model_list = irreco_string_table_new(
532 (GDestroyNotify) irreco_string_table_free, NULL);
533 for(i = 0; i < array_size; i++) {
534 xmlrpc_array_read_item(self->error_env, response,
535 i, &model_xml);
536 if (irreco_webdb_client_check_error(self)) goto cleanup;
537
538 xmlrpc_read_string(self->error_env, model_xml,
539 &model_str);
540 if (irreco_webdb_client_check_error(self)) goto cleanup;
541
542 IRRECO_DEBUG("Model: %s\n", model_str);
543 irreco_string_table_add(*model_list,
544 model_str, NULL);
545 xmlrpc_DECREF(model_xml);
546 }
547
548 /* No error occured. */
549 rvalue = TRUE;
550
551 cleanup:
552 if (response) xmlrpc_DECREF(response);
553 if (model_xml) xmlrpc_DECREF(model_xml);
554 if (rvalue == FALSE && *model_list != NULL) {
555 irreco_string_table_free(*model_list);
556 }
557 IRRECO_RETURN_BOOL(rvalue);
558 }
559
560
561 gboolean irreco_webdb_client_get_configs(IrrecoWebdbClient *self,
562 const gchar *category,
563 const gchar *manufacturer,
564 const gchar *model,
565 IrrecoStringTable **config_list)
566 {
567 gint i = 0;
568 gint array_size = 0;
569 gboolean rvalue = FALSE;
570 xmlrpc_value *response = NULL;
571 xmlrpc_value *config_xml = NULL;
572 const gchar *config_str = NULL;
573 IRRECO_ENTER
574
575 *config_list = NULL;
576 irreco_webdb_client_reset_env(self);
577
578 /* Execute XML-RPC call. */
579 response = xmlrpc_client_call_server(self->error_env, self->server,
580 "getConfigurations", "(ss)",
581 manufacturer,
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 gint 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 IRRECO_ENTER
640
641 *configuration = irreco_webdb_conf_new();
642
643 irreco_webdb_client_reset_env(self);
644
645 /* Execute XML-RPC call. */
646 response = xmlrpc_client_call_server(self->error_env, self->server,
647 "getConfigurationById", "(i)", id);
648 if (irreco_webdb_client_check_error(self)) {
649 response = NULL;
650 goto cleanup;
651 }
652
653 /* Get size responce of array. */
654
655 xmlrpc_struct_find_value(self->error_env, response, "user", &_xml);
656 if (irreco_webdb_client_check_error(self)) goto cleanup;
657 xmlrpc_read_string(self->error_env, _xml, &user);
658 xmlrpc_DECREF(_xml);
659 if (irreco_webdb_client_check_error(self)) goto cleanup;
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 if (irreco_webdb_client_check_error(self)) goto cleanup;
666
667 xmlrpc_struct_find_value(self->error_env, response, "category", &_xml);
668 if (irreco_webdb_client_check_error(self)) goto cleanup;
669 xmlrpc_read_string(self->error_env, _xml, &category);
670 xmlrpc_DECREF(_xml);
671 if (irreco_webdb_client_check_error(self)) goto cleanup;
672
673 xmlrpc_struct_find_value(self->error_env, response, "manufacturer",
674 &_xml);
675 if (irreco_webdb_client_check_error(self)) goto cleanup;
676 xmlrpc_read_string(self->error_env, _xml, &manufacturer);
677 xmlrpc_DECREF(_xml);
678 if (irreco_webdb_client_check_error(self)) goto cleanup;
679
680 xmlrpc_struct_find_value(self->error_env, response, "model", &_xml);
681 if (irreco_webdb_client_check_error(self)) goto cleanup;
682 xmlrpc_read_string(self->error_env, _xml, &model);
683 xmlrpc_DECREF(_xml);
684 if (irreco_webdb_client_check_error(self)) goto cleanup;
685
686 xmlrpc_struct_find_value(self->error_env, response, "file_hash", &_xml);
687 if (irreco_webdb_client_check_error(self)) goto cleanup;
688 xmlrpc_read_string(self->error_env, _xml, &file_hash);
689 xmlrpc_DECREF(_xml);
690 if (irreco_webdb_client_check_error(self)) goto cleanup;
691
692 xmlrpc_struct_find_value(self->error_env, response, "file_name", &_xml);
693 if (irreco_webdb_client_check_error(self)) goto cleanup;
694 xmlrpc_read_string(self->error_env, _xml, &file_name);
695 xmlrpc_DECREF(_xml);
696 if (irreco_webdb_client_check_error(self)) goto cleanup;
697
698 xmlrpc_struct_find_value(self->error_env, response, "uploaded", &_xml);
699 if (irreco_webdb_client_check_error(self)) goto cleanup;
700 xmlrpc_read_string(self->error_env, _xml, &uploaded);
701 xmlrpc_DECREF(_xml);
702 if (irreco_webdb_client_check_error(self)) goto cleanup;
703
704 xmlrpc_struct_find_value(self->error_env, response,
705 "download_count", &_xml);
706 if (irreco_webdb_client_check_error(self)) goto cleanup;
707 xmlrpc_read_string(self->error_env, _xml, &download_count);
708 xmlrpc_DECREF(_xml);
709 if (irreco_webdb_client_check_error(self)) goto cleanup;
710
711 IRRECO_DEBUG("Configuration: %d %s %s %s %s %s %s %s %s %s\n",
712 id, user, backend, category, manufacturer,
713 model, file_hash, file_name, uploaded, download_count);
714
715 irreco_webdb_conf_set(*configuration, id, user, backend, category,
716 manufacturer, model, file_hash, file_name,
717 uploaded, download_count);
718
719 /* No error occured. */
720 rvalue = TRUE;
721
722 cleanup:
723 if (response) xmlrpc_DECREF(response);
724 if (_xml) xmlrpc_DECREF(_xml);
725
726 IRRECO_RETURN_BOOL(rvalue);
727 }
728
729 gboolean irreco_webdb_client_get_file(IrrecoWebdbClient *self,
730 const gchar *file_hash,
731 const gchar *file_name,
732 GString **file_data)
733 {
734 gboolean rvalue = FALSE;
735 xmlrpc_value *response = NULL;
736 xmlrpc_value *_xml = NULL;
737 const gchar *data = NULL;
738
739 IRRECO_ENTER
740
741 irreco_webdb_client_reset_env(self);
742
743 IRRECO_LINE
744
745 /* Execute XML-RPC call. */
746 response = xmlrpc_client_call_server(self->error_env, self->server,
747 "getFile", "(ss)",
748 file_hash, file_name);
749 if (irreco_webdb_client_check_error(self)) {
750 response = NULL;
751 goto cleanup;
752 }
753
754 /* Get size responce of array. */
755
756 xmlrpc_struct_find_value(self->error_env, response, "data", &_xml);
757 if (irreco_webdb_client_check_error(self)) goto cleanup;
758 xmlrpc_read_string(self->error_env, _xml, &data);
759 xmlrpc_DECREF(_xml);
760
761 if (irreco_webdb_client_check_error(self)) goto cleanup;
762
763 IRRECO_DEBUG("File: %s\n", data);
764
765 *file_data = g_string_new (data);
766
767 /* No error occured. */
768 rvalue = TRUE;
769
770 cleanup:
771 if (response) xmlrpc_DECREF(response);
772 if (_xml) xmlrpc_DECREF(_xml);
773
774 IRRECO_RETURN_BOOL(rvalue);
775 }
776
777 gboolean irreco_webdb_client_get_user_exists(IrrecoWebdbClient *self,
778 const gchar *name,
779 gboolean *user_exists)
780 {
781 gboolean rvalue = FALSE;
782 xmlrpc_value *response = NULL;
783
784 IRRECO_ENTER
785
786 irreco_webdb_client_reset_env(self);
787
788 /* Execute XML-RPC call. */
789 response = xmlrpc_client_call_server(self->error_env,
790 self->server,
791 "getUserExists",
792 "(s)",
793 name);
794
795 if (irreco_webdb_client_check_error(self)) {
796 response = NULL;
797 goto cleanup;
798 }
799
800 /* Parse response and set to user_exists */
801 xmlrpc_read_bool(self->error_env, response, user_exists);
802
803 if (irreco_webdb_client_check_error(self)) goto cleanup;
804
805 rvalue = TRUE;
806
807 cleanup:
808 if (response) xmlrpc_DECREF(response);
809
810 IRRECO_RETURN_BOOL(rvalue);
811 }
812
813
814 #if 0
815 /**
816 *
817 */
818 gboolean irreco_webdb_client_get_category_list(GHashTable **category_list)
819 {
820 gint i;
821 IRRECO_ENTER
822
823 *category_list = NULL;
824
825 /* Execute XML-RPC call. */
826 irreco_webdb_client_reset_env();
827 self->result = xmlrpc_client_call_server(self->error_env, self->server,
828 "getCategoryList", "()");
829 if (!irreco_webdb_client_is_ok()) IRRECO_RETURN_BOOL(FALSE);
830
831 /* Get structure size. */
832 i = xmlrpc_struct_size(self->error_env, self->result);
833 if (!irreco_webdb_client_is_ok()) IRRECO_RETURN_BOOL(FALSE);
834
835 /* Create hashtable. */
836 *category_list = g_hash_table_new_full(g_int_hash, g_int_equal,
837 NULL, g_free);
838
839 /* Parse structure. */
840 while (i--) {
841 xmlrpc_value *xml_key;
842 xmlrpc_value *xml_value;
843 const gchar * str_key;
844 const gchar * str_value;
845
846 xmlrpc_struct_read_member(self->error_env, self->result, i,
847 &xml_key, &xml_value);
848 if (!irreco_webdb_client_is_ok()) goto error;
849
850 xmlrpc_read_string(self->error_env, xml_key, &str_key);
851 if (!irreco_webdb_client_is_ok()) goto error;
852
853 xmlrpc_read_string(self->error_env, xml_value, &str_value);
854 if (!irreco_webdb_client_is_ok()) goto error;
855
856 IRRECO_PRINTF("Key: %s, Val: %s\n", str_key, str_value);
857 /*g_hash_table_add();*/
858
859 xmlrpc_DECREF(xml_key);
860 xmlrpc_DECREF(xml_value);
861 }
862
863 IRRECO_RETURN_BOOL(TRUE);
864
865 error:
866 g_hash_table_destroy(*category_list);
867 *category_list = NULL;
868 IRRECO_RETURN_BOOL(FALSE);
869 }
870 #endif
871
872
873 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
874 /* Events and Callbacks */
875 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
876
877
878
879
880
881
882
883
884
Irreco is a remote control application for Nokia Internet Tablets.