← Back to branch summary

~ubuntu-branches/ubuntu/hardy/lasso/hardy

« back to all changes in this revision

Viewing changes to lasso/id-ff/name_registration.c

  • Committer: Bazaar Package Importer
  • Author(s): Michael Bienia
  • Date: 2007-07-31 21:35:26 UTC
  • mfrom: (1.1.4 upstream)
  • Revision ID: james.westby@ubuntu.com-20070731213526-oc6jw5mprcd5tjyy
Tags: 2.0.0-1ubuntu1
* Merge from debian unstable. Remaining changes:
  + debian/control:
    - Modify Maintainer value to match DebianMaintainerField spec.
* debian/rules:
  + Add CC=gcc-4.2 to the configure call else configure won't find jni.h
    from libgcj8-dev.
* configure{,.ac}:
  + Add missing quotes around the value for PHP[45]_LIBS.

Show diffs side-by-side

added added

removed removed

Lines of Context:
lasso/id-ff/name_registration.c
1
 
/* $Id: name_registration.c,v 1.76 2006/01/23 15:30:00 fpeters Exp $
 
1
/* $Id: name_registration.c,v 1.84 2007/01/06 22:55:24 fpeters Exp $
2
2
 *
3
3
 * Lasso - A free implementation of the Liberty Alliance specifications.
4
4
 *
61
61
        LassoProvider *remote_provider;
62
62
        char *url, *query;
63
63
 
64
 
        g_return_val_if_fail(LASSO_IS_NAME_REGISTRATION(name_registration), -1);
 
64
        g_return_val_if_fail(LASSO_IS_NAME_REGISTRATION(name_registration),
 
65
                        LASSO_PARAM_ERROR_INVALID_VALUE);
65
66
 
66
67
        profile = LASSO_PROFILE(name_registration);
 
68
        lasso_profile_clean_msg_info(profile);
67
69
 
68
70
        if (profile->remote_providerID == NULL) {
69
71
                /* this means lasso_logout_init_request was not called before */
103
105
                        return critical_error(LASSO_PROFILE_ERROR_BUILDING_QUERY_FAILED);
104
106
                }
105
107
                /* build the msg_url */
106
 
                profile->msg_url = g_strdup_printf("%s?%s", url, query);
 
108
                profile->msg_url = lasso_concat_url_query(url, query);
107
109
                profile->msg_body = NULL;
108
110
                g_free(url);
109
111
                g_free(query);
147
149
        LassoProvider *remote_provider;
148
150
        char *url, *query;
149
151
 
150
 
        g_return_val_if_fail(LASSO_IS_NAME_REGISTRATION(name_registration), -1);
 
152
        g_return_val_if_fail(LASSO_IS_NAME_REGISTRATION(name_registration),
 
153
                        LASSO_PARAM_ERROR_INVALID_VALUE);
151
154
 
152
155
        profile = LASSO_PROFILE(name_registration);
 
156
        lasso_profile_clean_msg_info(profile);
153
157
 
154
158
        if (profile->remote_providerID == NULL) {
155
159
                /* this means lasso_logout_init_request was not called before */
186
190
                        return critical_error(LASSO_PROFILE_ERROR_BUILDING_QUERY_FAILED);
187
191
                }
188
192
                /* build the msg_url */
189
 
                profile->msg_url = g_strdup_printf("%s?%s", url, query);
 
193
                profile->msg_url = lasso_concat_url_query(url, query);
190
194
                g_free(url);
191
195
                g_free(query);
192
196
                profile->msg_body = NULL;
232
236
        LassoFederation *federation;
233
237
        LassoSamlNameIdentifier *spNameIdentifier, *idpNameIdentifier, *oldNameIdentifier = NULL;
234
238
 
235
 
        g_return_val_if_fail(LASSO_IS_NAME_REGISTRATION(name_registration), -1);
236
 
        g_return_val_if_fail(remote_providerID != NULL, LASSO_PARAM_ERROR_BAD_TYPE_OR_NULL_OBJ);
 
239
        g_return_val_if_fail(LASSO_IS_NAME_REGISTRATION(name_registration),
 
240
                        LASSO_PARAM_ERROR_INVALID_VALUE);
 
241
        g_return_val_if_fail(remote_providerID != NULL, LASSO_PARAM_ERROR_INVALID_VALUE);
237
242
 
238
243
        profile = LASSO_PROFILE(name_registration);
239
244
 
