← Back to branch summary

~ubuntu-branches/ubuntu/utopic/lasso/utopic-proposed

« back to all changes in this revision

Viewing changes to lasso/protocols/provider.c

  • Committer: Bazaar Package Importer
  • Author(s): Frederic Peters
  • Date: 2004-09-13 09:26:34 UTC
  • Revision ID: james.westby@ubuntu.com-20040913092634-01vdfl8j9cp94exa
Tags: upstream-0.4.1
Import upstream version 0.4.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
lasso/protocols/provider.c
 
1
/* $Id: provider.c,v 1.45 2004/09/01 09:59:53 fpeters Exp $
 
2
 *
 
3
 * Lasso - A free implementation of the Liberty Alliance specifications.
 
4
 *
 
5
 * Copyright (C) 2004 Entr'ouvert
 
6
 * http://lasso.entrouvert.org
 
7
 * 
 
8
 * Authors: Nicolas Clapies <nclapies@entrouvert.com>
 
9
 *          Valery Febvre <vfebvre@easter-eggs.com>
 
10
 *
 
11
 * This program is free software; you can redistribute it and/or modify
 
12
 * it under the terms of the GNU General Public License as published by
 
13
 * the Free Software Foundation; either version 2 of the License, or
 
14
 * (at your option) any later version.
 
15
 * 
 
16
 * This program is distributed in the hope that it will be useful,
 
17
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
18
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
19
 * GNU General Public License for more details.
 
20
 * 
 
21
 * You should have received a copy of the GNU General Public License
 
22
 * along with this program; if not, write to the Free Software
 
23
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
24
 */
 
25
 
 
26
#include <lasso/protocols/provider.h>
 
27
#include <lasso/xml/errors.h>
 
28
 
 
29
struct _LassoProviderPrivate
 
30
{
 
31
  gboolean dispose_has_run;
 
32
};
 
33
 
 
34
static GObjectClass *parent_class = NULL;
 
35
 
 
36
/*****************************************************************************/
 
37
/* public methods                                                            */
 
38
/*****************************************************************************/
 
39
 
 
40
LassoProvider*
 
41
lasso_provider_copy(LassoProvider *provider)
 
42
{
 
43
  LassoProvider *copy;
 
44
 
 
45
  g_return_val_if_fail(LASSO_IS_PROVIDER(provider), NULL);
 
46
 
 
47
  copy = LASSO_PROVIDER(g_object_new(LASSO_TYPE_PROVIDER, NULL));
 
48
  copy->metadata = lasso_node_copy(provider->metadata);
 
49
  copy->public_key     = g_strdup(provider->public_key);
 
50
  copy->ca_certificate = g_strdup(provider->ca_certificate);
 
51
 
 
52
  return copy;
 
53
}
 
54
 
 
55
void
 
56
lasso_provider_destroy(LassoProvider *provider)
 
57
{
 
58
  g_object_unref(G_OBJECT(provider));
 
59
}
 
60
 
 
61
gchar *
 
62
lasso_provider_dump(LassoProvider *provider)
 
63
{
 
64
  LassoNode *provider_node, *metadata_node;
 
65
  LassoNodeClass *provider_class;
 
66
  gchar *provider_dump;
 
67
 
 
68
  provider_node = lasso_node_new();
 
69
 
 
70
  /* set the public key, ca_certificate, metadata */
 
71
  provider_class = LASSO_NODE_GET_CLASS(provider_node);
 
72
  provider_class->set_name(provider_node, LASSO_PROVIDER_NODE);
 
73
  provider_class->set_ns(provider_node, lassoLassoHRef, NULL);
 
74
  
 
75
  metadata_node = lasso_node_copy(provider->metadata);
 
76
  provider_class->add_child(provider_node, metadata_node, FALSE);
 
77
  lasso_node_destroy(metadata_node);
 
78
  if(provider->public_key != NULL) {
 
79
    provider_class->set_prop(provider_node, LASSO_PROVIDER_PUBLIC_KEY_NODE,
 
80
                             provider->public_key);
 
81
  }
 
82
  if(provider->ca_certificate != NULL) {
 
83
    provider_class->set_prop(provider_node, LASSO_PROVIDER_CA_CERTIFICATE_NODE,
 
84
                             provider->ca_certificate);
 
85
  }
 
86
  provider_dump = lasso_node_export(provider_node);
 
87
 
 
88
  lasso_node_destroy(provider_node);
 
89
 
 
90
  return provider_dump;
 
91
}
 
