← Back to branch summary

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

« back to all changes in this revision

Viewing changes to lasso/id-wsf/data_service.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-wsf/data_service.c
1
 
/* $Id: data_service.c,v 1.21 2005/12/06 13:22:08 nclapies Exp $
 
1
/* $Id: data_service.c,v 1.33 2007/01/05 11:40:10 fpeters Exp $
2
2
 *
3
3
 * Lasso - A free implementation of the Liberty Alliance specifications.
4
4
 *
61
61
        service->private_data->credentials = g_list_append(
62
62
                service->private_data->credentials,
63
63
                g_object_ref(assertion));
 
64
        return 0;
64
65
}
65
66
 
66
67
LassoDstModification*
126
127
gint
127
128
lasso_data_service_need_redirect_user(LassoDataService *service, const char *redirectUrl)
128
129
{
129
 
        LassoWsfProfile *profile;
130
 
        LassoSoapBody *body;
131
 
        LassoSoapFault *fault;
132
 
        LassoUtilityStatus *status;
133
130
        LassoSoapDetail *detail;
134
 
        GList *iter;
135
131
 
136
132
        /* Find a SOAP fault element */
137
133
        service->private_data->fault = lasso_soap_fault_new();
176
172
                query = lasso_dst_query_new(NULL);
177
173
        }
178
174
        profile->request = LASSO_NODE(query);
179
 
        
 
175
 
 
176
        if (service == NULL || service->private_data == NULL
 
177
                        || service->private_data->offering == NULL) {
 
178
                return LASSO_PROFILE_ERROR_MISSING_RESOURCE_OFFERING;
 
179
        }
180
180
        offering = service->private_data->offering;
181
181
 
 
182
        if (offering->ServiceInstance == NULL
 
183
                        || offering->ServiceInstance->ServiceType == NULL) {
 
184
                return LASSO_PROFILE_ERROR_MISSING_SERVICE_TYPE;
 
185
        }
182
186
        query->hrefServiceType = g_strdup(offering->ServiceInstance->ServiceType);
183
187
        query->prefixServiceType = lasso_get_prefix_for_dst_service_href(
184
188
                query->hrefServiceType);
185
189
        if (query->prefixServiceType == NULL) {
186
 
                return LASSO_ERROR_UNDEFINED;
 
190
                return LASSO_PROFILE_ERROR_MISSING_SERVICE_TYPE;
187
191
        }
188
192
 
