1 /*
2 * Copyright 1999-2006 University of Chicago
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17
18 /*
19 * This file is automatically generated by the Globus WSDLtoC converter
20 */
21
22 #include "globus_soap_message.h"
23 #include "SecureCounterService.h"
24 #include "SecureCounterService_skeleton.h"
25 #include "SecureCounterService_internal_skeleton.h"
26 #include "version.h"
27 #include "globus_soap_message_fault.h"
28 #include "globus_ws_addressing.h"
29 #include "globus_wsrf_resource.h"
30 #include "globus_wsrf_core_tools.h"
31
32 static
33 int
34 SecureCounterService_activate(void);
35
36 static
37 int
38 SecureCounterService_deactivate(void);
39
40 GlobusExtensionDefineModule(SecureCounterService) =
41 {
42 "SecureCounterService",
43 SecureCounterService_activate,
44 SecureCounterService_deactivate,
45 NULL,
46 NULL,
47 &local_version
48 };
49
50 0 GlobusDebugDefine(SECURECOUNTERSERVICE);
51
52 xsd_QName SecureCounterService_service_qname =
53 {
54 "http://counter.com/service",
55 "SecureCounterService"
56 };
57
58 globus_service_descriptor_t SecureCounterService_descriptor =
59 {
60 &SecureCounterService_service_qname,
61 GLOBUS_SERVICE_ENGINE_MODULE_PATH_PREFIX "/" SECURECOUNTERSERVICE_BASE_PATH,
62 NULL,
63 NULL,
64 NULL,
65 globus_resource_id_get_as_string
66 };
67
68
69 xsd_QName CounterPortType_SetTerminationTime_op_qname =
70 {
71 "http://localhost:8080/wsrf/services/SecureCounterService"
72 "SetTerminationTime"
73 };
74
75 xsd_QName CounterPortType_SetTerminationTime_input_qname =
76 {
77 "http://docs.oasis-open.org/wsrf/rl-2",
78 "SetTerminationTime"
79 };
80
81 typedef globus_result_t (* SetTerminationTime_invoke_func_t) (
82 globus_service_engine_t engine,
83 globus_soap_message_handle_t message,
84 globus_service_descriptor_t * descriptor,
85 wsrl_SetTerminationTimeType * input,
86 wsrl_SetTerminationTimeResponseType * output,
87 xsd_any * fault);
88
89 typedef struct SetTerminationTime_callback_handle_s
90 {
91 globus_service_engine_t engine;
92 globus_soap_message_handle_t message;
93 globus_operation_invoke_callback_func_t callback;
94 void * args;
95 } SetTerminationTime_callback_handle_t;
96
97 static
98 void
99 SetTerminationTime_deserialize_callback(
100 void * handle)
101 0 {
102 SetTerminationTime_callback_handle_t * callback_handle;
103 0 globus_result_t result = GLOBUS_SUCCESS;
104 struct globus_soap_message_fault_s soap_fault;
105 SetTerminationTime_invoke_func_t invoke_function;
106 0 wsrl_SetTerminationTimeType * input = NULL;
107 GlobusFuncName(SetTerminationTime_deserialize_callback);
108 0 SecureCounterServiceDebugEnter();
109
110 0 callback_handle = (SetTerminationTime_callback_handle_t *) handle;
111
112 0 result = globus_operation_table_get_operation(
113 SecureCounterService_descriptor.operations,
114 "SetTerminationTime",
115 (void **)&invoke_function);
116 0 if(result != GLOBUS_SUCCESS)
117 {
118 0 goto exit;
119 }
120
121 0 result = wsrl_SetTerminationTimeType_init(
122 &input);
123 0 if(result != GLOBUS_SUCCESS)
124 {
125 0 goto exit;
126 }
127
128 0 result = wsrl_SetTerminationTimeType_deserialize(
129 &CounterPortType_SetTerminationTime_input_qname,
130 input,
131 callback_handle->message,
132 0);
133 0 if(result != GLOBUS_SUCCESS)
134 {
135 0 goto free_exit;
136 }
137
138 0 result = globus_soap_message_handle_set_attr(
139 callback_handle->message,
140 "SetTerminationTimeOperationInputParameter",
141 wsrl_SetTerminationTimeType_info.copy,
142 wsrl_SetTerminationTimeType_info.destroy,
143 (void *)input);
144 if(result != GLOBUS_SUCCESS)
145 {
146 0 goto free_exit;
147 }
148
149 0 free_exit:
150 0 wsrl_SetTerminationTimeType_destroy(input);
151
152 0 exit:
153 0 callback_handle->callback(
154 result,
155 callback_handle->args);
156
157 0 free(callback_handle);
158 0 SecureCounterServiceDebugExit();
159 0 }
160 /* SetTerminationTime_deserialize_callback() */
161
162 static
163 globus_result_t
164 SetTerminationTime_deserialize(
165 globus_service_engine_t engine,
166 globus_soap_message_handle_t message,
167 globus_operation_invoke_callback_func_t invoke_callback,
168 void * args)
169 0 {
170 SetTerminationTime_callback_handle_t * callback_handle;
171 0 globus_result_t result = GLOBUS_SUCCESS;
172 GlobusFuncName(SetTerminationTime_deserialize);
173 0 SecureCounterServiceDebugEnter();
174
175 0 callback_handle = malloc(sizeof(SetTerminationTime_callback_handle_t));
176 0 globus_assert_string(callback_handle,
177 "Memory allocation failed "
178 "for SetTerminationTime callback handle");
179
180 0 callback_handle->engine = engine;
181 0 callback_handle->message = message;
182 0 callback_handle->callback = invoke_callback;
183 0 callback_handle->args = args;
184
185 0 result = globus_callback_register_oneshot(
186 NULL,
187 &globus_i_reltime_zero,
188 SetTerminationTime_deserialize_callback,
189 callback_handle);
190
191 0 SecureCounterServiceDebugExit();
192 0 return result;
193 }
194
195 static
196 void
197 SetTerminationTime_invoke_callback(
198 void * handle)
199 0 {
200 SetTerminationTime_callback_handle_t * callback_handle;
201 0 globus_result_t result = GLOBUS_SUCCESS;
202 struct globus_soap_message_fault_s soap_fault;
203 SetTerminationTime_invoke_func_t invoke_function;
204 wsrl_SetTerminationTimeType * input;
205 wsrl_SetTerminationTimeResponseType output;
206 xsd_QName element_qname;
207 xsd_any fault;
208
209 GlobusFuncName(SetTerminationTime_invoke_callback);
210 0 SecureCounterServiceDebugEnter();
211
212 0 callback_handle = (SetTerminationTime_callback_handle_t *) handle;
213
214 0 input = globus_soap_message_handle_get_attr(
215 callback_handle->message,
216 "SetTerminationTimeOperationInputParameter");
217 0 globus_assert(input);
218
219 0 result = globus_operation_table_get_operation(
220 SecureCounterService_descriptor.operations,
221 "SetTerminationTime",
222 (void **)&invoke_function);
223 0 if(result != GLOBUS_SUCCESS)
224 {
225 0 goto fault_exit;
226 }
227
228
229 0 result = wsrl_SetTerminationTimeResponseType_init_contents(
230 &output);
231 0 if(result != GLOBUS_SUCCESS)
232 {
233 0 goto fault_exit;
234 }
235 0 result = xsd_any_init_contents(&fault);
236 0 if(result != GLOBUS_SUCCESS)
237 {
238 0 goto fault_exit;
239 }
240 0 result = invoke_function(
241 callback_handle->engine,
242 callback_handle->message,
243 &SecureCounterService_descriptor,
244 input,
245 &output,
246 &fault);
247
248
249 0 fault_exit:
250
251 0 if(fault.value && fault.element)
252 {
253 0 result = globus_service_session_begin_response(
254 callback_handle->message);
255 0 if(result != GLOBUS_SUCCESS)
256 {
257 0 goto exit;
258 }
259
260 0 soap_fault.faultcode = "Server";
261 0 soap_fault.faultstring =
262 "An error occurred while processing the message";
263 0 soap_fault.faultactor = NULL;
264 0 soap_fault.detail = &fault;
265
266 0 result = globus_service_session_serialize_fault_response(
267 callback_handle->message, &soap_fault);
268 0 if(result != GLOBUS_SUCCESS)
269 {
270 0 goto exit;
271 }
272
273 0 xsd_any_destroy_contents(soap_fault.detail);
274
275 0 globus_soap_message_handle_set_attr(
276 callback_handle->message,
277 WSADDR_ACTION_RESPONSE_KEY,
278 globus_soap_message_attr_copy_string,
279 globus_libc_free,
280 WSADDRESSING_FAULT_NS);
281 }
282 0 else if(result != GLOBUS_SUCCESS)
283 {
284 globus_result_t local_result;
285 0 local_result = globus_service_session_begin_response(
286 callback_handle->message);
287 0 if(local_result != GLOBUS_SUCCESS)
288 {
289 0 result = local_result;
290 0 goto exit;
291 }
292
293 0 soap_fault.faultcode = "Server";
294 0 soap_fault.faultstring = globus_error_print_friendly(
295 globus_error_get(result));
296 0 result = GLOBUS_SUCCESS;
297 0 soap_fault.faultactor = NULL;
298 0 soap_fault.detail = NULL;
299 0 result = globus_service_session_serialize_fault_response(
300 callback_handle->message, &soap_fault);
301 0 if(result != GLOBUS_SUCCESS)
302 {
303 0 goto exit;
304 }
305
306 0 globus_soap_message_handle_set_attr(
307 callback_handle->message,
308 WSADDR_ACTION_RESPONSE_KEY,
309 globus_soap_message_attr_copy_string,
310 globus_libc_free,
311 WSADDRESSING_FAULT_NS);
312 }
313 else
314 {
315 0 result = globus_service_session_begin_response(
316 callback_handle->message);
317 0 if(result != GLOBUS_SUCCESS)
318 {
319 0 goto exit;
320 }
321
322 0 element_qname.local = "SetTerminationTimeResponse";
323 0 element_qname.Namespace = "http://docs.oasis-open.org/wsrf/rl-2";
324
325 0 result = wsrl_SetTerminationTimeResponseType_serialize(
326 &element_qname,
327 &output,
328 callback_handle->message,
329 GLOBUS_XSD_ELEMENT_SET_DEFAULT_NS);
330 0 if(result != GLOBUS_SUCCESS)
331 {
332 0 goto exit;
333 }
334
335 0 result = globus_service_session_end_response(
336 callback_handle->message);
337 0 if(result != GLOBUS_SUCCESS)
338 {
339 0 goto exit;
340 }
341
342 0 wsrl_SetTerminationTimeResponseType_destroy_contents(
343 &output);
344
345 0 globus_soap_message_handle_set_attr(
346 callback_handle->message,
347 WSADDR_ACTION_RESPONSE_KEY,
348 globus_soap_message_attr_copy_string,
349 globus_libc_free,
350 "http://docs.oasis-open.org/wsrf/rlw-2/ScheduledResourceTermination/SetTerminationTimeResponse");
351 }
352
353 0 exit:
354
355 0 callback_handle->callback(
356 result,
357 callback_handle->args);
358
359 0 globus_libc_free(callback_handle);
360
361 0 SecureCounterServiceDebugExit();
362 0 }
363
364 static
365 globus_result_t
366 SetTerminationTime_invoke(
367 globus_service_engine_t engine,
368 globus_soap_message_handle_t message,
369 globus_service_response_t * response,
370 globus_operation_invoke_callback_func_t invoke_callback,
371 void * args)
372 0 {
373 SetTerminationTime_callback_handle_t * callback_handle;
374 0 globus_result_t result = GLOBUS_SUCCESS;
375 GlobusFuncName(CounterPortType_SetTerminationTime);
376 0 SecureCounterServiceDebugEnter();
377
378 0 callback_handle = malloc(sizeof(SetTerminationTime_callback_handle_t));
379 0 if(!callback_handle)
380 {
381 0 result = GlobusSoapMessageErrorOutOfMemory;
382 0 goto exit;
383 }
384 0 callback_handle->engine = engine;
385 0 callback_handle->message = message;
386 0 callback_handle->callback = invoke_callback;
387 0 callback_handle->args = args;
388
389 0 result = globus_callback_register_oneshot(
390 NULL,
391 &globus_i_reltime_zero,
392 SetTerminationTime_invoke_callback,
393 callback_handle);
394
395 0 exit:
396 0 SecureCounterServiceDebugExit();
397 0 return result;
398 }
399
400 static
401 globus_service_operation_descriptor_t
402 SetTerminationTime_operation_descriptor =
403 {
404 SetTerminationTime_deserialize,
405 SetTerminationTime_invoke,
406 };
407
408 static
409 globus_operation_provider_descriptor_t SetTerminationTime_descriptor =
410 {
411 &CounterPortType_SetTerminationTime_op_qname,
412 "SetTerminationTime",
413 (void *)CounterPortType_SetTerminationTime_impl,
414 NULL
415 };
416
417
418 xsd_QName CounterPortType_Destroy_op_qname =
419 {
420 "http://localhost:8080/wsrf/services/SecureCounterService"
421 "Destroy"
422 };
423
424 xsd_QName CounterPortType_Destroy_input_qname =
425 {
426 "http://docs.oasis-open.org/wsrf/rl-2",
427 "Destroy"
428 };
429
430 typedef globus_result_t (* Destroy_invoke_func_t) (
431 globus_service_engine_t engine,
432 globus_soap_message_handle_t message,
433 globus_service_descriptor_t * descriptor,
434 wsrl_DestroyType * input,
435 wsrl_DestroyResponseType * output,
436 xsd_any * fault);
437
438 typedef struct Destroy_callback_handle_s
439 {
440 globus_service_engine_t engine;
441 globus_soap_message_handle_t message;
442 globus_operation_invoke_callback_func_t callback;
443 void * args;
444 } Destroy_callback_handle_t;
445
446 static
447 void
448 Destroy_deserialize_callback(
449 void * handle)
450 0 {
451 Destroy_callback_handle_t * callback_handle;
452 0 globus_result_t result = GLOBUS_SUCCESS;
453 struct globus_soap_message_fault_s soap_fault;
454 Destroy_invoke_func_t invoke_function;
455 0 wsrl_DestroyType * input = NULL;
456 GlobusFuncName(Destroy_deserialize_callback);
457 0 SecureCounterServiceDebugEnter();
458
459 0 callback_handle = (Destroy_callback_handle_t *) handle;
460
461 0 result = globus_operation_table_get_operation(
462 SecureCounterService_descriptor.operations,
463 "Destroy",
464 (void **)&invoke_function);
465 0 if(result != GLOBUS_SUCCESS)
466 {
467 0 goto exit;
468 }
469
470 0 result = wsrl_DestroyType_init(
471 &input);
472 0 if(result != GLOBUS_SUCCESS)
473 {
474 0 goto exit;
475 }
476
477 0 result = wsrl_DestroyType_deserialize(
478 &CounterPortType_Destroy_input_qname,
479 input,
480 callback_handle->message,
481 0);
482 0 if(result != GLOBUS_SUCCESS)
483 {
484 0 goto free_exit;
485 }
486
487 0 result = globus_soap_message_handle_set_attr(
488 callback_handle->message,
489 "DestroyOperationInputParameter",
490 wsrl_DestroyType_info.copy,
491 wsrl_DestroyType_info.destroy,
492 (void *)input);
493 if(result != GLOBUS_SUCCESS)
494 {
495 0 goto free_exit;
496 }
497
498 0 free_exit:
499 0 wsrl_DestroyType_destroy(input);
500
501 0 exit:
502 0 callback_handle->callback(
503 result,
504 callback_handle->args);
505
506 0 free(callback_handle);
507 0 SecureCounterServiceDebugExit();
508 0 }
509 /* Destroy_deserialize_callback() */
510
511 static
512 globus_result_t
513 Destroy_deserialize(
514 globus_service_engine_t engine,
515 globus_soap_message_handle_t message,
516 globus_operation_invoke_callback_func_t invoke_callback,
517 void * args)
518 0 {
519 Destroy_callback_handle_t * callback_handle;
520 0 globus_result_t result = GLOBUS_SUCCESS;
521 GlobusFuncName(Destroy_deserialize);
522 0 SecureCounterServiceDebugEnter();
523
524 0 callback_handle = malloc(sizeof(Destroy_callback_handle_t));
525 0 globus_assert_string(callback_handle,
526 "Memory allocation failed "
527 "for Destroy callback handle");
528
529 0 callback_handle->engine = engine;
530 0 callback_handle->message = message;
531 0 callback_handle->callback = invoke_callback;
532 0 callback_handle->args = args;
533
534 0 result = globus_callback_register_oneshot(
535 NULL,
536 &globus_i_reltime_zero,
537 Destroy_deserialize_callback,
538 callback_handle);
539
540 0 SecureCounterServiceDebugExit();
541 0 return result;
542 }
543
544 static
545 void
546 Destroy_invoke_callback(
547 void * handle)
548 0 {
549 Destroy_callback_handle_t * callback_handle;
550 0 globus_result_t result = GLOBUS_SUCCESS;
551 struct globus_soap_message_fault_s soap_fault;
552 Destroy_invoke_func_t invoke_function;
553 wsrl_DestroyType * input;
554 wsrl_DestroyResponseType output;
555 xsd_QName element_qname;
556 xsd_any fault;
557
558 GlobusFuncName(Destroy_invoke_callback);
559 0 SecureCounterServiceDebugEnter();
560
561 0 callback_handle = (Destroy_callback_handle_t *) handle;
562
563 0 input = globus_soap_message_handle_get_attr(
564 callback_handle->message,
565 "DestroyOperationInputParameter");
566 0 globus_assert(input);
567
568 0 result = globus_operation_table_get_operation(
569 SecureCounterService_descriptor.operations,
570 "Destroy",
571 (void **)&invoke_function);
572 0 if(result != GLOBUS_SUCCESS)
573 {
574 0 goto fault_exit;
575 }
576
577
578 0 result = wsrl_DestroyResponseType_init_contents(
579 &output);
580 0 if(result != GLOBUS_SUCCESS)
581 {
582 0 goto fault_exit;
583 }
584 0 result = xsd_any_init_contents(&fault);
585 0 if(result != GLOBUS_SUCCESS)
586 {
587 0 goto fault_exit;
588 }
589 0 result = invoke_function(
590 callback_handle->engine,
591 callback_handle->message,
592 &SecureCounterService_descriptor,
593 input,
594 &output,
595 &fault);
596
597
598 0 fault_exit:
599
600 0 if(fault.value && fault.element)
601 {
602 0 result = globus_service_session_begin_response(
603 callback_handle->message);
604 0 if(result != GLOBUS_SUCCESS)
605 {
606 0 goto exit;
607 }
608
609 0 soap_fault.faultcode = "Server";
610 0 soap_fault.faultstring =
611 "An error occurred while processing the message";
612 0 soap_fault.faultactor = NULL;
613 0 soap_fault.detail = &fault;
614
615 0 result = globus_service_session_serialize_fault_response(
616 callback_handle->message, &soap_fault);
617 0 if(result != GLOBUS_SUCCESS)
618 {
619 0 goto exit;
620 }
621
622 0 xsd_any_destroy_contents(soap_fault.detail);
623
624 0 globus_soap_message_handle_set_attr(
625 callback_handle->message,
626 WSADDR_ACTION_RESPONSE_KEY,
627 globus_soap_message_attr_copy_string,
628 globus_libc_free,
629 WSADDRESSING_FAULT_NS);
630 }
631 0 else if(result != GLOBUS_SUCCESS)
632 {
633 globus_result_t local_result;
634 0 local_result = globus_service_session_begin_response(
635 callback_handle->message);
636 0 if(local_result != GLOBUS_SUCCESS)
637 {
638 0 result = local_result;
639 0 goto exit;
640 }
641
642 0 soap_fault.faultcode = "Server";
643 0 soap_fault.faultstring = globus_error_print_friendly(
644 globus_error_get(result));
645 0 result = GLOBUS_SUCCESS;
646 0 soap_fault.faultactor = NULL;
647 0 soap_fault.detail = NULL;
648 0 result = globus_service_session_serialize_fault_response(
649 callback_handle->message, &soap_fault);
650 0 if(result != GLOBUS_SUCCESS)
651 {
652 0 goto exit;
653 }
654
655 0 globus_soap_message_handle_set_attr(
656 callback_handle->message,
657 WSADDR_ACTION_RESPONSE_KEY,
658 globus_soap_message_attr_copy_string,
659 globus_libc_free,
660 WSADDRESSING_FAULT_NS);
661 }
662 else
663 {
664 0 result = globus_service_session_begin_response(
665 callback_handle->message);
666 0 if(result != GLOBUS_SUCCESS)
667 {
668 0 goto exit;
669 }
670
671 0 element_qname.local = "DestroyResponse";
672 0 element_qname.Namespace = "http://docs.oasis-open.org/wsrf/rl-2";
673
674 0 result = wsrl_DestroyResponseType_serialize(
675 &element_qname,
676 &output,
677 callback_handle->message,
678 GLOBUS_XSD_ELEMENT_SET_DEFAULT_NS);
679 0 if(result != GLOBUS_SUCCESS)
680 {
681 0 goto exit;
682 }
683
684 0 result = globus_service_session_end_response(
685 callback_handle->message);
686 0 if(result != GLOBUS_SUCCESS)
687 {
688 0 goto exit;
689 }
690
691 0 wsrl_DestroyResponseType_destroy_contents(
692 &output);
693
694 0 globus_soap_message_handle_set_attr(
695 callback_handle->message,
696 WSADDR_ACTION_RESPONSE_KEY,
697 globus_soap_message_attr_copy_string,
698 globus_libc_free,
699 "http://docs.oasis-open.org/wsrf/rlw-2/ImmediateResourceTermination/DestroyResponse");
700 }
701
702 0 exit:
703
704 0 callback_handle->callback(
705 result,
706 callback_handle->args);
707
708 0 globus_libc_free(callback_handle);
709
710 0 SecureCounterServiceDebugExit();
711 0 }
712
713 static
714 globus_result_t
715 Destroy_invoke(
716 globus_service_engine_t engine,
717 globus_soap_message_handle_t message,
718 globus_service_response_t * response,
719 globus_operation_invoke_callback_func_t invoke_callback,
720 void * args)
721 0 {
722 Destroy_callback_handle_t * callback_handle;
723 0 globus_result_t result = GLOBUS_SUCCESS;
724 GlobusFuncName(CounterPortType_Destroy);
725 0 SecureCounterServiceDebugEnter();
726
727 0 callback_handle = malloc(sizeof(Destroy_callback_handle_t));
728 0 if(!callback_handle)
729 {
730 0 result = GlobusSoapMessageErrorOutOfMemory;
731 0 goto exit;
732 }
733 0 callback_handle->engine = engine;
734 0 callback_handle->message = message;
735 0 callback_handle->callback = invoke_callback;
736 0 callback_handle->args = args;
737
738 0 result = globus_callback_register_oneshot(
739 NULL,
740 &globus_i_reltime_zero,
741 Destroy_invoke_callback,
742 callback_handle);
743
744 0 exit:
745 0 SecureCounterServiceDebugExit();
746 0 return result;
747 }
748
749 static
750 globus_service_operation_descriptor_t
751 Destroy_operation_descriptor =
752 {
753 Destroy_deserialize,
754 Destroy_invoke,
755 };
756
757 static
758 globus_operation_provider_descriptor_t Destroy_descriptor =
759 {
760 &CounterPortType_Destroy_op_qname,
761 "Destroy",
762 (void *)CounterPortType_Destroy_impl,
763 NULL
764 };
765
766
767 xsd_QName CounterPortType_GetCurrentMessage_op_qname =
768 {
769 "http://localhost:8080/wsrf/services/SecureCounterService"
770 "GetCurrentMessage"
771 };
772
773 xsd_QName CounterPortType_GetCurrentMessage_input_qname =
774 {
775 "http://docs.oasis-open.org/wsn/b-2",
776 "GetCurrentMessage"
777 };
778
779 typedef globus_result_t (* GetCurrentMessage_invoke_func_t) (
780 globus_service_engine_t engine,
781 globus_soap_message_handle_t message,
782 globus_service_descriptor_t * descriptor,
783 wsnt_GetCurrentMessageType * input,
784 wsnt_GetCurrentMessageResponseType * output,
785 xsd_any * fault);
786
787 typedef struct GetCurrentMessage_callback_handle_s
788 {
789 globus_service_engine_t engine;
790 globus_soap_message_handle_t message;
791 globus_operation_invoke_callback_func_t callback;
792 void * args;
793 } GetCurrentMessage_callback_handle_t;
794
795 static
796 void
797 GetCurrentMessage_deserialize_callback(
798 void * handle)
799 0 {
800 GetCurrentMessage_callback_handle_t * callback_handle;
801 0 globus_result_t result = GLOBUS_SUCCESS;
802 struct globus_soap_message_fault_s soap_fault;
803 GetCurrentMessage_invoke_func_t invoke_function;
804 0 wsnt_GetCurrentMessageType * input = NULL;
805 GlobusFuncName(GetCurrentMessage_deserialize_callback);
806 0 SecureCounterServiceDebugEnter();
807
808 0 callback_handle = (GetCurrentMessage_callback_handle_t *) handle;
809
810 0 result = globus_operation_table_get_operation(
811 SecureCounterService_descriptor.operations,
812 "GetCurrentMessage",
813 (void **)&invoke_function);
814 0 if(result != GLOBUS_SUCCESS)
815 {
816 0 goto exit;
817 }
818
819 0 result = wsnt_GetCurrentMessageType_init(
820 &input);
821 0 if(result != GLOBUS_SUCCESS)
822 {
823 0 goto exit;
824 }
825
826 0 result = wsnt_GetCurrentMessageType_deserialize(
827 &CounterPortType_GetCurrentMessage_input_qname,
828 input,
829 callback_handle->message,
830 0);
831 0 if(result != GLOBUS_SUCCESS)
832 {
833 0 goto free_exit;
834 }
835
836 0 result = globus_soap_message_handle_set_attr(
837 callback_handle->message,
838 "GetCurrentMessageOperationInputParameter",
839 wsnt_GetCurrentMessageType_info.copy,
840 wsnt_GetCurrentMessageType_info.destroy,
841 (void *)input);
842 if(result != GLOBUS_SUCCESS)
843 {
844 0 goto free_exit;
845 }
846
847 0 free_exit:
848 0 wsnt_GetCurrentMessageType_destroy(input);
849
850 0 exit:
851 0 callback_handle->callback(
852 result,
853 callback_handle->args);
854
855 0 free(callback_handle);
856 0 SecureCounterServiceDebugExit();
857 0 }
858 /* GetCurrentMessage_deserialize_callback() */
859
860 static
861 globus_result_t
862 GetCurrentMessage_deserialize(
863 globus_service_engine_t engine,
864 globus_soap_message_handle_t message,
865 globus_operation_invoke_callback_func_t invoke_callback,
866 void * args)
867 0 {
868 GetCurrentMessage_callback_handle_t * callback_handle;
869 0 globus_result_t result = GLOBUS_SUCCESS;
870 GlobusFuncName(GetCurrentMessage_deserialize);
871 0 SecureCounterServiceDebugEnter();
872
873 0 callback_handle = malloc(sizeof(GetCurrentMessage_callback_handle_t));
874 0 globus_assert_string(callback_handle,
875 "Memory allocation failed "
876 "for GetCurrentMessage callback handle");
877
878 0 callback_handle->engine = engine;
879 0 callback_handle->message = message;
880 0 callback_handle->callback = invoke_callback;
881 0 callback_handle->args = args;
882
883 0 result = globus_callback_register_oneshot(
884 NULL,
885 &globus_i_reltime_zero,
886 GetCurrentMessage_deserialize_callback,
887 callback_handle);
888
889 0 SecureCounterServiceDebugExit();
890 0 return result;
891 }
892
893 static
894 void
895 GetCurrentMessage_invoke_callback(
896 void * handle)
897 0 {
898 GetCurrentMessage_callback_handle_t * callback_handle;
899 0 globus_result_t result = GLOBUS_SUCCESS;
900 struct globus_soap_message_fault_s soap_fault;
901 GetCurrentMessage_invoke_func_t invoke_function;
902 wsnt_GetCurrentMessageType * input;
903 wsnt_GetCurrentMessageResponseType output;
904 xsd_QName element_qname;
905 xsd_any fault;
906
907 GlobusFuncName(GetCurrentMessage_invoke_callback);
908 0 SecureCounterServiceDebugEnter();
909
910 0 callback_handle = (GetCurrentMessage_callback_handle_t *) handle;
911
912 0 input = globus_soap_message_handle_get_attr(
913 callback_handle->message,
914 "GetCurrentMessageOperationInputParameter");
915 0 globus_assert(input);
916
917 0 result = globus_operation_table_get_operation(
918 SecureCounterService_descriptor.operations,
919 "GetCurrentMessage",
920 (void **)&invoke_function);
921 0 if(result != GLOBUS_SUCCESS)
922 {
923 0 goto fault_exit;
924 }
925
926
927 0 result = wsnt_GetCurrentMessageResponseType_init_contents(
928 &output);
929 0 if(result != GLOBUS_SUCCESS)
930 {
931 0 goto fault_exit;
932 }
933 0 result = xsd_any_init_contents(&fault);
934 0 if(result != GLOBUS_SUCCESS)
935 {
936 0 goto fault_exit;
937 }
938 0 result = invoke_function(
939 callback_handle->engine,
940 callback_handle->message,
941 &SecureCounterService_descriptor,
942 input,
943 &output,
944 &fault);
945
946
947 0 fault_exit:
948
949 0 if(fault.value && fault.element)
950 {
951 0 result = globus_service_session_begin_response(
952 callback_handle->message);
953 0 if(result != GLOBUS_SUCCESS)
954 {
955 0 goto exit;
956 }
957
958 0 soap_fault.faultcode = "Server";
959 0 soap_fault.faultstring =
960 "An error occurred while processing the message";
961 0 soap_fault.faultactor = NULL;
962 0 soap_fault.detail = &fault;
963
964 0 result = globus_service_session_serialize_fault_response(
965 callback_handle->message, &soap_fault);
966 0 if(result != GLOBUS_SUCCESS)
967 {
968 0 goto exit;
969 }
970
971 0 xsd_any_destroy_contents(soap_fault.detail);
972
973 0 globus_soap_message_handle_set_attr(
974 callback_handle->message,
975 WSADDR_ACTION_RESPONSE_KEY,
976 globus_soap_message_attr_copy_string,
977 globus_libc_free,
978 WSADDRESSING_FAULT_NS);
979 }
980 0 else if(result != GLOBUS_SUCCESS)
981 {
982 globus_result_t local_result;
983 0 local_result = globus_service_session_begin_response(
984 callback_handle->message);
985 0 if(local_result != GLOBUS_SUCCESS)
986 {
987 0 result = local_result;
988 0 goto exit;
989 }
990
991 0 soap_fault.faultcode = "Server";
992 0 soap_fault.faultstring = globus_error_print_friendly(
993 globus_error_get(result));
994 0 result = GLOBUS_SUCCESS;
995 0 soap_fault.faultactor = NULL;
996 0 soap_fault.detail = NULL;
997 0 result = globus_service_session_serialize_fault_response(
998 callback_handle->message, &soap_fault);
999 0 if(result != GLOBUS_SUCCESS)
1000 {
1001 0 goto exit;
1002 }
1003
1004 0 globus_soap_message_handle_set_attr(
1005 callback_handle->message,
1006 WSADDR_ACTION_RESPONSE_KEY,
1007 globus_soap_message_attr_copy_string,
1008 globus_libc_free,
1009 WSADDRESSING_FAULT_NS);
1010 }
1011 else
1012 {
1013 0 result = globus_service_session_begin_response(
1014 callback_handle->message);
1015 0 if(result != GLOBUS_SUCCESS)
1016 {
1017 0 goto exit;
1018 }
1019
1020 0 element_qname.local = "GetCurrentMessageResponse";
1021 0 element_qname.Namespace = "http://docs.oasis-open.org/wsn/b-2";
1022
1023 0 result = wsnt_GetCurrentMessageResponseType_serialize(
1024 &element_qname,
1025 &output,
1026 callback_handle->message,
1027 GLOBUS_XSD_ELEMENT_SET_DEFAULT_NS);
1028 0 if(result != GLOBUS_SUCCESS)
1029 {
1030 0 goto exit;
1031 }
1032
1033 0 result = globus_service_session_end_response(
1034 callback_handle->message);
1035 0 if(result != GLOBUS_SUCCESS)
1036 {
1037 0 goto exit;
1038 }
1039
1040 0 wsnt_GetCurrentMessageResponseType_destroy_contents(
1041 &output);
1042
1043 0 globus_soap_message_handle_set_attr(
1044 callback_handle->message,
1045 WSADDR_ACTION_RESPONSE_KEY,
1046 globus_soap_message_attr_copy_string,
1047 globus_libc_free,
1048 "http://docs.oasis-open.org/wsn/bw-2/NotificationProducer/GetCurrentMessageResponse");
1049 }
1050
1051 0 exit:
1052
1053 0 callback_handle->callback(
1054 result,
1055 callback_handle->args);
1056
1057 0 globus_libc_free(callback_handle);
1058
1059 0 SecureCounterServiceDebugExit();
1060 0 }
1061
1062 static
1063 globus_result_t
1064 GetCurrentMessage_invoke(
1065 globus_service_engine_t engine,
1066 globus_soap_message_handle_t message,
1067 globus_service_response_t * response,
1068 globus_operation_invoke_callback_func_t invoke_callback,
1069 void * args)
1070 0 {
1071 GetCurrentMessage_callback_handle_t * callback_handle;
1072 0 globus_result_t result = GLOBUS_SUCCESS;
1073 GlobusFuncName(CounterPortType_GetCurrentMessage);
1074 0 SecureCounterServiceDebugEnter();
1075
1076 0 callback_handle = malloc(sizeof(GetCurrentMessage_callback_handle_t));
1077 0 if(!callback_handle)
1078 {
1079 0 result = GlobusSoapMessageErrorOutOfMemory;
1080 0 goto exit;
1081 }
1082 0 callback_handle->engine = engine;
1083 0 callback_handle->message = message;
1084 0 callback_handle->callback = invoke_callback;
1085 0 callback_handle->args = args;
1086
1087 0 result = globus_callback_register_oneshot(
1088 NULL,
1089 &globus_i_reltime_zero,
1090 GetCurrentMessage_invoke_callback,
1091 callback_handle);
1092
1093 0 exit:
1094 0 SecureCounterServiceDebugExit();
1095 0 return result;
1096 }
1097
1098 static
1099 globus_service_operation_descriptor_t
1100 GetCurrentMessage_operation_descriptor =
1101 {
1102 GetCurrentMessage_deserialize,
1103 GetCurrentMessage_invoke,
1104 };
1105
1106 static
1107 globus_operation_provider_descriptor_t GetCurrentMessage_descriptor =
1108 {
1109 &CounterPortType_GetCurrentMessage_op_qname,
1110 "GetCurrentMessage",
1111 (void *)CounterPortType_GetCurrentMessage_impl,
1112 NULL
1113 };
1114
1115
1116 xsd_QName CounterPortType_Subscribe_op_qname =
1117 {
1118 "http://localhost:8080/wsrf/services/SecureCounterService"
1119 "Subscribe"
1120 };
1121
1122 xsd_QName CounterPortType_Subscribe_input_qname =
1123 {
1124 "http://docs.oasis-open.org/wsn/b-2",
1125 "Subscribe"
1126 };
1127
1128 typedef globus_result_t (* Subscribe_invoke_func_t) (
1129 globus_service_engine_t engine,
1130 globus_soap_message_handle_t message,
1131 globus_service_descriptor_t * descriptor,
1132 wsnt_SubscribeType * input,
1133 wsnt_SubscribeResponseType * output,
1134 xsd_any * fault);
1135
1136 typedef struct Subscribe_callback_handle_s
1137 {
1138 globus_service_engine_t engine;
1139 globus_soap_message_handle_t message;
1140 globus_operation_invoke_callback_func_t callback;
1141 void * args;
1142 } Subscribe_callback_handle_t;
1143
1144 static
1145 void
1146 Subscribe_deserialize_callback(
1147 void * handle)
1148 1 {
1149 Subscribe_callback_handle_t * callback_handle;
1150 1 globus_result_t result = GLOBUS_SUCCESS;
1151 struct globus_soap_message_fault_s soap_fault;
1152 Subscribe_invoke_func_t invoke_function;
1153 1 wsnt_SubscribeType * input = NULL;
1154 GlobusFuncName(Subscribe_deserialize_callback);
1155 1 SecureCounterServiceDebugEnter();
1156
1157 1 callback_handle = (Subscribe_callback_handle_t *) handle;
1158
1159 1 result = globus_operation_table_get_operation(
1160 SecureCounterService_descriptor.operations,
1161 "Subscribe",
1162 (void **)&invoke_function);
1163 1 if(result != GLOBUS_SUCCESS)
1164 {
1165 0 goto exit;
1166 }
1167
1168 1 result = wsnt_SubscribeType_init(
1169 &input);
1170 1 if(result != GLOBUS_SUCCESS)
1171 {
1172 0 goto exit;
1173 }
1174
1175 1 result = wsnt_SubscribeType_deserialize(
1176 &CounterPortType_Subscribe_input_qname,
1177 input,
1178 callback_handle->message,
1179 0);
1180 1 if(result != GLOBUS_SUCCESS)
1181 {
1182 0 goto free_exit;
1183 }
1184
1185 1 result = globus_soap_message_handle_set_attr(
1186 callback_handle->message,
1187 "SubscribeOperationInputParameter",
1188 wsnt_SubscribeType_info.copy,
1189 wsnt_SubscribeType_info.destroy,
1190 (void *)input);
1191 if(result != GLOBUS_SUCCESS)
1192 {
1193 1 goto free_exit;
1194 }
1195
1196 1 free_exit:
1197 1 wsnt_SubscribeType_destroy(input);
1198
1199 1 exit:
1200 1 callback_handle->callback(
1201 result,
1202 callback_handle->args);
1203
1204 1 free(callback_handle);
1205 1 SecureCounterServiceDebugExit();
1206 1 }
1207 /* Subscribe_deserialize_callback() */
1208
1209 static
1210 globus_result_t
1211 Subscribe_deserialize(
1212 globus_service_engine_t engine,
1213 globus_soap_message_handle_t message,
1214 globus_operation_invoke_callback_func_t invoke_callback,
1215 void * args)
1216 1 {
1217 Subscribe_callback_handle_t * callback_handle;
1218 1 globus_result_t result = GLOBUS_SUCCESS;
1219 GlobusFuncName(Subscribe_deserialize);
1220 1 SecureCounterServiceDebugEnter();
1221
1222 1 callback_handle = malloc(sizeof(Subscribe_callback_handle_t));
1223 1 globus_assert_string(callback_handle,
1224 "Memory allocation failed "
1225 "for Subscribe callback handle");
1226
1227 1 callback_handle->engine = engine;
1228 1 callback_handle->message = message;
1229 1 callback_handle->callback = invoke_callback;
1230 1 callback_handle->args = args;
1231
1232 1 result = globus_callback_register_oneshot(
1233 NULL,
1234 &globus_i_reltime_zero,
1235 Subscribe_deserialize_callback,
1236 callback_handle);
1237
1238 1 SecureCounterServiceDebugExit();
1239 1 return result;
1240 }
1241
1242 static
1243 void
1244 Subscribe_invoke_callback(
1245 void * handle)
1246 1 {
1247 Subscribe_callback_handle_t * callback_handle;
1248 1 globus_result_t result = GLOBUS_SUCCESS;
1249 struct globus_soap_message_fault_s soap_fault;
1250 Subscribe_invoke_func_t invoke_function;
1251 wsnt_SubscribeType * input;
1252 wsnt_SubscribeResponseType output;
1253 xsd_QName element_qname;
1254 xsd_any fault;
1255
1256 GlobusFuncName(Subscribe_invoke_callback);
1257 1 SecureCounterServiceDebugEnter();
1258
1259 1 callback_handle = (Subscribe_callback_handle_t *) handle;
1260
1261 1 input = globus_soap_message_handle_get_attr(
1262 callback_handle->message,
1263 "SubscribeOperationInputParameter");
1264 1 globus_assert(input);
1265
1266 1 result = globus_operation_table_get_operation(
1267 SecureCounterService_descriptor.operations,
1268 "Subscribe",
1269 (void **)&invoke_function);
1270 1 if(result != GLOBUS_SUCCESS)
1271 {
1272 0 goto fault_exit;
1273 }
1274
1275
1276 1 result = wsnt_SubscribeResponseType_init_contents(
1277 &output);
1278 1 if(result != GLOBUS_SUCCESS)
1279 {
1280 0 goto fault_exit;
1281 }
1282 1 result = xsd_any_init_contents(&fault);
1283 1 if(result != GLOBUS_SUCCESS)
1284 {
1285 0 goto fault_exit;
1286 }
1287 1 result = invoke_function(
1288 callback_handle->engine,
1289 callback_handle->message,
1290 &SecureCounterService_descriptor,
1291 input,
1292 &output,
1293 &fault);
1294
1295
1296 1 fault_exit:
1297
1298 1 if(fault.value && fault.element)
1299 {
1300 0 result = globus_service_session_begin_response(
1301 callback_handle->message);
1302 0 if(result != GLOBUS_SUCCESS)
1303 {
1304 0 goto exit;
1305 }
1306
1307 0 soap_fault.faultcode = "Server";
1308 0 soap_fault.faultstring =
1309 "An error occurred while processing the message";
1310 0 soap_fault.faultactor = NULL;
1311 0 soap_fault.detail = &fault;
1312
1313 0 result = globus_service_session_serialize_fault_response(
1314 callback_handle->message, &soap_fault);
1315 0 if(result != GLOBUS_SUCCESS)
1316 {
1317 0 goto exit;
1318 }
1319
1320 0 xsd_any_destroy_contents(soap_fault.detail);
1321
1322 0 globus_soap_message_handle_set_attr(
1323 callback_handle->message,
1324 WSADDR_ACTION_RESPONSE_KEY,
1325 globus_soap_message_attr_copy_string,
1326 globus_libc_free,
1327 WSADDRESSING_FAULT_NS);
1328 }
1329 1 else if(result != GLOBUS_SUCCESS)
1330 {
1331 globus_result_t local_result;
1332 0 local_result = globus_service_session_begin_response(
1333 callback_handle->message);
1334 0 if(local_result != GLOBUS_SUCCESS)
1335 {
1336 0 result = local_result;
1337 0 goto exit;
1338 }
1339
1340 0 soap_fault.faultcode = "Server";
1341 0 soap_fault.faultstring = globus_error_print_friendly(
1342 globus_error_get(result));
1343 0 result = GLOBUS_SUCCESS;
1344 0 soap_fault.faultactor = NULL;
1345 0 soap_fault.detail = NULL;
1346 0 result = globus_service_session_serialize_fault_response(
1347 callback_handle->message, &soap_fault);
1348 0 if(result != GLOBUS_SUCCESS)
1349 {
1350 0 goto exit;
1351 }
1352
1353 0 globus_soap_message_handle_set_attr(
1354 callback_handle->message,
1355 WSADDR_ACTION_RESPONSE_KEY,
1356 globus_soap_message_attr_copy_string,
1357 globus_libc_free,
1358 WSADDRESSING_FAULT_NS);
1359 }
1360 else
1361 {
1362 1 result = globus_service_session_begin_response(
1363 callback_handle->message);
1364 1 if(result != GLOBUS_SUCCESS)
1365 {
1366 0 goto exit;
1367 }
1368
1369 1 element_qname.local = "SubscribeResponse";
1370 1 element_qname.Namespace = "http://docs.oasis-open.org/wsn/b-2";
1371
1372 1 result = wsnt_SubscribeResponseType_serialize(
1373 &element_qname,
1374 &output,
1375 callback_handle->message,
1376 GLOBUS_XSD_ELEMENT_SET_DEFAULT_NS);
1377 1 if(result != GLOBUS_SUCCESS)
1378 {
1379 0 goto exit;
1380 }
1381
1382 1 result = globus_service_session_end_response(
1383 callback_handle->message);
1384 1 if(result != GLOBUS_SUCCESS)
1385 {
1386 0 goto exit;
1387 }
1388
1389 1 wsnt_SubscribeResponseType_destroy_contents(
1390 &output);
1391
1392 1 globus_soap_message_handle_set_attr(
1393 callback_handle->message,
1394 WSADDR_ACTION_RESPONSE_KEY,
1395 globus_soap_message_attr_copy_string,
1396 globus_libc_free,
1397 "http://docs.oasis-open.org/wsn/bw-2/NotificationProducer/SubscribeResponse");
1398 }
1399
1400 1 exit:
1401
1402 1 callback_handle->callback(
1403 result,
1404 callback_handle->args);
1405
1406 1 globus_libc_free(callback_handle);
1407
1408 1 SecureCounterServiceDebugExit();
1409 1 }
1410
1411 static
1412 globus_result_t
1413 Subscribe_invoke(
1414 globus_service_engine_t engine,
1415 globus_soap_message_handle_t message,
1416 globus_service_response_t * response,
1417 globus_operation_invoke_callback_func_t invoke_callback,
1418 void * args)
1419 1 {
1420 Subscribe_callback_handle_t * callback_handle;
1421 1 globus_result_t result = GLOBUS_SUCCESS;
1422 GlobusFuncName(CounterPortType_Subscribe);
1423 1 SecureCounterServiceDebugEnter();
1424
1425 1 callback_handle = malloc(sizeof(Subscribe_callback_handle_t));
1426 1 if(!callback_handle)
1427 {
1428 0 result = GlobusSoapMessageErrorOutOfMemory;
1429 0 goto exit;
1430 }
1431 1 callback_handle->engine = engine;
1432 1 callback_handle->message = message;
1433 1 callback_handle->callback = invoke_callback;
1434 1 callback_handle->args = args;
1435
1436 1 result = globus_callback_register_oneshot(
1437 NULL,
1438 &globus_i_reltime_zero,
1439 Subscribe_invoke_callback,
1440 callback_handle);
1441
1442 1 exit:
1443 1 SecureCounterServiceDebugExit();
1444 1 return result;
1445 }
1446
1447 static
1448 globus_service_operation_descriptor_t
1449 Subscribe_operation_descriptor =
1450 {
1451 Subscribe_deserialize,
1452 Subscribe_invoke,
1453 };
1454
1455 static
1456 globus_operation_provider_descriptor_t Subscribe_descriptor =
1457 {
1458 &CounterPortType_Subscribe_op_qname,
1459 "Subscribe",
1460 (void *)CounterPortType_Subscribe_impl,
1461 NULL
1462 };
1463
1464
1465 xsd_QName CounterPortType_GetMultipleResourceProperties_op_qname =
1466 {
1467 "http://localhost:8080/wsrf/services/SecureCounterService"
1468 "GetMultipleResourceProperties"
1469 };
1470
1471 xsd_QName CounterPortType_GetMultipleResourceProperties_input_qname =
1472 {
1473 "http://docs.oasis-open.org/wsrf/rp-2",
1474 "GetMultipleResourceProperties"
1475 };
1476
1477 typedef globus_result_t (* GetMultipleResourceProperties_invoke_func_t) (
1478 globus_service_engine_t engine,
1479 globus_soap_message_handle_t message,
1480 globus_service_descriptor_t * descriptor,
1481 wsrp_GetMultipleResourcePropertiesType * input,
1482 wsrp_GetMultipleResourcePropertiesResponseType * output,
1483 xsd_any * fault);
1484
1485 typedef struct GetMultipleResourceProperties_callback_handle_s
1486 {
1487 globus_service_engine_t engine;
1488 globus_soap_message_handle_t message;
1489 globus_operation_invoke_callback_func_t callback;
1490 void * args;
1491 } GetMultipleResourceProperties_callback_handle_t;
1492
1493 static
1494 void
1495 GetMultipleResourceProperties_deserialize_callback(
1496 void * handle)
1497 0 {
1498 GetMultipleResourceProperties_callback_handle_t * callback_handle;
1499 0 globus_result_t result = GLOBUS_SUCCESS;
1500 struct globus_soap_message_fault_s soap_fault;
1501 GetMultipleResourceProperties_invoke_func_t invoke_function;
1502 0 wsrp_GetMultipleResourcePropertiesType * input = NULL;
1503 GlobusFuncName(GetMultipleResourceProperties_deserialize_callback);
1504 0 SecureCounterServiceDebugEnter();
1505
1506 0 callback_handle = (GetMultipleResourceProperties_callback_handle_t *) handle;
1507
1508 0 result = globus_operation_table_get_operation(
1509 SecureCounterService_descriptor.operations,
1510 "GetMultipleResourceProperties",
1511 (void **)&invoke_function);
1512 0 if(result != GLOBUS_SUCCESS)
1513 {
1514 0 goto exit;
1515 }
1516
1517 0 result = wsrp_GetMultipleResourcePropertiesType_init(
1518 &input);
1519 0 if(result != GLOBUS_SUCCESS)
1520 {
1521 0 goto exit;
1522 }
1523
1524 0 result = wsrp_GetMultipleResourcePropertiesType_deserialize(
1525 &CounterPortType_GetMultipleResourceProperties_input_qname,
1526 input,
1527 callback_handle->message,
1528 0);
1529 0 if(result != GLOBUS_SUCCESS)
1530 {
1531 0 goto free_exit;
1532 }
1533
1534 0 result = globus_soap_message_handle_set_attr(
1535 callback_handle->message,
1536 "GetMultipleResourcePropertiesOperationInputParameter",
1537 wsrp_GetMultipleResourcePropertiesType_info.copy,
1538 wsrp_GetMultipleResourcePropertiesType_info.destroy,
1539 (void *)input);
1540 if(result != GLOBUS_SUCCESS)
1541 {
1542 0 goto free_exit;
1543 }
1544
1545 0 free_exit:
1546 0 wsrp_GetMultipleResourcePropertiesType_destroy(input);
1547
1548 0 exit:
1549 0 callback_handle->callback(
1550 result,
1551 callback_handle->args);
1552
1553 0 free(callback_handle);
1554 0 SecureCounterServiceDebugExit();
1555 0 }
1556 /* GetMultipleResourceProperties_deserialize_callback() */
1557
1558 static
1559 globus_result_t
1560 GetMultipleResourceProperties_deserialize(
1561 globus_service_engine_t engine,
1562 globus_soap_message_handle_t message,
1563 globus_operation_invoke_callback_func_t invoke_callback,
1564 void * args)
1565 0 {
1566 GetMultipleResourceProperties_callback_handle_t * callback_handle;
1567 0 globus_result_t result = GLOBUS_SUCCESS;
1568 GlobusFuncName(GetMultipleResourceProperties_deserialize);
1569 0 SecureCounterServiceDebugEnter();
1570
1571 0 callback_handle = malloc(sizeof(GetMultipleResourceProperties_callback_handle_t));
1572 0 globus_assert_string(callback_handle,
1573 "Memory allocation failed "
1574 "for GetMultipleResourceProperties callback handle");
1575
1576 0 callback_handle->engine = engine;
1577 0 callback_handle->message = message;
1578 0 callback_handle->callback = invoke_callback;
1579 0 callback_handle->args = args;
1580
1581 0 result = globus_callback_register_oneshot(
1582 NULL,
1583 &globus_i_reltime_zero,
1584 GetMultipleResourceProperties_deserialize_callback,
1585 callback_handle);
1586
1587 0 SecureCounterServiceDebugExit();
1588 0 return result;
1589 }
1590
1591 static
1592 void
1593 GetMultipleResourceProperties_invoke_callback(
1594 void * handle)
1595 0 {
1596 GetMultipleResourceProperties_callback_handle_t * callback_handle;
1597 0 globus_result_t result = GLOBUS_SUCCESS;
1598 struct globus_soap_message_fault_s soap_fault;
1599 GetMultipleResourceProperties_invoke_func_t invoke_function;
1600 wsrp_GetMultipleResourcePropertiesType * input;
1601 wsrp_GetMultipleResourcePropertiesResponseType output;
1602 xsd_QName element_qname;
1603 xsd_any fault;
1604
1605 GlobusFuncName(GetMultipleResourceProperties_invoke_callback);
1606 0 SecureCounterServiceDebugEnter();
1607
1608 0 callback_handle = (GetMultipleResourceProperties_callback_handle_t *) handle;
1609
1610 0 input = globus_soap_message_handle_get_attr(
1611 callback_handle->message,
1612 "GetMultipleResourcePropertiesOperationInputParameter");
1613 0 globus_assert(input);
1614
1615 0 result = globus_operation_table_get_operation(
1616 SecureCounterService_descriptor.operations,
1617 "GetMultipleResourceProperties",
1618 (void **)&invoke_function);
1619 0 if(result != GLOBUS_SUCCESS)
1620 {
1621 0 goto fault_exit;
1622 }
1623
1624
1625 0 result = wsrp_GetMultipleResourcePropertiesResponseType_init_contents(
1626 &output);
1627 0 if(result != GLOBUS_SUCCESS)
1628 {
1629 0 goto fault_exit;
1630 }
1631 0 result = xsd_any_init_contents(&fault);
1632 0 if(result != GLOBUS_SUCCESS)
1633 {
1634 0 goto fault_exit;
1635 }
1636 0 result = invoke_function(
1637 callback_handle->engine,
1638 callback_handle->message,
1639 &SecureCounterService_descriptor,
1640 input,
1641 &output,
1642 &fault);
1643
1644
1645 0 fault_exit:
1646
1647 0 if(fault.value && fault.element)
1648 {
1649 0 result = globus_service_session_begin_response(
1650 callback_handle->message);
1651 0 if(result != GLOBUS_SUCCESS)
1652 {
1653 0 goto exit;
1654 }
1655
1656 0 soap_fault.faultcode = "Server";
1657 0 soap_fault.faultstring =
1658 "An error occurred while processing the message";
1659 0 soap_fault.faultactor = NULL;
1660 0 soap_fault.detail = &fault;
1661
1662 0 result = globus_service_session_serialize_fault_response(
1663 callback_handle->message, &soap_fault);
1664 0 if(result != GLOBUS_SUCCESS)
1665 {
1666 0 goto exit;
1667 }
1668
1669 0 xsd_any_destroy_contents(soap_fault.detail);
1670
1671 0 globus_soap_message_handle_set_attr(
1672 callback_handle->message,
1673 WSADDR_ACTION_RESPONSE_KEY,
1674 globus_soap_message_attr_copy_string,
1675 globus_libc_free,
1676 WSADDRESSING_FAULT_NS);
1677 }
1678 0 else if(result != GLOBUS_SUCCESS)
1679 {
1680 globus_result_t local_result;
1681 0 local_result = globus_service_session_begin_response(
1682 callback_handle->message);
1683 0 if(local_result != GLOBUS_SUCCESS)
1684 {
1685 0 result = local_result;
1686 0 goto exit;
1687 }
1688
1689 0 soap_fault.faultcode = "Server";
1690 0 soap_fault.faultstring = globus_error_print_friendly(
1691 globus_error_get(result));
1692 0 result = GLOBUS_SUCCESS;
1693 0 soap_fault.faultactor = NULL;
1694 0 soap_fault.detail = NULL;
1695 0 result = globus_service_session_serialize_fault_response(
1696 callback_handle->message, &soap_fault);
1697 0 if(result != GLOBUS_SUCCESS)
1698 {
1699 0 goto exit;
1700 }
1701
1702 0 globus_soap_message_handle_set_attr(
1703 callback_handle->message,
1704 WSADDR_ACTION_RESPONSE_KEY,
1705 globus_soap_message_attr_copy_string,
1706 globus_libc_free,
1707 WSADDRESSING_FAULT_NS);
1708 }
1709 else
1710 {
1711 0 result = globus_service_session_begin_response(
1712 callback_handle->message);
1713 0 if(result != GLOBUS_SUCCESS)
1714 {
1715 0 goto exit;
1716 }
1717
1718 0 element_qname.local = "GetMultipleResourcePropertiesResponse";
1719 0 element_qname.Namespace = "http://docs.oasis-open.org/wsrf/rp-2";
1720
1721 0 result = wsrp_GetMultipleResourcePropertiesResponseType_serialize(
1722 &element_qname,
1723 &output,
1724 callback_handle->message,
1725 GLOBUS_XSD_ELEMENT_SET_DEFAULT_NS);
1726 0 if(result != GLOBUS_SUCCESS)
1727 {
1728 0 goto exit;
1729 }
1730
1731 0 result = globus_service_session_end_response(
1732 callback_handle->message);
1733 0 if(result != GLOBUS_SUCCESS)
1734 {
1735 0 goto exit;
1736 }
1737
1738 0 wsrp_GetMultipleResourcePropertiesResponseType_destroy_contents(
1739 &output);
1740
1741 0 globus_soap_message_handle_set_attr(
1742 callback_handle->message,
1743 WSADDR_ACTION_RESPONSE_KEY,
1744 globus_soap_message_attr_copy_string,
1745 globus_libc_free,
1746 "http://docs.oasis-open.org/wsrf/rpw-2/GetMultipleResourceProperties/GetMultipleResourcePropertiesResponse");
1747 }
1748
1749 0 exit:
1750
1751 0 callback_handle->callback(
1752 result,
1753 callback_handle->args);
1754
1755 0 globus_libc_free(callback_handle);
1756
1757 0 SecureCounterServiceDebugExit();
1758 0 }
1759
1760 static
1761 globus_result_t
1762 GetMultipleResourceProperties_invoke(
1763 globus_service_engine_t engine,
1764 globus_soap_message_handle_t message,
1765 globus_service_response_t * response,
1766 globus_operation_invoke_callback_func_t invoke_callback,
1767 void * args)
1768 0 {
1769 GetMultipleResourceProperties_callback_handle_t * callback_handle;
1770 0 globus_result_t result = GLOBUS_SUCCESS;
1771 GlobusFuncName(CounterPortType_GetMultipleResourceProperties);
1772 0 SecureCounterServiceDebugEnter();
1773
1774 0 callback_handle = malloc(sizeof(GetMultipleResourceProperties_callback_handle_t));
1775 0 if(!callback_handle)
1776 {
1777 0 result = GlobusSoapMessageErrorOutOfMemory;
1778 0 goto exit;
1779 }
1780 0 callback_handle->engine = engine;
1781 0 callback_handle->message = message;
1782 0 callback_handle->callback = invoke_callback;
1783 0 callback_handle->args = args;
1784
1785 0 result = globus_callback_register_oneshot(
1786 NULL,
1787 &globus_i_reltime_zero,
1788 GetMultipleResourceProperties_invoke_callback,
1789 callback_handle);
1790
1791 0 exit:
1792 0 SecureCounterServiceDebugExit();
1793 0 return result;
1794 }
1795
1796 static
1797 globus_service_operation_descriptor_t
1798 GetMultipleResourceProperties_operation_descriptor =
1799 {
1800 GetMultipleResourceProperties_deserialize,
1801 GetMultipleResourceProperties_invoke,
1802 };
1803
1804 static
1805 globus_operation_provider_descriptor_t GetMultipleResourceProperties_descriptor =
1806 {
1807 &CounterPortType_GetMultipleResourceProperties_op_qname,
1808 "GetMultipleResourceProperties",
1809 (void *)CounterPortType_GetMultipleResourceProperties_impl,
1810 NULL
1811 };
1812
1813
1814 xsd_QName CounterPortType_QueryResourceProperties_op_qname =
1815 {
1816 "http://localhost:8080/wsrf/services/SecureCounterService"
1817 "QueryResourceProperties"
1818 };
1819
1820 xsd_QName CounterPortType_QueryResourceProperties_input_qname =
1821 {
1822 "http://docs.oasis-open.org/wsrf/rp-2",
1823 "QueryResourceProperties"
1824 };
1825
1826 typedef globus_result_t (* QueryResourceProperties_invoke_func_t) (
1827 globus_service_engine_t engine,
1828 globus_soap_message_handle_t message,
1829 globus_service_descriptor_t * descriptor,
1830 wsrp_QueryResourcePropertiesType * input,
1831 wsrp_QueryResourcePropertiesResponseType * output,
1832 xsd_any * fault);
1833
1834 typedef struct QueryResourceProperties_callback_handle_s
1835 {
1836 globus_service_engine_t engine;
1837 globus_soap_message_handle_t message;
1838 globus_operation_invoke_callback_func_t callback;
1839 void * args;
1840 } QueryResourceProperties_callback_handle_t;
1841
1842 static
1843 void
1844 QueryResourceProperties_deserialize_callback(
1845 void * handle)
1846 0 {
1847 QueryResourceProperties_callback_handle_t * callback_handle;
1848 0 globus_result_t result = GLOBUS_SUCCESS;
1849 struct globus_soap_message_fault_s soap_fault;
1850 QueryResourceProperties_invoke_func_t invoke_function;
1851 0 wsrp_QueryResourcePropertiesType * input = NULL;
1852 GlobusFuncName(QueryResourceProperties_deserialize_callback);
1853 0 SecureCounterServiceDebugEnter();
1854
1855 0 callback_handle = (QueryResourceProperties_callback_handle_t *) handle;
1856
1857 0 result = globus_operation_table_get_operation(
1858 SecureCounterService_descriptor.operations,
1859 "QueryResourceProperties",
1860 (void **)&invoke_function);
1861 0 if(result != GLOBUS_SUCCESS)
1862 {
1863 0 goto exit;
1864 }
1865
1866 0 result = wsrp_QueryResourcePropertiesType_init(
1867 &input);
1868 0 if(result != GLOBUS_SUCCESS)
1869 {
1870 0 goto exit;
1871 }
1872
1873 0 result = wsrp_QueryResourcePropertiesType_deserialize(
1874 &CounterPortType_QueryResourceProperties_input_qname,
1875 input,
1876 callback_handle->message,
1877 0);
1878 0 if(result != GLOBUS_SUCCESS)
1879 {
1880 0 goto free_exit;
1881 }
1882
1883 0 result = globus_soap_message_handle_set_attr(
1884 callback_handle->message,
1885 "QueryResourcePropertiesOperationInputParameter",
1886 wsrp_QueryResourcePropertiesType_info.copy,
1887 wsrp_QueryResourcePropertiesType_info.destroy,
1888 (void *)input);
1889 if(result != GLOBUS_SUCCESS)
1890 {
1891 0 goto free_exit;
1892 }
1893
1894 0 free_exit:
1895 0 wsrp_QueryResourcePropertiesType_destroy(input);
1896
1897 0 exit:
1898 0 callback_handle->callback(
1899 result,
1900 callback_handle->args);
1901
1902 0 free(callback_handle);
1903 0 SecureCounterServiceDebugExit();
1904 0 }
1905 /* QueryResourceProperties_deserialize_callback() */
1906
1907 static
1908 globus_result_t
1909 QueryResourceProperties_deserialize(
1910 globus_service_engine_t engine,
1911 globus_soap_message_handle_t message,
1912 globus_operation_invoke_callback_func_t invoke_callback,
1913 void * args)
1914 0 {
1915 QueryResourceProperties_callback_handle_t * callback_handle;
1916 0 globus_result_t result = GLOBUS_SUCCESS;
1917 GlobusFuncName(QueryResourceProperties_deserialize);
1918 0 SecureCounterServiceDebugEnter();
1919
1920 0 callback_handle = malloc(sizeof(QueryResourceProperties_callback_handle_t));
1921 0 globus_assert_string(callback_handle,
1922 "Memory allocation failed "
1923 "for QueryResourceProperties callback handle");
1924
1925 0 callback_handle->engine = engine;
1926 0 callback_handle->message = message;
1927 0 callback_handle->callback = invoke_callback;
1928 0 callback_handle->args = args;
1929
1930 0 result = globus_callback_register_oneshot(
1931 NULL,
1932 &globus_i_reltime_zero,
1933 QueryResourceProperties_deserialize_callback,
1934 callback_handle);
1935
1936 0 SecureCounterServiceDebugExit();
1937 0 return result;
1938 }
1939
1940 static
1941 void
1942 QueryResourceProperties_invoke_callback(
1943 void * handle)
1944 0 {
1945 QueryResourceProperties_callback_handle_t * callback_handle;
1946 0 globus_result_t result = GLOBUS_SUCCESS;
1947 struct globus_soap_message_fault_s soap_fault;
1948 QueryResourceProperties_invoke_func_t invoke_function;
1949 wsrp_QueryResourcePropertiesType * input;
1950 wsrp_QueryResourcePropertiesResponseType output;
1951 xsd_QName element_qname;
1952 xsd_any fault;
1953
1954 GlobusFuncName(QueryResourceProperties_invoke_callback);
1955 0 SecureCounterServiceDebugEnter();
1956
1957 0 callback_handle = (QueryResourceProperties_callback_handle_t *) handle;
1958
1959 0 input = globus_soap_message_handle_get_attr(
1960 callback_handle->message,
1961 "QueryResourcePropertiesOperationInputParameter");
1962 0 globus_assert(input);
1963
1964 0 result = globus_operation_table_get_operation(
1965 SecureCounterService_descriptor.operations,
1966 "QueryResourceProperties",
1967 (void **)&invoke_function);
1968 0 if(result != GLOBUS_SUCCESS)
1969 {
1970 0 goto fault_exit;
1971 }
1972
1973
1974 0 result = wsrp_QueryResourcePropertiesResponseType_init_contents(
1975 &output);
1976 0 if(result != GLOBUS_SUCCESS)
1977 {
1978 0 goto fault_exit;
1979 }
1980 0 result = xsd_any_init_contents(&fault);
1981 0 if(result != GLOBUS_SUCCESS)
1982 {
1983 0 goto fault_exit;
1984 }
1985 0 result = invoke_function(
1986 callback_handle->engine,
1987 callback_handle->message,
1988 &SecureCounterService_descriptor,
1989 input,
1990 &output,
1991 &fault);
1992
1993
1994 0 fault_exit:
1995
1996 0 if(fault.value && fault.element)
1997 {
1998 0 result = globus_service_session_begin_response(
1999 callback_handle->message);
2000 0 if(result != GLOBUS_SUCCESS)
2001 {
2002 0 goto exit;
2003 }
2004
2005 0 soap_fault.faultcode = "Server";
2006 0 soap_fault.faultstring =
2007 "An error occurred while processing the message";
2008 0 soap_fault.faultactor = NULL;
2009 0 soap_fault.detail = &fault;
2010
2011 0 result = globus_service_session_serialize_fault_response(
2012 callback_handle->message, &soap_fault);
2013 0 if(result != GLOBUS_SUCCESS)
2014 {
2015 0 goto exit;
2016 }
2017
2018 0 xsd_any_destroy_contents(soap_fault.detail);
2019
2020 0 globus_soap_message_handle_set_attr(
2021 callback_handle->message,
2022 WSADDR_ACTION_RESPONSE_KEY,
2023 globus_soap_message_attr_copy_string,
2024 globus_libc_free,
2025 WSADDRESSING_FAULT_NS);
2026 }
2027 0 else if(result != GLOBUS_SUCCESS)
2028 {
2029 globus_result_t local_result;
2030 0 local_result = globus_service_session_begin_response(
2031 callback_handle->message);
2032 0 if(local_result != GLOBUS_SUCCESS)
2033 {
2034 0 result = local_result;
2035 0 goto exit;
2036 }
2037
2038 0 soap_fault.faultcode = "Server";
2039 0 soap_fault.faultstring = globus_error_print_friendly(
2040 globus_error_get(result));
2041 0 result = GLOBUS_SUCCESS;
2042 0 soap_fault.faultactor = NULL;
2043 0 soap_fault.detail = NULL;
2044 0 result = globus_service_session_serialize_fault_response(
2045 callback_handle->message, &soap_fault);
2046 0 if(result != GLOBUS_SUCCESS)
2047 {
2048 0 goto exit;
2049 }
2050
2051 0 globus_soap_message_handle_set_attr(
2052 callback_handle->message,
2053 WSADDR_ACTION_RESPONSE_KEY,
2054 globus_soap_message_attr_copy_string,
2055 globus_libc_free,
2056 WSADDRESSING_FAULT_NS);
2057 }
2058 else
2059 {
2060 0 result = globus_service_session_begin_response(
2061 callback_handle->message);
2062 0 if(result != GLOBUS_SUCCESS)
2063 {
2064 0 goto exit;
2065 }
2066
2067 0 element_qname.local = "QueryResourcePropertiesResponse";
2068 0 element_qname.Namespace = "http://docs.oasis-open.org/wsrf/rp-2";
2069
2070 0 result = wsrp_QueryResourcePropertiesResponseType_serialize(
2071 &element_qname,
2072 &output,
2073 callback_handle->message,
2074 GLOBUS_XSD_ELEMENT_SET_DEFAULT_NS);
2075 0 if(result != GLOBUS_SUCCESS)
2076 {
2077 0 goto exit;
2078 }
2079
2080 0 result = globus_service_session_end_response(
2081 callback_handle->message);
2082 0 if(result != GLOBUS_SUCCESS)
2083 {
2084 0 goto exit;
2085 }
2086
2087 0 wsrp_QueryResourcePropertiesResponseType_destroy_contents(
2088 &output);
2089
2090 0 globus_soap_message_handle_set_attr(
2091 callback_handle->message,
2092 WSADDR_ACTION_RESPONSE_KEY,
2093 globus_soap_message_attr_copy_string,
2094 globus_libc_free,
2095 "http://docs.oasis-open.org/wsrf/rpw-2/QueryResourceProperties/QueryResourcePropertiesResponse");
2096 }
2097
2098 0 exit:
2099
2100 0 callback_handle->callback(
2101 result,
2102 callback_handle->args);
2103
2104 0 globus_libc_free(callback_handle);
2105
2106 0 SecureCounterServiceDebugExit();
2107 0 }
2108
2109 static
2110 globus_result_t
2111 QueryResourceProperties_invoke(
2112 globus_service_engine_t engine,
2113 globus_soap_message_handle_t message,
2114 globus_service_response_t * response,
2115 globus_operation_invoke_callback_func_t invoke_callback,
2116 void * args)
2117 0 {
2118 QueryResourceProperties_callback_handle_t * callback_handle;
2119 0 globus_result_t result = GLOBUS_SUCCESS;
2120 GlobusFuncName(CounterPortType_QueryResourceProperties);
2121 0 SecureCounterServiceDebugEnter();
2122
2123 0 callback_handle = malloc(sizeof(QueryResourceProperties_callback_handle_t));
2124 0 if(!callback_handle)
2125 {
2126 0 result = GlobusSoapMessageErrorOutOfMemory;
2127 0 goto exit;
2128 }
2129 0 callback_handle->engine = engine;
2130 0 callback_handle->message = message;
2131 0 callback_handle->callback = invoke_callback;
2132 0 callback_handle->args = args;
2133
2134 0 result = globus_callback_register_oneshot(
2135 NULL,
2136 &globus_i_reltime_zero,
2137 QueryResourceProperties_invoke_callback,
2138 callback_handle);
2139
2140 0 exit:
2141 0 SecureCounterServiceDebugExit();
2142 0 return result;
2143 }
2144
2145 static
2146 globus_service_operation_descriptor_t
2147 QueryResourceProperties_operation_descriptor =
2148 {
2149 QueryResourceProperties_deserialize,
2150 QueryResourceProperties_invoke,
2151 };
2152
2153 static
2154 globus_operation_provider_descriptor_t QueryResourceProperties_descriptor =
2155 {
2156 &CounterPortType_QueryResourceProperties_op_qname,
2157 "QueryResourceProperties",
2158 (void *)CounterPortType_QueryResourceProperties_impl,
2159 NULL
2160 };
2161
2162
2163 xsd_QName CounterPortType_GetResourceProperty_op_qname =
2164 {
2165 "http://localhost:8080/wsrf/services/SecureCounterService"
2166 "GetResourceProperty"
2167 };
2168
2169 xsd_QName CounterPortType_GetResourceProperty_input_qname =
2170 {
2171 "http://docs.oasis-open.org/wsrf/rp-2",
2172 "GetResourceProperty"
2173 };
2174
2175 typedef globus_result_t (* GetResourceProperty_invoke_func_t) (
2176 globus_service_engine_t engine,
2177 globus_soap_message_handle_t message,
2178 globus_service_descriptor_t * descriptor,
2179 xsd_QName * input,
2180 wsrp_GetResourcePropertyResponseType * output,
2181 xsd_any * fault);
2182
2183 typedef struct GetResourceProperty_callback_handle_s
2184 {
2185 globus_service_engine_t engine;
2186 globus_soap_message_handle_t message;
2187 globus_operation_invoke_callback_func_t callback;
2188 void * args;
2189 } GetResourceProperty_callback_handle_t;
2190
2191 static
2192 void
2193 GetResourceProperty_deserialize_callback(
2194 void * handle)
2195 0 {
2196 GetResourceProperty_callback_handle_t * callback_handle;
2197 0 globus_result_t result = GLOBUS_SUCCESS;
2198 struct globus_soap_message_fault_s soap_fault;
2199 GetResourceProperty_invoke_func_t invoke_function;
2200 0 xsd_QName * input = NULL;
2201 GlobusFuncName(GetResourceProperty_deserialize_callback);
2202 0 SecureCounterServiceDebugEnter();
2203
2204 0 callback_handle = (GetResourceProperty_callback_handle_t *) handle;
2205
2206 0 result = globus_operation_table_get_operation(
2207 SecureCounterService_descriptor.operations,
2208 "GetResourceProperty",
2209 (void **)&invoke_function);
2210 0 if(result != GLOBUS_SUCCESS)
2211 {
2212 0 goto exit;
2213 }
2214
2215 0 result = xsd_QName_init(
2216 &input);
2217 0 if(result != GLOBUS_SUCCESS)
2218 {
2219 0 goto exit;
2220 }
2221
2222 0 result = xsd_QName_deserialize(
2223 &CounterPortType_GetResourceProperty_input_qname,
2224 input,
2225 callback_handle->message,
2226 0);
2227 0 if(result != GLOBUS_SUCCESS)
2228 {
2229 0 goto free_exit;
2230 }
2231
2232 0 result = globus_soap_message_handle_set_attr(
2233 callback_handle->message,
2234 "GetResourcePropertyOperationInputParameter",
2235 xsd_QName_info.copy,
2236 xsd_QName_info.destroy,
2237 (void *)input);
2238 if(result != GLOBUS_SUCCESS)
2239 {
2240 0 goto free_exit;
2241 }
2242
2243 0 free_exit:
2244 0 xsd_QName_destroy(input);
2245
2246 0 exit:
2247 0 callback_handle->callback(
2248 result,
2249 callback_handle->args);
2250
2251 0 free(callback_handle);
2252 0 SecureCounterServiceDebugExit();
2253 0 }
2254 /* GetResourceProperty_deserialize_callback() */
2255
2256 static
2257 globus_result_t
2258 GetResourceProperty_deserialize(
2259 globus_service_engine_t engine,
2260 globus_soap_message_handle_t message,
2261 globus_operation_invoke_callback_func_t invoke_callback,
2262 void * args)
2263 0 {
2264 GetResourceProperty_callback_handle_t * callback_handle;
2265 0 globus_result_t result = GLOBUS_SUCCESS;
2266 GlobusFuncName(GetResourceProperty_deserialize);
2267 0 SecureCounterServiceDebugEnter();
2268
2269 0 callback_handle = malloc(sizeof(GetResourceProperty_callback_handle_t));
2270 0 globus_assert_string(callback_handle,
2271 "Memory allocation failed "
2272 "for GetResourceProperty callback handle");
2273
2274 0 callback_handle->engine = engine;
2275 0 callback_handle->message = message;
2276 0 callback_handle->callback = invoke_callback;
2277 0 callback_handle->args = args;
2278
2279 0 result = globus_callback_register_oneshot(
2280 NULL,
2281 &globus_i_reltime_zero,
2282 GetResourceProperty_deserialize_callback,
2283 callback_handle);
2284
2285 0 SecureCounterServiceDebugExit();
2286 0 return result;
2287 }
2288
2289 static
2290 void
2291 GetResourceProperty_invoke_callback(
2292 void * handle)
2293 0 {
2294 GetResourceProperty_callback_handle_t * callback_handle;
2295 0 globus_result_t result = GLOBUS_SUCCESS;
2296 struct globus_soap_message_fault_s soap_fault;
2297 GetResourceProperty_invoke_func_t invoke_function;
2298 xsd_QName * input;
2299 wsrp_GetResourcePropertyResponseType output;
2300 xsd_QName element_qname;
2301 xsd_any fault;
2302
2303 GlobusFuncName(GetResourceProperty_invoke_callback);
2304 0 SecureCounterServiceDebugEnter();
2305
2306 0 callback_handle = (GetResourceProperty_callback_handle_t *) handle;
2307
2308 0 input = globus_soap_message_handle_get_attr(
2309 callback_handle->message,
2310 "GetResourcePropertyOperationInputParameter");
2311 0 globus_assert(input);
2312
2313 0 result = globus_operation_table_get_operation(
2314 SecureCounterService_descriptor.operations,
2315 "GetResourceProperty",
2316 (void **)&invoke_function);
2317 0 if(result != GLOBUS_SUCCESS)
2318 {
2319 0 goto fault_exit;
2320 }
2321
2322
2323 0 result = wsrp_GetResourcePropertyResponseType_init_contents(
2324 &output);
2325 0 if(result != GLOBUS_SUCCESS)
2326 {
2327 0 goto fault_exit;
2328 }
2329 0 result = xsd_any_init_contents(&fault);
2330 0 if(result != GLOBUS_SUCCESS)
2331 {
2332 0 goto fault_exit;
2333 }
2334 0 result = invoke_function(
2335 callback_handle->engine,
2336 callback_handle->message,
2337 &SecureCounterService_descriptor,
2338 input,
2339 &output,
2340 &fault);
2341
2342
2343 0 fault_exit:
2344
2345 0 if(fault.value && fault.element)
2346 {
2347 0 result = globus_service_session_begin_response(
2348 callback_handle->message);
2349 0 if(result != GLOBUS_SUCCESS)
2350 {
2351 0 goto exit;
2352 }
2353
2354 0 soap_fault.faultcode = "Server";
2355 0 soap_fault.faultstring =
2356 "An error occurred while processing the message";
2357 0 soap_fault.faultactor = NULL;
2358 0 soap_fault.detail = &fault;
2359
2360 0 result = globus_service_session_serialize_fault_response(
2361 callback_handle->message, &soap_fault);
2362 0 if(result != GLOBUS_SUCCESS)
2363 {
2364 0 goto exit;
2365 }
2366
2367 0 xsd_any_destroy_contents(soap_fault.detail);
2368
2369 0 globus_soap_message_handle_set_attr(
2370 callback_handle->message,
2371 WSADDR_ACTION_RESPONSE_KEY,
2372 globus_soap_message_attr_copy_string,
2373 globus_libc_free,
2374 WSADDRESSING_FAULT_NS);
2375 }
2376 0 else if(result != GLOBUS_SUCCESS)
2377 {
2378 globus_result_t local_result;
2379 0 local_result = globus_service_session_begin_response(
2380 callback_handle->message);
2381 0 if(local_result != GLOBUS_SUCCESS)
2382 {
2383 0 result = local_result;
2384 0 goto exit;
2385 }
2386
2387 0 soap_fault.faultcode = "Server";
2388 0 soap_fault.faultstring = globus_error_print_friendly(
2389 globus_error_get(result));
2390 0 result = GLOBUS_SUCCESS;
2391 0 soap_fault.faultactor = NULL;
2392 0 soap_fault.detail = NULL;
2393 0 result = globus_service_session_serialize_fault_response(
2394 callback_handle->message, &soap_fault);
2395 0 if(result != GLOBUS_SUCCESS)
2396 {
2397 0 goto exit;
2398 }
2399
2400 0 globus_soap_message_handle_set_attr(
2401 callback_handle->message,
2402 WSADDR_ACTION_RESPONSE_KEY,
2403 globus_soap_message_attr_copy_string,
2404 globus_libc_free,
2405 WSADDRESSING_FAULT_NS);
2406 }
2407 else
2408 {
2409 0 result = globus_service_session_begin_response(
2410 callback_handle->message);
2411 0 if(result != GLOBUS_SUCCESS)
2412 {
2413 0 goto exit;
2414 }
2415
2416 0 element_qname.local = "GetResourcePropertyResponse";
2417 0 element_qname.Namespace = "http://docs.oasis-open.org/wsrf/rp-2";
2418
2419 0 result = wsrp_GetResourcePropertyResponseType_serialize(
2420 &element_qname,
2421 &output,
2422 callback_handle->message,
2423 GLOBUS_XSD_ELEMENT_SET_DEFAULT_NS);
2424 0 if(result != GLOBUS_SUCCESS)
2425 {
2426 0 goto exit;
2427 }
2428
2429 0 result = globus_service_session_end_response(
2430 callback_handle->message);
2431 0 if(result != GLOBUS_SUCCESS)
2432 {
2433 0 goto exit;
2434 }
2435
2436 0 wsrp_GetResourcePropertyResponseType_destroy_contents(
2437 &output);
2438
2439 0 globus_soap_message_handle_set_attr(
2440 callback_handle->message,
2441 WSADDR_ACTION_RESPONSE_KEY,
2442 globus_soap_message_attr_copy_string,
2443 globus_libc_free,
2444 "http://docs.oasis-open.org/wsrf/rpw-2/GetResourceProperty/GetResourcePropertyResponse");
2445 }
2446
2447 0 exit:
2448
2449 0 callback_handle->callback(
2450 result,
2451 callback_handle->args);
2452
2453 0 globus_libc_free(callback_handle);
2454
2455 0 SecureCounterServiceDebugExit();
2456 0 }
2457
2458 static
2459 globus_result_t
2460 GetResourceProperty_invoke(
2461 globus_service_engine_t engine,
2462 globus_soap_message_handle_t message,
2463 globus_service_response_t * response,
2464 globus_operation_invoke_callback_func_t invoke_callback,
2465 void * args)
2466 0 {
2467 GetResourceProperty_callback_handle_t * callback_handle;
2468 0 globus_result_t result = GLOBUS_SUCCESS;
2469 GlobusFuncName(CounterPortType_GetResourceProperty);
2470 0 SecureCounterServiceDebugEnter();
2471
2472 0 callback_handle = malloc(sizeof(GetResourceProperty_callback_handle_t));
2473 0 if(!callback_handle)
2474 {
2475 0 result = GlobusSoapMessageErrorOutOfMemory;
2476 0 goto exit;
2477 }
2478 0 callback_handle->engine = engine;
2479 0 callback_handle->message = message;
2480 0 callback_handle->callback = invoke_callback;
2481 0 callback_handle->args = args;
2482
2483 0 result = globus_callback_register_oneshot(
2484 NULL,
2485 &globus_i_reltime_zero,
2486 GetResourceProperty_invoke_callback,
2487 callback_handle);
2488
2489 0 exit:
2490 0 SecureCounterServiceDebugExit();
2491 0 return result;
2492 }
2493
2494 static
2495 globus_service_operation_descriptor_t
2496 GetResourceProperty_operation_descriptor =
2497 {
2498 GetResourceProperty_deserialize,
2499 GetResourceProperty_invoke,
2500 };
2501
2502 static
2503 globus_operation_provider_descriptor_t GetResourceProperty_descriptor =
2504 {
2505 &CounterPortType_GetResourceProperty_op_qname,
2506 "GetResourceProperty",
2507 (void *)CounterPortType_GetResourceProperty_impl,
2508 NULL
2509 };
2510
2511
2512 xsd_QName CounterPortType_add_op_qname =
2513 {
2514 "http://localhost:8080/wsrf/services/SecureCounterService"
2515 "add"
2516 };
2517
2518 xsd_QName CounterPortType_add_input_qname =
2519 {
2520 "http://counter.com",
2521 "add"
2522 };
2523
2524 typedef globus_result_t (* add_invoke_func_t) (
2525 globus_service_engine_t engine,
2526 globus_soap_message_handle_t message,
2527 globus_service_descriptor_t * descriptor,
2528 xsd_int * input,
2529 xsd_int * output,
2530 xsd_any * fault);
2531
2532 typedef struct add_callback_handle_s
2533 {
2534 globus_service_engine_t engine;
2535 globus_soap_message_handle_t message;
2536 globus_operation_invoke_callback_func_t callback;
2537 void * args;
2538 } add_callback_handle_t;
2539
2540 static
2541 void
2542 add_deserialize_callback(
2543 void * handle)
2544 1 {
2545 add_callback_handle_t * callback_handle;
2546 1 globus_result_t result = GLOBUS_SUCCESS;
2547 struct globus_soap_message_fault_s soap_fault;
2548 add_invoke_func_t invoke_function;
2549 1 xsd_int * input = NULL;
2550 GlobusFuncName(add_deserialize_callback);
2551 1 SecureCounterServiceDebugEnter();
2552
2553 1 callback_handle = (add_callback_handle_t *) handle;
2554
2555 1 result = globus_operation_table_get_operation(
2556 SecureCounterService_descriptor.operations,
2557 "add",
2558 (void **)&invoke_function);
2559 1 if(result != GLOBUS_SUCCESS)
2560 {
2561 0 goto exit;
2562 }
2563
2564 1 result = xsd_int_init(
2565 &input);
2566 1 if(result != GLOBUS_SUCCESS)
2567 {
2568 0 goto exit;
2569 }
2570
2571 1 result = xsd_int_deserialize(
2572 &CounterPortType_add_input_qname,
2573 input,
2574 callback_handle->message,
2575 0);
2576 1 if(result != GLOBUS_SUCCESS)
2577 {
2578 0 goto free_exit;
2579 }
2580
2581 1 result = globus_soap_message_handle_set_attr(
2582 callback_handle->message,
2583 "addOperationInputParameter",
2584 xsd_int_info.copy,
2585 xsd_int_info.destroy,
2586 (void *)input);
2587 if(result != GLOBUS_SUCCESS)
2588 {
2589 1 goto free_exit;
2590 }
2591
2592 1 free_exit:
2593 1 xsd_int_destroy(input);
2594
2595 1 exit:
2596 1 callback_handle->callback(
2597 result,
2598 callback_handle->args);
2599
2600 1 free(callback_handle);
2601 1 SecureCounterServiceDebugExit();
2602 1 }
2603 /* add_deserialize_callback() */
2604
2605 static
2606 globus_result_t
2607 add_deserialize(
2608 globus_service_engine_t engine,
2609 globus_soap_message_handle_t message,
2610 globus_operation_invoke_callback_func_t invoke_callback,
2611 void * args)
2612 1 {
2613 add_callback_handle_t * callback_handle;
2614 1 globus_result_t result = GLOBUS_SUCCESS;
2615 GlobusFuncName(add_deserialize);
2616 1 SecureCounterServiceDebugEnter();
2617
2618 1 callback_handle = malloc(sizeof(add_callback_handle_t));
2619 1 globus_assert_string(callback_handle,
2620 "Memory allocation failed "
2621 "for add callback handle");
2622
2623 1 callback_handle->engine = engine;
2624 1 callback_handle->message = message;
2625 1 callback_handle->callback = invoke_callback;
2626 1 callback_handle->args = args;
2627
2628 1 result = globus_callback_register_oneshot(
2629 NULL,
2630 &globus_i_reltime_zero,
2631 add_deserialize_callback,
2632 callback_handle);
2633
2634 1 SecureCounterServiceDebugExit();
2635 1 return result;
2636 }
2637
2638 static
2639 void
2640 add_invoke_callback(
2641 void * handle)
2642 1 {
2643 add_callback_handle_t * callback_handle;
2644 1 globus_result_t result = GLOBUS_SUCCESS;
2645 struct globus_soap_message_fault_s soap_fault;
2646 add_invoke_func_t invoke_function;
2647 xsd_int * input;
2648 xsd_int output;
2649 xsd_QName element_qname;
2650 xsd_any fault;
2651
2652 GlobusFuncName(add_invoke_callback);
2653 1 SecureCounterServiceDebugEnter();
2654
2655 1 callback_handle = (add_callback_handle_t *) handle;
2656
2657 1 input = globus_soap_message_handle_get_attr(
2658 callback_handle->message,
2659 "addOperationInputParameter");
2660 1 globus_assert(input);
2661
2662 1 result = globus_operation_table_get_operation(
2663 SecureCounterService_descriptor.operations,
2664 "add",
2665 (void **)&invoke_function);
2666 1 if(result != GLOBUS_SUCCESS)
2667 {
2668 0 goto fault_exit;
2669 }
2670
2671
2672 1 result = xsd_int_init_contents(
2673 &output);
2674 1 if(result != GLOBUS_SUCCESS)
2675 {
2676 0 goto fault_exit;
2677 }
2678 1 result = xsd_any_init_contents(&fault);
2679 1 if(result != GLOBUS_SUCCESS)
2680 {
2681 0 goto fault_exit;
2682 }
2683 1 result = invoke_function(
2684 callback_handle->engine,
2685 callback_handle->message,
2686 &SecureCounterService_descriptor,
2687 input,
2688 &output,
2689 &fault);
2690
2691
2692 1 fault_exit:
2693
2694 1 if(fault.value && fault.element)
2695 {
2696 0 result = globus_service_session_begin_response(
2697 callback_handle->message);
2698 0 if(result != GLOBUS_SUCCESS)
2699 {
2700 0 goto exit;
2701 }
2702
2703 0 soap_fault.faultcode = "Server";
2704 0 soap_fault.faultstring =
2705 "An error occurred while processing the message";
2706 0 soap_fault.faultactor = NULL;
2707 0 soap_fault.detail = &fault;
2708
2709 0 result = globus_service_session_serialize_fault_response(
2710 callback_handle->message, &soap_fault);
2711 0 if(result != GLOBUS_SUCCESS)
2712 {
2713 0 goto exit;
2714 }
2715
2716 0 xsd_any_destroy_contents(soap_fault.detail);
2717
2718 0 globus_soap_message_handle_set_attr(
2719 callback_handle->message,
2720 WSADDR_ACTION_RESPONSE_KEY,
2721 globus_soap_message_attr_copy_string,
2722 globus_libc_free,
2723 WSADDRESSING_FAULT_NS);
2724 }
2725 1 else if(result != GLOBUS_SUCCESS)
2726 {
2727 globus_result_t local_result;
2728 0 local_result = globus_service_session_begin_response(
2729 callback_handle->message);
2730 0 if(local_result != GLOBUS_SUCCESS)
2731 {
2732 0 result = local_result;
2733 0 goto exit;
2734 }
2735
2736 0 soap_fault.faultcode = "Server";
2737 0 soap_fault.faultstring = globus_error_print_friendly(
2738 globus_error_get(result));
2739 0 result = GLOBUS_SUCCESS;
2740 0 soap_fault.faultactor = NULL;
2741 0 soap_fault.detail = NULL;
2742 0 result = globus_service_session_serialize_fault_response(
2743 callback_handle->message, &soap_fault);
2744 0 if(result != GLOBUS_SUCCESS)
2745 {
2746 0 goto exit;
2747 }
2748
2749 0 globus_soap_message_handle_set_attr(
2750 callback_handle->message,
2751 WSADDR_ACTION_RESPONSE_KEY,
2752 globus_soap_message_attr_copy_string,
2753 globus_libc_free,
2754 WSADDRESSING_FAULT_NS);
2755 }
2756 else
2757 {
2758 1 result = globus_service_session_begin_response(
2759 callback_handle->message);
2760 1 if(result != GLOBUS_SUCCESS)
2761 {
2762 0 goto exit;
2763 }
2764
2765 1 element_qname.local = "addResponse";
2766 1 element_qname.Namespace = "http://counter.com";
2767
2768 1 result = xsd_int_serialize(
2769 &element_qname,
2770 &output,
2771 callback_handle->message,
2772 GLOBUS_XSD_ELEMENT_SET_DEFAULT_NS);
2773 1 if(result != GLOBUS_SUCCESS)
2774 {
2775 0 goto exit;
2776 }
2777
2778 1 result = globus_service_session_end_response(
2779 callback_handle->message);
2780 1 if(result != GLOBUS_SUCCESS)
2781 {
2782 0 goto exit;
2783 }
2784
2785 1 xsd_int_destroy_contents(
2786 &output);
2787
2788 1 globus_soap_message_handle_set_attr(
2789 callback_handle->message,
2790 WSADDR_ACTION_RESPONSE_KEY,
2791 globus_soap_message_attr_copy_string,
2792 globus_libc_free,
2793 "http://counter.com/CounterPortType/addResponse");
2794 }
2795
2796 1 exit:
2797
2798 1 callback_handle->callback(
2799 result,
2800 callback_handle->args);
2801
2802 1 globus_libc_free(callback_handle);
2803
2804 1 SecureCounterServiceDebugExit();
2805 1 }
2806
2807 static
2808 globus_result_t
2809 add_invoke(
2810 globus_service_engine_t engine,
2811 globus_soap_message_handle_t message,
2812 globus_service_response_t * response,
2813 globus_operation_invoke_callback_func_t invoke_callback,
2814 void * args)
2815 1 {
2816 add_callback_handle_t * callback_handle;
2817 1 globus_result_t result = GLOBUS_SUCCESS;
2818 GlobusFuncName(CounterPortType_add);
2819 1 SecureCounterServiceDebugEnter();
2820
2821 1 callback_handle = malloc(sizeof(add_callback_handle_t));
2822 1 if(!callback_handle)
2823 {
2824 0 result = GlobusSoapMessageErrorOutOfMemory;
2825 0 goto exit;
2826 }
2827 1 callback_handle->engine = engine;
2828 1 callback_handle->message = message;
2829 1 callback_handle->callback = invoke_callback;
2830 1 callback_handle->args = args;
2831
2832 1 result = globus_callback_register_oneshot(
2833 NULL,
2834 &globus_i_reltime_zero,
2835 add_invoke_callback,
2836 callback_handle);
2837
2838 1 exit:
2839 1 SecureCounterServiceDebugExit();
2840 1 return result;
2841 }
2842
2843 static
2844 globus_service_operation_descriptor_t
2845 add_operation_descriptor =
2846 {
2847 add_deserialize,
2848 add_invoke,
2849 };
2850
2851 static
2852 globus_operation_provider_descriptor_t add_descriptor =
2853 {
2854 &CounterPortType_add_op_qname,
2855 "add",
2856 (void *)CounterPortType_add_impl,
2857 NULL
2858 };
2859
2860
2861 xsd_QName CounterPortType_createCounter_op_qname =
2862 {
2863 "http://localhost:8080/wsrf/services/SecureCounterService"
2864 "createCounter"
2865 };
2866
2867 xsd_QName CounterPortType_createCounter_input_qname =
2868 {
2869 "http://counter.com",
2870 "createCounter"
2871 };
2872
2873 typedef globus_result_t (* createCounter_invoke_func_t) (
2874 globus_service_engine_t engine,
2875 globus_soap_message_handle_t message,
2876 globus_service_descriptor_t * descriptor,
2877 counter_createCounterType * input,
2878 counter_createCounterResponseType * output,
2879 xsd_any * fault);
2880
2881 typedef struct createCounter_callback_handle_s
2882 {
2883 globus_service_engine_t engine;
2884 globus_soap_message_handle_t message;
2885 globus_operation_invoke_callback_func_t callback;
2886 void * args;
2887 } createCounter_callback_handle_t;
2888
2889 static
2890 void
2891 createCounter_deserialize_callback(
2892 void * handle)
2893 1 {
2894 createCounter_callback_handle_t * callback_handle;
2895 1 globus_result_t result = GLOBUS_SUCCESS;
2896 struct globus_soap_message_fault_s soap_fault;
2897 createCounter_invoke_func_t invoke_function;
2898 1 counter_createCounterType * input = NULL;
2899 GlobusFuncName(createCounter_deserialize_callback);
2900 1 SecureCounterServiceDebugEnter();
2901
2902 1 callback_handle = (createCounter_callback_handle_t *) handle;
2903
2904 1 result = globus_operation_table_get_operation(
2905 SecureCounterService_descriptor.operations,
2906 "createCounter",
2907 (void **)&invoke_function);
2908 1 if(result != GLOBUS_SUCCESS)
2909 {
2910 0 goto exit;
2911 }
2912
2913 1 result = counter_createCounterType_init(
2914 &input);
2915 1 if(result != GLOBUS_SUCCESS)
2916 {
2917 0 goto exit;
2918 }
2919
2920 1 result = counter_createCounterType_deserialize(
2921 &CounterPortType_createCounter_input_qname,
2922 input,
2923 callback_handle->message,
2924 0);
2925 1 if(result != GLOBUS_SUCCESS)
2926 {
2927 0 goto free_exit;
2928 }
2929
2930 1 result = globus_soap_message_handle_set_attr(
2931 callback_handle->message,
2932 "createCounterOperationInputParameter",
2933 counter_createCounterType_info.copy,
2934 counter_createCounterType_info.destroy,
2935 (void *)input);
2936 if(result != GLOBUS_SUCCESS)
2937 {
2938 1 goto free_exit;
2939 }
2940
2941 1 free_exit:
2942 1 counter_createCounterType_destroy(input);
2943
2944 1 exit:
2945 1 callback_handle->callback(
2946 result,
2947 callback_handle->args);
2948
2949 1 free(callback_handle);
2950 1 SecureCounterServiceDebugExit();
2951 1 }
2952 /* createCounter_deserialize_callback() */
2953
2954 static
2955 globus_result_t
2956 createCounter_deserialize(
2957 globus_service_engine_t engine,
2958 globus_soap_message_handle_t message,
2959 globus_operation_invoke_callback_func_t invoke_callback,
2960 void * args)
2961 1 {
2962 createCounter_callback_handle_t * callback_handle;
2963 1 globus_result_t result = GLOBUS_SUCCESS;
2964 GlobusFuncName(createCounter_deserialize);
2965 1 SecureCounterServiceDebugEnter();
2966
2967 1 callback_handle = malloc(sizeof(createCounter_callback_handle_t));
2968 1 globus_assert_string(callback_handle,
2969 "Memory allocation failed "
2970 "for createCounter callback handle");
2971
2972 1 callback_handle->engine = engine;
2973 1 callback_handle->message = message;
2974 1 callback_handle->callback = invoke_callback;
2975 1 callback_handle->args = args;
2976
2977 1 result = globus_callback_register_oneshot(
2978 NULL,
2979 &globus_i_reltime_zero,
2980 createCounter_deserialize_callback,
2981 callback_handle);
2982
2983 1 SecureCounterServiceDebugExit();
2984 1 return result;
2985 }
2986
2987 static
2988 void
2989 createCounter_invoke_callback(
2990 void * handle)
2991 1 {
2992 createCounter_callback_handle_t * callback_handle;
2993 1 globus_result_t result = GLOBUS_SUCCESS;
2994 struct globus_soap_message_fault_s soap_fault;
2995 createCounter_invoke_func_t invoke_function;
2996 counter_createCounterType * input;
2997 counter_createCounterResponseType output;
2998 xsd_QName element_qname;
2999 xsd_any fault;
3000
3001 GlobusFuncName(createCounter_invoke_callback);
3002 1 SecureCounterServiceDebugEnter();
3003
3004 1 callback_handle = (createCounter_callback_handle_t *) handle;
3005
3006 1 input = globus_soap_message_handle_get_attr(
3007 callback_handle->message,
3008 "createCounterOperationInputParameter");
3009 1 globus_assert(input);
3010
3011 1 result = globus_operation_table_get_operation(
3012 SecureCounterService_descriptor.operations,
3013 "createCounter",
3014 (void **)&invoke_function);
3015 1 if(result != GLOBUS_SUCCESS)
3016 {
3017 0 goto fault_exit;
3018 }
3019
3020
3021 1 result = counter_createCounterResponseType_init_contents(
3022 &output);
3023 1 if(result != GLOBUS_SUCCESS)
3024 {
3025 0 goto fault_exit;
3026 }
3027 1 result = xsd_any_init_contents(&fault);
3028 1 if(result != GLOBUS_SUCCESS)
3029 {
3030 0 goto fault_exit;
3031 }
3032 1 result = invoke_function(
3033 callback_handle->engine,
3034 callback_handle->message,
3035 &SecureCounterService_descriptor,
3036 input,
3037 &output,
3038 &fault);
3039
3040
3041 1 fault_exit:
3042
3043 1 if(fault.value && fault.element)
3044 {
3045 0 result = globus_service_session_begin_response(
3046 callback_handle->message);
3047 0 if(result != GLOBUS_SUCCESS)
3048 {
3049 0 goto exit;
3050 }
3051
3052 0 soap_fault.faultcode = "Server";
3053 0 soap_fault.faultstring =
3054 "An error occurred while processing the message";
3055 0 soap_fault.faultactor = NULL;
3056 0 soap_fault.detail = &fault;
3057
3058 0 result = globus_service_session_serialize_fault_response(
3059 callback_handle->message, &soap_fault);
3060 0 if(result != GLOBUS_SUCCESS)
3061 {
3062 0 goto exit;
3063 }
3064
3065 0 xsd_any_destroy_contents(soap_fault.detail);
3066
3067 0 globus_soap_message_handle_set_attr(
3068 callback_handle->message,
3069 WSADDR_ACTION_RESPONSE_KEY,
3070 globus_soap_message_attr_copy_string,
3071 globus_libc_free,
3072 WSADDRESSING_FAULT_NS);
3073 }
3074 1 else if(result != GLOBUS_SUCCESS)
3075 {
3076 globus_result_t local_result;
3077 0 local_result = globus_service_session_begin_response(
3078 callback_handle->message);
3079 0 if(local_result != GLOBUS_SUCCESS)
3080 {
3081 0 result = local_result;
3082 0 goto exit;
3083 }
3084
3085 0 soap_fault.faultcode = "Server";
3086 0 soap_fault.faultstring = globus_error_print_friendly(
3087 globus_error_get(result));
3088 0 result = GLOBUS_SUCCESS;
3089 0 soap_fault.faultactor = NULL;
3090 0 soap_fault.detail = NULL;
3091 0 result = globus_service_session_serialize_fault_response(
3092 callback_handle->message, &soap_fault);
3093 0 if(result != GLOBUS_SUCCESS)
3094 {
3095 0 goto exit;
3096 }
3097
3098 0 globus_soap_message_handle_set_attr(
3099 callback_handle->message,
3100 WSADDR_ACTION_RESPONSE_KEY,
3101 globus_soap_message_attr_copy_string,
3102 globus_libc_free,
3103 WSADDRESSING_FAULT_NS);
3104 }
3105 else
3106 {
3107 1 result = globus_service_session_begin_response(
3108 callback_handle->message);
3109 1 if(result != GLOBUS_SUCCESS)
3110 {
3111 0 goto exit;
3112 }
3113
3114 1 element_qname.local = "createCounterResponse";
3115 1 element_qname.Namespace = "http://counter.com";
3116
3117 1 result = counter_createCounterResponseType_serialize(
3118 &element_qname,
3119 &output,
3120 callback_handle->message,
3121 GLOBUS_XSD_ELEMENT_SET_DEFAULT_NS);
3122 1 if(result != GLOBUS_SUCCESS)
3123 {
3124 0 goto exit;
3125 }
3126
3127 1 result = globus_service_session_end_response(
3128 callback_handle->message);
3129 1 if(result != GLOBUS_SUCCESS)
3130 {
3131 0 goto exit;
3132 }
3133
3134 1 counter_createCounterResponseType_destroy_contents(
3135 &output);
3136
3137 1 globus_soap_message_handle_set_attr(
3138 callback_handle->message,
3139 WSADDR_ACTION_RESPONSE_KEY,
3140 globus_soap_message_attr_copy_string,
3141 globus_libc_free,
3142 "http://counter.com/CounterPortType/createCounterResponse");
3143 }
3144
3145 1 exit:
3146
3147 1 callback_handle->callback(
3148 result,
3149 callback_handle->args);
3150
3151 1 globus_libc_free(callback_handle);
3152
3153 1 SecureCounterServiceDebugExit();
3154 1 }
3155
3156 static
3157 globus_result_t
3158 createCounter_invoke(
3159 globus_service_engine_t engine,
3160 globus_soap_message_handle_t message,
3161 globus_service_response_t * response,
3162 globus_operation_invoke_callback_func_t invoke_callback,
3163 void * args)
3164 1 {
3165 createCounter_callback_handle_t * callback_handle;
3166 1 globus_result_t result = GLOBUS_SUCCESS;
3167 GlobusFuncName(CounterPortType_createCounter);
3168 1 SecureCounterServiceDebugEnter();
3169
3170 1 callback_handle = malloc(sizeof(createCounter_callback_handle_t));
3171 1 if(!callback_handle)
3172 {
3173 0 result = GlobusSoapMessageErrorOutOfMemory;
3174 0 goto exit;
3175 }
3176 1 callback_handle->engine = engine;
3177 1 callback_handle->message = message;
3178 1 callback_handle->callback = invoke_callback;
3179 1 callback_handle->args = args;
3180
3181 1 result = globus_callback_register_oneshot(
3182 NULL,
3183 &globus_i_reltime_zero,
3184 createCounter_invoke_callback,
3185 callback_handle);
3186
3187 1 exit:
3188 1 SecureCounterServiceDebugExit();
3189 1 return result;
3190 }
3191
3192 static
3193 globus_service_operation_descriptor_t
3194 createCounter_operation_descriptor =
3195 {
3196 createCounter_deserialize,
3197 createCounter_invoke,
3198 };
3199
3200 static
3201 globus_operation_provider_descriptor_t createCounter_descriptor =
3202 {
3203 &CounterPortType_createCounter_op_qname,
3204 "createCounter",
3205 (void *)CounterPortType_createCounter_impl,
3206 NULL
3207 };
3208
3209
3210
3211 static xsd_QName SecureCounterService_l_wsrp_GetResourceProperty_qname;
3212 static xsd_QName SecureCounterService_l_wsrp_GetMultipleResourceProperties_qname;
3213 static xsd_QName SecureCounterService_l_wsrp_SetResourceProperties_qname;
3214 static xsd_QName SecureCounterService_l_wsrp_QueryResourceProperties_qname;
3215 static xsd_QName SecureCounterService_l_wsrl_Destroy_qname;
3216 static xsd_QName SecureCounterService_l_wsrl_SetTerminationTime_qname;
3217 static xsd_QName SecureCounterService_l_wsnt_Subscribe_qname;
3218 static xsd_QName SecureCounterService_l_wsnt_GetCurrentMessage_qname;
3219
3220 static
3221 int
3222 SecureCounterService_activate()
3223 1 {
3224 1 globus_result_t result = GLOBUS_SUCCESS;
3225 1 int rc = 0;
3226 GlobusFuncName(SecureCounterService_activate);
3227
3228 1 rc = globus_module_activate(GLOBUS_COMMON_MODULE);
3229 1 if(rc != GLOBUS_SUCCESS)
3230 {
3231 0 return rc;
3232 }
3233
3234 1 GlobusDebugInit(SECURECOUNTERSERVICE, INFO DEBUG TRACE WARN ERROR);
3235
3236 1 rc = globus_module_activate(GLOBUS_SOAP_MESSAGE_MODULE);
3237 1 if(rc != GLOBUS_SUCCESS)
3238 {
3239 0 return rc;
3240 }
3241
3242 1 SecureCounterServiceDebugEnter();
3243
3244 1 result = globus_module_activate(GLOBUS_WSRF_RESOURCE_MODULE);
3245 1 if (result != GLOBUS_SUCCESS)
3246 {
3247 0 rc = (int) result;
3248 0 goto exit;
3249 }
3250
3251 1 result = globus_module_activate(GLOBUS_WSRF_CORE_TOOLS_MODULE);
3252 1 if (result != GLOBUS_SUCCESS)
3253 {
3254 0 rc = (int) result;
3255 0 goto exit;
3256 }
3257
3258 1 rc = globus_extension_activate(
3259 "globus_wsrp_GetResourceProperty_provider");
3260 1 if(rc != GLOBUS_SUCCESS)
3261 {
3262 0 goto deactivate_resource_out;
3263 }
3264
3265 1 rc = globus_extension_activate(
3266 "globus_wsrp_GetMultipleResourceProperties_provider");
3267 1 if (rc != GLOBUS_SUCCESS)
3268 {
3269 0 goto deactivate_getrp;
3270 }
3271
3272 1 rc = globus_extension_activate(
3273 "globus_wsrp_SetResourceProperties_provider");
3274 1 if (rc != GLOBUS_SUCCESS)
3275 {
3276 0 goto deactivate_getmrp;
3277 }
3278
3279 1 rc = globus_extension_activate(
3280 "globus_wsrp_QueryResourceProperties_provider");
3281 1 if (rc != GLOBUS_SUCCESS)
3282 {
3283 0 goto deactivate_setrp;
3284 }
3285
3286 1 rc = globus_extension_activate(
3287 "globus_wsrl_ImmediateResourceTermination_provider");
3288 1 if (rc != GLOBUS_SUCCESS)
3289 {
3290 0 goto deactivate_queryrp;
3291 }
3292
3293 1 rc = globus_extension_activate(
3294 "globus_wsrl_ScheduledResourceTermination_provider");
3295 1 if (rc != GLOBUS_SUCCESS)
3296 {
3297 0 goto deactivate_irt;
3298 }
3299
3300 1 rc = globus_extension_activate(
3301 "globus_wsnt_NotificationProducer_provider");
3302 1 if (rc != GLOBUS_SUCCESS)
3303 {
3304 0 goto deactivate_srt;
3305 }
3306
3307 1 if(GLOBUS_GLOBAL_TYPE_REGISTRY != NULL)
3308 {
3309 1 result = SecureCounterService_registry_add_types(
3310 GLOBUS_GLOBAL_TYPE_REGISTRY);
3311 1 if(result != GLOBUS_SUCCESS)
3312 {
3313 0 rc = (int) result;
3314 0 goto deactivate_nrt;
3315 }
3316 }
3317
3318 1 rc = globus_hashtable_init(
3319 &SecureCounterService_descriptor.op_mapper,
3320 10,
3321 xsd_QName_hash,
3322 xsd_QName_keyeq);
3323 1 if(rc != GLOBUS_SUCCESS)
3324 {
3325 0 goto clear_global_registry;
3326 }
3327
3328 1 globus_mutex_init(&SecureCounterService_descriptor.mutex, NULL);
3329
3330 1 rc = globus_hashtable_insert(
3331 &SecureCounterService_descriptor.op_mapper,
3332 (void *)&CounterPortType_SetTerminationTime_input_qname,
3333 (void *)&SetTerminationTime_operation_descriptor);
3334 1 if(rc != GLOBUS_SUCCESS)
3335 {
3336 0 goto remove_SetTerminationTime_op;
3337 }
3338
3339 1 rc = globus_hashtable_insert(
3340 &SecureCounterService_descriptor.op_mapper,
3341 (void *)&CounterPortType_Destroy_input_qname,
3342 (void *)&Destroy_operation_descriptor);
3343 1 if(rc != GLOBUS_SUCCESS)
3344 {
3345 0 goto remove_Destroy_op;
3346 }
3347
3348 1 rc = globus_hashtable_insert(
3349 &SecureCounterService_descriptor.op_mapper,
3350 (void *)&CounterPortType_GetCurrentMessage_input_qname,
3351 (void *)&GetCurrentMessage_operation_descriptor);
3352 1 if(rc != GLOBUS_SUCCESS)
3353 {
3354 0 goto remove_GetCurrentMessage_op;
3355 }
3356
3357 1 rc = globus_hashtable_insert(
3358 &SecureCounterService_descriptor.op_mapper,
3359 (void *)&CounterPortType_Subscribe_input_qname,
3360 (void *)&Subscribe_operation_descriptor);
3361 1 if(rc != GLOBUS_SUCCESS)
3362 {
3363 0 goto remove_Subscribe_op;
3364 }
3365
3366 1 rc = globus_hashtable_insert(
3367 &SecureCounterService_descriptor.op_mapper,
3368 (void *)&CounterPortType_GetMultipleResourceProperties_input_qname,
3369 (void *)&GetMultipleResourceProperties_operation_descriptor);
3370 1 if(rc != GLOBUS_SUCCESS)
3371 {
3372 0 goto remove_GetMultipleResourceProperties_op;
3373 }
3374
3375 1 rc = globus_hashtable_insert(
3376 &SecureCounterService_descriptor.op_mapper,
3377 (void *)&CounterPortType_QueryResourceProperties_input_qname,
3378 (void *)&QueryResourceProperties_operation_descriptor);
3379 1 if(rc != GLOBUS_SUCCESS)
3380 {
3381 0 goto remove_QueryResourceProperties_op;
3382 }
3383
3384 1 rc = globus_hashtable_insert(
3385 &SecureCounterService_descriptor.op_mapper,
3386 (void *)&CounterPortType_GetResourceProperty_input_qname,
3387 (void *)&GetResourceProperty_operation_descriptor);
3388 1 if(rc != GLOBUS_SUCCESS)
3389 {
3390 0 goto remove_GetResourceProperty_op;
3391 }
3392
3393 1 rc = globus_hashtable_insert(
3394 &SecureCounterService_descriptor.op_mapper,
3395 (void *)&CounterPortType_add_input_qname,
3396 (void *)&add_operation_descriptor);
3397 1 if(rc != GLOBUS_SUCCESS)
3398 {
3399 0 goto remove_add_op;
3400 }
3401
3402 1 rc = globus_hashtable_insert(
3403 &SecureCounterService_descriptor.op_mapper,
3404 (void *)&CounterPortType_createCounter_input_qname,
3405 (void *)&createCounter_operation_descriptor);
3406 1 if(rc != GLOBUS_SUCCESS)
3407 {
3408 0 goto remove_createCounter_op;
3409 }
3410
3411
3412 1 result = globus_operation_table_init(
3413 &SecureCounterService_descriptor.operations,
3414 SecureCounterService_service_qname.Namespace);
3415 1 if(result != GLOBUS_SUCCESS)
3416 {
3417 0 rc = (int) result;
3418 0 goto remove_all_ops;
3419 }
3420
3421
3422 1 result = globus_extension_registry_add(
3423 GLOBUS_OPERATION_PROVIDER_REGISTRY,
3424 (void *)&CounterPortType_SetTerminationTime_op_qname,
3425 GlobusExtensionMyModule(SecureCounterService),
3426 (void *)&SetTerminationTime_descriptor);
3427 1 if(result != GLOBUS_SUCCESS)
3428 {
3429 0 rc = (int) result;
3430 0 goto remove_SetTerminationTime_op_provider;
3431 }
3432
3433 1 result = globus_operation_table_add_default_provider(
3434 SecureCounterService_descriptor.operations,
3435 &CounterPortType_SetTerminationTime_op_qname,
3436 &SetTerminationTime_descriptor);
3437 1 if(result != GLOBUS_SUCCESS)
3438 {
3439 0 rc = (int) result;
3440 0 goto remove_SetTerminationTime_op_provider;
3441 }
3442
3443 1 result = globus_extension_registry_add(
3444 GLOBUS_OPERATION_PROVIDER_REGISTRY,
3445 (void *)&CounterPortType_Destroy_op_qname,
3446 GlobusExtensionMyModule(SecureCounterService),
3447 (void *)&Destroy_descriptor);
3448 1 if(result != GLOBUS_SUCCESS)
3449 {
3450 0 rc = (int) result;
3451 0 goto remove_Destroy_op_provider;
3452 }
3453
3454 1 result = globus_operation_table_add_default_provider(
3455 SecureCounterService_descriptor.operations,
3456 &CounterPortType_Destroy_op_qname,
3457 &Destroy_descriptor);
3458 1 if(result != GLOBUS_SUCCESS)
3459 {
3460 0 rc = (int) result;
3461 0 goto remove_Destroy_op_provider;
3462 }
3463
3464 1 result = globus_extension_registry_add(
3465 GLOBUS_OPERATION_PROVIDER_REGISTRY,
3466 (void *)&CounterPortType_GetCurrentMessage_op_qname,
3467 GlobusExtensionMyModule(SecureCounterService),
3468 (void *)&GetCurrentMessage_descriptor);
3469 1 if(result != GLOBUS_SUCCESS)
3470 {
3471 0 rc = (int) result;
3472 0 goto remove_GetCurrentMessage_op_provider;
3473 }
3474
3475 1 result = globus_operation_table_add_default_provider(
3476 SecureCounterService_descriptor.operations,
3477 &CounterPortType_GetCurrentMessage_op_qname,
3478 &GetCurrentMessage_descriptor);
3479 1 if(result != GLOBUS_SUCCESS)
3480 {
3481 0 rc = (int) result;
3482 0 goto remove_GetCurrentMessage_op_provider;
3483 }
3484
3485 1 result = globus_extension_registry_add(
3486 GLOBUS_OPERATION_PROVIDER_REGISTRY,
3487 (void *)&CounterPortType_Subscribe_op_qname,
3488 GlobusExtensionMyModule(SecureCounterService),
3489 (void *)&Subscribe_descriptor);
3490 1 if(result != GLOBUS_SUCCESS)
3491 {
3492 0 rc = (int) result;
3493 0 goto remove_Subscribe_op_provider;
3494 }
3495
3496 1 result = globus_operation_table_add_default_provider(
3497 SecureCounterService_descriptor.operations,
3498 &CounterPortType_Subscribe_op_qname,
3499 &Subscribe_descriptor);
3500 1 if(result != GLOBUS_SUCCESS)
3501 {
3502 0 rc = (int) result;
3503 0 goto remove_Subscribe_op_provider;
3504 }
3505
3506 1 result = globus_extension_registry_add(
3507 GLOBUS_OPERATION_PROVIDER_REGISTRY,
3508 (void *)&CounterPortType_GetMultipleResourceProperties_op_qname,
3509 GlobusExtensionMyModule(SecureCounterService),
3510 (void *)&GetMultipleResourceProperties_descriptor);
3511 1 if(result != GLOBUS_SUCCESS)
3512 {
3513 0 rc = (int) result;
3514 0 goto remove_GetMultipleResourceProperties_op_provider;
3515 }
3516
3517 1 result = globus_operation_table_add_default_provider(
3518 SecureCounterService_descriptor.operations,
3519 &CounterPortType_GetMultipleResourceProperties_op_qname,
3520 &GetMultipleResourceProperties_descriptor);
3521 1 if(result != GLOBUS_SUCCESS)
3522 {
3523 0 rc = (int) result;
3524 0 goto remove_GetMultipleResourceProperties_op_provider;
3525 }
3526
3527 1 result = globus_extension_registry_add(
3528 GLOBUS_OPERATION_PROVIDER_REGISTRY,
3529 (void *)&CounterPortType_QueryResourceProperties_op_qname,
3530 GlobusExtensionMyModule(SecureCounterService),
3531 (void *)&QueryResourceProperties_descriptor);
3532 1 if(result != GLOBUS_SUCCESS)
3533 {
3534 0 rc = (int) result;
3535 0 goto remove_QueryResourceProperties_op_provider;
3536 }
3537
3538 1 result = globus_operation_table_add_default_provider(
3539 SecureCounterService_descriptor.operations,
3540 &CounterPortType_QueryResourceProperties_op_qname,
3541 &QueryResourceProperties_descriptor);
3542 1 if(result != GLOBUS_SUCCESS)
3543 {
3544 0 rc = (int) result;
3545 0 goto remove_QueryResourceProperties_op_provider;
3546 }
3547
3548 1 result = globus_extension_registry_add(
3549 GLOBUS_OPERATION_PROVIDER_REGISTRY,
3550 (void *)&CounterPortType_GetResourceProperty_op_qname,
3551 GlobusExtensionMyModule(SecureCounterService),
3552 (void *)&GetResourceProperty_descriptor);
3553 1 if(result != GLOBUS_SUCCESS)
3554 {
3555 0 rc = (int) result;
3556 0 goto remove_GetResourceProperty_op_provider;
3557 }
3558
3559 1 result = globus_operation_table_add_default_provider(
3560 SecureCounterService_descriptor.operations,
3561 &CounterPortType_GetResourceProperty_op_qname,
3562 &GetResourceProperty_descriptor);
3563 1 if(result != GLOBUS_SUCCESS)
3564 {
3565 0 rc = (int) result;
3566 0 goto remove_GetResourceProperty_op_provider;
3567 }
3568
3569 1 result = globus_extension_registry_add(
3570 GLOBUS_OPERATION_PROVIDER_REGISTRY,
3571 (void *)&CounterPortType_add_op_qname,
3572 GlobusExtensionMyModule(SecureCounterService),
3573 (void *)&add_descriptor);
3574 1 if(result != GLOBUS_SUCCESS)
3575 {
3576 0 rc = (int) result;
3577 0 goto remove_add_op_provider;
3578 }
3579
3580 1 result = globus_operation_table_add_default_provider(
3581 SecureCounterService_descriptor.operations,
3582 &CounterPortType_add_op_qname,
3583 &add_descriptor);
3584 1 if(result != GLOBUS_SUCCESS)
3585 {
3586 0 rc = (int) result;
3587 0 goto remove_add_op_provider;
3588 }
3589
3590 1 result = globus_extension_registry_add(
3591 GLOBUS_OPERATION_PROVIDER_REGISTRY,
3592 (void *)&CounterPortType_createCounter_op_qname,
3593 GlobusExtensionMyModule(SecureCounterService),
3594 (void *)&createCounter_descriptor);
3595 1 if(result != GLOBUS_SUCCESS)
3596 {
3597 0 rc = (int) result;
3598 0 goto remove_createCounter_op_provider;
3599 }
3600
3601 1 result = globus_operation_table_add_default_provider(
3602 SecureCounterService_descriptor.operations,
3603 &CounterPortType_createCounter_op_qname,
3604 &createCounter_descriptor);
3605 1 if(result != GLOBUS_SUCCESS)
3606 {
3607 0 rc = (int) result;
3608 0 goto remove_createCounter_op_provider;
3609 }
3610
3611 1 result = globus_operation_table_add_provider(
3612 SecureCounterService_descriptor.operations,
3613 &SecureCounterService_l_wsrp_GetResourceProperty_qname);
3614 1 if (result != GLOBUS_SUCCESS)
3615 {
3616 0 rc = (int) result;
3617 0 goto remove_op_providers;
3618 }
3619
3620 1 result = globus_operation_table_add_provider(
3621 SecureCounterService_descriptor.operations,
3622 &SecureCounterService_l_wsrp_GetMultipleResourceProperties_qname);
3623 1 if (result != GLOBUS_SUCCESS)
3624 {
3625 0 rc = (int) result;
3626
3627 0 goto remove_op_providers;
3628 }
3629
3630 1 result = globus_operation_table_add_provider(
3631 SecureCounterService_descriptor.operations,
3632 &SecureCounterService_l_wsrp_SetResourceProperties_qname);
3633 1 if (result != GLOBUS_SUCCESS)
3634 {
3635 0 rc = (int) result;
3636
3637 0 goto remove_op_providers;
3638 }
3639
3640 1 result = globus_operation_table_add_provider(
3641 SecureCounterService_descriptor.operations,
3642 &SecureCounterService_l_wsrp_QueryResourceProperties_qname);
3643 1 if (result != GLOBUS_SUCCESS)
3644 {
3645 0 rc = (int) result;
3646
3647 0 goto remove_op_providers;
3648 }
3649
3650 1 result = globus_operation_table_add_provider(
3651 SecureCounterService_descriptor.operations,
3652 &SecureCounterService_l_wsrl_Destroy_qname);
3653 1 if (result != GLOBUS_SUCCESS)
3654 {
3655 0 rc = (int) result;
3656
3657 0 goto remove_op_providers;
3658 }
3659
3660 1 result = globus_operation_table_add_provider(
3661 SecureCounterService_descriptor.operations,
3662 &SecureCounterService_l_wsrl_SetTerminationTime_qname);
3663 1 if (result != GLOBUS_SUCCESS)
3664 {
3665 0 rc = (int) result;
3666
3667 0 goto remove_op_providers;
3668 }
3669
3670 1 result = globus_operation_table_add_provider(
3671 SecureCounterService_descriptor.operations,
3672 &SecureCounterService_l_wsnt_Subscribe_qname);
3673 1 if (result != GLOBUS_SUCCESS)
3674 {
3675 0 rc = (int) result;
3676
3677 0 goto remove_op_providers;
3678 }
3679
3680 1 result = globus_operation_table_add_provider(
3681 SecureCounterService_descriptor.operations,
3682 &SecureCounterService_l_wsnt_GetCurrentMessage_qname);
3683 1 if (result != GLOBUS_SUCCESS)
3684 {
3685 0 rc = (int) result;
3686
3687 0 goto remove_op_providers;
3688 }
3689
3690 1 rc = globus_extension_registry_add(
3691 GLOBUS_SERVICE_REGISTRY,
3692 (void *)SecureCounterService_descriptor.path,
3693 GlobusExtensionMyModule(SecureCounterService),
3694 &SecureCounterService_descriptor);
3695 1 if(rc != GLOBUS_SUCCESS)
3696 {
3697 0 goto remove_op_providers;
3698 }
3699
3700 1 result = SecureCounterService_init(&SecureCounterService_descriptor);
3701 1 if(result != GLOBUS_SUCCESS)
3702 {
3703 0 rc = (int) result;
3704 0 goto service_extension_remove;
3705 }
3706
3707 1 goto exit;
3708
3709 0 service_extension_remove:
3710 0 globus_extension_registry_remove(
3711 GLOBUS_SERVICE_REGISTRY,
3712 (void *)SecureCounterService_descriptor.path);
3713 0 remove_op_providers:
3714
3715 0 globus_extension_registry_remove(
3716 GLOBUS_OPERATION_PROVIDER_REGISTRY,
3717 (void *)&CounterPortType_SetTerminationTime_op_qname);
3718 0 remove_SetTerminationTime_op_provider:
3719
3720 0 globus_extension_registry_remove(
3721 GLOBUS_OPERATION_PROVIDER_REGISTRY,
3722 (void *)&CounterPortType_Destroy_op_qname);
3723 0 remove_Destroy_op_provider:
3724
3725 0 globus_extension_registry_remove(
3726 GLOBUS_OPERATION_PROVIDER_REGISTRY,
3727 (void *)&CounterPortType_GetCurrentMessage_op_qname);
3728 0 remove_GetCurrentMessage_op_provider:
3729
3730 0 globus_extension_registry_remove(
3731 GLOBUS_OPERATION_PROVIDER_REGISTRY,
3732 (void *)&CounterPortType_Subscribe_op_qname);
3733 0 remove_Subscribe_op_provider:
3734
3735 0 globus_extension_registry_remove(
3736 GLOBUS_OPERATION_PROVIDER_REGISTRY,
3737 (void *)&CounterPortType_GetMultipleResourceProperties_op_qname);
3738 0 remove_GetMultipleResourceProperties_op_provider:
3739
3740 0 globus_extension_registry_remove(
3741 GLOBUS_OPERATION_PROVIDER_REGISTRY,
3742 (void *)&CounterPortType_QueryResourceProperties_op_qname);
3743 0 remove_QueryResourceProperties_op_provider:
3744
3745 0 globus_extension_registry_remove(
3746 GLOBUS_OPERATION_PROVIDER_REGISTRY,
3747 (void *)&CounterPortType_GetResourceProperty_op_qname);
3748 0 remove_GetResourceProperty_op_provider:
3749
3750 0 globus_extension_registry_remove(
3751 GLOBUS_OPERATION_PROVIDER_REGISTRY,
3752 (void *)&CounterPortType_add_op_qname);
3753 0 remove_add_op_provider:
3754
3755 0 globus_extension_registry_remove(
3756 GLOBUS_OPERATION_PROVIDER_REGISTRY,
3757 (void *)&CounterPortType_createCounter_op_qname);
3758 0 remove_createCounter_op_provider:
3759
3760 0 destroy_op_table:
3761 0 globus_operation_table_destroy(SecureCounterService_descriptor.operations);
3762 0 remove_all_ops:
3763
3764 0 globus_hashtable_remove(
3765 &SecureCounterService_descriptor.op_mapper,
3766 (void *)&CounterPortType_SetTerminationTime_input_qname);
3767 0 remove_SetTerminationTime_op:
3768
3769 0 globus_hashtable_remove(
3770 &SecureCounterService_descriptor.op_mapper,
3771 (void *)&CounterPortType_Destroy_input_qname);
3772 0 remove_Destroy_op:
3773
3774 0 globus_hashtable_remove(
3775 &SecureCounterService_descriptor.op_mapper,
3776 (void *)&CounterPortType_GetCurrentMessage_input_qname);
3777 0 remove_GetCurrentMessage_op:
3778
3779 0 globus_hashtable_remove(
3780 &SecureCounterService_descriptor.op_mapper,
3781 (void *)&CounterPortType_Subscribe_input_qname);
3782 0 remove_Subscribe_op:
3783
3784 0 globus_hashtable_remove(
3785 &SecureCounterService_descriptor.op_mapper,
3786 (void *)&CounterPortType_GetMultipleResourceProperties_input_qname);
3787 0 remove_GetMultipleResourceProperties_op:
3788
3789 0 globus_hashtable_remove(
3790 &SecureCounterService_descriptor.op_mapper,
3791 (void *)&CounterPortType_QueryResourceProperties_input_qname);
3792 0 remove_QueryResourceProperties_op:
3793
3794 0 globus_hashtable_remove(
3795 &SecureCounterService_descriptor.op_mapper,
3796 (void *)&CounterPortType_GetResourceProperty_input_qname);
3797 0 remove_GetResourceProperty_op:
3798
3799 0 globus_hashtable_remove(
3800 &SecureCounterService_descriptor.op_mapper,
3801 (void *)&CounterPortType_add_input_qname);
3802 0 remove_add_op:
3803
3804 0 globus_hashtable_remove(
3805 &SecureCounterService_descriptor.op_mapper,
3806 (void *)&CounterPortType_createCounter_input_qname);
3807 0 remove_createCounter_op:
3808
3809 0 destroy_mutex:
3810 0 globus_mutex_destroy(&SecureCounterService_descriptor.mutex);
3811 0 clear_service_registry:
3812 0 destroy_service_registry:
3813 0 destroy_op_mapper:
3814 0 globus_hashtable_destroy(&SecureCounterService_descriptor.op_mapper);
3815 0 clear_global_registry:
3816 0 if(GLOBUS_GLOBAL_TYPE_REGISTRY != NULL)
3817 {
3818 0 SecureCounterService_registry_remove_types(
3819 GLOBUS_GLOBAL_TYPE_REGISTRY);
3820 }
3821 0 deactivate_nrt:
3822 0 globus_extension_deactivate(
3823 "globus_wsnt_NotificationProducer_provider");
3824 0 deactivate_srt:
3825 0 globus_extension_deactivate(
3826 "globus_wsrl_ScheduledResourceTermination_provider");
3827 0 deactivate_irt:
3828 0 globus_extension_deactivate(
3829 "globus_wsrl_ImmediateResourceTermination_provider");
3830 0 deactivate_queryrp:
3831 0 globus_extension_deactivate(
3832 "globus_wsrp_QueryResourceProperties_provider");
3833 0 deactivate_setrp:
3834 0 globus_extension_deactivate("globus_wsrp_SetResourceProperties_provider");
3835 0 deactivate_getmrp:
3836 0 globus_extension_deactivate("globus_wsrp_GetMultipleResourceProperties_provider");
3837 0 deactivate_getrp:
3838 0 globus_extension_deactivate("globus_wsrp_GetResourceProperty_provider");
3839 0 deactivate_resource_out:
3840 0 globus_module_deactivate(GLOBUS_WSRF_RESOURCE_MODULE);
3841
3842 1 exit:
3843 1 SecureCounterServiceDebugExit();
3844 1 return rc;
3845 }
3846
3847 static
3848 int
3849 SecureCounterService_deactivate()
3850 0 {
3851 0 globus_result_t result = GLOBUS_SUCCESS;
3852 0 int rc = 0;
3853
3854 0 result = SecureCounterService_finalize(&SecureCounterService_descriptor);
3855 0 if(result != GLOBUS_SUCCESS)
3856 {
3857 0 return GLOBUS_FAILURE;
3858 }
3859
3860 0 globus_extension_registry_remove(
3861 GLOBUS_SERVICE_REGISTRY,
3862 (void *)SecureCounterService_descriptor.path);
3863
3864 0 globus_extension_registry_remove(
3865 GLOBUS_OPERATION_PROVIDER_REGISTRY,
3866 (void *)&CounterPortType_SetTerminationTime_op_qname);
3867
3868 0 globus_extension_registry_remove(
3869 GLOBUS_OPERATION_PROVIDER_REGISTRY,
3870 (void *)&CounterPortType_Destroy_op_qname);
3871
3872 0 globus_extension_registry_remove(
3873 GLOBUS_OPERATION_PROVIDER_REGISTRY,
3874 (void *)&CounterPortType_GetCurrentMessage_op_qname);
3875
3876 0 globus_extension_registry_remove(
3877 GLOBUS_OPERATION_PROVIDER_REGISTRY,
3878 (void *)&CounterPortType_Subscribe_op_qname);
3879
3880 0 globus_extension_registry_remove(
3881 GLOBUS_OPERATION_PROVIDER_REGISTRY,
3882 (void *)&CounterPortType_GetMultipleResourceProperties_op_qname);
3883
3884 0 globus_extension_registry_remove(
3885 GLOBUS_OPERATION_PROVIDER_REGISTRY,
3886 (void *)&CounterPortType_QueryResourceProperties_op_qname);
3887
3888 0 globus_extension_registry_remove(
3889 GLOBUS_OPERATION_PROVIDER_REGISTRY,
3890 (void *)&CounterPortType_GetResourceProperty_op_qname);
3891
3892 0 globus_extension_registry_remove(
3893 GLOBUS_OPERATION_PROVIDER_REGISTRY,
3894 (void *)&CounterPortType_add_op_qname);
3895
3896 0 globus_extension_registry_remove(
3897 GLOBUS_OPERATION_PROVIDER_REGISTRY,
3898 (void *)&CounterPortType_createCounter_op_qname);
3899
3900 0 globus_operation_table_destroy(SecureCounterService_descriptor.operations);
3901
3902
3903 0 globus_hashtable_remove(
3904 &SecureCounterService_descriptor.op_mapper,
3905 (void *)&CounterPortType_SetTerminationTime_input_qname);
3906
3907 0 globus_hashtable_remove(
3908 &SecureCounterService_descriptor.op_mapper,
3909 (void *)&CounterPortType_Destroy_input_qname);
3910
3911 0 globus_hashtable_remove(
3912 &SecureCounterService_descriptor.op_mapper,
3913 (void *)&CounterPortType_GetCurrentMessage_input_qname);
3914
3915 0 globus_hashtable_remove(
3916 &SecureCounterService_descriptor.op_mapper,
3917 (void *)&CounterPortType_Subscribe_input_qname);
3918
3919 0 globus_hashtable_remove(
3920 &SecureCounterService_descriptor.op_mapper,
3921 (void *)&CounterPortType_GetMultipleResourceProperties_input_qname);
3922
3923 0 globus_hashtable_remove(
3924 &SecureCounterService_descriptor.op_mapper,
3925 (void *)&CounterPortType_QueryResourceProperties_input_qname);
3926
3927 0 globus_hashtable_remove(
3928 &SecureCounterService_descriptor.op_mapper,
3929 (void *)&CounterPortType_GetResourceProperty_input_qname);
3930
3931 0 globus_hashtable_remove(
3932 &SecureCounterService_descriptor.op_mapper,
3933 (void *)&CounterPortType_add_input_qname);
3934
3935 0 globus_hashtable_remove(
3936 &SecureCounterService_descriptor.op_mapper,
3937 (void *)&CounterPortType_createCounter_input_qname);
3938
3939
3940 0 globus_mutex_destroy(&SecureCounterService_descriptor.mutex);
3941
3942
3943 0 globus_hashtable_destroy(&SecureCounterService_descriptor.op_mapper);
3944
3945 0 if(GLOBUS_GLOBAL_TYPE_REGISTRY != NULL)
3946 {
3947 0 SecureCounterService_registry_remove_types(
3948 GLOBUS_GLOBAL_TYPE_REGISTRY);
3949 }
3950
3951 0 globus_extension_deactivate(
3952 "globus_wsnt_NotificationProducer_provider");
3953 0 globus_extension_deactivate(
3954 "globus_wsrl_ScheduledResourceTermination_provider");
3955 0 globus_extension_deactivate(
3956 "globus_wsrl_ImmediateResourceTermination_provider");
3957 0 globus_extension_deactivate(
3958 "globus_wsrp_QueryResourceProperties_provider");
3959 0 globus_extension_deactivate("globus_wsrp_SetResourceProperties_provider");
3960 0 globus_extension_deactivate(
3961 "globus_wsrp_GetMultipleResourceProperties_provider");
3962 0 globus_extension_deactivate("globus_wsrp_GetResourceProperty_provider");
3963 0 globus_module_deactivate(GLOBUS_WSRF_RESOURCE_MODULE);
3964
3965 0 rc = globus_module_deactivate(GLOBUS_SOAP_MESSAGE_MODULE);
3966 0 if(rc != GLOBUS_SUCCESS)
3967 {
3968 0 return rc;
3969 }
3970
3971 0 GlobusDebugDestroy(SECURECOUNTERSERVICE);
3972
3973 0 rc = globus_module_deactivate(GLOBUS_COMMON_MODULE);
3974 0 if(rc != GLOBUS_SUCCESS)
3975 {
3976 0 return rc;
3977 }
3978
3979 0 return rc;
3980 }
3981
3982 #define WSRP_PROVIDER_NS "http://docs.oasis-open.org/wsrf/rpw-2/providers"
3983
3984 static xsd_QName SecureCounterService_l_wsrp_GetResourceProperty_qname =
3985 {
3986 WSRP_PROVIDER_NS,
3987 "GetResourceProperty"
3988 };
3989
3990 static xsd_QName SecureCounterService_l_wsrp_GetMultipleResourceProperties_qname =
3991 {
3992 WSRP_PROVIDER_NS,
3993 "GetMultipleResourceProperties"
3994 };
3995
3996 static xsd_QName SecureCounterService_l_wsrp_SetResourceProperties_qname =
3997 {
3998 WSRP_PROVIDER_NS,
3999 "SetResourceProperties"
4000 };
4001
4002 static xsd_QName SecureCounterService_l_wsrp_QueryResourceProperties_qname =
4003 {
4004 WSRP_PROVIDER_NS,
4005 "QueryResourceProperties"
4006 };
4007
4008 #define WSRL_PROVIDER_NS "http://docs.oasis-open.org/wsrf/rlw-2/providers"
4009
4010 static xsd_QName SecureCounterService_l_wsrl_Destroy_qname =
4011 {
4012 WSRL_PROVIDER_NS,
4013 "Destroy"
4014 };
4015
4016 static xsd_QName SecureCounterService_l_wsrl_SetTerminationTime_qname =
4017 {
4018 WSRL_PROVIDER_NS,
4019 "SetTerminationTime"
4020 };
4021
4022 #define WSNT_PROVIDER_NS "http://docs.oasis-open.org/wsn/bw-2/providers"
4023
4024 static xsd_QName SecureCounterService_l_wsnt_Subscribe_qname =
4025 {
4026 WSNT_PROVIDER_NS,
4027 "Subscribe"
4028 };
4029
4030 static xsd_QName SecureCounterService_l_wsnt_GetCurrentMessage_qname =
4031 {
4032 WSNT_PROVIDER_NS,
4033 "GetCurrentMessage"