92
 
 
93
gchar *
 
94
lasso_provider_get_metadata_value(LassoProvider      *provider,
 
95
                                  lassoProviderType   provider_type,
 
96
                                  gchar              *name,
 
97
                                  GError            **err)
 
98
{
 
99
  xmlChar *content;
 
100
  LassoNode *descriptor;
 
101
  GError *tmp_err = NULL;
 
102
  gchar *result = NULL;
 
103
 
 
104
  if (err != NULL && *err != NULL) {
 
105
    g_set_error(err, g_quark_from_string("Lasso"),
 
106
                LASSO_PARAM_ERROR_CHECK_FAILED,
 
107
                lasso_strerror(LASSO_PARAM_ERROR_CHECK_FAILED));
 
108
    g_return_val_if_fail (err == NULL || *err == NULL, NULL);
 
109
  }
 
110
  if (LASSO_IS_PROVIDER(provider) == FALSE) {
 
111
    g_set_error(err, g_quark_from_string("Lasso"),
 
112
                LASSO_PARAM_ERROR_BAD_TYPE_OR_NULL_OBJ,
 
113
                lasso_strerror(LASSO_PARAM_ERROR_BAD_TYPE_OR_NULL_OBJ));
 
114
    g_return_val_if_fail(LASSO_IS_PROVIDER(provider), NULL);
 
115
  }
 
116
  if (name == NULL) {
 
117
    g_set_error(err, g_quark_from_string("Lasso"),
 
118
                LASSO_PARAM_ERROR_INVALID_VALUE,
 
119
                lasso_strerror(LASSO_PARAM_ERROR_INVALID_VALUE));
 
120
    g_return_val_if_fail(name != NULL, NULL);
 
121
  }
 
122
 
 
123
  switch (provider_type) {
 
124
  case lassoProviderTypeSp:
 
125
    descriptor = lasso_node_get_child(provider->metadata,
 
126
                                      "SPDescriptor", NULL, &tmp_err);
 
127
    break;
 
128
  case lassoProviderTypeIdp:
 
129
    descriptor = lasso_node_get_child(provider->metadata,
 
130
                                      "IDPDescriptor", NULL, &tmp_err);
 
131
    break;
 
132
  default:
 
133
    descriptor = NULL;
 
134
    break;
 
135
  }
 
136
  if (descriptor == NULL) {
 
137
    g_propagate_error (err, tmp_err);
 
138
    return NULL;
 
139
  }
 
140
 
 
141
  content = lasso_node_get_child_content(descriptor, name, NULL, &tmp_err);
 
142
  lasso_node_destroy(descriptor);
 
143
 
 
144
  if (content == NULL) {
 
145
    g_propagate_error (err, tmp_err);
 
146
  } else {
 
147
    result = g_strdup(g_strstrip(content));
 
148
    xmlFree(content);
 
149
  }
 
150
 
 
151
  return result;
 
152
}
 
153
 
 
154
gchar *
 
155
lasso_provider_get_assertionConsumerServiceURL(LassoProvider      *provider,
 
156
                                               lassoProviderType   provider_type,
 
157
                                               GError            **err)
 
158
{
 
159
  xmlChar *value;
 
160
  GError  *tmp_err = NULL;
 
161
 
 
162
  if (err != NULL && *err != NULL) {
 
163
    g_set_error(err, g_quark_from_string("Lasso"),
 
164
                LASSO_PARAM_ERROR_CHECK_FAILED,
 
165
                lasso_strerror(LASSO_PARAM_ERROR_CHECK_FAILED));
 
166
    g_return_val_if_fail (err == NULL || *err == NULL, NULL);
 
167
  }
 
168
 
 
169
  value = lasso_provider_get_metadata_value(provider,
 
170
                                            provider_type,
 
171
                                            "AssertionConsumerServiceURL",
 
172
                                            &tmp_err);
 
173
  if (value == NULL) {
 
174
    g_propagate_error (err, tmp_err);
 
175
  }
 
176
 
 
177
  return value;
 
178
}
 
179
 
 
180
gchar *
 
181
lasso_provider_get_authnRequestsSigned(LassoProvider  *provider,
 
182
                                       GError        **err)
 