189
193
        if (offering->ResourceID) {
197
201
 
198
202
        lasso_wsf_profile_init_soap_request(LASSO_WSF_PROFILE(service), LASSO_NODE(query));
199
203
 
200
 
        if (!security_mech_id)
 
204
        if (security_mech_id == NULL) {
201
205
                description = LASSO_DISCO_DESCRIPTION(offering->ServiceInstance->Description->data);
202
 
        else {
 
206
        } else {
203
207
                description = lasso_discovery_get_description_auto(offering, security_mech_id);
204
208
        }
205
 
        if (!description)
206
 
                return -1;
 
209
 
 
210
        if (description == NULL) {
 
211
                return LASSO_PROFILE_ERROR_MISSING_SERVICE_DESCRIPTION;
 
212
        }
207
213
        lasso_wsf_profile_set_description(LASSO_WSF_PROFILE(service), description);
208
214
 
209
215
        if (description->Endpoint != NULL) {
215
221
 
216
222
        /* Added needed credential for remote service */
217
223
        if (description->CredentialRef) {
218
 
                        char *credentialRef = description->CredentialRef->data;
219
 
                        iter = service->private_data->credentials;
220
 
                        while (iter) {
221
 
                                LassoSamlAssertion *credential = LASSO_SAML_ASSERTION(
222
 
                                        iter->data);
223
 
                                if (strcmp(credentialRef, credential->AssertionID) == 0)
224
 
                                  //lasso_wsf_profile_add_saml_authentication(
225
 
                                  //    LASSO_WSF_PROFILE(service), credential);
 
224
                char *credentialRef = description->CredentialRef->data;
 
225
                iter = service->private_data->credentials;
 
226
                while (iter) {
 
227
                        LassoSamlAssertion *credential = LASSO_SAML_ASSERTION(iter->data);
 
228
                        if (strcmp(credentialRef, credential->AssertionID) == 0) {
 
229
                                //lasso_wsf_profile_add_saml_authentication(
 
230
                                //      LASSO_WSF_PROFILE(service), credential);
226
231
                                iter = iter->next;
227
232
                        }
 
233
                }
228
234
        }
229
235
 
230
236
        return 0;
246
252
        LassoIsRedirectRequest *redirect_request = NULL;
247
253
        GList *iter;
248
254
 
 
255
        if (LASSO_WSF_PROFILE(service)->soap_envelope_response == NULL ||
 
256
                        LASSO_WSF_PROFILE(service)->soap_envelope_response->Body == NULL) {
 
257
                return NULL;
 
258
        }
 
259
 
249
260
        iter = LASSO_WSF_PROFILE(service)->soap_envelope_response->Body->any;
250
261
        while (iter) {
251
262
                if (LASSO_IS_SOAP_FAULT(iter->data) == TRUE) {
254
265
                }
255
266
                iter = iter->next;
256
267
        }
257
 
        if (!fault)
 
268
        if (fault == NULL || fault->Detail == NULL)
258
269
                return NULL;
259
270
 
260
271
        iter = fault->Detail->any;
263
274
                        redirect_request = LASSO_IS_REDIRECT_REQUEST(iter->data);
264
275
                        break;
265
276
                }
266
 
                iter = iter->next;
 
277
                iter = g_list_next(iter);
267
278
        }
268
 
        if (!redirect_request)
 
279
        if (redirect_request == NULL)
269
280
                return NULL;
270
281
 
271
282
        return g_strdup(redirect_request->redirectURL);
289
300
        LassoWsfProfile *profile;
290
301
        int rc;
291
302
        gchar *service_type;
 
303
        GList *node_list;
 
304
        LassoSoapEnvelope *envelope;
 
305
        LassoDstQuery *request;
 
306
        xmlDoc *doc;
 
307
        xmlNode *xmlnode;
292
308
 
293
309
        /* FIXME: another way to get the service type ? */
294
 
        {
295
 
                LassoSoapEnvelope *envelope;
296
 
                LassoDstQuery *request;
297
 
                xmlDoc *doc;
298
 
                doc = xmlParseMemory(message, strlen(message));
299
 
                xmlNode *xmlnode = xmlSecFindNode(xmlDocGetRootElement(doc), xmlSecNodeSignature,
300
 
                                                  xmlSecDSigNs);
301
 
                if (xmlnode) {
302
 
                        xmlUnlinkNode(xmlnode);
303
 
                        xmlFreeNode(xmlnode);
304
 
                }
305
 
                envelope = LASSO_SOAP_ENVELOPE(
306
 
                        lasso_node_new_from_xmlNode(xmlDocGetRootElement(doc)));
307
 
                request = LASSO_DST_QUERY(envelope->Body->any->data);
308
 
                service_type = g_strdup(request->hrefServiceType);
309
 
                xmlFreeDoc(doc);
310
 
        }
 
310
 
 
311
        g_return_val_if_fail(message != NULL, LASSO_PARAM_ERROR_INVALID_VALUE);
 
312
 
 
313
        doc = xmlParseMemory(message, strlen(message));
 
314
        if (doc == NULL) {
 
315
                return critical_error(LASSO_PROFILE_ERROR_INVALID_MSG);
 
316
        }
 
317
        
 
318
        xmlnode = xmlSecFindNode(xmlDocGetRootElement(doc), xmlSecNodeSignature,
 
319
                                          xmlSecDSigNs);
 
320
        if (xmlnode) {
 
321
                xmlUnlinkNode(xmlnode);
 
322
                xmlFreeNode(xmlnode);
 
323
                xmlnode = NULL;
 
324
        }
 
325
 
 
326
        envelope = LASSO_SOAP_ENVELOPE(
 
327
                lasso_node_new_from_xmlNode(xmlDocGetRootElement(doc)));
 
328
        request = LASSO_DST_QUERY(envelope->Body->any->data);
 
329
        service_type = g_strdup(request->hrefServiceType);
 
330
        xmlFreeDoc(doc);
311
331
 
312
332
        profile = LASSO_WSF_PROFILE(service);
313
333
        rc = lasso_wsf_profile_process_soap_request_msg(profile, message, service_type,
314
334
                                                        security_mech_id);
315
335
        if (rc)
316
336
                return rc;
317
 
 
 
337
        
 
338
        /* get provider id from soap:Header */
 
339
        for (node_list = profile->soap_envelope_request->Header->Other;
 
340
                        node_list; node_list = g_list_next(node_list)) {
 
341
                LassoNode *node = node_list->data;
 
342
                if (LASSO_IS_SOAP_BINDING_PROVIDER(node)) {
 
343
                        if (service->provider_id)
 
344
                                g_free(service->provider_id);
 
345
                        service->provider_id = g_strdup(
 
346
                                LASSO_SOAP_BINDING_PROVIDER(node)->providerID);
 
347
                }
 
348
        }
 
349
        
318
350
        query = LASSO_DST_QUERY(profile->request);
319
 
        if (query->ResourceID)
 
351
        if (query->ResourceID) {
320
352
                service->resource_id = g_object_ref(query->ResourceID);
321
 
        else if (query->EncryptedResourceID)
 
353
        } else if (query->EncryptedResourceID) {
322
354
                service->encrypted_resource_id = g_object_ref(query->EncryptedResourceID);
323
 
        else {
 
355
        } else {
324
356
                return LASSO_ERROR_UNIMPLEMENTED; /* implied ? */
325
357
        }
326
358
 
367
399
                        xmlNode *node = xpathObj->nodesetval->nodeTab[0];
368
400
                        xmlReplaceNode(node, newNode);
369
401
                }
 
402
                xmlXPathFreeObject(xpathObj);
 
403
                xpathObj = NULL;
370
404
 
371
405
                iter = g_list_next(iter);
372
406
        }
373
407
 
 
408
        xmlXPathFreeContext(xpathCtx);
 
409
        xmlFreeDoc(doc);
 
410
 
374
411
        return lasso_wsf_profile_build_soap_response_msg(profile);
375
412
}
376
413
 