284
289
        } else { /* if (remote_provider->role == LASSO_PROVIDER_ROLE_SP) { */
285
290
                /* Initiating it, from an IdP */
286
291
                if (federation->local_nameIdentifier == NULL) {
287
 
                        message(G_LOG_LEVEL_CRITICAL, "Local name identifier not found");
288
 
                        return LASSO_ERROR_UNDEFINED;
 
292
                        return LASSO_PROFILE_ERROR_NAME_IDENTIFIER_NOT_FOUND;
289
293
                }
290
294
 
291
295
                oldNameIdentifier = g_object_ref(federation->local_nameIdentifier);
305
309
        }
306
310
 
307
311
        if (oldNameIdentifier == NULL) {
308
 
                message(G_LOG_LEVEL_CRITICAL, "Invalid provider type");
309
 
                return LASSO_ERROR_UNDEFINED;
 
312
                message(G_LOG_LEVEL_CRITICAL, "Invalid provider type"); /* ??? */
 
313
                return LASSO_PROFILE_ERROR_MISSING_NAME_IDENTIFIER;
310
314
        }
311
315
 
312
316
        if (http_method == LASSO_HTTP_METHOD_ANY) {
370
374
        LassoSamlNameIdentifier *nameIdentifier;
371
375
        LassoLibRegisterNameIdentifierRequest *request;
372
376
 
373
 
        g_return_val_if_fail(LASSO_IS_NAME_REGISTRATION(name_registration), -1);
374
 
        g_return_val_if_fail(request_msg != NULL, -1);
 
377
        g_return_val_if_fail(LASSO_IS_NAME_REGISTRATION(name_registration),
 
378
                        LASSO_PARAM_ERROR_INVALID_VALUE);
 
379
        g_return_val_if_fail(request_msg != NULL,
 
380
                        LASSO_PARAM_ERROR_INVALID_VALUE);
375
381
 
376
382
        profile = LASSO_PROFILE(name_registration);
377
383
 
440
446
        LassoFederation *federation;
441
447
        LassoSamlNameIdentifier *nameIdentifier = NULL;
442
448
        LassoHttpMethod response_method;
 
449
        LassoLibStatusResponse *response;
443
450
        LassoMessageFormat format;
444
451
        int rc;
445
452
        char *statusCodeValue;
446
453
 
447
 
        g_return_val_if_fail(LASSO_IS_NAME_REGISTRATION(name_registration), -1);
448
 
        g_return_val_if_fail(response_msg != NULL, -1);
 
454
        g_return_val_if_fail(LASSO_IS_NAME_REGISTRATION(name_registration),
 
455
                        LASSO_PARAM_ERROR_INVALID_VALUE);
 
456
        g_return_val_if_fail(response_msg != NULL, LASSO_PARAM_ERROR_INVALID_VALUE);
449
457
 
450
458
        profile = LASSO_PROFILE(name_registration);
451
459
 
459
467
                response_method = LASSO_HTTP_METHOD_SOAP;
460
468
        if (format == LASSO_MESSAGE_FORMAT_QUERY)
461
469
                response_method = LASSO_HTTP_METHOD_REDIRECT;
462
 
 
 
470
 
463
471
        remote_provider = g_hash_table_lookup(profile->server->providers,
464
472
                        LASSO_LIB_STATUS_RESPONSE(profile->response)->ProviderID);
465
473
        if (LASSO_IS_PROVIDER(remote_provider) == FALSE) {
469
477
        /* verify signature */
470
478
        rc = lasso_provider_verify_signature(remote_provider, response_msg, "ResponseID", format);
471
479
 
472
 
        statusCodeValue = LASSO_LIB_STATUS_RESPONSE(profile->response)->Status->StatusCode->Value;
 
480
        response = LASSO_LIB_STATUS_RESPONSE(profile->response);
 
481
        if (response->Status == NULL || response->Status->StatusCode == NULL
 
482
                        || response->Status->StatusCode->Value == NULL) {
 
483
                return critical_error(LASSO_PROFILE_ERROR_MISSING_STATUS_CODE);
 
484
        }
 
485
        statusCodeValue = response->Status->StatusCode->Value;
 
486
 
473
487
        if (strcmp(statusCodeValue, LASSO_SAML_STATUS_CODE_SUCCESS) != 0) {
474
 
                message(G_LOG_LEVEL_CRITICAL, "%s", statusCodeValue);
475
 
                return LASSO_ERROR_UNDEFINED;
 
488
                message(G_LOG_LEVEL_CRITICAL, "Status code not success: %s", statusCodeValue);
 
489
                return LASSO_PROFILE_ERROR_STATUS_NOT_SUCCESS;
476
490
        }
477
491
 
478
492
        /* Update federation with the nameIdentifier attribute. NameQualifier
502
516
                                profile->request)->SPProvidedNameIdentifier;
503
517
        }
504
518
        if (nameIdentifier == NULL) {
505
 
                message(G_LOG_LEVEL_CRITICAL, "Invalid provider role");
506
 
                return LASSO_ERROR_UNDEFINED;
 
519
                message(G_LOG_LEVEL_CRITICAL, "Invalid provider role"); /* ??? */
 
520
                return LASSO_PROFILE_ERROR_MISSING_NAME_IDENTIFIER;
507
521
        }
508
522
 
509
523
        if (federation->local_nameIdentifier)
538
552
        LassoLibRegisterNameIdentifierRequest *request;
539
553
        LassoSamlNameIdentifier *providedNameIdentifier = NULL;
540
554
 
541
 
        g_return_val_if_fail(LASSO_IS_NAME_REGISTRATION(name_registration), -1);
 
555
        g_return_val_if_fail(LASSO_IS_NAME_REGISTRATION(name_registration),
 
556
                        LASSO_PARAM_ERROR_INVALID_VALUE);
542
557
 
543
558
        profile = LASSO_PROFILE(name_registration);
544
559
 
545
560
        /* verify the register name identifier request */
546
561
        if (LASSO_IS_LIB_REGISTER_NAME_IDENTIFIER_REQUEST(profile->request) == FALSE) {
547
562
                message(G_LOG_LEVEL_CRITICAL, "Register Name Identifier request not found");
548
 
                return LASSO_ERROR_UNDEFINED;
 
563
                return LASSO_PROFILE_ERROR_MISSING_REQUEST;
549
564
        }
550
565
 
551
566
        request = LASSO_LIB_REGISTER_NAME_IDENTIFIER_REQUEST(profile->request);
553
568
        /* set the remote provider id from the request */
554
569
        profile->remote_providerID = g_strdup(request->ProviderID);
555
570
        if (profile->remote_providerID == NULL) {
556
 
                message(G_LOG_LEVEL_CRITICAL, "No provider id found in name registration request");
557
 
                return LASSO_ERROR_UNDEFINED;
 
571
                return LASSO_PROFILE_ERROR_MISSING_REMOTE_PROVIDERID;
558
572
        }
559
573
 
560
574
        /* set register name identifier response */
582
596
 
583
597
        if (request->OldProvidedNameIdentifier == NULL) {
584
598
                message(G_LOG_LEVEL_CRITICAL, "Old provided name identifier not found");
585
 
                return LASSO_ERROR_UNDEFINED;
 
599
                return LASSO_PROFILE_ERROR_MISSING_NAME_IDENTIFIER;
586
600
        }
587
601
 
588
602
        if (lasso_federation_verify_name_identifier(federation, LASSO_NODE(
589
603
                                        request->OldProvidedNameIdentifier)) == FALSE) {
590
604
                message(G_LOG_LEVEL_CRITICAL, "No name identifier");
591
 
                return LASSO_ERROR_UNDEFINED;
 
605
                return LASSO_PROFILE_ERROR_MISSING_NAME_IDENTIFIER;
592
606
        }
593
607
 
594
608
        remote_provider = g_hash_table_lookup(profile->server->providers,
606
620
        }
607
621
        if (providedNameIdentifier == NULL) {
608
622
                message(G_LOG_LEVEL_CRITICAL, "Sp provided name identifier not found");
609
 
                return LASSO_ERROR_UNDEFINED;
 
623
                return LASSO_PROFILE_ERROR_MISSING_NAME_IDENTIFIER;
610
624
        }
611
625
 
612
626
        if (federation->remote_nameIdentifier)
733
747
        LassoNameRegistration *name_registration;
734
748
        xmlDoc *doc;
735
749
 
 
750
        if (dump == NULL)
 
751
                return NULL;
 
752
 
736
753
        name_registration = lasso_name_registration_new(server);
737
754
        doc = xmlParseMemory(dump, strlen(dump));
738
755
        init_from_xml(LASSO_NODE(name_registration), xmlDocGetRootElement(doc)); 
 
756
        xmlFreeDoc(doc);
739
757
 
740
758
        return name_registration;
741
759
}