183
{
 
184
  xmlChar *value;
 
185
  GError  *tmp_err = NULL;
 
186
 
 
187
  if (err != NULL && *err != NULL) {
 
188
    g_set_error(err, g_quark_from_string("Lasso"),
 
189
                LASSO_PARAM_ERROR_CHECK_FAILED,
 
190
                lasso_strerror(LASSO_PARAM_ERROR_CHECK_FAILED));
 
191
    g_return_val_if_fail (err == NULL || *err == NULL, NULL);
 
192
  }
 
193
 
 
194
  value = lasso_provider_get_metadata_value(provider,
 
195
                                            lassoProviderTypeSp,
 
196
                                            "AuthnRequestsSigned",
 
197
                                            &tmp_err);
 
198
  if (value == NULL) {
 
199
    g_propagate_error (err, tmp_err);
 
200
  }
 
201
 
 
202
  return value;
 
203
}
 
204
 
 
205
gchar *
 
206
lasso_provider_get_federationTerminationNotificationProtocolProfile(LassoProvider      *provider,
 
207
                                                                    lassoProviderType   provider_type,
 
208
                                                                    GError            **err)
 
209
{
 
210
  xmlChar *value;
 
211
  GError  *tmp_err = NULL;
 
212
 
 
213
  if (err != NULL && *err != NULL) {
 
214
    g_set_error(err, g_quark_from_string("Lasso"),
 
215
                LASSO_PARAM_ERROR_CHECK_FAILED,
 
216
                lasso_strerror(LASSO_PARAM_ERROR_CHECK_FAILED));
 
217
    g_return_val_if_fail (err == NULL || *err == NULL, NULL);
 
218
  }
 
219
 
 
220
  value = lasso_provider_get_metadata_value(provider,
 
221
                                            provider_type,
 
222
                                            "FederationTerminationNotificationProtocolProfile",
 
223
                                            &tmp_err);
 
224
  if (value == NULL) {
 
225
    g_propagate_error (err, tmp_err);
 
226
  }
 
227
 
 
228
  return value;
 
229
}
 
230
 
 
231
gchar *
 
232
lasso_provider_get_federationTerminationServiceReturnURL(LassoProvider      *provider,
 
233
                                                         lassoProviderType   provider_type,
 
234
                                                         GError            **err)
 
235
{
 
236
  xmlChar *value;
 
237
  GError  *tmp_err = NULL;
 
238
 
 
239
  if (err != NULL && *err != NULL) {
 
240
    g_set_error(err, g_quark_from_string("Lasso"),
 
241
                LASSO_PARAM_ERROR_CHECK_FAILED,
 
242
                lasso_strerror(LASSO_PARAM_ERROR_CHECK_FAILED));
 
243
    g_return_val_if_fail (err == NULL || *err == NULL, NULL);
 
244
  }
 
245
 
 
246
  value = lasso_provider_get_metadata_value(provider,
 
247
                                            provider_type,
 
248
                                            "FederationTerminationServiceReturnURL",
 
249
                                            &tmp_err);
 
250
  if (value == NULL) {
 
251
    g_propagate_error (err, tmp_err);
 
252
  }
 
253
 
 
254
  return value;
 
255
}
 
256
 
 
257
gchar *
 
258
lasso_provider_get_federationTerminationServiceURL(LassoProvider      *provider,
 
259
                                                   lassoProviderType   provider_type,
 
260
                                                   GError            **err)
 
261
{
 
262
  xmlChar *value;
 
263
  GError  *tmp_err = NULL;
 
264
 
 
265
  if (err != NULL && *err != NULL) {
 
266
    g_set_error(err, g_quark_from_string("Lasso"),
 
267
                LASSO_PARAM_ERROR_CHECK_FAILED,
 
268
                lasso_strerror(LASSO_PARAM_ERROR_CHECK_FAILED));
 
269
    g_return_val_if_fail (err == NULL || *err == NULL, NULL);
 
270
  }
 
271
 
 
272
  value = lasso_provider_get_metadata_value(provider,
 
273
                                            provider_type,
 
274
                                            "FederationTerminationServiceURL",
 
275
                                            &tmp_err);
 
276
  if (value == NULL) {
 
277
    g_propagate_error (err, tmp_err);
 
278
  }
 
279
 
 
280
  return value;
 
281
}
 
282
 
 
283
gchar *
 