434
471
                        }
435
472
                        response->Data = g_list_append(response->Data, data);
436
473
                }
 
474
                xmlXPathFreeObject(xpathObj);
 
475
                xpathObj = NULL;
437
476
                iter = g_list_next(iter);
438
477
        }
439
478
 
440
479
        xmlUnlinkNode(service->resource_data);
 
480
        xmlXPathFreeContext(xpathCtx);
441
481
        xmlFreeDoc(doc);
442
482
 
443
483
        return lasso_wsf_profile_build_soap_response_msg(profile);
570
610
        const char *message)
571
611
{
572
612
        int rc;
573
 
        LassoDstQueryResponse *response;
574
613
        LassoSoapFault *fault = NULL;
575
614
        LassoIsRedirectRequest *redirect_request = NULL;
576
615
        GList *iter;
602
641
                return LASSO_SOAP_FAULT_REDIRECT_REQUEST;
603
642
 
604
643
        return 0;
605
 
 
606
 
        /*if (! LASSO_IS_DST_QUERY_RESPONSE(LASSO_WSF_PROFILE(service)->response))
607
 
                return LASSO_ERROR_UNDEFINED;
608
 
 
609
 
        response = LASSO_DST_QUERY_RESPONSE(LASSO_WSF_PROFILE(service)->response);
610
 
        if (response->Status == NULL || strcmp(response->Status->code, "OK") != 0)
611
 
        return LASSO_ERROR_UNDEFINED;*/
612
 
 
613
 
        return 0;
614
644
}
615
645
 
616
646
 
643
673
        
644
674
        modify->hrefServiceType = g_strdup(offering->ServiceInstance->ServiceType);
645
675
        modify->prefixServiceType = lasso_get_prefix_for_dst_service_href(
646
 
                modify->hrefServiceType);
 
676
                        modify->hrefServiceType);
647
677
        if (modify->prefixServiceType == NULL) {
648
 
                return LASSO_ERROR_UNDEFINED;
 
678
                return LASSO_DATA_SERVICE_ERROR_UNREGISTERED_DST;
649
679
        }
650
680
 
651
681
        /* get ResourceID / EncryptedResourceID */
652
682
        if (offering->ResourceID) {
653
683
                modify->ResourceID = offering->ResourceID;
654
 
        }
655
 
        else if (offering->EncryptedResourceID) {
 
684
        } else if (offering->EncryptedResourceID) {
656
685
          modify->EncryptedResourceID = offering->EncryptedResourceID;
657
 
        }
658
 
        else {
 
686
        } else {
659
687
                /* XXX: no resource id, implied:resource, etc. */
660
688
                return LASSO_ERROR_UNIMPLEMENTED;
661
689
        }
691
719
        }
692
720
 
693
721
        modify = LASSO_DST_MODIFY(profile->request);
694
 
        if (modify->ResourceID)
 
722
        if (modify->ResourceID) {
695
723
                service->resource_id = g_object_ref(modify->ResourceID);
696
 
        else if (modify->EncryptedResourceID)
 
724
        } else if (modify->EncryptedResourceID) {
697
725
                service->encrypted_resource_id = g_object_ref(modify->EncryptedResourceID);
698
 
        else {
 
726
        } else {
699
727
                return LASSO_ERROR_UNIMPLEMENTED; /* implied ? */
700
728
        }
701
729
 
707
735
        LassoDstModifyResponse *response;
708
736
        LassoSoapEnvelope *envelope;
709
737
 
710
 
        g_return_val_if_fail(LASSO_IS_PROFILE_SERVICE(service), -1);
711
 
        g_return_val_if_fail(soap_msg != NULL, -1);
 
738
        g_return_val_if_fail(LASSO_IS_PROFILE_SERVICE(service),
 
739
                        LASSO_PARAM_ERROR_BAD_TYPE_OR_NULL_OBJ);
 
740
        g_return_val_if_fail(soap_msg != NULL, LASSO_PARAM_ERROR_INVALID_VALUE);
712
741
 
713
742
        envelope = LASSO_SOAP_ENVELOPE(lasso_node_new_from_dump(soap_msg));
714
743
        LASSO_WSF_PROFILE(service)->soap_envelope_response = envelope;
745
774
 
746
775
        if (service->private_data->dispose_has_run == TRUE)
747
776
                return;
 
777
        g_free(service->provider_id);
 
778
        service->provider_id = NULL;
748
779
        service->private_data->dispose_has_run = TRUE;
749
780
 
750
781
        G_OBJECT_CLASS(parent_class)->dispose(object);