284
lasso_provider_get_nameIdentifierMappingProtocolProfile(LassoProvider      *provider,
 
285
                                                        lassoProviderType   provider_type,
 
286
                                                        GError            **err)
 
287
{
 
288
  xmlChar *value;
 
289
  GError  *tmp_err = NULL;
 
290
 
 
291
  if (err != NULL && *err != NULL) {
 
292
    g_set_error(err, g_quark_from_string("Lasso"),
 
293
                LASSO_PARAM_ERROR_CHECK_FAILED,
 
294
                lasso_strerror(LASSO_PARAM_ERROR_CHECK_FAILED));
 
295
    g_return_val_if_fail (err == NULL || *err == NULL, NULL);
 
296
  }
 
297
  
 
298
  value = lasso_provider_get_metadata_value(provider,
 
299
                                            provider_type,
 
300
                                            "NameIdentifierMappingProtocolProfile",
 
301
                                            &tmp_err);
 
302
  if (value == NULL) {
 
303
    g_propagate_error (err, tmp_err);
 
304
  }
 
305
 
 
306
  return value;
 
307
}
 
308
 
 
309
gchar *
 
310
lasso_provider_get_providerID(LassoProvider  *provider)
 
311
{
 
312
  LassoNode *descriptor;
 
313
  xmlChar *value;
 
314
  GError  *err = NULL;
 
315
 
 
316
  descriptor = lasso_node_get_child(provider->metadata,
 
317
                                    "EntityDescriptor", NULL, &err);    
 
318
  if (descriptor == NULL) {
 
319
    message(G_LOG_LEVEL_CRITICAL, err->message);
 
320
    g_error_free(err);
 
321
    return NULL;
 
322
  }
 
323
 
 
324
  value = lasso_node_get_attr_value(descriptor, "providerID", &err);
 
325
  lasso_node_destroy(descriptor);
 
326
 
 
327
  if (value == NULL) {
 
328
    /* providerID attr is required */
 
329
    message(G_LOG_LEVEL_CRITICAL, err->message);
 
330
    g_error_free(err);
 
331
  }
 
332
 
 
333
  return value;
 
334
}
 
335
 
 
336
gchar *
 
337
lasso_provider_get_registerNameIdentifierProtocolProfile(LassoProvider      *provider,
 
338
                                                         lassoProviderType   provider_type,
 
339
                                                         GError            **err)
 
340
{
 
341
  xmlChar *value;
 
342
  GError  *tmp_err = NULL;
 
343
 
 
344
  if (err != NULL && *err != NULL) {
 
345
    g_set_error(err, g_quark_from_string("Lasso"),
 
346
                LASSO_PARAM_ERROR_CHECK_FAILED,
 
347
                lasso_strerror(LASSO_PARAM_ERROR_CHECK_FAILED));
 
348
    g_return_val_if_fail (err == NULL || *err == NULL, NULL);
 
349
  }
 
350
  
 
351
  value = lasso_provider_get_metadata_value(provider,
 
352
                                            provider_type,
 
353
                                            "RegisterNameIdentifierProtocolProfile",
 
354
                                            &tmp_err);
 
355
  if (value == NULL) {
 
356
    g_propagate_error (err, tmp_err);
 
357
  }
 
358
 
 
359
  return value;
 
360
}
 
361
 
 
362
gchar *
 
363
lasso_provider_get_registerNameIdentifierServiceURL(LassoProvider      *provider,
 
364
                                                    lassoProviderType   provider_type,
 
365
                                                    GError            **err)
 
366
{
 
367
  xmlChar *value;
 
368
  GError  *tmp_err = NULL;
 
369
 
 
370
  if (err != NULL && *err != NULL) {
 
371
    g_set_error(err, g_quark_from_string("Lasso"),
 
372
                LASSO_PARAM_ERROR_CHECK_FAILED,
 
373
                lasso_strerror(LASSO_PARAM_ERROR_CHECK_FAILED));
 
374
    g_return_val_if_fail (err == NULL || *err == NULL, NULL);
 
375
  }
 
376
  
 
377
  value = lasso_provider_get_metadata_value(provider,
 
378
                                            provider_type,
 
379
                                            "RegisterNameIdentifierServiceURL",
 
380
                                            &tmp_err);
 
381
  if (value == NULL) {
 
382
    g_propagate_error (err, tmp_err);
 
383
  }
 
384
 
 
385
  return value;
 
386
}
 
387
 
 
388
gchar *
 
389
lasso_provider_get_singleSignOnProtocolProfile(LassoProvider  *provider,
 
390
                                               GError        **err)
 
391
{
 
392
  xmlChar *value;
 
393
  GError  *tmp_err = NULL;
 
394
 
 
395
  if (err != NULL && *err != NULL) {
 
396
    g_set_error(err, g_quark_from_string("Lasso"),
 
397
                LASSO_PARAM_ERROR_CHECK_FAILED,
 
398
                lasso_strerror(LASSO_PARAM_ERROR_CHECK_FAILED));
 
399
    g_return_val_if_fail (err == NULL || *err == NULL, NULL);
 
400
  }
 
401
  
 
402
  value = lasso_provider_get_metadata_value(provider,
 
403
                                            lassoProviderTypeIdp,
 
404
                                            "SingleSignOnProtocolProfile",
 
405
                                            &tmp_err);
 
406
  if (tmp_err != NULL) {
 
407
    g_propagate_error (err, tmp_err);
 
408
  }
 
409
 
 
410
  return value;
 
411
}
 
412
 
 
413
gchar *
 
414
lasso_provider_get_singleSignOnServiceURL(LassoProvider  *provider,
 
415
                                          GError        **err)
 
416
{
 
417
  xmlChar *value;
 
418
  GError  *tmp_err = NULL;
 
419
 
 
420
  if (err != NULL && *err != NULL) {
 
421
    g_set_error(err, g_quark_from_string("Lasso"),
 
422
                LASSO_PARAM_ERROR_CHECK_FAILED,
 
423
                lasso_strerror(LASSO_PARAM_ERROR_CHECK_FAILED));
 
424
    g_return_val_if_fail (err == NULL || *err == NULL, NULL);
 
425
  }
 
426
  
 
427
  value = lasso_provider_get_metadata_value(provider,
 
428
                                            lassoProviderTypeIdp,
 
429
                                            "SingleSignOnServiceURL",
 
430
                                            &tmp_err);
 
431
  if (tmp_err != NULL) {
 
432
    g_propagate_error (err, tmp_err);
 
433
  }
 
434
 
 
435
  return value;
 
436
}
 
437
 
 
438
gchar *
 
439
lasso_provider_get_singleLogoutProtocolProfile(LassoProvider      *provider,
 
440
                                               lassoProviderType   provider_type,
 
441
                                               GError            **err)
 
442
{
 
443
  xmlChar *value;
 
444
  GError  *tmp_err = NULL;
 
445
 
 
446
  if (err != NULL && *err != NULL) {
 
447
    g_set_error(err, g_quark_from_string("Lasso"),
 
448
                LASSO_PARAM_ERROR_CHECK_FAILED,
 
449
                lasso_strerror(LASSO_PARAM_ERROR_CHECK_FAILED));
 
450
    g_return_val_if_fail (err == NULL || *err == NULL, NULL);
 
451
  }
 
452
  
 
453
  value = lasso_provider_get_metadata_value(provider,
 
454
                                            provider_type,
 
455
                                            "SingleLogoutProtocolProfile",
 
456
                                            &tmp_err);
 
457
  if (value == NULL) {
 
458
    g_propagate_error (err, tmp_err);
 
459
  }
 
460
 
 
461
  return value;
 
462
}
 
463
 
 
464
gchar *
 
465
lasso_provider_get_singleLogoutServiceURL(LassoProvider      *provider,
 
466
                                          lassoProviderType   provider_type,
 
467
                                          GError            **err)
 
468
{
 
469
  xmlChar *value;
 
470
  GError  *tmp_err = NULL;
 
471
 
 
472
  if (err != NULL && *err != NULL) {
 
473
    g_set_error(err, g_quark_from_string("Lasso"),
 
474
                LASSO_PARAM_ERROR_CHECK_FAILED,
 
475
                lasso_strerror(LASSO_PARAM_ERROR_CHECK_FAILED));
 
476
    g_return_val_if_fail (err == NULL || *err == NULL, NULL);
 
477
  }
 
478
  
 
479
  value = lasso_provider_get_metadata_value(provider,
 
480
                                            provider_type,
 
481
                                            "SingleLogoutServiceURL",
 
482
                                            &tmp_err);
 
483
  if (value == NULL) {
 
484
    g_propagate_error (err, tmp_err);
 
485
  }
 
486
 
 
487
  return value;
 
488
}
 
489
 
 
490
gchar *
 
491
lasso_provider_get_singleLogoutServiceReturnURL(LassoProvider      *provider,
 
492
                                                lassoProviderType   provider_type,
 
493
                                                GError            **err)
 
494
{
 
495
  xmlChar *value;
 
496
  GError  *tmp_err = NULL;
 
497
 
 
498
  if (err != NULL && *err != NULL) {
 
499
    g_set_error(err, g_quark_from_string("Lasso"),
 
500
                LASSO_PARAM_ERROR_CHECK_FAILED,
 
501
                lasso_strerror(LASSO_PARAM_ERROR_CHECK_FAILED));
 
502
    g_return_val_if_fail (err == NULL || *err == NULL, NULL);
 
503
  }
 
504
  
 
505
  value = lasso_provider_get_metadata_value(provider,
 
506
                                            provider_type,
 
507
                                            "SingleLogoutServiceReturnURL",
 
508
                                            &tmp_err);
 
509
  if (value == NULL) {
 
510
    g_propagate_error (err, tmp_err);
 
511
  }
 
512
 
 
513
  return value;
 
514
}
 
515
 
 
516
gchar *
 
517
lasso_provider_get_soapEndpoint(LassoProvider      *provider,
 
518
                                lassoProviderType   provider_type,
 
519
                                GError            **err)
 
520
{
 
521
  xmlChar *value;
 
522
  GError  *tmp_err = NULL;
 
523
 
 
524
  if (err != NULL && *err != NULL) {
 
525
    g_set_error(err, g_quark_from_string("Lasso"),
 
526
                LASSO_PARAM_ERROR_CHECK_FAILED,
 
527
                lasso_strerror(LASSO_PARAM_ERROR_CHECK_FAILED));
 
528
    g_return_val_if_fail (err == NULL || *err == NULL, NULL);
 
529
  }
 
530
  
 
531
  value = lasso_provider_get_metadata_value(provider,
 
532
                                            provider_type,
 
533
                                            "SoapEndpoint",
 
534
                                            &tmp_err);
 
535
  if (value == NULL) {
 
536
    g_propagate_error (err, tmp_err);
 
537
  }
 
538
 
 
539
  return value;
 
540
}
 
541
 
 
542
void
 
543
lasso_provider_set_public_key(LassoProvider *provider,
 
544
                              gchar         *public_key)
 
545
{
 
546
  provider->public_key = g_strdup(public_key);
 
547
}
 
548
 
 
549
void
 
550
lasso_provider_set_ca_certificate(LassoProvider *provider,
 
551
                                  gchar *ca_certificate)
 
552
{
 
553
  provider->ca_certificate = g_strdup(ca_certificate);
 
554
}
 
555
 
 
556
/*****************************************************************************/
 
557
/* private methods                                                           */
 
558
/*****************************************************************************/
 
559
 
 
560
static gchar *lasso_provider_get_direct_child_content(LassoProvider *provider, 
 
561
                                                      const gchar   *name)
 
562
{
 
563
  LassoNode *node;
 
564
  xmlChar *content;
 
565
 
 
566
  node = lasso_node_get_child(LASSO_NODE(provider), name, NULL, NULL);
 
567
  if(node == NULL) {
 
568
    return NULL;
 
569
  }
 
570
  content = lasso_node_get_content(node, NULL);
 
571
  lasso_node_destroy(node);
 
572
 
 
573
  return content;
 
574
}
 
575
 
 
576
/*****************************************************************************/
 
577
/* overrided parent class methods                                            */
 
578
/*****************************************************************************/
 
579
 
 
580
static void
 
581
lasso_provider_dispose(LassoProvider *provider)
 
582
{
 
583
  if (provider->private->dispose_has_run) {
 
584
    return;
 
585
  }
 
586
  provider->private->dispose_has_run = TRUE;
 
587
 
 
588
  debug("Provider object 0x%x disposed ...\n", provider);
 
589
 
 
590
  /* unref reference counted objects */
 
591
  lasso_node_destroy(provider->metadata);
 
592
 
 
593
  parent_class->dispose(G_OBJECT(provider));
 
594
}
 
595
 
 
596
static void
 
597
lasso_provider_finalize(LassoProvider *provider)
 
598
{
 
599
  debug("Provider object 0x%x finalized ...\n", provider);
 
600
 
 
601
  g_free(provider->public_key);
 
602
  g_free(provider->ca_certificate);
 
603
  g_free(provider->private);
 
604
 
 
605
  parent_class->finalize(G_OBJECT(provider));
 
606
}
 
607
 
 
608
/*****************************************************************************/
 
609
/* instance and class init functions                                         */
 
610
/*****************************************************************************/
 
611
 
 
612
static void
 
613
lasso_provider_instance_init(LassoProvider *provider)
 
614
{
 
615
  provider->private = g_new (LassoProviderPrivate, 1);
 
616
  provider->private->dispose_has_run = FALSE;
 
617
  provider->metadata       = NULL;
 
618
  provider->public_key     = NULL;
 
619
  provider->ca_certificate = NULL;
 
620
}
 
621
 
 
622
static void
 
623
lasso_provider_class_init(LassoProviderClass *class) {
 
624
  GObjectClass *gobject_class = G_OBJECT_CLASS(class);
 
625
  
 
626
  parent_class = g_type_class_peek_parent(class);
 
627
  /* override parent class methods */
 
628
  gobject_class->dispose  = (void *)lasso_provider_dispose;
 
629
  gobject_class->finalize = (void *)lasso_provider_finalize;
 
630
}
 
631
 
 
632
GType lasso_provider_get_type() {
 
633
  static GType this_type = 0;
 
634
 
 
635
  if (!this_type) {
 
636
    static const GTypeInfo this_info = {
 
637
      sizeof (LassoProviderClass),
 
638
      NULL,
 
639
      NULL,
 
640
      (GClassInitFunc) lasso_provider_class_init,
 
641
      NULL,
 
642
      NULL,
 
643
      sizeof(LassoProvider),
 
644
      0,
 
645
      (GInstanceInitFunc) lasso_provider_instance_init,
 
646
    };
 
647
    
 
648
    this_type = g_type_register_static(G_TYPE_OBJECT,
 
649
                                       "LassoProvider",
 
650
                                       &this_info, 0);
 
651
  }
 
652
  return this_type;
 
653
}
 
654
 
 
655
LassoProvider*
 
656
lasso_provider_new(gchar *metadata,
 
657
                   gchar *public_key,
 
658
                   gchar *ca_certificate)
 
659
{
 
660
  LassoProvider *provider;
 
661
  
 
662
  provider = lasso_provider_new_metadata_filename(metadata);
 
663
  if (provider != NULL) {
 
664
    provider->public_key = g_strdup(public_key);
 
665
    provider->ca_certificate = g_strdup(ca_certificate);
 
666
  }
 
667
 
 
668
  return provider;
 
669
}
 
670
 
 
671
 
 
672
LassoProvider*
 
673
lasso_provider_new_from_metadata_node(LassoNode *metadata_node)
 
674
{
 
675
  LassoProvider *provider;
 
676
  
 
677
  provider = LASSO_PROVIDER(g_object_new(LASSO_TYPE_PROVIDER, NULL));
 
678
  provider->metadata = lasso_node_copy(metadata_node);
 
679
  
 
680
  return provider;
 
681
}
 
682
 
 
683
LassoProvider*
 
684
lasso_provider_new_metadata_filename(gchar *metadata_filename)
 
685
{
 
686
  LassoProvider *provider = NULL;
 
687
  xmlDocPtr  doc;
 
688
  xmlNodePtr root;
 
689
  
 
690
  doc = xmlParseFile(metadata_filename);
 
691
  if (doc != NULL) {
 
692
    /* get root element of doc and duplicate it */
 
693
    root = xmlCopyNode(xmlDocGetRootElement(doc), 1);
 
694
    xmlFreeDoc(doc);
 
695
 
 
696
    provider = LASSO_PROVIDER(g_object_new(LASSO_TYPE_PROVIDER, NULL));
 
697
    provider->metadata = lasso_node_new();
 
698
    LASSO_NODE_GET_CLASS(provider->metadata)->set_xmlNode(provider->metadata, root);
 
699
  }
 
700
  else {
 
701
    message(G_LOG_LEVEL_CRITICAL,
 
702
            "Failed to build LassoProvider: invalid metadata file.\n");
 
703
  }
 
704
 
 
705
  return provider;
 
706
}