~ubuntu-branches/ubuntu/dapper/lasso/dapper

« back to all changes in this revision

Viewing changes to csharp/liblassosharpglue_wrap.c

  • Committer: Bazaar Package Importer
  • Author(s): Loic Pefferkorn
  • Date: 2005-11-25 19:20:59 UTC
  • mfrom: (1.1.2 upstream)
  • Revision ID: james.westby@ubuntu.com-20051125192059-m4894lhpynmkrmwr
Tags: 0.6.3-4ubuntu1
Resynchronise with Debian.

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
/* ----------------------------------------------------------------------------
2
 
 * This file was automatically generated by SWIG (http://www.swig.org).
3
 
 * Version 1.3.24
4
 
 * 
5
 
 * This file is not intended to be easily readable and contains a number of 
6
 
 * coding conventions designed to improve portability and efficiency. Do not make
7
 
 * changes to this file unless you know what you are doing--modify the SWIG 
8
 
 * interface file instead. 
9
 
 * ----------------------------------------------------------------------------- */
10
 
 
11
 
 
12
 
#ifndef SWIG_TEMPLATE_DISAMBIGUATOR
13
 
#  if defined(__SUNPRO_CC) 
14
 
#    define SWIG_TEMPLATE_DISAMBIGUATOR template
15
 
#  else
16
 
#    define SWIG_TEMPLATE_DISAMBIGUATOR 
17
 
#  endif
18
 
#endif
19
 
 
20
 
 
21
 
#include <stdlib.h>
22
 
#include <string.h>
23
 
#include <stdio.h>
24
 
#if defined(_WIN32) || defined(__CYGWIN32__)
25
 
#  define DllExport   __declspec( dllexport )
26
 
#  define SWIGSTDCALL __stdcall
27
 
#else
28
 
#  define DllExport  
29
 
#  define SWIGSTDCALL
30
 
#endif 
31
 
 
32
 
 
33
 
/* Support for throwing C# exceptions from C/C++ */
34
 
typedef enum {
35
 
  SWIG_CSharpException,
36
 
  SWIG_CSharpOutOfMemoryException,
37
 
  SWIG_CSharpIndexOutOfRangeException,
38
 
  SWIG_CSharpDivideByZeroException,
39
 
  SWIG_CSharpArgumentOutOfRangeException,
40
 
  SWIG_CSharpNullReferenceException
41
 
} SWIG_CSharpExceptionCodes;
42
 
 
43
 
typedef void (SWIGSTDCALL* SWIG_CSharpExceptionCallback_t)(const char *);
44
 
 
45
 
typedef struct {
46
 
  SWIG_CSharpExceptionCodes code;
47
 
  SWIG_CSharpExceptionCallback_t callback;
48
 
} SWIG_CSharpExceptions_t;
49
 
 
50
 
static SWIG_CSharpExceptions_t SWIG_csharp_exceptions[] = {
51
 
  { SWIG_CSharpException, NULL },
52
 
  { SWIG_CSharpOutOfMemoryException, NULL },
53
 
  { SWIG_CSharpIndexOutOfRangeException, NULL },
54
 
  { SWIG_CSharpDivideByZeroException, NULL },
55
 
  { SWIG_CSharpArgumentOutOfRangeException, NULL },
56
 
  { SWIG_CSharpNullReferenceException, NULL } };
57
 
 
58
 
static void SWIG_CSharpThrowException(SWIG_CSharpExceptionCodes code, const char *msg) {
59
 
  SWIG_CSharpExceptionCallback_t callback = SWIG_csharp_exceptions[SWIG_CSharpException].callback;
60
 
  if (code >=0 && (size_t)code < sizeof(SWIG_csharp_exceptions)/sizeof(SWIG_CSharpExceptions_t)) {
61
 
    callback = SWIG_csharp_exceptions[code].callback;
62
 
  }
63
 
  callback(msg);
64
 
}
65
 
 
66
 
 
67
 
#ifdef __cplusplus
68
 
extern "C" 
69
 
#endif
70
 
DllExport void SWIGSTDCALL SWIGRegisterExceptionCallbacks_lasso(SWIG_CSharpExceptionCallback_t systemException,
71
 
                                                          SWIG_CSharpExceptionCallback_t outOfMemory, 
72
 
                                                          SWIG_CSharpExceptionCallback_t indexOutOfRange, 
73
 
                                                          SWIG_CSharpExceptionCallback_t divideByZero, 
74
 
                                                          SWIG_CSharpExceptionCallback_t argumentOutOfRange,
75
 
                                                          SWIG_CSharpExceptionCallback_t nullReference) {
76
 
  SWIG_csharp_exceptions[SWIG_CSharpException].callback = systemException;
77
 
  SWIG_csharp_exceptions[SWIG_CSharpOutOfMemoryException].callback = outOfMemory;
78
 
  SWIG_csharp_exceptions[SWIG_CSharpIndexOutOfRangeException].callback = indexOutOfRange;
79
 
  SWIG_csharp_exceptions[SWIG_CSharpDivideByZeroException].callback = divideByZero;
80
 
  SWIG_csharp_exceptions[SWIG_CSharpArgumentOutOfRangeException].callback = argumentOutOfRange;
81
 
  SWIG_csharp_exceptions[SWIG_CSharpNullReferenceException].callback = nullReference;
82
 
}
83
 
 
84
 
 
85
 
/* Callback for returning strings to C# without leaking memory */
86
 
typedef char * (SWIGSTDCALL* SWIG_CSharpStringHelperCallback)(const char *);
87
 
static SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback = NULL;
88
 
 
89
 
 
90
 
#ifdef __cplusplus
91
 
extern "C" 
92
 
#endif
93
 
DllExport void SWIGSTDCALL SWIGRegisterStringCallback_lasso(SWIG_CSharpStringHelperCallback callback) {
94
 
  SWIG_csharp_string_callback = callback;
95
 
}
96
 
 
97
 
/* Contract support */
98
 
 
99
 
#define SWIG_contract_assert(nullreturn, expr, msg) if (!(expr)) {SWIG_CSharpThrowException(SWIG_CSharpArgumentOutOfRangeException, msg); return nullreturn; } else
100
 
 
101
 
 
102
 
#define  SWIG_MemoryError    1
103
 
#define  SWIG_IOError        2
104
 
#define  SWIG_RuntimeError   3
105
 
#define  SWIG_IndexError     4
106
 
#define  SWIG_TypeError      5
107
 
#define  SWIG_DivisionByZero 6
108
 
#define  SWIG_OverflowError  7
109
 
#define  SWIG_SyntaxError    8
110
 
#define  SWIG_ValueError     9
111
 
#define  SWIG_SystemError   10
112
 
#define  SWIG_UnknownError  99
113
 
 
114
 
 
115
 
static void SWIG_exception(int code, const char *msg) {
116
 
  SWIG_CSharpExceptionCodes exception_code = SWIG_CSharpException;
117
 
  switch(code) {
118
 
  case SWIG_MemoryError:
119
 
    exception_code = SWIG_CSharpOutOfMemoryException;
120
 
    break;
121
 
  case SWIG_IndexError:
122
 
    exception_code = SWIG_CSharpIndexOutOfRangeException;
123
 
    break;
124
 
  case SWIG_DivisionByZero:
125
 
    exception_code = SWIG_CSharpDivideByZeroException;
126
 
    break;
127
 
  case SWIG_ValueError:
128
 
    exception_code = SWIG_CSharpArgumentOutOfRangeException;
129
 
    break;
130
 
  case SWIG_IOError:
131
 
  case SWIG_RuntimeError:
132
 
  case SWIG_TypeError:
133
 
  case SWIG_OverflowError:
134
 
  case SWIG_SyntaxError:
135
 
  case SWIG_SystemError:
136
 
  case SWIG_UnknownError:
137
 
  default:
138
 
    exception_code = SWIG_CSharpException;
139
 
    break;
140
 
  }
141
 
  SWIG_CSharpThrowException(exception_code, msg);
142
 
}
143
 
 
144
 
 
145
 
 
146
 
#if defined(SWIGRUBY) || defined (PHP_VERSION)
147
 
/* Ruby and PHP pollute the #define space with these names */
148
 
#undef PACKAGE_NAME
149
 
#undef PACKAGE_STRING
150
 
#undef PACKAGE_TARNAME
151
 
#undef PACKAGE_VERSION
152
 
#undef PACKAGE_BUGREPORT
153
 
#endif
154
 
 
155
 
#include <lasso/lasso_config.h>
156
 
#include <lasso/lasso.h>
157
 
#include <lasso/xml/lib_assertion.h>
158
 
#include <lasso/xml/saml_attribute_value.h>
159
 
 
160
 
#ifdef LASSO_WSF_ENABLED
161
 
#include <lasso/xml/disco_resource_id.h>
162
 
#include <lasso/xml/disco_encrypted_resource_id.h>
163
 
#endif
164
 
 
165
 
 
166
 
 
167
 
#define bool int
168
 
#define false 0
169
 
#define true 1
170
 
 
171
 
 
172
 
 
173
 
/* 
174
 
 * Thanks to the patch in this Debian bug for the solution
175
 
 * to the crash inside vsnprintf on some architectures.
176
 
 *
177
 
 * "reuse of args inside the while(1) loop is in violation of the
178
 
 * specs and only happens to work by accident on other systems."
179
 
 *
180
 
 * http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=104325 
181
 
 */
182
 
 
183
 
#ifndef va_copy
184
 
#ifdef __va_copy
185
 
#define va_copy(dest,src) __va_copy(dest,src)
186
 
#else
187
 
#define va_copy(dest,src) (dest) = (src)
188
 
#endif
189
 
#endif
190
 
 
191
 
 
192
 
 
193
 
 
194
 
static void build_exception_msg(int errorCode, char *errorMsg) {
195
 
        if (errorCode > 0)
196
 
                sprintf(errorMsg, "%d / Lasso Warning: %s", errorCode, lasso_strerror(errorCode));
197
 
        else
198
 
                sprintf(errorMsg, "%d / Lasso Error: %s", errorCode, lasso_strerror(errorCode));
199
 
}
200
 
 
201
 
 
202
 
 
203
 
 
204
 
typedef struct {
205
 
} DowncastableNode;
206
 
 
207
 
DowncastableNode *downcast_node(LassoNode *node) {
208
 
        return (DowncastableNode *) node;
209
 
}
210
 
 
211
 
 
212
 
 
213
 
#include <lasso/errors.h>
214
 
 
215
 
 
216
 
 
217
 
static void add_key_to_array(char *key, gpointer pointer, GPtrArray *array)
218
 
{
219
 
        g_ptr_array_add(array, g_strdup(key));
220
 
}
221
 
 
222
 
static void add_node_to_array(gpointer node, GPtrArray *array)
223
 
{
224
 
        if (node != NULL)
225
 
                g_object_ref(node);
226
 
        g_ptr_array_add(array, node);
227
 
}
228
 
 
229
 
static void add_string_to_array(char *string, GPtrArray *array)
230
 
{
231
 
        if (string != NULL)
232
 
                string = g_strdup(string);
233
 
        g_ptr_array_add(array, string);
234
 
}
235
 
 
236
 
static void add_xml_to_array(xmlNode *xmlnode, GPtrArray *array)
237
 
{
238
 
        xmlOutputBufferPtr buf;
239
 
        gchar *xmlString;
240
 
 
241
 
        buf = xmlAllocOutputBuffer(NULL);
242
 
        if (buf == NULL)
243
 
                xmlString = NULL;
244
 
        else {
245
 
                xmlNodeDumpOutput(buf, NULL, xmlnode, 0, 1, NULL);
246
 
                xmlOutputBufferFlush(buf);
247
 
                if (buf->conv == NULL)
248
 
                        xmlString = g_strdup(buf->buffer->content);
249
 
                else
250
 
                        xmlString = g_strdup(buf->conv->content);
251
 
                xmlOutputBufferClose(buf);
252
 
        }
253
 
        g_ptr_array_add(array, xmlString);
254
 
}
255
 
 
256
 
static void free_node_array_item(gpointer node, gpointer unused)
257
 
{
258
 
        if (node != NULL)
259
 
                /* Test added to help debugging. */
260
 
                if (LASSO_IS_NODE(node))
261
 
                        lasso_node_destroy(LASSO_NODE(node));
262
 
                else
263
 
                        g_object_unref(node);
264
 
}
265
 
 
266
 
static void free_node_list_item(gpointer node, gpointer unused)
267
 
{
268
 
        if (node != NULL)
269
 
                /* Test added to help debugging. */
270
 
                if (LASSO_IS_NODE(node))
271
 
                        lasso_node_destroy(LASSO_NODE(node));
272
 
                else
273
 
                        g_object_unref(node);
274
 
}
275
 
 
276
 
static void free_string_list_item(char *string, gpointer unused)
277
 
{
278
 
        if (string != NULL)
279
 
                g_free(string);
280
 
}
281
 
 
282
 
static void free_xml_list_item(xmlNode *xmlnode, gpointer unused)
283
 
{
284
 
        if (xmlnode != NULL)
285
 
                xmlFreeNode(xmlnode);
286
 
}
287
 
 
288
 
static gpointer get_node(gpointer node)
289
 
{
290
 
        return node == NULL ? NULL : g_object_ref(node);
291
 
}
292
 
 
293
 
static GPtrArray *get_node_list(GList *nodeList) {
294
 
        GPtrArray *nodeArray;
295
 
 
296
 
        if (nodeList == NULL)
297
 
                return NULL;
298
 
        nodeArray = g_ptr_array_sized_new(g_list_length(nodeList));
299
 
        g_list_foreach(nodeList, (GFunc) add_node_to_array, nodeArray);
300
 
        return nodeArray;
301
 
}
302
 
 
303
 
static GPtrArray *get_string_list(GList *stringList) {
304
 
        GPtrArray *stringArray;
305
 
 
306
 
        if (stringList == NULL)
307
 
                return NULL;
308
 
        stringArray = g_ptr_array_sized_new(g_list_length(stringList));
309
 
        g_list_foreach(stringList, (GFunc) add_string_to_array, stringArray);
310
 
        return stringArray;
311
 
}
312
 
 
313
 
static GPtrArray *get_xml_list(GList *xmlList) {
314
 
        GPtrArray *xmlArray;
315
 
 
316
 
        if (xmlList == NULL)
317
 
                return NULL;
318
 
        xmlArray = g_ptr_array_sized_new(g_list_length(xmlList));
319
 
        g_list_foreach(xmlList, (GFunc) add_xml_to_array, xmlArray);
320
 
        return xmlArray;
321
 
}
322
 
 
323
 
static char* get_xml_string(xmlNode *xmlnode)
324
 
{
325
 
        xmlOutputBufferPtr buf;
326
 
        char *xmlString;
327
 
 
328
 
        buf = xmlAllocOutputBuffer(NULL);
329
 
        if (buf == NULL)
330
 
                xmlString = NULL;
331
 
        else {
332
 
                xmlNodeDumpOutput(buf, NULL, xmlnode, 0, 1, NULL);
333
 
                xmlOutputBufferFlush(buf);
334
 
                if (buf->conv == NULL)
335
 
                        xmlString = g_strdup(buf->buffer->content);
336
 
                else
337
 
                        xmlString = g_strdup(buf->conv->content);
338
 
                xmlOutputBufferClose(buf);
339
 
        }
340
 
        xmlFreeNode(xmlnode);
341
 
        return xmlString;
342
 
}
343
 
 
344
 
static void set_node(gpointer *nodePointer, gpointer value)
345
 
{
346
 
        if (*nodePointer != NULL)
347
 
                /* Test added to help debugging. */
348
 
                if (LASSO_IS_NODE(*nodePointer))
349
 
                        lasso_node_destroy(LASSO_NODE(*nodePointer));
350
 
                else
351
 
                        g_object_unref(*nodePointer);
352
 
        *nodePointer = value == NULL ? NULL : g_object_ref(value);
353
 
}
354
 
 
355
 
static void set_node_list(GList **nodeListPointer, GPtrArray *nodeArray) {
356
 
        if (*nodeListPointer != NULL) {
357
 
                g_list_foreach(*nodeListPointer, (GFunc) free_node_list_item, NULL);
358
 
                g_list_free(*nodeListPointer);
359
 
        }
360
 
        if (nodeArray == NULL)
361
 
                *nodeListPointer = NULL;
362
 
        else {
363
 
                gpointer node;
364
 
                int index;
365
 
 
366
 
                for (index = 0; index < nodeArray->len; index ++) {
367
 
                        node = g_ptr_array_index(nodeArray, index);
368
 
                        if (node != NULL)
369
 
                                g_object_ref(node);
370
 
                        *nodeListPointer = g_list_append(*nodeListPointer, node);
371
 
                }
372
 
        }
373
 
}
374
 
 
375
 
static void set_string(char **pointer, char *value)
376
 
{
377
 
        if (*pointer != NULL)
378
 
                g_free(*pointer);
379
 
        *pointer = value == NULL ? NULL : strdup(value);
380
 
}
381
 
 
382
 
static void set_string_list(GList **stringListPointer, GPtrArray *stringArray) {
383
 
        if (*stringListPointer != NULL) {
384
 
                g_list_foreach(*stringListPointer, (GFunc) free_string_list_item, NULL);
385
 
                g_list_free(*stringListPointer);
386
 
        }
387
 
        if (stringArray == NULL)
388
 
                *stringListPointer = NULL;
389
 
        else {
390
 
                char *string;
391
 
                int index;
392
 
 
393
 
                for (index = 0; index < stringArray->len; index ++) {
394
 
                        string = g_ptr_array_index(stringArray, index);
395
 
                        if (string != NULL)
396
 
                                string = g_strdup(string);
397
 
                        *stringListPointer = g_list_append(*stringListPointer, string);
398
 
                }
399
 
        }
400
 
}
401
 
 
402
 
static void set_xml_list(GList **xmlListPointer, GPtrArray *xmlArray) {
403
 
        if (*xmlListPointer != NULL) {
404
 
                g_list_foreach(*xmlListPointer, (GFunc) free_xml_list_item, NULL);
405
 
                g_list_free(*xmlListPointer);
406
 
        }
407
 
        if (xmlArray == NULL)
408
 
                *xmlListPointer = NULL;
409
 
        else {
410
 
                xmlDoc *doc;
411
 
                int index;
412
 
                xmlNode *node;
413
 
                char *xmlString;
414
 
 
415
 
                for (index = 0; index < xmlArray->len; index ++) {
416
 
                        xmlString = g_ptr_array_index(xmlArray, index);
417
 
                        if (xmlString == NULL)
418
 
                                node = NULL;
419
 
                        else {
420
 
                                doc = xmlReadDoc(g_ptr_array_index(xmlArray, index), NULL, NULL,
421
 
                                                 XML_PARSE_NONET);
422
 
                                if (doc == NULL)
423
 
                                        continue;
424
 
                                node = xmlDocGetRootElement(doc);
425
 
                                if (node != NULL)
426
 
                                        node = xmlCopyNode(node, 1);
427
 
                                xmlFreeDoc(doc);
428
 
                        }
429
 
                        *xmlListPointer = g_list_append(*xmlListPointer, node);
430
 
                }
431
 
        }
432
 
}
433
 
 
434
 
 
435
 
 
436
 
 
437
 
/* Constructors, destructors & static methods implementations */
438
 
 
439
 
#define new_LassoNode lasso_node_new
440
 
#define delete_LassoNode lasso_node_destroy
441
 
 
442
 
/* Methods implementations */
443
 
 
444
 
#define LassoNode_dump(self) lasso_node_dump(LASSO_NODE(self))
445
 
 
446
 
 
447
 
 
448
 
typedef GPtrArray LassoNodeList;
449
 
 
450
 
static void LassoNodeList_append(LassoNodeList *self,LassoNode *item){
451
 
                        if (item != NULL)
452
 
                                g_object_ref(item);
453
 
                        g_ptr_array_add(self, item);
454
 
                }
455
 
static void *LassoNodeList_cast(LassoNodeList *self){
456
 
                        return self;
457
 
                }
458
 
static LassoNodeList *NodeList_frompointer(void *nodeArray){
459
 
                        return (LassoNodeList *) nodeArray;
460
 
                }
461
 
static LassoNode *LassoNodeList_getItem(LassoNodeList *self,int index){
462
 
                        LassoNode *item;
463
 
 
464
 
                        item = g_ptr_array_index(self, index);
465
 
                        if (item != NULL)
466
 
                                g_object_ref(item);
467
 
                        return item;
468
 
                }
469
 
static int LassoNodeList_length(LassoNodeList *self){
470
 
                        return self->len;
471
 
                }
472
 
static void LassoNodeList_setItem(LassoNodeList *self,int index,LassoNode *item){
473
 
                        LassoNode **itemPointer = (LassoNode **) &g_ptr_array_index(self, index);
474
 
                        if (*itemPointer != NULL)
475
 
                                /* Test added to help debugging. */
476
 
                                if (LASSO_IS_NODE(*itemPointer))
477
 
                                        lasso_node_destroy(LASSO_NODE(*itemPointer));
478
 
                                else
479
 
                                        g_object_unref(*itemPointer);
480
 
                        if (item == NULL)
481
 
                                *itemPointer = NULL;
482
 
                        else
483
 
                                *itemPointer = g_object_ref(item);
484
 
                }
485
 
 
486
 
 
487
 
/* Constructors, destructors & static methods implementations */
488
 
 
489
 
#define new_LassoNodeList g_ptr_array_new
490
 
 
491
 
void delete_LassoNodeList(GPtrArray *self) {
492
 
        g_ptr_array_foreach(self, (GFunc) free_node_array_item, NULL);
493
 
        g_ptr_array_free(self, false);
494
 
}
495
 
 
496
 
 
497
 
 
498
 
typedef GPtrArray LassoStringList;
499
 
 
500
 
static void LassoStringList_append(LassoStringList *self,char *item){
501
 
                        if (item != NULL)
502
 
                                item = g_strdup(item);
503
 
                        g_ptr_array_add(self, item);
504
 
                }
505
 
static void *LassoStringList_cast(LassoStringList *self){
506
 
                        return self;
507
 
                }
508
 
static LassoStringList *StringList_frompointer(void *stringArray){
509
 
                        return (LassoStringList *) stringArray;
510
 
                }
511
 
static char *LassoStringList_getItem(LassoStringList *self,int index){
512
 
                        return g_ptr_array_index(self, index);
513
 
                }
514
 
static int LassoStringList_length(LassoStringList *self){
515
 
                        return self->len;
516
 
                }
517
 
static void LassoStringList_setItem(LassoStringList *self,int index,char *item){
518
 
                        char **itemPointer = (char **) &g_ptr_array_index(self, index);
519
 
                        if (*itemPointer != NULL)
520
 
                                g_free(*itemPointer);
521
 
                        if (item == NULL)
522
 
                                *itemPointer = NULL;
523
 
                        else
524
 
                                *itemPointer = g_strdup(item);
525
 
                }
526
 
 
527
 
 
528
 
/* Constructors, destructors & static methods implementations */
529
 
 
530
 
#define new_LassoStringList g_ptr_array_new
531
 
#define delete_LassoStringList(self) g_ptr_array_free(self, true)
532
 
 
533
 
 
534
 
 
535
 
 
536
 
/* Attributes implementations */
537
 
/* Assertion */
538
 
#define LassoSamlAdvice_get_Assertion(self) get_node((self)->Assertion)
539
 
#define LassoSamlAdvice_Assertion_get(self) get_node((self)->Assertion)
540
 
#define LassoSamlAdvice_set_Assertion(self, value) set_node((gpointer *) &(self)->Assertion, (value))
541
 
#define LassoSamlAdvice_Assertion_set(self, value) set_node((gpointer *) &(self)->Assertion, (value))
542
 
 
543
 
/* assertionIdReference */
544
 
#define LassoSamlAdvice_get_assertionIdReference(self) get_string_list((self)->AssertionIDReference)
545
 
#define LassoSamlAdvice_assertionIdReference_get(self) get_string_list((self)->AssertionIDReference)
546
 
#define LassoSamlAdvice_set_assertionIdReference(self, value) set_string_list(&(self)->AssertionIDReference, (value))
547
 
#define LassoSamlAdvice_assertionIdReference_set(self, value) set_string_list(&(self)->AssertionIDReference, (value))
548
 
 
549
 
/* Constructors, destructors & static methods implementations */
550
 
 
551
 
#define new_LassoSamlAdvice lasso_saml_advice_new
552
 
#define delete_LassoSamlAdvice(self) lasso_node_destroy(LASSO_NODE(self))
553
 
 
554
 
/* Implementations of methods inherited from LassoNode */
555
 
 
556
 
#define LassoSamlAdvice_dump(self) lasso_node_dump(LASSO_NODE(self))
557
 
 
558
 
 
559
 
 
560
 
 
561
 
/* Attributes Implementations */
562
 
 
563
 
/* Advice */
564
 
#define LassoSamlAssertion_get_Advice(self) get_node((self)->Advice)
565
 
#define LassoSamlAssertion_Advice_get(self) get_node((self)->Advice)
566
 
#define LassoSamlAssertion_set_Advice(self, value) set_node((gpointer *) &(self)->Advice, (value))
567
 
#define LassoSamlAssertion_Advice_set(self, value) set_node((gpointer *) &(self)->Advice, (value))
568
 
 
569
 
/* AttributeStatement */
570
 
#define LassoSamlAssertion_get_AttributeStatement(self) get_node((self)->AttributeStatement)
571
 
#define LassoSamlAssertion_AttributeStatement_get(self) get_node((self)->AttributeStatement)
572
 
#define LassoSamlAssertion_set_AttributeStatement(self, value) set_node((gpointer *) &(self)->AttributeStatement, (value))
573
 
#define LassoSamlAssertion_AttributeStatement_set(self, value) set_node((gpointer *) &(self)->AttributeStatement, (value))
574
 
 
575
 
/* AuthenticationStatement */
576
 
#define LassoSamlAssertion_get_AuthenticationStatement(self) get_node((self)->AuthenticationStatement)
577
 
#define LassoSamlAssertion_AuthenticationStatement_get(self) get_node((self)->AuthenticationStatement)
578
 
#define LassoSamlAssertion_set_AuthenticationStatement(self, value) set_node((gpointer *) &(self)->AuthenticationStatement, (value))
579
 
#define LassoSamlAssertion_AuthenticationStatement_set(self, value) set_node((gpointer *) &(self)->AuthenticationStatement, (value))
580
 
 
581
 
/* Conditions */
582
 
#define LassoSamlAssertion_get_Conditions(self) get_node((self)->Conditions)
583
 
#define LassoSamlAssertion_Conditions_get(self) get_node((self)->Conditions)
584
 
#define LassoSamlAssertion_set_Conditions(self, value) set_node((gpointer *) &(self)->Conditions, (value))
585
 
#define LassoSamlAssertion_Conditions_set(self, value) set_node((gpointer *) &(self)->Conditions, (value))
586
 
 
587
 
/* SubjectStatement */
588
 
#define LassoSamlAssertion_get_SubjectStatement(self) get_node((self)->SubjectStatement)
589
 
#define LassoSamlAssertion_SubjectStatement_get(self) get_node((self)->SubjectStatement)
590
 
#define LassoSamlAssertion_set_SubjectStatement(self, value) set_node((gpointer *) &(self)->SubjectStatement, (value))
591
 
#define LassoSamlAssertion_SubjectStatement_set(self, value) set_node((gpointer *) &(self)->SubjectStatement, (value))
592
 
 
593
 
/* Constructors, destructors & static methods implementations */
594
 
 
595
 
#define new_LassoSamlAssertion lasso_saml_assertion_new
596
 
#define delete_LassoSamlAssertion(self) lasso_node_destroy(LASSO_NODE(self))
597
 
 
598
 
/* Implementations of methods inherited from LassoNode */
599
 
 
600
 
#define LassoSamlAssertion_dump(self) lasso_node_dump(LASSO_NODE(self))
601
 
 
602
 
 
603
 
 
604
 
 
605
 
/* Implementations of attributes inherited from SamlAttributeDesignator */
606
 
 
607
 
/* AttributeName */
608
 
#define LassoSamlAttribute_get_AttributeName(self) LASSO_SAML_ATTRIBUTE_DESIGNATOR(self)->AttributeName
609
 
#define LassoSamlAttribute_AttributeName_get(self) LASSO_SAML_ATTRIBUTE_DESIGNATOR(self)->AttributeName
610
 
#define LassoSamlAttribute_set_AttributeName(self, value) set_string(&LASSO_SAML_ATTRIBUTE_DESIGNATOR(self)->AttributeName, (value))
611
 
#define LassoSamlAttribute_AttributeName_set(self, value) set_string(&LASSO_SAML_ATTRIBUTE_DESIGNATOR(self)->AttributeName, (value))
612
 
 
613
 
/* AttributeNamespace */
614
 
#define LassoSamlAttribute_get_AttributeNamespace(self) LASSO_SAML_ATTRIBUTE_DESIGNATOR(self)->AttributeNamespace
615
 
#define LassoSamlAttribute_AttributeNamespace_get(self) LASSO_SAML_ATTRIBUTE_DESIGNATOR(self)->AttributeNamespace
616
 
#define LassoSamlAttribute_set_AttributeNamespace(self, value) set_string(&LASSO_SAML_ATTRIBUTE_DESIGNATOR(self)->AttributeNamespace, (value))
617
 
#define LassoSamlAttribute_AttributeNamespace_set(self, value) set_string(&LASSO_SAML_ATTRIBUTE_DESIGNATOR(self)->AttributeNamespace, (value))
618
 
 
619
 
/* Attributes implementations */
620
 
 
621
 
/* AttributeValue */
622
 
#define LassoSamlAttribute_get_AttributeValue(self) get_node_list((self)->AttributeValue)
623
 
#define LassoSamlAttribute_AttributeValue_get(self) get_node_list((self)->AttributeValue)
624
 
#define LassoSamlAttribute_set_AttributeValue(self, value) set_node_list(&(self)->AttributeValue, (value))
625
 
#define LassoSamlAttribute_AttributeValue_set(self, value) set_node_list(&(self)->AttributeValue, (value))
626
 
 
627
 
/* Constructors, destructors & static methods implementations */
628
 
 
629
 
#define new_LassoSamlAttribute lasso_saml_attribute_new
630
 
#define delete_LassoSamlAttribute(self) lasso_node_destroy(LASSO_NODE(self))
631
 
 
632
 
/* Implementations of methods inherited from LassoNode */
633
 
 
634
 
#define LassoSamlAttribute_dump(self) lasso_node_dump(LASSO_NODE(self))
635
 
 
636
 
 
637
 
 
638
 
 
639
 
/* Constructors, destructors & static methods implementations */
640
 
 
641
 
#define new_LassoSamlAttributeDesignator lasso_saml_attribute_designator_new
642
 
#define delete_LassoSamlAttributeDesignator(self) lasso_node_destroy(LASSO_NODE(self))
643
 
 
644
 
/* Implementations of methods inherited from LassoNode */
645
 
 
646
 
#define LassoSamlAttributeDesignator_dump(self) lasso_node_dump(LASSO_NODE(self))
647
 
 
648
 
 
649
 
 
650
 
 
651
 
/* Implementations of attributes inherited from SamlSubjectStatementAbstract */
652
 
 
653
 
/* Subject */
654
 
#define LassoSamlAttributeStatement_get_Subject(self) get_node(LASSO_SAML_SUBJECT_STATEMENT_ABSTRACT(self)->Subject)
655
 
#define LassoSamlAttributeStatement_Subject_get(self) get_node(LASSO_SAML_SUBJECT_STATEMENT_ABSTRACT(self)->Subject)
656
 
#define LassoSamlAttributeStatement_set_Subject(self, value) set_node((gpointer *) &LASSO_SAML_SUBJECT_STATEMENT_ABSTRACT(self)->Subject, (value))
657
 
#define LassoSamlAttributeStatement_Subject_set(self, value) set_node((gpointer *) &LASSO_SAML_SUBJECT_STATEMENT_ABSTRACT(self)->Subject, (value))
658
 
 
659
 
/* Attributes Implementations */
660
 
 
661
 
/* Attribute */
662
 
#define LassoSamlAttributeStatement_get_Attribute(self) get_node_list((self)->Attribute)
663
 
#define LassoSamlAttributeStatement_Attribute_get(self) get_node_list((self)->Attribute)
664
 
#define LassoSamlAttributeStatement_set_Attribute(self, value) set_node_list(&(self)->Attribute, (value))
665
 
#define LassoSamlAttributeStatement_Attribute_set(self, value) set_node_list(&(self)->Attribute, (value))
666
 
 
667
 
/* Constructors, destructors & static methods implementations */
668
 
 
669
 
#define new_LassoSamlAttributeStatement lasso_saml_attribute_statement_new
670
 
#define delete_LassoSamlAttributeStatement(self) lasso_node_destroy(LASSO_NODE(self))
671
 
 
672
 
/* Implementations of methods inherited from LassoNode */
673
 
 
674
 
#define LassoSamlAttributeStatement_dump(self) lasso_node_dump(LASSO_NODE(self))
675
 
 
676
 
 
677
 
 
678
 
 
679
 
/* Attributes Implementations */
680
 
 
681
 
/* any */
682
 
#define LassoSamlAttributeValue_get_any(self) get_node_list((self)->any)
683
 
#define LassoSamlAttributeValue_any_get(self) get_node_list((self)->any)
684
 
#define LassoSamlAttributeValue_set_any(self, value) set_node_list(&(self)->any, (value))
685
 
#define LassoSamlAttributeValue_any_set(self, value) set_node_list(&(self)->any, (value))
686
 
 
687
 
/* Constructors, destructors & static methods implementations */
688
 
 
689
 
#define new_LassoSamlAttributeValue lasso_saml_attribute_value_new
690
 
#define delete_LassoSamlAttributeValue(self) lasso_node_destroy(LASSO_NODE(self))
691
 
 
692
 
/* Implementations of methods inherited from LassoNode */
693
 
 
694
 
#define LassoSamlAttributeValue_dump(self) lasso_node_dump(LASSO_NODE(self))
695
 
 
696
 
 
697
 
 
698
 
 
699
 
/* Attributes implementations */
700
 
 
701
 
/* audience */
702
 
#define LassoSamlAudienceRestrictionCondition_get_audience(self) get_string_list((self)->Audience)
703
 
#define LassoSamlAudienceRestrictionCondition_audience_get(self) get_string_list((self)->Audience)
704
 
#define LassoSamlAudienceRestrictionCondition_set_audience(self, value) set_string_list(&(self)->Audience, (value))
705
 
#define LassoSamlAudienceRestrictionCondition_audience_set(self, value) set_string_list(&(self)->Audience, (value))
706
 
 
707
 
/* Constructors, destructors & static methods implementations */
708
 
 
709
 
#define new_LassoSamlAudienceRestrictionCondition lasso_saml_audience_restriction_condition_new
710
 
#define delete_LassoSamlAudienceRestrictionCondition(self) lasso_node_destroy(LASSO_NODE(self))
711
 
 
712
 
/* Implementations of methods inherited from LassoNode */
713
 
 
714
 
#define LassoSamlAudienceRestrictionCondition_dump(self) lasso_node_dump(LASSO_NODE(self))
715
 
 
716
 
 
717
 
 
718
 
 
719
 
/* Attributes Implementations */
720
 
 
721
 
/* AuthorityBinding */
722
 
#define LassoSamlAuthenticationStatement_get_AuthorityBinding(self) get_node_list((self)->AuthorityBinding)
723
 
#define LassoSamlAuthenticationStatement_AuthorityBinding_get(self) get_node_list((self)->AuthorityBinding)
724
 
#define LassoSamlAuthenticationStatement_set_AuthorityBinding(self, value) set_node_list(&(self)->AuthorityBinding, (value))
725
 
#define LassoSamlAuthenticationStatement_AuthorityBinding_set(self, value) set_node_list(&(self)->AuthorityBinding, (value))
726
 
 
727
 
/* SubjectLocality */
728
 
#define LassoSamlAuthenticationStatement_get_SubjectLocality(self) get_node((self)->SubjectLocality)
729
 
#define LassoSamlAuthenticationStatement_SubjectLocality_get(self) get_node((self)->SubjectLocality)
730
 
#define LassoSamlAuthenticationStatement_set_SubjectLocality(self, value) set_node((gpointer *) &(self)->SubjectLocality, (value))
731
 
#define LassoSamlAuthenticationStatement_SubjectLocality_set(self, value) set_node((gpointer *) &(self)->SubjectLocality, (value))
732
 
 
733
 
/* Constructors, destructors & static methods implementations */
734
 
 
735
 
#define new_LassoSamlAuthenticationStatement lasso_saml_authentication_statement_new
736
 
#define delete_LassoSamlAuthenticationStatement(self) lasso_node_destroy(LASSO_NODE(self))
737
 
 
738
 
/* Implementations of methods inherited from LassoNode */
739
 
 
740
 
#define LassoSamlAuthenticationStatement_dump(self) lasso_node_dump(LASSO_NODE(self))
741
 
 
742
 
 
743
 
 
744
 
 
745
 
/* Constructors, destructors & static methods implementations */
746
 
 
747
 
#define new_LassoSamlAuthorityBinding lasso_saml_authority_binding_new
748
 
#define delete_LassoSamlAuthorityBinding(self) lasso_node_destroy(LASSO_NODE(self))
749
 
 
750
 
/* Implementations of methods inherited from LassoNode */
751
 
 
752
 
#define LassoSamlAuthorityBinding_dump(self) lasso_node_dump(LASSO_NODE(self))
753
 
 
754
 
 
755
 
 
756
 
 
757
 
/* Implementations of methods inherited from LassoNode */
758
 
 
759
 
#define LassoSamlConditionAbstract_dump(self) lasso_node_dump(LASSO_NODE(self))
760
 
 
761
 
 
762
 
 
763
 
 
764
 
/* Attributes Implementations */
765
 
 
766
 
/* AudienceRestrictionCondition */
767
 
#define LassoSamlConditions_get_AudienceRestrictionCondition(self) get_node_list((self)->AudienceRestrictionCondition)
768
 
#define LassoSamlConditions_AudienceRestrictionCondition_get(self) get_node_list((self)->AudienceRestrictionCondition)
769
 
#define LassoSamlConditions_set_AudienceRestrictionCondition(self, value) set_node_list(&(self)->AudienceRestrictionCondition, (value))
770
 
#define LassoSamlConditions_AudienceRestrictionCondition_set(self, value) set_node_list(&(self)->AudienceRestrictionCondition, (value))
771
 
 
772
 
/* Condition */
773
 
#define LassoSamlConditions_get_Condition(self) get_node_list((self)->Condition)
774
 
#define LassoSamlConditions_Condition_get(self) get_node_list((self)->Condition)
775
 
#define LassoSamlConditions_set_Condition(self, value) set_node_list(&(self)->Condition, (value))
776
 
#define LassoSamlConditions_Condition_set(self, value) set_node_list(&(self)->Condition, (value))
777
 
 
778
 
/* Constructors, destructors & static methods implementations */
779
 
 
780
 
#define new_LassoSamlConditions lasso_saml_conditions_new
781
 
#define delete_LassoSamlConditions(self) lasso_node_destroy(LASSO_NODE(self))
782
 
 
783
 
/* Implementations of methods inherited from LassoNode */
784
 
 
785
 
#define LassoSamlConditions_dump(self) lasso_node_dump(LASSO_NODE(self))
786
 
 
787
 
 
788
 
 
789
 
 
790
 
/* Constructors, destructors & static methods implementations */
791
 
 
792
 
#define new_LassoSamlNameIdentifier lasso_saml_name_identifier_new
793
 
#define delete_LassoSamlNameIdentifier(self) lasso_node_destroy(LASSO_NODE(self))
794
 
 
795
 
/* Implementations of methods inherited from LassoNode */
796
 
 
797
 
#define LassoSamlNameIdentifier_dump(self) lasso_node_dump(LASSO_NODE(self))
798
 
 
799
 
 
800
 
 
801
 
 
802
 
/* Implementations of methods inherited from LassoNode */
803
 
 
804
 
#define LassoSamlStatementAbstract_dump(self) lasso_node_dump(LASSO_NODE(self))
805
 
 
806
 
 
807
 
 
808
 
 
809
 
/* Attributes implementations */
810
 
 
811
 
/* NameIdentifier */
812
 
#define LassoSamlSubject_get_NameIdentifier(self) get_node((self)->NameIdentifier)
813
 
#define LassoSamlSubject_NameIdentifier_get(self) get_node((self)->NameIdentifier)
814
 
#define LassoSamlSubject_set_NameIdentifier(self, value) set_node((gpointer *) &(self)->NameIdentifier, (value))
815
 
#define LassoSamlSubject_NameIdentifier_set(self, value) set_node((gpointer *) &(self)->NameIdentifier, (value))
816
 
 
817
 
/* SubjectConfirmation */
818
 
#define LassoSamlSubject_get_SubjectConfirmation(self) get_node((self)->SubjectConfirmation)
819
 
#define LassoSamlSubject_SubjectConfirmation_get(self) get_node((self)->SubjectConfirmation)
820
 
#define LassoSamlSubject_set_SubjectConfirmation(self, value) set_node((gpointer *) &(self)->SubjectConfirmation, (value))
821
 
#define LassoSamlSubject_SubjectConfirmation_set(self, value) set_node((gpointer *) &(self)->SubjectConfirmation, (value))
822
 
 
823
 
/* Constructors, destructors & static methods implementations */
824
 
 
825
 
#define new_LassoSamlSubject lasso_saml_subject_new
826
 
#define delete_LassoSamlSubject(self) lasso_node_destroy(LASSO_NODE(self))
827
 
 
828
 
/* Implementations of methods inherited from LassoNode */
829
 
 
830
 
#define LassoSamlSubject_dump(self) lasso_node_dump(LASSO_NODE(self))
831
 
 
832
 
 
833
 
 
834
 
 
835
 
/* Attributes implementations */
836
 
 
837
 
/* confirmationMethod */
838
 
#define LassoSamlSubjectConfirmation_get_confirmationMethod(self) get_string_list((self)->ConfirmationMethod)
839
 
#define LassoSamlSubjectConfirmation_confirmationMethod_get(self) get_string_list((self)->ConfirmationMethod)
840
 
#define LassoSamlSubjectConfirmation_set_confirmationMethod(self, value) set_string_list(&(self)->ConfirmationMethod, (value))
841
 
#define LassoSamlSubjectConfirmation_confirmationMethod_set(self, value) set_string_list(&(self)->ConfirmationMethod, (value))
842
 
 
843
 
/* Constructors, destructors & static methods implementations */
844
 
 
845
 
#define new_LassoSamlSubjectConfirmation lasso_saml_subject_confirmation_new
846
 
#define delete_LassoSamlSubjectConfirmation(self) lasso_node_destroy(LASSO_NODE(self))
847
 
 
848
 
/* Implementations of methods inherited from LassoNode */
849
 
 
850
 
#define LassoSamlSubjectConfirmation_dump(self) lasso_node_dump(LASSO_NODE(self))
851
 
 
852
 
 
853
 
 
854
 
 
855
 
/* Constructors, destructors & static methods implementations */
856
 
 
857
 
#define new_LassoSamlSubjectLocality lasso_saml_subject_locality_new
858
 
#define delete_LassoSamlSubjectLocality(self) lasso_node_destroy(LASSO_NODE(self))
859
 
 
860
 
/* Implementations of methods inherited from LassoNode */
861
 
 
862
 
#define LassoSamlSubjectLocality_dump(self) lasso_node_dump(LASSO_NODE(self))
863
 
 
864
 
 
865
 
 
866
 
 
867
 
/* Implementations of attributes inherited from SamlSubjectStatementAbstract */
868
 
 
869
 
/* Subject */
870
 
#define LassoSamlSubjectStatement_get_Subject(self) get_node(LASSO_SAML_SUBJECT_STATEMENT_ABSTRACT(self)->Subject)
871
 
#define LassoSamlSubjectStatement_Subject_get(self) get_node(LASSO_SAML_SUBJECT_STATEMENT_ABSTRACT(self)->Subject)
872
 
#define LassoSamlSubjectStatement_set_Subject(self, value) set_node((gpointer *) &LASSO_SAML_SUBJECT_STATEMENT_ABSTRACT(self)->Subject, (value))
873
 
#define LassoSamlSubjectStatement_Subject_set(self, value) set_node((gpointer *) &LASSO_SAML_SUBJECT_STATEMENT_ABSTRACT(self)->Subject, (value))
874
 
 
875
 
/* Constructors, destructors & static methods implementations */
876
 
 
877
 
#define new_LassoSamlSubjectStatement lasso_saml_subject_statement_new
878
 
#define delete_LassoSamlSubjectStatement(self) lasso_node_destroy(LASSO_NODE(self))
879
 
 
880
 
/* Implementations of methods inherited from LassoNode */
881
 
 
882
 
#define LassoSamlSubjectStatement_dump(self) lasso_node_dump(LASSO_NODE(self))
883
 
 
884
 
 
885
 
 
886
 
 
887
 
/* Attributes implementations */
888
 
 
889
 
/* Subject */
890
 
#define LassoSamlSubjectStatementAbstract_get_Subject(self) get_node((self)->Subject)
891
 
#define LassoSamlSubjectStatementAbstract_Subject_get(self) get_node((self)->Subject)
892
 
#define LassoSamlSubjectStatementAbstract_set_Subject(self, value) set_node((gpointer *) &(self)->Subject, (value))
893
 
#define LassoSamlSubjectStatementAbstract_Subject_set(self, value) set_node((gpointer *) &(self)->Subject, (value))
894
 
 
895
 
/* Implementations of methods inherited from LassoNode */
896
 
 
897
 
#define LassoSamlSubjectStatementAbstract_dump(self) lasso_node_dump(LASSO_NODE(self))
898
 
 
899
 
 
900
 
 
901
 
 
902
 
/* Implementations of attributes inherited from SamlpRequestAbstract */
903
 
 
904
 
/* certificate_file */
905
 
#define LassoSamlpRequest_get_certificate_file(self) LASSO_SAMLP_REQUEST_ABSTRACT(self)->certificate_file
906
 
#define LassoSamlpRequest_certificate_file_get(self) LASSO_SAMLP_REQUEST_ABSTRACT(self)->certificate_file
907
 
#define LassoSamlpRequest_set_certificate_file(self, value) set_string(&LASSO_SAMLP_REQUEST_ABSTRACT(self)->certificate_file, (value))
908
 
#define LassoSamlpRequest_certificate_file_set(self, value) set_string(&LASSO_SAMLP_REQUEST_ABSTRACT(self)->certificate_file, (value))
909
 
 
910
 
/* IssueInstant */
911
 
#define LassoSamlpRequest_get_IssueInstant(self) LASSO_SAMLP_REQUEST_ABSTRACT(self)->IssueInstant
912
 
#define LassoSamlpRequest_IssueInstant_get(self) LASSO_SAMLP_REQUEST_ABSTRACT(self)->IssueInstant
913
 
#define LassoSamlpRequest_set_IssueInstant(self, value) set_string(&LASSO_SAMLP_REQUEST_ABSTRACT(self)->IssueInstant, (value))
914
 
#define LassoSamlpRequest_IssueInstant_set(self, value) set_string(&LASSO_SAMLP_REQUEST_ABSTRACT(self)->IssueInstant, (value))
915
 
 
916
 
/* MajorVersion */
917
 
#define LassoSamlpRequest_get_MajorVersion(self) LASSO_SAMLP_REQUEST_ABSTRACT(self)->MajorVersion
918
 
#define LassoSamlpRequest_MajorVersion_get(self) LASSO_SAMLP_REQUEST_ABSTRACT(self)->MajorVersion
919
 
#define LassoSamlpRequest_set_MajorVersion(self, value) LASSO_SAMLP_REQUEST_ABSTRACT(self)->MajorVersion = (value)
920
 
#define LassoSamlpRequest_MajorVersion_set(self, value) LASSO_SAMLP_REQUEST_ABSTRACT(self)->MajorVersion = (value)
921
 
 
922
 
/* MinorVersion */
923
 
#define LassoSamlpRequest_get_MinorVersion(self) LASSO_SAMLP_REQUEST_ABSTRACT(self)->MinorVersion
924
 
#define LassoSamlpRequest_MinorVersion_get(self) LASSO_SAMLP_REQUEST_ABSTRACT(self)->MinorVersion
925
 
#define LassoSamlpRequest_set_MinorVersion(self, value) LASSO_SAMLP_REQUEST_ABSTRACT(self)->MinorVersion = (value)
926
 
#define LassoSamlpRequest_MinorVersion_set(self, value) LASSO_SAMLP_REQUEST_ABSTRACT(self)->MinorVersion = (value)
927
 
 
928
 
/* private_key_file */
929
 
#define LassoSamlpRequest_get_private_key_file(self) LASSO_SAMLP_REQUEST_ABSTRACT(self)->private_key_file
930
 
#define LassoSamlpRequest_private_key_file_get(self) LASSO_SAMLP_REQUEST_ABSTRACT(self)->private_key_file
931
 
#define LassoSamlpRequest_set_private_key_file(self, value) set_string(&LASSO_SAMLP_REQUEST_ABSTRACT(self)->private_key_file, (value))
932
 
#define LassoSamlpRequest_private_key_file_set(self, value) set_string(&LASSO_SAMLP_REQUEST_ABSTRACT(self)->private_key_file, (value))
933
 
 
934
 
/* RequestID */
935
 
#define LassoSamlpRequest_get_RequestID(self) LASSO_SAMLP_REQUEST_ABSTRACT(self)->RequestID
936
 
#define LassoSamlpRequest_RequestID_get(self) LASSO_SAMLP_REQUEST_ABSTRACT(self)->RequestID
937
 
#define LassoSamlpRequest_set_RequestID(self, value) set_string(&LASSO_SAMLP_REQUEST_ABSTRACT(self)->RequestID, (value))
938
 
#define LassoSamlpRequest_RequestID_set(self, value) set_string(&LASSO_SAMLP_REQUEST_ABSTRACT(self)->RequestID, (value))
939
 
 
940
 
/* RespondWith */
941
 
#define LassoSamlpRequest_get_RespondWith(self) get_string_list(LASSO_SAMLP_REQUEST_ABSTRACT(self)->RespondWith)
942
 
#define LassoSamlpRequest_RespondWith_get(self) get_string_list(LASSO_SAMLP_REQUEST_ABSTRACT(self)->RespondWith)
943
 
#define LassoSamlpRequest_set_RespondWith(self, value) set_string_list(&LASSO_SAMLP_REQUEST_ABSTRACT(self)->RespondWith, (value))
944
 
#define LassoSamlpRequest_RespondWith_set(self, value) set_string_list(&LASSO_SAMLP_REQUEST_ABSTRACT(self)->RespondWith, (value))
945
 
 
946
 
/* sign_method */
947
 
#define LassoSamlpRequest_get_sign_method(self) LASSO_SAMLP_REQUEST_ABSTRACT(self)->sign_method
948
 
#define LassoSamlpRequest_sign_method_get(self) LASSO_SAMLP_REQUEST_ABSTRACT(self)->sign_method
949
 
#define LassoSamlpRequest_set_sign_method(self, value) LASSO_SAMLP_REQUEST_ABSTRACT(self)->sign_method = (value)
950
 
#define LassoSamlpRequest_sign_method_set(self, value) LASSO_SAMLP_REQUEST_ABSTRACT(self)->sign_method = (value)
951
 
 
952
 
/* sign_type */
953
 
#define LassoSamlpRequest_get_sign_type(self) LASSO_SAMLP_REQUEST_ABSTRACT(self)->sign_type
954
 
#define LassoSamlpRequest_sign_type_get(self) LASSO_SAMLP_REQUEST_ABSTRACT(self)->sign_type
955
 
#define LassoSamlpRequest_set_sign_type(self, value) LASSO_SAMLP_REQUEST_ABSTRACT(self)->sign_type = (value)
956
 
#define LassoSamlpRequest_sign_type_set(self, value) LASSO_SAMLP_REQUEST_ABSTRACT(self)->sign_type = (value)
957
 
 
958
 
/* Constructors, destructors & static methods implementations */
959
 
 
960
 
#define new_LassoSamlpRequest lasso_samlp_request_new
961
 
#define delete_LassoSamlpRequest(self) lasso_node_destroy(LASSO_NODE(self))
962
 
 
963
 
/* Implementations of methods inherited from LassoNode */
964
 
 
965
 
#define LassoSamlpRequest_dump(self) lasso_node_dump(LASSO_NODE(self))
966
 
 
967
 
 
968
 
 
969
 
 
970
 
/* Attributes implementations */
971
 
 
972
 
/* RespondWith */
973
 
#define LassoSamlpRequestAbstract_get_RespondWith(self) get_string_list((self)->RespondWith)
974
 
#define LassoSamlpRequestAbstract_RespondWith_get(self) get_string_list((self)->RespondWith)
975
 
#define LassoSamlpRequestAbstract_set_RespondWith(self, value) set_string_list(&(self)->RespondWith, (value))
976
 
#define LassoSamlpRequestAbstract_RespondWith_set(self, value) set_string_list(&(self)->RespondWith, (value))
977
 
 
978
 
/* Implementations of methods inherited from LassoNode */
979
 
 
980
 
#define LassoSamlpRequestAbstract_dump(self) lasso_node_dump(LASSO_NODE(self))
981
 
 
982
 
 
983
 
 
984
 
 
985
 
/* Implementations of attributes inherited from SamlpResponseAbstract */
986
 
 
987
 
/* certificate_file */
988
 
#define LassoSamlpResponse_get_certificate_file(self) LASSO_SAMLP_RESPONSE_ABSTRACT(self)->certificate_file
989
 
#define LassoSamlpResponse_certificate_file_get(self) LASSO_SAMLP_RESPONSE_ABSTRACT(self)->certificate_file
990
 
#define LassoSamlpResponse_set_certificate_file(self, value) set_string(&LASSO_SAMLP_RESPONSE_ABSTRACT(self)->certificate_file, (value))
991
 
#define LassoSamlpResponse_certificate_file_set(self, value) set_string(&LASSO_SAMLP_RESPONSE_ABSTRACT(self)->certificate_file, (value))
992
 
 
993
 
/* InResponseTo */
994
 
#define LassoSamlpResponse_get_InResponseTo(self) LASSO_SAMLP_RESPONSE_ABSTRACT(self)->InResponseTo
995
 
#define LassoSamlpResponse_InResponseTo_get(self) LASSO_SAMLP_RESPONSE_ABSTRACT(self)->InResponseTo
996
 
#define LassoSamlpResponse_set_InResponseTo(self, value) set_string(&LASSO_SAMLP_RESPONSE_ABSTRACT(self)->InResponseTo, (value))
997
 
#define LassoSamlpResponse_InResponseTo_set(self, value) set_string(&LASSO_SAMLP_RESPONSE_ABSTRACT(self)->InResponseTo, (value))
998
 
 
999
 
/* IssueInstant */
1000
 
#define LassoSamlpResponse_get_IssueInstant(self) LASSO_SAMLP_RESPONSE_ABSTRACT(self)->IssueInstant
1001
 
#define LassoSamlpResponse_IssueInstant_get(self) LASSO_SAMLP_RESPONSE_ABSTRACT(self)->IssueInstant
1002
 
#define LassoSamlpResponse_set_IssueInstant(self, value) set_string(&LASSO_SAMLP_RESPONSE_ABSTRACT(self)->IssueInstant, (value))
1003
 
#define LassoSamlpResponse_IssueInstant_set(self, value) set_string(&LASSO_SAMLP_RESPONSE_ABSTRACT(self)->IssueInstant, (value))
1004
 
 
1005
 
/* MajorVersion */
1006
 
#define LassoSamlpResponse_get_MajorVersion(self) LASSO_SAMLP_RESPONSE_ABSTRACT(self)->MajorVersion
1007
 
#define LassoSamlpResponse_MajorVersion_get(self) LASSO_SAMLP_RESPONSE_ABSTRACT(self)->MajorVersion
1008
 
#define LassoSamlpResponse_set_MajorVersion(self, value) LASSO_SAMLP_RESPONSE_ABSTRACT(self)->MajorVersion = (value)
1009
 
#define LassoSamlpResponse_MajorVersion_set(self, value) LASSO_SAMLP_RESPONSE_ABSTRACT(self)->MajorVersion = (value)
1010
 
 
1011
 
/* MinorVersion */
1012
 
#define LassoSamlpResponse_get_MinorVersion(self) LASSO_SAMLP_RESPONSE_ABSTRACT(self)->MinorVersion
1013
 
#define LassoSamlpResponse_MinorVersion_get(self) LASSO_SAMLP_RESPONSE_ABSTRACT(self)->MinorVersion
1014
 
#define LassoSamlpResponse_set_MinorVersion(self, value) LASSO_SAMLP_RESPONSE_ABSTRACT(self)->MinorVersion = (value)
1015
 
#define LassoSamlpResponse_MinorVersion_set(self, value) LASSO_SAMLP_RESPONSE_ABSTRACT(self)->MinorVersion = (value)
1016
 
 
1017
 
/* private_key_file */
1018
 
#define LassoSamlpResponse_get_private_key_file(self) LASSO_SAMLP_RESPONSE_ABSTRACT(self)->private_key_file
1019
 
#define LassoSamlpResponse_private_key_file_get(self) LASSO_SAMLP_RESPONSE_ABSTRACT(self)->private_key_file
1020
 
#define LassoSamlpResponse_set_private_key_file(self, value) set_string(&LASSO_SAMLP_RESPONSE_ABSTRACT(self)->private_key_file, (value))
1021
 
#define LassoSamlpResponse_private_key_file_set(self, value) set_string(&LASSO_SAMLP_RESPONSE_ABSTRACT(self)->private_key_file, (value))
1022
 
 
1023
 
/* Recipient */
1024
 
#define LassoSamlpResponse_get_Recipient(self) LASSO_SAMLP_RESPONSE_ABSTRACT(self)->Recipient
1025
 
#define LassoSamlpResponse_Recipient_get(self) LASSO_SAMLP_RESPONSE_ABSTRACT(self)->Recipient
1026
 
#define LassoSamlpResponse_set_Recipient(self, value) set_string(&LASSO_SAMLP_RESPONSE_ABSTRACT(self)->Recipient, (value))
1027
 
#define LassoSamlpResponse_Recipient_set(self, value) set_string(&LASSO_SAMLP_RESPONSE_ABSTRACT(self)->Recipient, (value))
1028
 
 
1029
 
/* ResponseID */
1030
 
#define LassoSamlpResponse_get_ResponseID(self) LASSO_SAMLP_RESPONSE_ABSTRACT(self)->ResponseID
1031
 
#define LassoSamlpResponse_ResponseID_get(self) LASSO_SAMLP_RESPONSE_ABSTRACT(self)->ResponseID
1032
 
#define LassoSamlpResponse_set_ResponseID(self, value) set_string(&LASSO_SAMLP_RESPONSE_ABSTRACT(self)->ResponseID, (value))
1033
 
#define LassoSamlpResponse_ResponseID_set(self, value) set_string(&LASSO_SAMLP_RESPONSE_ABSTRACT(self)->ResponseID, (value))
1034
 
 
1035
 
/* sign_method */
1036
 
#define LassoSamlpResponse_get_sign_method(self) LASSO_SAMLP_RESPONSE_ABSTRACT(self)->sign_method
1037
 
#define LassoSamlpResponse_sign_method_get(self) LASSO_SAMLP_RESPONSE_ABSTRACT(self)->sign_method
1038
 
#define LassoSamlpResponse_set_sign_method(self, value) LASSO_SAMLP_RESPONSE_ABSTRACT(self)->sign_method = (value)
1039
 
#define LassoSamlpResponse_sign_method_set(self, value) LASSO_SAMLP_RESPONSE_ABSTRACT(self)->sign_method = (value)
1040
 
 
1041
 
/* sign_type */
1042
 
#define LassoSamlpResponse_get_sign_type(self) LASSO_SAMLP_RESPONSE_ABSTRACT(self)->sign_type
1043
 
#define LassoSamlpResponse_sign_type_get(self) LASSO_SAMLP_RESPONSE_ABSTRACT(self)->sign_type
1044
 
#define LassoSamlpResponse_set_sign_type(self, value) LASSO_SAMLP_RESPONSE_ABSTRACT(self)->sign_type = (value)
1045
 
#define LassoSamlpResponse_sign_type_set(self, value) LASSO_SAMLP_RESPONSE_ABSTRACT(self)->sign_type = (value)
1046
 
 
1047
 
/* Attributes Implementations */
1048
 
 
1049
 
/* Assertion */
1050
 
#define LassoSamlpResponse_get_Assertion(self) get_node_list((self)->Assertion)
1051
 
#define LassoSamlpResponse_Assertion_get(self) get_node_list((self)->Assertion)
1052
 
#define LassoSamlpResponse_set_Assertion(self, value) set_node_list(&(self)->Assertion, (value))
1053
 
#define LassoSamlpResponse_Assertion_set(self, value) set_node_list(&(self)->Assertion, (value))
1054
 
 
1055
 
/* Status */
1056
 
#define LassoSamlpResponse_get_Status(self) get_node((self)->Status)
1057
 
#define LassoSamlpResponse_Status_get(self) get_node((self)->Status)
1058
 
#define LassoSamlpResponse_set_Status(self, value) set_node((gpointer *) &(self)->Status, (value))
1059
 
#define LassoSamlpResponse_Status_set(self, value) set_node((gpointer *) &(self)->Status, (value))
1060
 
 
1061
 
/* Constructors, destructors & static methods implementations */
1062
 
 
1063
 
#define new_LassoSamlpResponse lasso_samlp_response_new
1064
 
#define delete_LassoSamlpResponse(self) lasso_node_destroy(LASSO_NODE(self))
1065
 
 
1066
 
/* Implementations of methods inherited from LassoNode */
1067
 
 
1068
 
#define LassoSamlpResponse_dump(self) lasso_node_dump(LASSO_NODE(self))
1069
 
 
1070
 
 
1071
 
 
1072
 
 
1073
 
/* Implementations of methods inherited from LassoNode */
1074
 
 
1075
 
#define LassoSamlpResponseAbstract_dump(self) lasso_node_dump(LASSO_NODE(self))
1076
 
 
1077
 
 
1078
 
 
1079
 
 
1080
 
/* Attributes Implementations */
1081
 
 
1082
 
/* StatusCode */
1083
 
#define LassoSamlpStatus_get_StatusCode(self) get_node((self)->StatusCode)
1084
 
#define LassoSamlpStatus_StatusCode_get(self) get_node((self)->StatusCode)
1085
 
#define LassoSamlpStatus_set_StatusCode(self, value) set_node((gpointer *) &(self)->StatusCode, (value))
1086
 
#define LassoSamlpStatus_StatusCode_set(self, value) set_node((gpointer *) &(self)->StatusCode, (value))
1087
 
 
1088
 
/* Constructors, destructors & static methods implementations */
1089
 
 
1090
 
#define new_LassoSamlpStatus lasso_samlp_status_new
1091
 
#define delete_LassoSamlpStatus(self) lasso_node_destroy(LASSO_NODE(self))
1092
 
 
1093
 
/* Implementations of methods inherited from LassoNode */
1094
 
 
1095
 
#define LassoSamlpStatus_dump(self) lasso_node_dump(LASSO_NODE(self))
1096
 
 
1097
 
 
1098
 
 
1099
 
 
1100
 
/* Attributes Implementations */
1101
 
 
1102
 
/* StatusCode */
1103
 
#define LassoSamlpStatusCode_get_StatusCode(self) get_node((self)->StatusCode)
1104
 
#define LassoSamlpStatusCode_StatusCode_get(self) get_node((self)->StatusCode)
1105
 
#define LassoSamlpStatusCode_set_StatusCode(self, value) set_node((gpointer *) &(self)->StatusCode, (value))
1106
 
#define LassoSamlpStatusCode_StatusCode_set(self, value) set_node((gpointer *) &(self)->StatusCode, (value))
1107
 
 
1108
 
/* Constructors, destructors & static methods implementations */
1109
 
 
1110
 
#define new_LassoSamlpStatusCode lasso_samlp_status_code_new
1111
 
#define delete_LassoSamlpStatusCode(self) lasso_node_destroy(LASSO_NODE(self))
1112
 
 
1113
 
/* Implementations of methods inherited from LassoNode */
1114
 
 
1115
 
#define LassoSamlpStatusCode_dump(self) lasso_node_dump(LASSO_NODE(self))
1116
 
 
1117
 
 
1118
 
 
1119
 
 
1120
 
/* Implementations of attributes inherited from SamlAssertion */
1121
 
 
1122
 
/* Advice */
1123
 
#define LassoLibAssertion_get_Advice(self) get_node(LASSO_SAML_ASSERTION(self)->Advice)
1124
 
#define LassoLibAssertion_Advice_get(self) get_node(LASSO_SAML_ASSERTION(self)->Advice)
1125
 
#define LassoLibAssertion_set_Advice(self, value) set_node((gpointer *) &LASSO_SAML_ASSERTION(self)->Advice, (value))
1126
 
#define LassoLibAssertion_Advice_set(self, value) set_node((gpointer *) &LASSO_SAML_ASSERTION(self)->Advice, (value))
1127
 
 
1128
 
/* AssertionID */
1129
 
#define LassoLibAssertion_get_AssertionID(self) LASSO_SAML_ASSERTION(self)->AssertionID
1130
 
#define LassoLibAssertion_AssertionID_get(self) LASSO_SAML_ASSERTION(self)->AssertionID
1131
 
#define LassoLibAssertion_set_AssertionID(self, value) set_string(&LASSO_SAML_ASSERTION(self)->AssertionID, (value))
1132
 
#define LassoLibAssertion_AssertionID_set(self, value) set_string(&LASSO_SAML_ASSERTION(self)->AssertionID, (value))
1133
 
 
1134
 
/* AttributeStatement */
1135
 
#define LassoLibAssertion_get_AttributeStatement(self) get_node(LASSO_SAML_ASSERTION(self)->AttributeStatement)
1136
 
#define LassoLibAssertion_AttributeStatement_get(self) get_node(LASSO_SAML_ASSERTION(self)->AttributeStatement)
1137
 
#define LassoLibAssertion_set_AttributeStatement(self, value) set_node((gpointer *) &LASSO_SAML_ASSERTION(self)->AttributeStatement, (value))
1138
 
#define LassoLibAssertion_AttributeStatement_set(self, value) set_node((gpointer *) &LASSO_SAML_ASSERTION(self)->AttributeStatement, (value))
1139
 
 
1140
 
/* AuthenticationStatement */
1141
 
#define LassoLibAssertion_get_AuthenticationStatement(self) get_node(LASSO_SAML_ASSERTION(self)->AuthenticationStatement)
1142
 
#define LassoLibAssertion_AuthenticationStatement_get(self) get_node(LASSO_SAML_ASSERTION(self)->AuthenticationStatement)
1143
 
#define LassoLibAssertion_set_AuthenticationStatement(self, value) set_node((gpointer *) &LASSO_SAML_ASSERTION(self)->AuthenticationStatement, (value))
1144
 
#define LassoLibAssertion_AuthenticationStatement_set(self, value) set_node((gpointer *) &LASSO_SAML_ASSERTION(self)->AuthenticationStatement, (value))
1145
 
 
1146
 
/* certificate_file */
1147
 
#define LassoLibAssertion_get_certificate_file(self) LASSO_SAML_ASSERTION(self)->certificate_file
1148
 
#define LassoLibAssertion_certificate_file_get(self) LASSO_SAML_ASSERTION(self)->certificate_file
1149
 
#define LassoLibAssertion_set_certificate_file(self, value) set_string(&LASSO_SAML_ASSERTION(self)->certificate_file, (value))
1150
 
#define LassoLibAssertion_certificate_file_set(self, value) set_string(&LASSO_SAML_ASSERTION(self)->certificate_file, (value))
1151
 
 
1152
 
/* Conditions */
1153
 
#define LassoLibAssertion_get_Conditions(self) get_node(LASSO_SAML_ASSERTION(self)->Conditions)
1154
 
#define LassoLibAssertion_Conditions_get(self) get_node(LASSO_SAML_ASSERTION(self)->Conditions)
1155
 
#define LassoLibAssertion_set_Conditions(self, value) set_node((gpointer *) &LASSO_SAML_ASSERTION(self)->Conditions, (value))
1156
 
#define LassoLibAssertion_Conditions_set(self, value) set_node((gpointer *) &LASSO_SAML_ASSERTION(self)->Conditions, (value))
1157
 
 
1158
 
/* IssueInstant */
1159
 
#define LassoLibAssertion_get_IssueInstant(self) LASSO_SAML_ASSERTION(self)->IssueInstant
1160
 
#define LassoLibAssertion_IssueInstant_get(self) LASSO_SAML_ASSERTION(self)->IssueInstant
1161
 
#define LassoLibAssertion_set_IssueInstant(self, value) set_string(&LASSO_SAML_ASSERTION(self)->IssueInstant, (value))
1162
 
#define LassoLibAssertion_IssueInstant_set(self, value) set_string(&LASSO_SAML_ASSERTION(self)->IssueInstant, (value))
1163
 
 
1164
 
/* Issuer */
1165
 
#define LassoLibAssertion_get_Issuer(self) LASSO_SAML_ASSERTION(self)->Issuer
1166
 
#define LassoLibAssertion_Issuer_get(self) LASSO_SAML_ASSERTION(self)->Issuer
1167
 
#define LassoLibAssertion_set_Issuer(self, value) set_string(&LASSO_SAML_ASSERTION(self)->Issuer, (value))
1168
 
#define LassoLibAssertion_Issuer_set(self, value) set_string(&LASSO_SAML_ASSERTION(self)->Issuer, (value))
1169
 
 
1170
 
/* MajorVersion */
1171
 
#define LassoLibAssertion_get_MajorVersion(self) LASSO_SAML_ASSERTION(self)->MajorVersion
1172
 
#define LassoLibAssertion_MajorVersion_get(self) LASSO_SAML_ASSERTION(self)->MajorVersion
1173
 
#define LassoLibAssertion_set_MajorVersion(self, value) LASSO_SAML_ASSERTION(self)->MajorVersion = (value)
1174
 
#define LassoLibAssertion_MajorVersion_set(self, value) LASSO_SAML_ASSERTION(self)->MajorVersion = (value)
1175
 
 
1176
 
/* MinorVersion */
1177
 
#define LassoLibAssertion_get_MinorVersion(self) LASSO_SAML_ASSERTION(self)->MinorVersion
1178
 
#define LassoLibAssertion_MinorVersion_get(self) LASSO_SAML_ASSERTION(self)->MinorVersion
1179
 
#define LassoLibAssertion_set_MinorVersion(self, value) LASSO_SAML_ASSERTION(self)->MinorVersion = (value)
1180
 
#define LassoLibAssertion_MinorVersion_set(self, value) LASSO_SAML_ASSERTION(self)->MinorVersion = (value)
1181
 
 
1182
 
/* private_key_file */
1183
 
#define LassoLibAssertion_get_private_key_file(self) LASSO_SAML_ASSERTION(self)->private_key_file
1184
 
#define LassoLibAssertion_private_key_file_get(self) LASSO_SAML_ASSERTION(self)->private_key_file
1185
 
#define LassoLibAssertion_set_private_key_file(self, value) set_string(&LASSO_SAML_ASSERTION(self)->private_key_file, (value))
1186
 
#define LassoLibAssertion_private_key_file_set(self, value) set_string(&LASSO_SAML_ASSERTION(self)->private_key_file, (value))
1187
 
 
1188
 
/* sign_method */
1189
 
#define LassoLibAssertion_get_sign_method(self) LASSO_SAML_ASSERTION(self)->sign_method
1190
 
#define LassoLibAssertion_sign_method_get(self) LASSO_SAML_ASSERTION(self)->sign_method
1191
 
#define LassoLibAssertion_set_sign_method(self, value) LASSO_SAML_ASSERTION(self)->sign_method = (value)
1192
 
#define LassoLibAssertion_sign_method_set(self, value) LASSO_SAML_ASSERTION(self)->sign_method = (value)
1193
 
 
1194
 
/* sign_type */
1195
 
#define LassoLibAssertion_get_sign_type(self) LASSO_SAML_ASSERTION(self)->sign_type
1196
 
#define LassoLibAssertion_sign_type_get(self) LASSO_SAML_ASSERTION(self)->sign_type
1197
 
#define LassoLibAssertion_set_sign_type(self, value) LASSO_SAML_ASSERTION(self)->sign_type = (value)
1198
 
#define LassoLibAssertion_sign_type_set(self, value) LASSO_SAML_ASSERTION(self)->sign_type = (value)
1199
 
 
1200
 
/* SubjectStatement */
1201
 
#define LassoLibAssertion_get_SubjectStatement(self) get_node(LASSO_SAML_ASSERTION(self)->SubjectStatement)
1202
 
#define LassoLibAssertion_SubjectStatement_get(self) get_node(LASSO_SAML_ASSERTION(self)->SubjectStatement)
1203
 
#define LassoLibAssertion_set_SubjectStatement(self, value) set_node((gpointer *) &LASSO_SAML_ASSERTION(self)->SubjectStatement, (value))
1204
 
#define LassoLibAssertion_SubjectStatement_set(self, value) set_node((gpointer *) &LASSO_SAML_ASSERTION(self)->SubjectStatement, (value))
1205
 
 
1206
 
/* Implementations of methods inherited from SamlAssertion */
1207
 
 
1208
 
/* Constructors, destructors & static methods implementations */
1209
 
 
1210
 
#define new_LassoLibAssertion lasso_lib_assertion_new
1211
 
#define delete_LassoLibAssertion(self) lasso_node_destroy(LASSO_NODE(self))
1212
 
#ifdef PHP_VERSION
1213
 
#define LassoLibAssertion_newFull lasso_lib_assertion_new_full
1214
 
#else
1215
 
#define LibAssertion_newFull lasso_lib_assertion_new_full
1216
 
#endif
1217
 
 
1218
 
/* Implementations of methods inherited from LassoNode */
1219
 
 
1220
 
#define LassoLibAssertion_dump(self) lasso_node_dump(LASSO_NODE(self))
1221
 
 
1222
 
 
1223
 
 
1224
 
 
1225
 
/* Implementations of attributes inherited from SamlpRequestAbstract */
1226
 
 
1227
 
/* certificate_file */
1228
 
#define LassoLibAuthnRequest_get_certificate_file(self) LASSO_SAMLP_REQUEST_ABSTRACT(self)->certificate_file
1229
 
#define LassoLibAuthnRequest_certificate_file_get(self) LASSO_SAMLP_REQUEST_ABSTRACT(self)->certificate_file
1230
 
#define LassoLibAuthnRequest_set_certificate_file(self, value) set_string(&LASSO_SAMLP_REQUEST_ABSTRACT(self)->certificate_file, (value))
1231
 
#define LassoLibAuthnRequest_certificate_file_set(self, value) set_string(&LASSO_SAMLP_REQUEST_ABSTRACT(self)->certificate_file, (value))
1232
 
 
1233
 
/* IssueInstant */
1234
 
#define LassoLibAuthnRequest_get_IssueInstant(self) LASSO_SAMLP_REQUEST_ABSTRACT(self)->IssueInstant
1235
 
#define LassoLibAuthnRequest_IssueInstant_get(self) LASSO_SAMLP_REQUEST_ABSTRACT(self)->IssueInstant
1236
 
#define LassoLibAuthnRequest_set_IssueInstant(self, value) set_string(&LASSO_SAMLP_REQUEST_ABSTRACT(self)->IssueInstant, (value))
1237
 
#define LassoLibAuthnRequest_IssueInstant_set(self, value) set_string(&LASSO_SAMLP_REQUEST_ABSTRACT(self)->IssueInstant, (value))
1238
 
 
1239
 
/* MajorVersion */
1240
 
#define LassoLibAuthnRequest_get_MajorVersion(self) LASSO_SAMLP_REQUEST_ABSTRACT(self)->MajorVersion
1241
 
#define LassoLibAuthnRequest_MajorVersion_get(self) LASSO_SAMLP_REQUEST_ABSTRACT(self)->MajorVersion
1242
 
#define LassoLibAuthnRequest_set_MajorVersion(self, value) LASSO_SAMLP_REQUEST_ABSTRACT(self)->MajorVersion = (value)
1243
 
#define LassoLibAuthnRequest_MajorVersion_set(self, value) LASSO_SAMLP_REQUEST_ABSTRACT(self)->MajorVersion = (value)
1244
 
 
1245
 
/* MinorVersion */
1246
 
#define LassoLibAuthnRequest_get_MinorVersion(self) LASSO_SAMLP_REQUEST_ABSTRACT(self)->MinorVersion
1247
 
#define LassoLibAuthnRequest_MinorVersion_get(self) LASSO_SAMLP_REQUEST_ABSTRACT(self)->MinorVersion
1248
 
#define LassoLibAuthnRequest_set_MinorVersion(self, value) LASSO_SAMLP_REQUEST_ABSTRACT(self)->MinorVersion = (value)
1249
 
#define LassoLibAuthnRequest_MinorVersion_set(self, value) LASSO_SAMLP_REQUEST_ABSTRACT(self)->MinorVersion = (value)
1250
 
 
1251
 
/* private_key_file */
1252
 
#define LassoLibAuthnRequest_get_private_key_file(self) LASSO_SAMLP_REQUEST_ABSTRACT(self)->private_key_file
1253
 
#define LassoLibAuthnRequest_private_key_file_get(self) LASSO_SAMLP_REQUEST_ABSTRACT(self)->private_key_file
1254
 
#define LassoLibAuthnRequest_set_private_key_file(self, value) set_string(&LASSO_SAMLP_REQUEST_ABSTRACT(self)->private_key_file, (value))
1255
 
#define LassoLibAuthnRequest_private_key_file_set(self, value) set_string(&LASSO_SAMLP_REQUEST_ABSTRACT(self)->private_key_file, (value))
1256
 
 
1257
 
/* RequestID */
1258
 
#define LassoLibAuthnRequest_get_RequestID(self) LASSO_SAMLP_REQUEST_ABSTRACT(self)->RequestID
1259
 
#define LassoLibAuthnRequest_RequestID_get(self) LASSO_SAMLP_REQUEST_ABSTRACT(self)->RequestID
1260
 
#define LassoLibAuthnRequest_set_RequestID(self, value) set_string(&LASSO_SAMLP_REQUEST_ABSTRACT(self)->RequestID, (value))
1261
 
#define LassoLibAuthnRequest_RequestID_set(self, value) set_string(&LASSO_SAMLP_REQUEST_ABSTRACT(self)->RequestID, (value))
1262
 
 
1263
 
/* RespondWith */
1264
 
#define LassoLibAuthnRequest_get_RespondWith(self) get_string_list(LASSO_SAMLP_REQUEST_ABSTRACT(self)->RespondWith)
1265
 
#define LassoLibAuthnRequest_RespondWith_get(self) get_string_list(LASSO_SAMLP_REQUEST_ABSTRACT(self)->RespondWith)
1266
 
#define LassoLibAuthnRequest_set_RespondWith(self, value) set_string_list(&LASSO_SAMLP_REQUEST_ABSTRACT(self)->RespondWith, (value))
1267
 
#define LassoLibAuthnRequest_RespondWith_set(self, value) set_string_list(&LASSO_SAMLP_REQUEST_ABSTRACT(self)->RespondWith, (value))
1268
 
 
1269
 
/* sign_method */
1270
 
#define LassoLibAuthnRequest_get_sign_method(self) LASSO_SAMLP_REQUEST_ABSTRACT(self)->sign_method
1271
 
#define LassoLibAuthnRequest_sign_method_get(self) LASSO_SAMLP_REQUEST_ABSTRACT(self)->sign_method
1272
 
#define LassoLibAuthnRequest_set_sign_method(self, value) LASSO_SAMLP_REQUEST_ABSTRACT(self)->sign_method = (value)
1273
 
#define LassoLibAuthnRequest_sign_method_set(self, value) LASSO_SAMLP_REQUEST_ABSTRACT(self)->sign_method = (value)
1274
 
 
1275
 
/* sign_type */
1276
 
#define LassoLibAuthnRequest_get_sign_type(self) LASSO_SAMLP_REQUEST_ABSTRACT(self)->sign_type
1277
 
#define LassoLibAuthnRequest_sign_type_get(self) LASSO_SAMLP_REQUEST_ABSTRACT(self)->sign_type
1278
 
#define LassoLibAuthnRequest_set_sign_type(self, value) LASSO_SAMLP_REQUEST_ABSTRACT(self)->sign_type = (value)
1279
 
#define LassoLibAuthnRequest_sign_type_set(self, value) LASSO_SAMLP_REQUEST_ABSTRACT(self)->sign_type = (value)
1280
 
 
1281
 
/* Attributes Implementations */
1282
 
 
1283
 
/* Extension */
1284
 
#define LassoLibAuthnRequest_get_Extension(self) get_xml_list((self)->Extension)
1285
 
#define LassoLibAuthnRequest_Extension_get(self) get_xml_list((self)->Extension)
1286
 
#define LassoLibAuthnRequest_set_Extension(self, value) set_xml_list(&(self)->Extension, (value))
1287
 
#define LassoLibAuthnRequest_Extension_set(self, value) set_xml_list(&(self)->Extension, (value))
1288
 
 
1289
 
/* RequestAuthnContext */
1290
 
#define LassoLibAuthnRequest_get_RequestAuthnContext(self) get_node((self)->RequestAuthnContext)
1291
 
#define LassoLibAuthnRequest_RequestAuthnContext_get(self) get_node((self)->RequestAuthnContext)
1292
 
#define LassoLibAuthnRequest_set_RequestAuthnContext(self, value) set_node((gpointer *) &(self)->RequestAuthnContext, (value))
1293
 
#define LassoLibAuthnRequest_RequestAuthnContext_set(self, value) set_node((gpointer *) &(self)->RequestAuthnContext, (value))
1294
 
 
1295
 
/* Constructors, destructors & static methods implementations */
1296
 
 
1297
 
#define new_LassoLibAuthnRequest lasso_lib_authn_request_new
1298
 
#define delete_LassoLibAuthnRequest(self) lasso_node_destroy(LASSO_NODE(self))
1299
 
 
1300
 
/* Implementations of methods inherited from LassoNode */
1301
 
 
1302
 
#define LassoLibAuthnRequest_dump(self) lasso_node_dump(LASSO_NODE(self))
1303
 
 
1304
 
 
1305
 
 
1306
 
 
1307
 
/* Implementations of attributes inherited from SamlpResponse */
1308
 
 
1309
 
/* Extension */
1310
 
#define LassoLibAuthnResponse_get_Extension(self) get_xml_list((self)->Extension)
1311
 
#define LassoLibAuthnResponse_Extension_get(self) get_xml_list((self)->Extension)
1312
 
#define LassoLibAuthnResponse_set_Extension(self, value) set_xml_list(&(self)->Extension, (value))
1313
 
#define LassoLibAuthnResponse_Extension_set(self, value) set_xml_list(&(self)->Extension, (value))
1314
 
 
1315
 
/* Status */
1316
 
#define LassoLibAuthnResponse_get_Status(self) get_node(LASSO_SAMLP_RESPONSE(self)->Status)
1317
 
#define LassoLibAuthnResponse_Status_get(self) get_node(LASSO_SAMLP_RESPONSE(self)->Status)
1318
 
#define LassoLibAuthnResponse_set_Status(self, value) set_node((gpointer *) &LASSO_SAMLP_RESPONSE(self)->Status, (value))
1319
 
#define LassoLibAuthnResponse_Status_set(self, value) set_node((gpointer *) &LASSO_SAMLP_RESPONSE(self)->Status, (value))
1320
 
 
1321
 
/* Constructors, destructors & static methods implementations */
1322
 
 
1323
 
#define new_LassoLibAuthnResponse lasso_lib_authn_response_new
1324
 
#define delete_LassoLibAuthnResponse(self) lasso_node_destroy(LASSO_NODE(self))
1325
 
 
1326
 
/* Implementations of methods inherited from LassoNode */
1327
 
 
1328
 
#define LassoLibAuthnResponse_dump(self) lasso_node_dump(LASSO_NODE(self))
1329
 
 
1330
 
 
1331
 
 
1332
 
 
1333
 
/* Implementations of attributes inherited from SamlpRequestAbstract */
1334
 
 
1335
 
/* certificate_file */
1336
 
#define LassoLibFederationTerminationNotification_get_certificate_file(self) LASSO_SAMLP_REQUEST_ABSTRACT(self)->certificate_file
1337
 
#define LassoLibFederationTerminationNotification_certificate_file_get(self) LASSO_SAMLP_REQUEST_ABSTRACT(self)->certificate_file
1338
 
#define LassoLibFederationTerminationNotification_set_certificate_file(self, value) set_string(&LASSO_SAMLP_REQUEST_ABSTRACT(self)->certificate_file, (value))
1339
 
#define LassoLibFederationTerminationNotification_certificate_file_set(self, value) set_string(&LASSO_SAMLP_REQUEST_ABSTRACT(self)->certificate_file, (value))
1340
 
 
1341
 
/* IssueInstant */
1342
 
#define LassoLibFederationTerminationNotification_get_IssueInstant(self) LASSO_SAMLP_REQUEST_ABSTRACT(self)->IssueInstant
1343
 
#define LassoLibFederationTerminationNotification_IssueInstant_get(self) LASSO_SAMLP_REQUEST_ABSTRACT(self)->IssueInstant
1344
 
#define LassoLibFederationTerminationNotification_set_IssueInstant(self, value) set_string(&LASSO_SAMLP_REQUEST_ABSTRACT(self)->IssueInstant, (value))
1345
 
#define LassoLibFederationTerminationNotification_IssueInstant_set(self, value) set_string(&LASSO_SAMLP_REQUEST_ABSTRACT(self)->IssueInstant, (value))
1346
 
 
1347
 
/* MajorVersion */
1348
 
#define LassoLibFederationTerminationNotification_get_MajorVersion(self) LASSO_SAMLP_REQUEST_ABSTRACT(self)->MajorVersion
1349
 
#define LassoLibFederationTerminationNotification_MajorVersion_get(self) LASSO_SAMLP_REQUEST_ABSTRACT(self)->MajorVersion
1350
 
#define LassoLibFederationTerminationNotification_set_MajorVersion(self, value) LASSO_SAMLP_REQUEST_ABSTRACT(self)->MajorVersion = (value)
1351
 
#define LassoLibFederationTerminationNotification_MajorVersion_set(self, value) LASSO_SAMLP_REQUEST_ABSTRACT(self)->MajorVersion = (value)
1352
 
 
1353
 
/* MinorVersion */
1354
 
#define LassoLibFederationTerminationNotification_get_MinorVersion(self) LASSO_SAMLP_REQUEST_ABSTRACT(self)->MinorVersion
1355
 
#define LassoLibFederationTerminationNotification_MinorVersion_get(self) LASSO_SAMLP_REQUEST_ABSTRACT(self)->MinorVersion
1356
 
#define LassoLibFederationTerminationNotification_set_MinorVersion(self, value) LASSO_SAMLP_REQUEST_ABSTRACT(self)->MinorVersion = (value)
1357
 
#define LassoLibFederationTerminationNotification_MinorVersion_set(self, value) LASSO_SAMLP_REQUEST_ABSTRACT(self)->MinorVersion = (value)
1358
 
 
1359
 
/* private_key_file */
1360
 
#define LassoLibFederationTerminationNotification_get_private_key_file(self) LASSO_SAMLP_REQUEST_ABSTRACT(self)->private_key_file
1361
 
#define LassoLibFederationTerminationNotification_private_key_file_get(self) LASSO_SAMLP_REQUEST_ABSTRACT(self)->private_key_file
1362
 
#define LassoLibFederationTerminationNotification_set_private_key_file(self, value) set_string(&LASSO_SAMLP_REQUEST_ABSTRACT(self)->private_key_file, (value))
1363
 
#define LassoLibFederationTerminationNotification_private_key_file_set(self, value) set_string(&LASSO_SAMLP_REQUEST_ABSTRACT(self)->private_key_file, (value))
1364
 
 
1365
 
/* RequestID */
1366
 
#define LassoLibFederationTerminationNotification_get_RequestID(self) LASSO_SAMLP_REQUEST_ABSTRACT(self)->RequestID
1367
 
#define LassoLibFederationTerminationNotification_RequestID_get(self) LASSO_SAMLP_REQUEST_ABSTRACT(self)->RequestID
1368
 
#define LassoLibFederationTerminationNotification_set_RequestID(self, value) set_string(&LASSO_SAMLP_REQUEST_ABSTRACT(self)->RequestID, (value))
1369
 
#define LassoLibFederationTerminationNotification_RequestID_set(self, value) set_string(&LASSO_SAMLP_REQUEST_ABSTRACT(self)->RequestID, (value))
1370
 
 
1371
 
/* RespondWith */
1372
 
#define LassoLibFederationTerminationNotification_get_RespondWith(self) get_string_list(LASSO_SAMLP_REQUEST_ABSTRACT(self)->RespondWith)
1373
 
#define LassoLibFederationTerminationNotification_RespondWith_get(self) get_string_list(LASSO_SAMLP_REQUEST_ABSTRACT(self)->RespondWith)
1374
 
#define LassoLibFederationTerminationNotification_set_RespondWith(self, value) set_string_list(&LASSO_SAMLP_REQUEST_ABSTRACT(self)->RespondWith, (value))
1375
 
#define LassoLibFederationTerminationNotification_RespondWith_set(self, value) set_string_list(&LASSO_SAMLP_REQUEST_ABSTRACT(self)->RespondWith, (value))
1376
 
 
1377
 
/* sign_method */
1378
 
#define LassoLibFederationTerminationNotification_get_sign_method(self) LASSO_SAMLP_REQUEST_ABSTRACT(self)->sign_method
1379
 
#define LassoLibFederationTerminationNotification_sign_method_get(self) LASSO_SAMLP_REQUEST_ABSTRACT(self)->sign_method
1380
 
#define LassoLibFederationTerminationNotification_set_sign_method(self, value) LASSO_SAMLP_REQUEST_ABSTRACT(self)->sign_method = (value)
1381
 
#define LassoLibFederationTerminationNotification_sign_method_set(self, value) LASSO_SAMLP_REQUEST_ABSTRACT(self)->sign_method = (value)
1382
 
 
1383
 
/* sign_type */
1384
 
#define LassoLibFederationTerminationNotification_get_sign_type(self) LASSO_SAMLP_REQUEST_ABSTRACT(self)->sign_type
1385
 
#define LassoLibFederationTerminationNotification_sign_type_get(self) LASSO_SAMLP_REQUEST_ABSTRACT(self)->sign_type
1386
 
#define LassoLibFederationTerminationNotification_set_sign_type(self, value) LASSO_SAMLP_REQUEST_ABSTRACT(self)->sign_type = (value)
1387
 
#define LassoLibFederationTerminationNotification_sign_type_set(self, value) LASSO_SAMLP_REQUEST_ABSTRACT(self)->sign_type = (value)
1388
 
 
1389
 
/* Attributes implementations */
1390
 
 
1391
 
/* Extension */
1392
 
#define LassoLibFederationTerminationNotification_get_Extension(self) get_xml_list((self)->Extension)
1393
 
#define LassoLibFederationTerminationNotification_Extension_get(self) get_xml_list((self)->Extension)
1394
 
#define LassoLibFederationTerminationNotification_set_Extension(self, value) set_xml_list(&(self)->Extension, (value))
1395
 
#define LassoLibFederationTerminationNotification_Extension_set(self, value) set_xml_list(&(self)->Extension, (value))
1396
 
 
1397
 
/* NameIdentifier */
1398
 
#define LassoLibFederationTerminationNotification_get_NameIdentifier(self) get_node((self)->NameIdentifier)
1399
 
#define LassoLibFederationTerminationNotification_NameIdentifier_get(self) get_node((self)->NameIdentifier)
1400
 
#define LassoLibFederationTerminationNotification_set_NameIdentifier(self, value) set_node((gpointer *) &(self)->NameIdentifier, (value))
1401
 
#define LassoLibFederationTerminationNotification_NameIdentifier_set(self, value) set_node((gpointer *) &(self)->NameIdentifier, (value))
1402
 
 
1403
 
/* Constructors, destructors & static methods implementations */
1404
 
 
1405
 
#define new_LassoLibFederationTerminationNotification lasso_lib_federation_termination_notification_new
1406
 
#define delete_LassoLibFederationTerminationNotification(self) lasso_node_destroy(LASSO_NODE(self))
1407
 
#ifdef PHP_VERSION
1408
 
#define LassoLibFederationTerminationNotification_newFull lasso_lib_federation_termination_notification_new_full
1409
 
#else
1410
 
#define LibFederationTerminationNotification_newFull lasso_lib_federation_termination_notification_new_full
1411
 
#endif
1412
 
 
1413
 
/* Implementations of methods inherited from LassoNode */
1414
 
 
1415
 
#define LassoLibFederationTerminationNotification_dump(self) lasso_node_dump(LASSO_NODE(self))
1416
 
 
1417
 
 
1418
 
 
1419
 
 
1420
 
/* Implementations of attributes inherited from SamlpRequestAbstract */
1421
 
 
1422
 
/* certificate_file */
1423
 
#define LassoLibLogoutRequest_get_certificate_file(self) LASSO_SAMLP_REQUEST_ABSTRACT(self)->certificate_file
1424
 
#define LassoLibLogoutRequest_certificate_file_get(self) LASSO_SAMLP_REQUEST_ABSTRACT(self)->certificate_file
1425
 
#define LassoLibLogoutRequest_set_certificate_file(self, value) set_string(&LASSO_SAMLP_REQUEST_ABSTRACT(self)->certificate_file, (value))
1426
 
#define LassoLibLogoutRequest_certificate_file_set(self, value) set_string(&LASSO_SAMLP_REQUEST_ABSTRACT(self)->certificate_file, (value))
1427
 
 
1428
 
/* IssueInstant */
1429
 
#define LassoLibLogoutRequest_get_IssueInstant(self) LASSO_SAMLP_REQUEST_ABSTRACT(self)->IssueInstant
1430
 
#define LassoLibLogoutRequest_IssueInstant_get(self) LASSO_SAMLP_REQUEST_ABSTRACT(self)->IssueInstant
1431
 
#define LassoLibLogoutRequest_set_IssueInstant(self, value) set_string(&LASSO_SAMLP_REQUEST_ABSTRACT(self)->IssueInstant, (value))
1432
 
#define LassoLibLogoutRequest_IssueInstant_set(self, value) set_string(&LASSO_SAMLP_REQUEST_ABSTRACT(self)->IssueInstant, (value))
1433
 
 
1434
 
/* MajorVersion */
1435
 
#define LassoLibLogoutRequest_get_MajorVersion(self) LASSO_SAMLP_REQUEST_ABSTRACT(self)->MajorVersion
1436
 
#define LassoLibLogoutRequest_MajorVersion_get(self) LASSO_SAMLP_REQUEST_ABSTRACT(self)->MajorVersion
1437
 
#define LassoLibLogoutRequest_set_MajorVersion(self, value) LASSO_SAMLP_REQUEST_ABSTRACT(self)->MajorVersion = (value)
1438
 
#define LassoLibLogoutRequest_MajorVersion_set(self, value) LASSO_SAMLP_REQUEST_ABSTRACT(self)->MajorVersion = (value)
1439
 
 
1440
 
/* MinorVersion */
1441
 
#define LassoLibLogoutRequest_get_MinorVersion(self) LASSO_SAMLP_REQUEST_ABSTRACT(self)->MinorVersion
1442
 
#define LassoLibLogoutRequest_MinorVersion_get(self) LASSO_SAMLP_REQUEST_ABSTRACT(self)->MinorVersion
1443
 
#define LassoLibLogoutRequest_set_MinorVersion(self, value) LASSO_SAMLP_REQUEST_ABSTRACT(self)->MinorVersion = (value)
1444
 
#define LassoLibLogoutRequest_MinorVersion_set(self, value) LASSO_SAMLP_REQUEST_ABSTRACT(self)->MinorVersion = (value)
1445
 
 
1446
 
/* private_key_file */
1447
 
#define LassoLibLogoutRequest_get_private_key_file(self) LASSO_SAMLP_REQUEST_ABSTRACT(self)->private_key_file
1448
 
#define LassoLibLogoutRequest_private_key_file_get(self) LASSO_SAMLP_REQUEST_ABSTRACT(self)->private_key_file
1449
 
#define LassoLibLogoutRequest_set_private_key_file(self, value) set_string(&LASSO_SAMLP_REQUEST_ABSTRACT(self)->private_key_file, (value))
1450
 
#define LassoLibLogoutRequest_private_key_file_set(self, value) set_string(&LASSO_SAMLP_REQUEST_ABSTRACT(self)->private_key_file, (value))
1451
 
 
1452
 
/* RequestID */
1453
 
#define LassoLibLogoutRequest_get_RequestID(self) LASSO_SAMLP_REQUEST_ABSTRACT(self)->RequestID
1454
 
#define LassoLibLogoutRequest_RequestID_get(self) LASSO_SAMLP_REQUEST_ABSTRACT(self)->RequestID
1455
 
#define LassoLibLogoutRequest_set_RequestID(self, value) set_string(&LASSO_SAMLP_REQUEST_ABSTRACT(self)->RequestID, (value))
1456
 
#define LassoLibLogoutRequest_RequestID_set(self, value) set_string(&LASSO_SAMLP_REQUEST_ABSTRACT(self)->RequestID, (value))
1457
 
 
1458
 
/* RespondWith */
1459
 
#define LassoLibLogoutRequest_get_RespondWith(self) get_string_list(LASSO_SAMLP_REQUEST_ABSTRACT(self)->RespondWith)
1460
 
#define LassoLibLogoutRequest_RespondWith_get(self) get_string_list(LASSO_SAMLP_REQUEST_ABSTRACT(self)->RespondWith)
1461
 
#define LassoLibLogoutRequest_set_RespondWith(self, value) set_string_list(&LASSO_SAMLP_REQUEST_ABSTRACT(self)->RespondWith, (value))
1462
 
#define LassoLibLogoutRequest_RespondWith_set(self, value) set_string_list(&LASSO_SAMLP_REQUEST_ABSTRACT(self)->RespondWith, (value))
1463
 
 
1464
 
/* sign_method */
1465
 
#define LassoLibLogoutRequest_get_sign_method(self) LASSO_SAMLP_REQUEST_ABSTRACT(self)->sign_method
1466
 
#define LassoLibLogoutRequest_sign_method_get(self) LASSO_SAMLP_REQUEST_ABSTRACT(self)->sign_method
1467
 
#define LassoLibLogoutRequest_set_sign_method(self, value) LASSO_SAMLP_REQUEST_ABSTRACT(self)->sign_method = (value)
1468
 
#define LassoLibLogoutRequest_sign_method_set(self, value) LASSO_SAMLP_REQUEST_ABSTRACT(self)->sign_method = (value)
1469
 
 
1470
 
/* sign_type */
1471
 
#define LassoLibLogoutRequest_get_sign_type(self) LASSO_SAMLP_REQUEST_ABSTRACT(self)->sign_type
1472
 
#define LassoLibLogoutRequest_sign_type_get(self) LASSO_SAMLP_REQUEST_ABSTRACT(self)->sign_type
1473
 
#define LassoLibLogoutRequest_set_sign_type(self, value) LASSO_SAMLP_REQUEST_ABSTRACT(self)->sign_type = (value)
1474
 
#define LassoLibLogoutRequest_sign_type_set(self, value) LASSO_SAMLP_REQUEST_ABSTRACT(self)->sign_type = (value)
1475
 
 
1476
 
/* Attributes implementations */
1477
 
 
1478
 
/* Extension */
1479
 
#define LassoLibLogoutRequest_get_Extension(self) get_xml_list((self)->Extension)
1480
 
#define LassoLibLogoutRequest_Extension_get(self) get_xml_list((self)->Extension)
1481
 
#define LassoLibLogoutRequest_set_Extension(self, value) set_xml_list(&(self)->Extension, (value))
1482
 
#define LassoLibLogoutRequest_Extension_set(self, value) set_xml_list(&(self)->Extension, (value))
1483
 
 
1484
 
/* nameIdentifier */
1485
 
#define LassoLibLogoutRequest_get_NameIdentifier(self) get_node((self)->NameIdentifier)
1486
 
#define LassoLibLogoutRequest_NameIdentifier_get(self) get_node((self)->NameIdentifier)
1487
 
#define LassoLibLogoutRequest_set_NameIdentifier(self, value) set_node((gpointer *) &(self)->NameIdentifier, (value))
1488
 
#define LassoLibLogoutRequest_NameIdentifier_set(self, value) set_node((gpointer *) &(self)->NameIdentifier, (value))
1489
 
 
1490
 
/* Constructors, destructors & static methods implementations */
1491
 
 
1492
 
#define new_LassoLibLogoutRequest lasso_lib_logout_request_new
1493
 
#define delete_LassoLibLogoutRequest(self) lasso_node_destroy(LASSO_NODE(self))
1494
 
#ifdef PHP_VERSION
1495
 
#define LassoLibLogoutRequest_newFull lasso_lib_logout_request_new_full
1496
 
#else
1497
 
#define LibLogoutRequest_newFull lasso_lib_logout_request_new_full
1498
 
#endif
1499
 
 
1500
 
/* Implementations of methods inherited from LassoNode */
1501
 
 
1502
 
#define LassoLibLogoutRequest_dump(self) lasso_node_dump(LASSO_NODE(self))
1503
 
 
1504
 
 
1505
 
 
1506
 
 
1507
 
/* Implementations of attributes inherited from LibStatusResponse */
1508
 
 
1509
 
/* Extension */
1510
 
#define LassoLibLogoutResponse_get_Extension(self) get_xml_list(LASSO_LIB_STATUS_RESPONSE(self)->Extension)
1511
 
#define LassoLibLogoutResponse_Extension_get(self) get_xml_list(LASSO_LIB_STATUS_RESPONSE(self)->Extension)
1512
 
#define LassoLibLogoutResponse_set_Extension(self, value) set_xml_list(&LASSO_LIB_STATUS_RESPONSE(self)->Extension, (value))
1513
 
#define LassoLibLogoutResponse_Extension_set(self, value) set_xml_list(&LASSO_LIB_STATUS_RESPONSE(self)->Extension, (value))
1514
 
 
1515
 
/* providerId */
1516
 
#define LassoLibLogoutResponse_get_ProviderID(self) LASSO_LIB_STATUS_RESPONSE(self)->ProviderID
1517
 
#define LassoLibLogoutResponse_ProviderID_get(self) LASSO_LIB_STATUS_RESPONSE(self)->ProviderID
1518
 
#define LassoLibLogoutResponse_set_ProviderID(self, value) set_string(&LASSO_LIB_STATUS_RESPONSE(self)->ProviderID, (value))
1519
 
#define LassoLibLogoutResponse_ProviderID_set(self, value) set_string(&LASSO_LIB_STATUS_RESPONSE(self)->ProviderID, (value))
1520
 
 
1521
 
/* RelayState */
1522
 
#define LassoLibLogoutResponse_get_RelayState(self) LASSO_LIB_STATUS_RESPONSE(self)->RelayState
1523
 
#define LassoLibLogoutResponse_RelayState_get(self) LASSO_LIB_STATUS_RESPONSE(self)->RelayState
1524
 
#define LassoLibLogoutResponse_set_RelayState(self, value) set_string(&LASSO_LIB_STATUS_RESPONSE(self)->RelayState, (value))
1525
 
#define LassoLibLogoutResponse_RelayState_set(self, value) set_string(&LASSO_LIB_STATUS_RESPONSE(self)->RelayState, (value))
1526
 
 
1527
 
/* Status */
1528
 
#define LassoLibLogoutResponse_get_Status(self) get_node(LASSO_LIB_STATUS_RESPONSE(self)->Status)
1529
 
#define LassoLibLogoutResponse_Status_get(self) get_node(LASSO_LIB_STATUS_RESPONSE(self)->Status)
1530
 
#define LassoLibLogoutResponse_set_Status(self, value) set_node((gpointer *) &LASSO_LIB_STATUS_RESPONSE(self)->Status, (value))
1531
 
#define LassoLibLogoutResponse_Status_set(self, value) set_node((gpointer *) &LASSO_LIB_STATUS_RESPONSE(self)->Status, (value))
1532
 
 
1533
 
/* Constructors, destructors & static methods implementations */
1534
 
 
1535
 
#define new_LassoLibLogoutResponse lasso_lib_logout_response_new
1536
 
#define delete_LassoLibLogoutResponse(self) lasso_node_destroy(LASSO_NODE(self))
1537
 
#ifdef PHP_VERSION
1538
 
#define LassoLibLogoutResponse_newFull lasso_lib_logout_response_new_full
1539
 
#else
1540
 
#define LibLogoutResponse_newFull lasso_lib_logout_response_new_full
1541
 
#endif
1542
 
 
1543
 
/* Implementations of methods inherited from LassoNode */
1544
 
 
1545
 
#define LassoLibLogoutResponse_dump(self) lasso_node_dump(LASSO_NODE(self))
1546
 
 
1547
 
 
1548
 
 
1549
 
 
1550
 
/* Implementations of attributes inherited from SamlpRequestAbstract */
1551
 
 
1552
 
/* certificate_file */
1553
 
#define LassoLibRegisterNameIdentifierRequest_get_certificate_file(self) LASSO_SAMLP_REQUEST_ABSTRACT(self)->certificate_file
1554
 
#define LassoLibRegisterNameIdentifierRequest_certificate_file_get(self) LASSO_SAMLP_REQUEST_ABSTRACT(self)->certificate_file
1555
 
#define LassoLibRegisterNameIdentifierRequest_set_certificate_file(self, value) set_string(&LASSO_SAMLP_REQUEST_ABSTRACT(self)->certificate_file, (value))
1556
 
#define LassoLibRegisterNameIdentifierRequest_certificate_file_set(self, value) set_string(&LASSO_SAMLP_REQUEST_ABSTRACT(self)->certificate_file, (value))
1557
 
 
1558
 
/* IssueInstant */
1559
 
#define LassoLibRegisterNameIdentifierRequest_get_IssueInstant(self) LASSO_SAMLP_REQUEST_ABSTRACT(self)->IssueInstant
1560
 
#define LassoLibRegisterNameIdentifierRequest_IssueInstant_get(self) LASSO_SAMLP_REQUEST_ABSTRACT(self)->IssueInstant
1561
 
#define LassoLibRegisterNameIdentifierRequest_set_IssueInstant(self, value) set_string(&LASSO_SAMLP_REQUEST_ABSTRACT(self)->IssueInstant, (value))
1562
 
#define LassoLibRegisterNameIdentifierRequest_IssueInstant_set(self, value) set_string(&LASSO_SAMLP_REQUEST_ABSTRACT(self)->IssueInstant, (value))
1563
 
 
1564
 
/* MajorVersion */
1565
 
#define LassoLibRegisterNameIdentifierRequest_get_MajorVersion(self) LASSO_SAMLP_REQUEST_ABSTRACT(self)->MajorVersion
1566
 
#define LassoLibRegisterNameIdentifierRequest_MajorVersion_get(self) LASSO_SAMLP_REQUEST_ABSTRACT(self)->MajorVersion
1567
 
#define LassoLibRegisterNameIdentifierRequest_set_MajorVersion(self, value) LASSO_SAMLP_REQUEST_ABSTRACT(self)->MajorVersion = (value)
1568
 
#define LassoLibRegisterNameIdentifierRequest_MajorVersion_set(self, value) LASSO_SAMLP_REQUEST_ABSTRACT(self)->MajorVersion = (value)
1569
 
 
1570
 
/* MinorVersion */
1571
 
#define LassoLibRegisterNameIdentifierRequest_get_MinorVersion(self) LASSO_SAMLP_REQUEST_ABSTRACT(self)->MinorVersion
1572
 
#define LassoLibRegisterNameIdentifierRequest_MinorVersion_get(self) LASSO_SAMLP_REQUEST_ABSTRACT(self)->MinorVersion
1573
 
#define LassoLibRegisterNameIdentifierRequest_set_MinorVersion(self, value) LASSO_SAMLP_REQUEST_ABSTRACT(self)->MinorVersion = (value)
1574
 
#define LassoLibRegisterNameIdentifierRequest_MinorVersion_set(self, value) LASSO_SAMLP_REQUEST_ABSTRACT(self)->MinorVersion = (value)
1575
 
 
1576
 
/* private_key_file */
1577
 
#define LassoLibRegisterNameIdentifierRequest_get_private_key_file(self) LASSO_SAMLP_REQUEST_ABSTRACT(self)->private_key_file
1578
 
#define LassoLibRegisterNameIdentifierRequest_private_key_file_get(self) LASSO_SAMLP_REQUEST_ABSTRACT(self)->private_key_file
1579
 
#define LassoLibRegisterNameIdentifierRequest_set_private_key_file(self, value) set_string(&LASSO_SAMLP_REQUEST_ABSTRACT(self)->private_key_file, (value))
1580
 
#define LassoLibRegisterNameIdentifierRequest_private_key_file_set(self, value) set_string(&LASSO_SAMLP_REQUEST_ABSTRACT(self)->private_key_file, (value))
1581
 
 
1582
 
/* RequestID */
1583
 
#define LassoLibRegisterNameIdentifierRequest_get_RequestID(self) LASSO_SAMLP_REQUEST_ABSTRACT(self)->RequestID
1584
 
#define LassoLibRegisterNameIdentifierRequest_RequestID_get(self) LASSO_SAMLP_REQUEST_ABSTRACT(self)->RequestID
1585
 
#define LassoLibRegisterNameIdentifierRequest_set_RequestID(self, value) set_string(&LASSO_SAMLP_REQUEST_ABSTRACT(self)->RequestID, (value))
1586
 
#define LassoLibRegisterNameIdentifierRequest_RequestID_set(self, value) set_string(&LASSO_SAMLP_REQUEST_ABSTRACT(self)->RequestID, (value))
1587
 
 
1588
 
/* RespondWith */
1589
 
#define LassoLibRegisterNameIdentifierRequest_get_RespondWith(self) get_string_list(LASSO_SAMLP_REQUEST_ABSTRACT(self)->RespondWith)
1590
 
#define LassoLibRegisterNameIdentifierRequest_RespondWith_get(self) get_string_list(LASSO_SAMLP_REQUEST_ABSTRACT(self)->RespondWith)
1591
 
#define LassoLibRegisterNameIdentifierRequest_set_RespondWith(self, value) set_string_list(&LASSO_SAMLP_REQUEST_ABSTRACT(self)->RespondWith, (value))
1592
 
#define LassoLibRegisterNameIdentifierRequest_RespondWith_set(self, value) set_string_list(&LASSO_SAMLP_REQUEST_ABSTRACT(self)->RespondWith, (value))
1593
 
 
1594
 
/* sign_method */
1595
 
#define LassoLibRegisterNameIdentifierRequest_get_sign_method(self) LASSO_SAMLP_REQUEST_ABSTRACT(self)->sign_method
1596
 
#define LassoLibRegisterNameIdentifierRequest_sign_method_get(self) LASSO_SAMLP_REQUEST_ABSTRACT(self)->sign_method
1597
 
#define LassoLibRegisterNameIdentifierRequest_set_sign_method(self, value) LASSO_SAMLP_REQUEST_ABSTRACT(self)->sign_method = (value)
1598
 
#define LassoLibRegisterNameIdentifierRequest_sign_method_set(self, value) LASSO_SAMLP_REQUEST_ABSTRACT(self)->sign_method = (value)
1599
 
 
1600
 
/* sign_type */
1601
 
#define LassoLibRegisterNameIdentifierRequest_get_sign_type(self) LASSO_SAMLP_REQUEST_ABSTRACT(self)->sign_type
1602
 
#define LassoLibRegisterNameIdentifierRequest_sign_type_get(self) LASSO_SAMLP_REQUEST_ABSTRACT(self)->sign_type
1603
 
#define LassoLibRegisterNameIdentifierRequest_set_sign_type(self, value) LASSO_SAMLP_REQUEST_ABSTRACT(self)->sign_type = (value)
1604
 
#define LassoLibRegisterNameIdentifierRequest_sign_type_set(self, value) LASSO_SAMLP_REQUEST_ABSTRACT(self)->sign_type = (value)
1605
 
 
1606
 
/* Attributes implementations */
1607
 
 
1608
 
/* Extension */
1609
 
#define LassoLibRegisterNameIdentifierRequest_get_Extension(self) get_xml_list((self)->Extension)
1610
 
#define LassoLibRegisterNameIdentifierRequest_Extension_get(self) get_xml_list((self)->Extension)
1611
 
#define LassoLibRegisterNameIdentifierRequest_set_Extension(self, value) set_xml_list(&(self)->Extension, (value))
1612
 
#define LassoLibRegisterNameIdentifierRequest_Extension_set(self, value) set_xml_list(&(self)->Extension, (value))
1613
 
 
1614
 
/* idpProvidedNameIdentifier */
1615
 
#define LassoLibRegisterNameIdentifierRequest_get_IDPProvidedNameIdentifier(self) get_node((self)->IDPProvidedNameIdentifier)
1616
 
#define LassoLibRegisterNameIdentifierRequest_IDPProvidedNameIdentifier_get(self) get_node((self)->IDPProvidedNameIdentifier)
1617
 
#define LassoLibRegisterNameIdentifierRequest_set_IDPProvidedNameIdentifier(self, value) set_node((gpointer *) &(self)->IDPProvidedNameIdentifier, (value))
1618
 
#define LassoLibRegisterNameIdentifierRequest_IDPProvidedNameIdentifier_set(self, value) set_node((gpointer *) &(self)->IDPProvidedNameIdentifier, (value))
1619
 
 
1620
 
/* oldProvidedNameIdentifier */
1621
 
#define LassoLibRegisterNameIdentifierRequest_get_OldProvidedNameIdentifier(self) get_node((self)->OldProvidedNameIdentifier)
1622
 
#define LassoLibRegisterNameIdentifierRequest_OldProvidedNameIdentifier_get(self) get_node((self)->OldProvidedNameIdentifier)
1623
 
#define LassoLibRegisterNameIdentifierRequest_set_OldProvidedNameIdentifier(self, value) set_node((gpointer *) &(self)->OldProvidedNameIdentifier, (value))
1624
 
#define LassoLibRegisterNameIdentifierRequest_OldProvidedNameIdentifier_set(self, value) set_node((gpointer *) &(self)->OldProvidedNameIdentifier, (value))
1625
 
 
1626
 
/* spProvidedNameIdentifier */
1627
 
#define LassoLibRegisterNameIdentifierRequest_get_SPProvidedNameIdentifier(self) get_node((self)->SPProvidedNameIdentifier)
1628
 
#define LassoLibRegisterNameIdentifierRequest_SPProvidedNameIdentifier_get(self) get_node((self)->SPProvidedNameIdentifier)
1629
 
#define LassoLibRegisterNameIdentifierRequest_set_SPProvidedNameIdentifier(self, value) set_node((gpointer *) &(self)->SPProvidedNameIdentifier, (value))
1630
 
#define LassoLibRegisterNameIdentifierRequest_SPProvidedNameIdentifier_set(self, value) set_node((gpointer *) &(self)->SPProvidedNameIdentifier, (value))
1631
 
 
1632
 
/* Constructors, destructors & static methods implementations */
1633
 
 
1634
 
#define new_LassoLibRegisterNameIdentifierRequest lasso_lib_register_name_identifier_request_new
1635
 
#define delete_LassoLibRegisterNameIdentifierRequest(self) lasso_node_destroy(LASSO_NODE(self))
1636
 
#ifdef PHP_VERSION
1637
 
#define LassoLibRegisterNameIdentifierRequest_newFull lasso_lib_register_name_identifier_request_new_full
1638
 
#else
1639
 
#define LibRegisterNameIdentifierRequest_newFull lasso_lib_register_name_identifier_request_new_full
1640
 
#endif
1641
 
 
1642
 
/* Implementations of methods inherited from LassoNode */
1643
 
 
1644
 
#define LassoLibRegisterNameIdentifierRequest_dump(self) lasso_node_dump(LASSO_NODE(self))
1645
 
 
1646
 
 
1647
 
 
1648
 
 
1649
 
/* Implementations of attributes inherited from LibStatusResponse */
1650
 
 
1651
 
/* Extension */
1652
 
#define LassoLibRegisterNameIdentifierResponse_get_Extension(self) get_xml_list(LASSO_LIB_STATUS_RESPONSE(self)->Extension)
1653
 
#define LassoLibRegisterNameIdentifierResponse_Extension_get(self) get_xml_list(LASSO_LIB_STATUS_RESPONSE(self)->Extension)
1654
 
#define LassoLibRegisterNameIdentifierResponse_set_Extension(self, value) set_xml_list(&LASSO_LIB_STATUS_RESPONSE(self)->Extension, (value))
1655
 
#define LassoLibRegisterNameIdentifierResponse_Extension_set(self, value) set_xml_list(&LASSO_LIB_STATUS_RESPONSE(self)->Extension, (value))
1656
 
 
1657
 
/* providerId */
1658
 
#define LassoLibRegisterNameIdentifierResponse_get_ProviderID(self) LASSO_LIB_STATUS_RESPONSE(self)->ProviderID
1659
 
#define LassoLibRegisterNameIdentifierResponse_ProviderID_get(self) LASSO_LIB_STATUS_RESPONSE(self)->ProviderID
1660
 
#define LassoLibRegisterNameIdentifierResponse_set_ProviderID(self, value) set_string(&LASSO_LIB_STATUS_RESPONSE(self)->ProviderID, (value))
1661
 
#define LassoLibRegisterNameIdentifierResponse_ProviderID_set(self, value) set_string(&LASSO_LIB_STATUS_RESPONSE(self)->ProviderID, (value))
1662
 
 
1663
 
/* RelayState */
1664
 
#define LassoLibRegisterNameIdentifierResponse_get_RelayState(self) LASSO_LIB_STATUS_RESPONSE(self)->RelayState
1665
 
#define LassoLibRegisterNameIdentifierResponse_RelayState_get(self) LASSO_LIB_STATUS_RESPONSE(self)->RelayState
1666
 
#define LassoLibRegisterNameIdentifierResponse_set_RelayState(self, value) set_string(&LASSO_LIB_STATUS_RESPONSE(self)->RelayState, (value))
1667
 
#define LassoLibRegisterNameIdentifierResponse_RelayState_set(self, value) set_string(&LASSO_LIB_STATUS_RESPONSE(self)->RelayState, (value))
1668
 
 
1669
 
/* Status */
1670
 
#define LassoLibRegisterNameIdentifierResponse_get_Status(self) get_node(LASSO_LIB_STATUS_RESPONSE(self)->Status)
1671
 
#define LassoLibRegisterNameIdentifierResponse_Status_get(self) get_node(LASSO_LIB_STATUS_RESPONSE(self)->Status)
1672
 
#define LassoLibRegisterNameIdentifierResponse_set_Status(self, value) set_node((gpointer *) &LASSO_LIB_STATUS_RESPONSE(self)->Status, (value))
1673
 
#define LassoLibRegisterNameIdentifierResponse_Status_set(self, value) set_node((gpointer *) &LASSO_LIB_STATUS_RESPONSE(self)->Status, (value))
1674
 
 
1675
 
/* Constructors, destructors & static methods implementations */
1676
 
 
1677
 
#define new_LassoLibRegisterNameIdentifierResponse lasso_lib_register_name_identifier_response_new
1678
 
#define delete_LassoLibRegisterNameIdentifierResponse(self) lasso_node_destroy(LASSO_NODE(self))
1679
 
#ifdef PHP_VERSION
1680
 
#define LassoLibRegisterNameIdentifierResponse_newFull lasso_lib_register_name_identifier_response_new_full
1681
 
#else
1682
 
#define LibRegisterNameIdentifierResponse_newFull lasso_lib_register_name_identifier_response_new_full
1683
 
#endif
1684
 
 
1685
 
/* Implementations of methods inherited from LassoNode */
1686
 
 
1687
 
#define LassoLibRegisterNameIdentifierResponse_dump(self) lasso_node_dump(LASSO_NODE(self))
1688
 
 
1689
 
 
1690
 
 
1691
 
 
1692
 
/* Attributes implementations */
1693
 
 
1694
 
/* authnContextClassRef */
1695
 
#define LassoLibRequestAuthnContext_get_authnContextClassRef(self) get_string_list((self)->AuthnContextClassRef)
1696
 
#define LassoLibRequestAuthnContext_authnContextClassRef_get(self) get_string_list((self)->AuthnContextClassRef)
1697
 
#define LassoLibRequestAuthnContext_set_authnContextClassRef(self, value) set_string_list(&(self)->AuthnContextClassRef, (value))
1698
 
#define LassoLibRequestAuthnContext_authnContextClassRef_set(self, value) set_string_list(&(self)->AuthnContextClassRef, (value))
1699
 
 
1700
 
/* authnContextStatementRef */
1701
 
#define LassoLibRequestAuthnContext_get_authnContextStatementRef(self) get_string_list((self)->AuthnContextStatementRef)
1702
 
#define LassoLibRequestAuthnContext_authnContextStatementRef_get(self) get_string_list((self)->AuthnContextStatementRef)
1703
 
#define LassoLibRequestAuthnContext_set_authnContextStatementRef(self, value) set_string_list(&(self)->AuthnContextStatementRef, (value))
1704
 
#define LassoLibRequestAuthnContext_authnContextStatementRef_set(self, value) set_string_list(&(self)->AuthnContextStatementRef, (value))
1705
 
 
1706
 
/* Constructors, destructors & static methods implementations */
1707
 
 
1708
 
#define new_LassoLibRequestAuthnContext lasso_lib_request_authn_context_new
1709
 
#define delete_LassoLibRequestAuthnContext(self) lasso_node_destroy(LASSO_NODE(self))
1710
 
 
1711
 
/* Implementations of methods inherited from LassoNode */
1712
 
 
1713
 
#define LassoLibRequestAuthnContext_dump(self) lasso_node_dump(LASSO_NODE(self))
1714
 
 
1715
 
 
1716
 
 
1717
 
 
1718
 
/* Attributes implementations */
1719
 
 
1720
 
/* Extension */
1721
 
#define LassoLibStatusResponse_get_Extension(self) get_xml_list((self)->Extension)
1722
 
#define LassoLibStatusResponse_Extension_get(self) get_xml_list((self)->Extension)
1723
 
#define LassoLibStatusResponse_set_Extension(self, value) set_xml_list(&(self)->Extension, (value))
1724
 
#define LassoLibStatusResponse_Extension_set(self, value) set_xml_list(&(self)->Extension, (value))
1725
 
 
1726
 
/* Status */
1727
 
#define LassoLibStatusResponse_get_Status(self) get_node((self)->Status)
1728
 
#define LassoLibStatusResponse_Status_get(self) get_node((self)->Status)
1729
 
#define LassoLibStatusResponse_set_Status(self, value) set_node((gpointer *) &(self)->Status, (value))
1730
 
#define LassoLibStatusResponse_Status_set(self, value) set_node((gpointer *) &(self)->Status, (value))
1731
 
 
1732
 
/* Constructors, destructors & static methods implementations */
1733
 
 
1734
 
#define new_LassoLibStatusResponse lasso_lib_status_response_new
1735
 
#define delete_LassoLibStatusResponse(self) lasso_node_destroy(LASSO_NODE(self))
1736
 
 
1737
 
/* Implementations of methods inherited from LassoNode */
1738
 
 
1739
 
#define LassoLibStatusResponse_dump(self) lasso_node_dump(LASSO_NODE(self))
1740
 
 
1741
 
 
1742
 
 
1743
 
 
1744
 
/* Constructors, destructors & static methods implementations */
1745
 
 
1746
 
#define new_LassoProvider lasso_provider_new
1747
 
#define delete_LassoProvider(self) lasso_node_destroy(LASSO_NODE(self))
1748
 
#ifdef PHP_VERSION
1749
 
#define LassoProvider_newFromDump lasso_provider_new_from_dump
1750
 
#else
1751
 
#define Provider_newFromDump lasso_provider_new_from_dump
1752
 
#endif
1753
 
 
1754
 
/* Implementations of methods inherited from LassoNode */
1755
 
 
1756
 
#define LassoProvider_dump(self) lasso_node_dump(LASSO_NODE(self))
1757
 
 
1758
 
/* Methods implementations */
1759
 
 
1760
 
#define LassoProvider_acceptHttpMethod lasso_provider_accept_http_method
1761
 
#define LassoProvider_getAssertionConsumerServiceUrl lasso_provider_get_assertion_consumer_service_url
1762
 
#define LassoProvider_getBase64SuccinctId lasso_provider_get_base64_succinct_id
1763
 
#define LassoProvider_getFirstHttpMethod lasso_provider_get_first_http_method
1764
 
#define LassoProvider_getMetadataOne lasso_provider_get_metadata_one
1765
 
#define LassoProvider_hasProtocolProfile lasso_provider_has_protocol_profile
1766
 
#define LassoProvider_getOrganization(self) get_xml_string(lasso_provider_get_organization(self))
1767
 
 
1768
 
 
1769
 
 
1770
 
 
1771
 
/* Implementations of attributes inherited from Provider */
1772
 
 
1773
 
/* providerId */
1774
 
#define LassoServer_get_ProviderID(self) LASSO_PROVIDER(self)->ProviderID
1775
 
#define LassoServer_ProviderID_get(self) LASSO_PROVIDER(self)->ProviderID
1776
 
#define LassoServer_set_ProviderID(self, value) set_string(&LASSO_PROVIDER(self)->ProviderID, (value))
1777
 
#define LassoServer_ProviderID_set(self, value) set_string(&LASSO_PROVIDER(self)->ProviderID, (value))
1778
 
 
1779
 
/* ca_cert_chain */
1780
 
#define LassoServer_get_ca_cert_chain(self) LASSO_PROVIDER(self)->ca_cert_chain
1781
 
#define LassoServer_ca_cert_chain_get(self) LASSO_PROVIDER(self)->ca_cert_chain
1782
 
#define LassoServer_set_ca_cert_chain(self, value) set_string(&LASSO_PROVIDER(self)->ca_cert_chain, (value))
1783
 
#define LassoServer_ca_cert_chain_set(self, value) set_string(&LASSO_PROVIDER(self)->ca_cert_chain, (value))
1784
 
 
1785
 
/* metadata_filename */
1786
 
#define LassoServer_get_metadata_filename(self) LASSO_PROVIDER(self)->metadata_filename
1787
 
#define LassoServer_metadata_filename_get(self) LASSO_PROVIDER(self)->metadata_filename
1788
 
#define LassoServer_set_metadata_filename(self, value) set_string(&LASSO_PROVIDER(self)->metadata_filename, (value))
1789
 
#define LassoServer_metadata_filename_set(self, value) set_string(&LASSO_PROVIDER(self)->metadata_filename, (value))
1790
 
 
1791
 
/* public_key */
1792
 
#define LassoServer_get_public_key(self) LASSO_PROVIDER(self)->public_key
1793
 
#define LassoServer_public_key_get(self) LASSO_PROVIDER(self)->public_key
1794
 
#define LassoServer_set_public_key(self, value) set_string(&LASSO_PROVIDER(self)->public_key, (value))
1795
 
#define LassoServer_public_key_set(self, value) set_string(&LASSO_PROVIDER(self)->public_key, (value))
1796
 
 
1797
 
/* Attributes implementations */
1798
 
 
1799
 
/* providerIds */
1800
 
#define LassoServer_get_providerIds LassoServer_providerIds_get
1801
 
LassoStringList *LassoServer_providerIds_get(LassoServer *self) {
1802
 
        GPtrArray *providerIds = g_ptr_array_sized_new(g_hash_table_size(self->providers));
1803
 
        g_hash_table_foreach(self->providers, (GHFunc) add_key_to_array, providerIds);
1804
 
        return providerIds;
1805
 
}
1806
 
 
1807
 
/* Constructors, destructors & static methods implementations */
1808
 
 
1809
 
#define new_LassoServer lasso_server_new
1810
 
#define delete_LassoServer(self) lasso_node_destroy(LASSO_NODE(self))
1811
 
#ifdef PHP_VERSION
1812
 
#define LassoServer_newFromDump lasso_server_new_from_dump
1813
 
#else
1814
 
#define Server_newFromDump lasso_server_new_from_dump
1815
 
#endif
1816
 
 
1817
 
/* Implementations of methods inherited from Provider */
1818
 
 
1819
 
#define LassoServer_acceptHttpMethod(server, remote_provider, protocol_type, http_method, initiate_profile) lasso_provider_accept_http_method(LASSO_PROVIDER(server), remote_provider, protocol_type, http_method, initiate_profile)
1820
 
#define LassoServer_getAssertionConsumerServiceUrl(server, service_id) lasso_provider_get_assertion_consumer_service_url(LASSO_PROVIDER(server), service_id)
1821
 
#define LassoServer_getBase64SuccinctId(server) lasso_provider_get_base64_succinct_id(LASSO_PROVIDER(server))
1822
 
#define LassoServer_getFirstHttpMethod(server, remote_provider, protocol_type) lasso_provider_get_first_http_method(LASSO_PROVIDER(server), remote_provider, protocol_type)
1823
 
#define LassoServer_getMetadataOne(server, name) lasso_provider_get_metadata_one(LASSO_PROVIDER(server), name)
1824
 
#define LassoServer_hasProtocolProfile(server, protocol_type, protocol_profile) lasso_provider_has_protocol_profile(LASSO_PROVIDER(server), protocol_type, protocol_profile)
1825
 
#define LassoServer_getOrganization(server) get_xml_string(lasso_provider_get_organization(LASSO_PROVIDER(server)))
1826
 
 
1827
 
/* Methods implementations */
1828
 
 
1829
 
#define LassoServer_addProvider lasso_server_add_provider
1830
 
#define LassoServer_addService lasso_server_add_service
1831
 
#define LassoServer_dump lasso_server_dump
1832
 
#define LassoServer_getProvider lasso_server_get_provider
1833
 
#define LassoServer_getService lasso_server_get_service
1834
 
 
1835
 
 
1836
 
 
1837
 
 
1838
 
/* Attributes implementations */
1839
 
 
1840
 
/* localNameIdentifier */
1841
 
#define LassoFederation_get_local_nameIdentifier(self) get_node((self)->local_nameIdentifier)
1842
 
#define LassoFederation_local_nameIdentifier_get(self) get_node((self)->local_nameIdentifier)
1843
 
#define LassoFederation_set_local_nameIdentifier(self, value) set_node((gpointer *) &(self)->local_nameIdentifier, (value))
1844
 
#define LassoFederation_local_nameIdentifier_set(self, value) set_node((gpointer *) &(self)->local_nameIdentifier, (value))
1845
 
 
1846
 
/* remoteNameIdentifier */
1847
 
#define LassoFederation_get_remote_nameIdentifier(self) get_node((self)->remote_nameIdentifier)
1848
 
#define LassoFederation_remote_nameIdentifier_get(self) get_node((self)->remote_nameIdentifier)
1849
 
#define LassoFederation_set_remote_nameIdentifier(self, value) set_node((gpointer *) &(self)->remote_nameIdentifier, (value))
1850
 
#define LassoFederation_remote_nameIdentifier_set(self, value) set_node((gpointer *) &(self)->remote_nameIdentifier, (value))
1851
 
 
1852
 
/* Constructors, destructors & static methods implementations */
1853
 
 
1854
 
#define new_LassoFederation lasso_federation_new
1855
 
#define delete_LassoFederation(self) lasso_node_destroy(LASSO_NODE(self))
1856
 
 
1857
 
/* Implementations of methods inherited from LassoNode */
1858
 
 
1859
 
#define LassoFederation_dump(self) lasso_node_dump(LASSO_NODE(self))
1860
 
 
1861
 
/* Methods implementations */
1862
 
 
1863
 
#define LassoFederation_buildLocalNameIdentifier lasso_federation_build_local_name_identifier
1864
 
#define LassoFederation_verifyNameIdentifier lasso_federation_verify_name_identifier
1865
 
 
1866
 
 
1867
 
 
1868
 
 
1869
 
/* Attributes implementations */
1870
 
 
1871
 
/* providerIds */
1872
 
#define LassoIdentity_get_providerIds LassoIdentity_providerIds_get
1873
 
LassoStringList *LassoIdentity_providerIds_get(LassoIdentity *self) {
1874
 
        GPtrArray *providerIds = g_ptr_array_sized_new(g_hash_table_size(self->federations));
1875
 
        g_hash_table_foreach(self->federations, (GHFunc) add_key_to_array, providerIds);
1876
 
        return providerIds;
1877
 
}
1878
 
 
1879
 
/* Constructors, destructors & static methods implementations */
1880
 
 
1881
 
#define new_LassoIdentity lasso_identity_new
1882
 
#define delete_LassoIdentity(self) lasso_node_destroy(LASSO_NODE(self))
1883
 
#ifdef PHP_VERSION
1884
 
#define LassoIdentity_newFromDump lasso_identity_new_from_dump
1885
 
#else
1886
 
#define Identity_newFromDump lasso_identity_new_from_dump
1887
 
#endif
1888
 
 
1889
 
/* Methods implementations */
1890
 
 
1891
 
#define LassoIdentity_dump lasso_identity_dump
1892
 
#define LassoIdentity_getFederation lasso_identity_get_federation
1893
 
 
1894
 
 
1895
 
 
1896
 
 
1897
 
/* Attributes implementations */
1898
 
 
1899
 
/* providerIds */
1900
 
#define LassoSession_get_providerIds LassoSession_providerIds_get
1901
 
LassoStringList *LassoSession_providerIds_get(LassoSession *self) {
1902
 
        GPtrArray *providerIds = g_ptr_array_sized_new(g_hash_table_size(self->assertions));
1903
 
        g_hash_table_foreach(self->assertions, (GHFunc) add_key_to_array, providerIds);
1904
 
        return providerIds;
1905
 
}
1906
 
 
1907
 
/* Constructors, destructors & static methods implementations */
1908
 
 
1909
 
#define new_LassoSession lasso_session_new
1910
 
#define delete_LassoSession(self) lasso_node_destroy(LASSO_NODE(self))
1911
 
#ifdef PHP_VERSION
1912
 
#define LassoSession_newFromDump lasso_session_new_from_dump
1913
 
#else
1914
 
#define Session_newFromDump lasso_session_new_from_dump
1915
 
#endif
1916
 
 
1917
 
/* Methods implementations */
1918
 
 
1919
 
#define LassoSession_dump lasso_session_dump
1920
 
 
1921
 
LassoNodeList *LassoSession_getAssertions(LassoSession *self, char *providerId) {
1922
 
        GPtrArray *assertionsArray;
1923
 
        GList *assertionsList;
1924
 
 
1925
 
        assertionsList = lasso_session_get_assertions(self, providerId);
1926
 
        if (assertionsList) {
1927
 
                assertionsArray = get_node_list(assertionsList);
1928
 
                g_list_foreach(assertionsList, (GFunc) free_node_list_item, NULL);
1929
 
                g_list_free(assertionsList);
1930
 
        } else
1931
 
                assertionsArray = NULL;
1932
 
        return assertionsArray;
1933
 
}
1934
 
 
1935
 
 
1936
 
 
1937
 
 
1938
 
/* Implementations of attributes inherited from Profile */
1939
 
 
1940
 
/* identity */
1941
 
#define LassoDefederation_get_identity(self) lasso_profile_get_identity(LASSO_PROFILE(self))
1942
 
#define LassoDefederation_identity_get(self) lasso_profile_get_identity(LASSO_PROFILE(self))
1943
 
#define LassoDefederation_set_identity(self, value) set_node((gpointer *) &LASSO_PROFILE(self)->identity, (value))
1944
 
#define LassoDefederation_identity_set(self, value) set_node((gpointer *) &LASSO_PROFILE(self)->identity, (value))
1945
 
 
1946
 
/* isIdentityDirty */
1947
 
#define LassoDefederation_get_isIdentityDirty(self) lasso_profile_is_identity_dirty(LASSO_PROFILE(self))
1948
 
#define LassoDefederation_isIdentityDirty_get(self) lasso_profile_is_identity_dirty(LASSO_PROFILE(self))
1949
 
 
1950
 
/* isSessionDirty */
1951
 
#define LassoDefederation_get_isSessionDirty(self) lasso_profile_is_session_dirty(LASSO_PROFILE(self))
1952
 
#define LassoDefederation_isSessionDirty_get(self) lasso_profile_is_session_dirty(LASSO_PROFILE(self))
1953
 
 
1954
 
/* msgBody */
1955
 
#define LassoDefederation_get_msgBody(self) LASSO_PROFILE(self)->msg_body
1956
 
#define LassoDefederation_msgBody_get(self) LASSO_PROFILE(self)->msg_body
1957
 
 
1958
 
/* msgRelayState */
1959
 
#define LassoDefederation_get_msgRelayState(self) LASSO_PROFILE(self)->msg_relayState
1960
 
#define LassoDefederation_msgRelayState_get(self) LASSO_PROFILE(self)->msg_relayState
1961
 
 
1962
 
/* msgUrl */
1963
 
#define LassoDefederation_get_msgUrl(self) LASSO_PROFILE(self)->msg_url
1964
 
#define LassoDefederation_msgUrl_get(self) LASSO_PROFILE(self)->msg_url
1965
 
 
1966
 
/* nameIdentifier */
1967
 
#define LassoDefederation_get_nameIdentifier(self) get_node(LASSO_PROFILE(self)->nameIdentifier)
1968
 
#define LassoDefederation_nameIdentifier_get(self) get_node(LASSO_PROFILE(self)->nameIdentifier)
1969
 
#define LassoDefederation_set_nameIdentifier(self, value) set_node((gpointer *) &LASSO_PROFILE(self)->nameIdentifier, (value))
1970
 
#define LassoDefederation_nameIdentifier_set(self, value) set_node((gpointer *) &LASSO_PROFILE(self)->nameIdentifier, (value))
1971
 
 
1972
 
/* remoteProviderId */
1973
 
#define LassoDefederation_get_remoteProviderId(self) LASSO_PROFILE(self)->remote_providerID
1974
 
#define LassoDefederation_remoteProviderId_get(self) LASSO_PROFILE(self)->remote_providerID
1975
 
#define LassoDefederation_set_remoteProviderId(self, value) set_string(&LASSO_PROFILE(self)->remote_providerID, (value))
1976
 
#define LassoDefederation_remoteProviderId_set(self, value) set_string(&LASSO_PROFILE(self)->remote_providerID, (value))
1977
 
 
1978
 
/* request */
1979
 
#define LassoDefederation_get_request(self) get_node(LASSO_PROFILE(self)->request)
1980
 
#define LassoDefederation_request_get(self) get_node(LASSO_PROFILE(self)->request)
1981
 
#define LassoDefederation_set_request(self, value) set_node((gpointer *) &LASSO_PROFILE(self)->request, (value))
1982
 
#define LassoDefederation_request_set(self, value) set_node((gpointer *) &LASSO_PROFILE(self)->request, (value))
1983
 
 
1984
 
/* response */
1985
 
#define LassoDefederation_get_response(self) get_node(LASSO_PROFILE(self)->response)
1986
 
#define LassoDefederation_response_get(self) get_node(LASSO_PROFILE(self)->response)
1987
 
#define LassoDefederation_set_response(self, value) set_node((gpointer *) &LASSO_PROFILE(self)->response, (value))
1988
 
#define LassoDefederation_response_set(self, value) set_node((gpointer *) &LASSO_PROFILE(self)->response, (value))
1989
 
 
1990
 
/* server */
1991
 
#define LassoDefederation_get_server(self) get_node(LASSO_PROFILE(self)->server)
1992
 
#define LassoDefederation_server_get(self) get_node(LASSO_PROFILE(self)->server)
1993
 
#define LassoDefederation_set_server(self, value) set_node((gpointer *) &LASSO_PROFILE(self)->server, (value))
1994
 
#define LassoDefederation_server_set(self, value) set_node((gpointer *) &LASSO_PROFILE(self)->server, (value))
1995
 
 
1996
 
/* session */
1997
 
#define LassoDefederation_get_session(self) lasso_profile_get_session(LASSO_PROFILE(self))
1998
 
#define LassoDefederation_session_get(self) lasso_profile_get_session(LASSO_PROFILE(self))
1999
 
#define LassoDefederation_set_session(self, value) set_node((gpointer *) &LASSO_PROFILE(self)->session, (value))
2000
 
#define LassoDefederation_session_set(self, value) set_node((gpointer *) &LASSO_PROFILE(self)->session, (value))
2001
 
 
2002
 
/* Constructors, destructors & static methods implementations */
2003
 
 
2004
 
#define new_LassoDefederation lasso_defederation_new
2005
 
#define delete_LassoDefederation(self) lasso_node_destroy(LASSO_NODE(self))
2006
 
 
2007
 
/* Implementations of methods inherited from Profile */
2008
 
 
2009
 
int LassoDefederation_setIdentityFromDump(LassoDefederation *self, char *dump) {
2010
 
        return lasso_profile_set_identity_from_dump(LASSO_PROFILE(self), dump);
2011
 
}
2012
 
 
2013
 
int LassoDefederation_setSessionFromDump(LassoDefederation *self, char *dump) {
2014
 
        return lasso_profile_set_session_from_dump(LASSO_PROFILE(self), dump);
2015
 
}
2016
 
 
2017
 
/* Methods implementations */
2018
 
 
2019
 
#define LassoDefederation_buildNotificationMsg lasso_defederation_build_notification_msg
2020
 
#define LassoDefederation_initNotification lasso_defederation_init_notification
2021
 
#define LassoDefederation_processNotificationMsg lasso_defederation_process_notification_msg
2022
 
#define LassoDefederation_validateNotification lasso_defederation_validate_notification
2023
 
 
2024
 
 
2025
 
 
2026
 
 
2027
 
/* Implementations of attributes inherited from Profile */
2028
 
 
2029
 
/* identity */
2030
 
#define LassoLogin_get_identity(self) lasso_profile_get_identity(LASSO_PROFILE(self))
2031
 
#define LassoLogin_identity_get(self) lasso_profile_get_identity(LASSO_PROFILE(self))
2032
 
#define LassoLogin_set_identity(self, value) set_node((gpointer *) &LASSO_PROFILE(self)->identity, (value))
2033
 
#define LassoLogin_identity_set(self, value) set_node((gpointer *) &LASSO_PROFILE(self)->identity, (value))
2034
 
 
2035
 
/* isIdentityDirty */
2036
 
#define LassoLogin_get_isIdentityDirty(self) lasso_profile_is_identity_dirty(LASSO_PROFILE(self))
2037
 
#define LassoLogin_isIdentityDirty_get(self) lasso_profile_is_identity_dirty(LASSO_PROFILE(self))
2038
 
 
2039
 
/* isSessionDirty */
2040
 
#define LassoLogin_get_isSessionDirty(self) lasso_profile_is_session_dirty(LASSO_PROFILE(self))
2041
 
#define LassoLogin_isSessionDirty_get(self) lasso_profile_is_session_dirty(LASSO_PROFILE(self))
2042
 
 
2043
 
/* msgBody */
2044
 
#define LassoLogin_get_msgBody(self) LASSO_PROFILE(self)->msg_body
2045
 
#define LassoLogin_msgBody_get(self) LASSO_PROFILE(self)->msg_body
2046
 
 
2047
 
/* msgRelayState */
2048
 
#define LassoLogin_get_msgRelayState(self) LASSO_PROFILE(self)->msg_relayState
2049
 
#define LassoLogin_msgRelayState_get(self) LASSO_PROFILE(self)->msg_relayState
2050
 
 
2051
 
/* msgUrl */
2052
 
#define LassoLogin_get_msgUrl(self) LASSO_PROFILE(self)->msg_url
2053
 
#define LassoLogin_msgUrl_get(self) LASSO_PROFILE(self)->msg_url
2054
 
 
2055
 
/* nameIdentifier */
2056
 
#define LassoLogin_get_nameIdentifier(self) get_node(LASSO_PROFILE(self)->nameIdentifier)
2057
 
#define LassoLogin_nameIdentifier_get(self) get_node(LASSO_PROFILE(self)->nameIdentifier)
2058
 
#define LassoLogin_set_nameIdentifier(self, value) set_node((gpointer *) &LASSO_PROFILE(self)->nameIdentifier, (value))
2059
 
#define LassoLogin_nameIdentifier_set(self, value) set_node((gpointer *) &LASSO_PROFILE(self)->nameIdentifier, (value))
2060
 
 
2061
 
/* remoteProviderId */
2062
 
#define LassoLogin_get_remoteProviderId(self) LASSO_PROFILE(self)->remote_providerID
2063
 
#define LassoLogin_remoteProviderId_get(self) LASSO_PROFILE(self)->remote_providerID
2064
 
#define LassoLogin_set_remoteProviderId(self, value) set_string(&LASSO_PROFILE(self)->remote_providerID, (value))
2065
 
#define LassoLogin_remoteProviderId_set(self, value) set_string(&LASSO_PROFILE(self)->remote_providerID, (value))
2066
 
 
2067
 
/* request */
2068
 
#define LassoLogin_get_request(self) get_node(LASSO_PROFILE(self)->request)
2069
 
#define LassoLogin_request_get(self) get_node(LASSO_PROFILE(self)->request)
2070
 
#define LassoLogin_set_request(self, value) set_node((gpointer *) &LASSO_PROFILE(self)->request, (value))
2071
 
#define LassoLogin_request_set(self, value) set_node((gpointer *) &LASSO_PROFILE(self)->request, (value))
2072
 
 
2073
 
/* response */
2074
 
#define LassoLogin_get_response(self) get_node(LASSO_PROFILE(self)->response)
2075
 
#define LassoLogin_response_get(self) get_node(LASSO_PROFILE(self)->response)
2076
 
#define LassoLogin_set_response(self, value) set_node((gpointer *) &LASSO_PROFILE(self)->response, (value))
2077
 
#define LassoLogin_response_set(self, value) set_node((gpointer *) &LASSO_PROFILE(self)->response, (value))
2078
 
 
2079
 
/* server */
2080
 
#define LassoLogin_get_server(self) get_node(LASSO_PROFILE(self)->server)
2081
 
#define LassoLogin_server_get(self) get_node(LASSO_PROFILE(self)->server)
2082
 
#define LassoLogin_set_server(self, value) set_node((gpointer *) &LASSO_PROFILE(self)->server, (value))
2083
 
#define LassoLogin_server_set(self, value) set_node((gpointer *) &LASSO_PROFILE(self)->server, (value))
2084
 
 
2085
 
/* session */
2086
 
#define LassoLogin_get_session(self) lasso_profile_get_session(LASSO_PROFILE(self))
2087
 
#define LassoLogin_session_get(self) lasso_profile_get_session(LASSO_PROFILE(self))
2088
 
#define LassoLogin_set_session(self, value) set_node((gpointer *) &LASSO_PROFILE(self)->session, (value))
2089
 
#define LassoLogin_session_set(self, value) set_node((gpointer *) &LASSO_PROFILE(self)->session, (value))
2090
 
 
2091
 
/* Constructors, destructors & static methods implementations */
2092
 
 
2093
 
#define new_LassoLogin lasso_login_new
2094
 
#define delete_LassoLogin(self) lasso_node_destroy(LASSO_NODE(self))
2095
 
#ifdef PHP_VERSION
2096
 
#define LassoLogin_newFromDump lasso_login_new_from_dump
2097
 
#else
2098
 
#define Login_newFromDump lasso_login_new_from_dump
2099
 
#endif
2100
 
 
2101
 
/* Implementations of methods inherited from Profile */
2102
 
 
2103
 
int LassoLogin_setIdentityFromDump(LassoLogin *self, char *dump) {
2104
 
        return lasso_profile_set_identity_from_dump(LASSO_PROFILE(self), dump);
2105
 
}
2106
 
 
2107
 
int LassoLogin_setSessionFromDump(LassoLogin *self, char *dump) {
2108
 
        return lasso_profile_set_session_from_dump(LASSO_PROFILE(self), dump);
2109
 
}
2110
 
 
2111
 
/* Methods implementations */
2112
 
 
2113
 
#define LassoLogin_acceptSso lasso_login_accept_sso
2114
 
#define LassoLogin_buildAssertion lasso_login_build_assertion
2115
 
#define LassoLogin_buildArtifactMsg lasso_login_build_artifact_msg
2116
 
#define LassoLogin_buildAuthnRequestMsg lasso_login_build_authn_request_msg
2117
 
#define LassoLogin_buildAuthnResponseMsg lasso_login_build_authn_response_msg
2118
 
#define LassoLogin_buildRequestMsg lasso_login_build_request_msg
2119
 
#define LassoLogin_buildResponseMsg lasso_login_build_response_msg
2120
 
#define LassoLogin_dump lasso_login_dump
2121
 
#define LassoLogin_initAuthnRequest lasso_login_init_authn_request
2122
 
#define LassoLogin_initRequest lasso_login_init_request
2123
 
#define LassoLogin_initIdpInitiatedAuthnRequest lasso_login_init_idp_initiated_authn_request
2124
 
#define LassoLogin_mustAskForConsent lasso_login_must_ask_for_consent
2125
 
#define LassoLogin_mustAuthenticate lasso_login_must_authenticate
2126
 
#define LassoLogin_processAuthnRequestMsg lasso_login_process_authn_request_msg
2127
 
#define LassoLogin_processAuthnResponseMsg lasso_login_process_authn_response_msg
2128
 
#define LassoLogin_processRequestMsg lasso_login_process_request_msg
2129
 
#define LassoLogin_processResponseMsg lasso_login_process_response_msg
2130
 
#define LassoLogin_setEncryptedResourceId lasso_login_set_encryptedResourceId 
2131
 
#define LassoLogin_setResourceId lasso_login_set_resourceId
2132
 
#define LassoLogin_validateRequestMsg lasso_login_validate_request_msg
2133
 
 
2134
 
 
2135
 
 
2136
 
 
2137
 
/* Implementations of attributes inherited from Profile */
2138
 
 
2139
 
/* identity */
2140
 
#define LassoLogout_get_identity(self) lasso_profile_get_identity(LASSO_PROFILE(self))
2141
 
#define LassoLogout_identity_get(self) lasso_profile_get_identity(LASSO_PROFILE(self))
2142
 
#define LassoLogout_set_identity(self, value) set_node((gpointer *) &LASSO_PROFILE(self)->identity, (value))
2143
 
#define LassoLogout_identity_set(self, value) set_node((gpointer *) &LASSO_PROFILE(self)->identity, (value))
2144
 
 
2145
 
/* isIdentityDirty */
2146
 
#define LassoLogout_get_isIdentityDirty(self) lasso_profile_is_identity_dirty(LASSO_PROFILE(self))
2147
 
#define LassoLogout_isIdentityDirty_get(self) lasso_profile_is_identity_dirty(LASSO_PROFILE(self))
2148
 
 
2149
 
/* isSessionDirty */
2150
 
#define LassoLogout_get_isSessionDirty(self) lasso_profile_is_session_dirty(LASSO_PROFILE(self))
2151
 
#define LassoLogout_isSessionDirty_get(self) lasso_profile_is_session_dirty(LASSO_PROFILE(self))
2152
 
 
2153
 
/* msgBody */
2154
 
#define LassoLogout_get_msgBody(self) LASSO_PROFILE(self)->msg_body
2155
 
#define LassoLogout_msgBody_get(self) LASSO_PROFILE(self)->msg_body
2156
 
 
2157
 
/* msgRelayState */
2158
 
#define LassoLogout_get_msgRelayState(self) LASSO_PROFILE(self)->msg_relayState
2159
 
#define LassoLogout_msgRelayState_get(self) LASSO_PROFILE(self)->msg_relayState
2160
 
 
2161
 
/* msgUrl */
2162
 
#define LassoLogout_get_msgUrl(self) LASSO_PROFILE(self)->msg_url
2163
 
#define LassoLogout_msgUrl_get(self) LASSO_PROFILE(self)->msg_url
2164
 
 
2165
 
/* nameIdentifier */
2166
 
#define LassoLogout_get_nameIdentifier(self) get_node(LASSO_PROFILE(self)->nameIdentifier)
2167
 
#define LassoLogout_nameIdentifier_get(self) get_node(LASSO_PROFILE(self)->nameIdentifier)
2168
 
#define LassoLogout_set_nameIdentifier(self, value) set_node((gpointer *) &LASSO_PROFILE(self)->nameIdentifier, (value))
2169
 
#define LassoLogout_nameIdentifier_set(self, value) set_node((gpointer *) &LASSO_PROFILE(self)->nameIdentifier, (value))
2170
 
 
2171
 
/* remoteProviderId */
2172
 
#define LassoLogout_get_remoteProviderId(self) LASSO_PROFILE(self)->remote_providerID
2173
 
#define LassoLogout_remoteProviderId_get(self) LASSO_PROFILE(self)->remote_providerID
2174
 
#define LassoLogout_set_remoteProviderId(self, value) set_string(&LASSO_PROFILE(self)->remote_providerID, (value))
2175
 
#define LassoLogout_remoteProviderId_set(self, value) set_string(&LASSO_PROFILE(self)->remote_providerID, (value))
2176
 
 
2177
 
/* request */
2178
 
#define LassoLogout_get_request(self) get_node(LASSO_PROFILE(self)->request)
2179
 
#define LassoLogout_request_get(self) get_node(LASSO_PROFILE(self)->request)
2180
 
#define LassoLogout_set_request(self, value) set_node((gpointer *) &LASSO_PROFILE(self)->request, (value))
2181
 
#define LassoLogout_request_set(self, value) set_node((gpointer *) &LASSO_PROFILE(self)->request, (value))
2182
 
 
2183
 
/* response */
2184
 
#define LassoLogout_get_response(self) get_node(LASSO_PROFILE(self)->response)
2185
 
#define LassoLogout_response_get(self) get_node(LASSO_PROFILE(self)->response)
2186
 
#define LassoLogout_set_response(self, value) set_node((gpointer *) &LASSO_PROFILE(self)->response, (value))
2187
 
#define LassoLogout_response_set(self, value) set_node((gpointer *) &LASSO_PROFILE(self)->response, (value))
2188
 
 
2189
 
/* server */
2190
 
#define LassoLogout_get_server(self) get_node(LASSO_PROFILE(self)->server)
2191
 
#define LassoLogout_server_get(self) get_node(LASSO_PROFILE(self)->server)
2192
 
#define LassoLogout_set_server(self, value) set_node((gpointer *) &LASSO_PROFILE(self)->server, (value))
2193
 
#define LassoLogout_server_set(self, value) set_node((gpointer *) &LASSO_PROFILE(self)->server, (value))
2194
 
 
2195
 
/* session */
2196
 
#define LassoLogout_get_session(self) lasso_profile_get_session(LASSO_PROFILE(self))
2197
 
#define LassoLogout_session_get(self) lasso_profile_get_session(LASSO_PROFILE(self))
2198
 
#define LassoLogout_set_session(self, value) set_node((gpointer *) &LASSO_PROFILE(self)->session, (value))
2199
 
#define LassoLogout_session_set(self, value) set_node((gpointer *) &LASSO_PROFILE(self)->session, (value))
2200
 
 
2201
 
/* Constructors, destructors & static methods implementations */
2202
 
 
2203
 
#define new_LassoLogout lasso_logout_new
2204
 
#define delete_LassoLogout(self) lasso_node_destroy(LASSO_NODE(self))
2205
 
#ifdef PHP_VERSION
2206
 
#define LassoLogout_newFromDump lasso_logout_new_from_dump
2207
 
#else
2208
 
#define Logout_newFromDump lasso_logout_new_from_dump
2209
 
#endif
2210
 
 
2211
 
/* Implementations of methods inherited from Profile */
2212
 
 
2213
 
int LassoLogout_setIdentityFromDump(LassoLogout *self, char *dump) {
2214
 
        return lasso_profile_set_identity_from_dump(LASSO_PROFILE(self), dump);
2215
 
}
2216
 
 
2217
 
int LassoLogout_setSessionFromDump(LassoLogout *self, char *dump) {
2218
 
        return lasso_profile_set_session_from_dump(LASSO_PROFILE(self), dump);
2219
 
}
2220
 
 
2221
 
/* Methods implementations */
2222
 
 
2223
 
#define LassoLogout_buildRequestMsg lasso_logout_build_request_msg
2224
 
#define LassoLogout_buildResponseMsg lasso_logout_build_response_msg
2225
 
#define LassoLogout_dump lasso_logout_dump
2226
 
#define LassoLogout_getNextProviderId lasso_logout_get_next_providerID
2227
 
#define LassoLogout_initRequest lasso_logout_init_request
2228
 
#define LassoLogout_processRequestMsg lasso_logout_process_request_msg
2229
 
#define LassoLogout_processResponseMsg lasso_logout_process_response_msg
2230
 
#define LassoLogout_resetProviderIdIndex lasso_logout_reset_providerID_index
2231
 
#define LassoLogout_validateRequest lasso_logout_validate_request
2232
 
 
2233
 
 
2234
 
 
2235
 
 
2236
 
/* Implementations of attributes inherited from Profile */
2237
 
 
2238
 
/* identity */
2239
 
#define LassoLecp_get_identity(self) lasso_profile_get_identity(LASSO_PROFILE(self))
2240
 
#define LassoLecp_identity_get(self) lasso_profile_get_identity(LASSO_PROFILE(self))
2241
 
#define LassoLecp_set_identity(self, value) set_node((gpointer *) &LASSO_PROFILE(self)->identity, (value))
2242
 
#define LassoLecp_identity_set(self, value) set_node((gpointer *) &LASSO_PROFILE(self)->identity, (value))
2243
 
 
2244
 
/* isIdentityDirty */
2245
 
#define LassoLecp_get_isIdentityDirty(self) lasso_profile_is_identity_dirty(LASSO_PROFILE(self))
2246
 
#define LassoLecp_isIdentityDirty_get(self) lasso_profile_is_identity_dirty(LASSO_PROFILE(self))
2247
 
 
2248
 
/* isSessionDirty */
2249
 
#define LassoLecp_get_isSessionDirty(self) lasso_profile_is_session_dirty(LASSO_PROFILE(self))
2250
 
#define LassoLecp_isSessionDirty_get(self) lasso_profile_is_session_dirty(LASSO_PROFILE(self))
2251
 
 
2252
 
/* msgBody */
2253
 
#define LassoLecp_get_msgBody(self) LASSO_PROFILE(self)->msg_body
2254
 
#define LassoLecp_msgBody_get(self) LASSO_PROFILE(self)->msg_body
2255
 
 
2256
 
/* msgRelayState */
2257
 
#define LassoLecp_get_msgRelayState(self) LASSO_PROFILE(self)->msg_relayState
2258
 
#define LassoLecp_msgRelayState_get(self) LASSO_PROFILE(self)->msg_relayState
2259
 
 
2260
 
/* msgUrl */
2261
 
#define LassoLecp_get_msgUrl(self) LASSO_PROFILE(self)->msg_url
2262
 
#define LassoLecp_msgUrl_get(self) LASSO_PROFILE(self)->msg_url
2263
 
 
2264
 
/* nameIdentifier */
2265
 
#define LassoLecp_get_nameIdentifier(self) get_node(LASSO_PROFILE(self)->nameIdentifier)
2266
 
#define LassoLecp_nameIdentifier_get(self) get_node(LASSO_PROFILE(self)->nameIdentifier)
2267
 
#define LassoLecp_set_nameIdentifier(self, value) set_node((gpointer *) &LASSO_PROFILE(self)->nameIdentifier, (value))
2268
 
#define LassoLecp_nameIdentifier_set(self, value) set_node((gpointer *) &LASSO_PROFILE(self)->nameIdentifier, (value))
2269
 
 
2270
 
/* remoteProviderId */
2271
 
#define LassoLecp_get_remoteProviderId(self) LASSO_PROFILE(self)->remote_providerID
2272
 
#define LassoLecp_remoteProviderId_get(self) LASSO_PROFILE(self)->remote_providerID
2273
 
#define LassoLecp_set_remoteProviderId(self, value) set_string(&LASSO_PROFILE(self)->remote_providerID, (value))
2274
 
#define LassoLecp_remoteProviderId_set(self, value) set_string(&LASSO_PROFILE(self)->remote_providerID, (value))
2275
 
 
2276
 
/* request */
2277
 
#define LassoLecp_get_request(self) get_node(LASSO_PROFILE(self)->request)
2278
 
#define LassoLecp_request_get(self) get_node(LASSO_PROFILE(self)->request)
2279
 
#define LassoLecp_set_request(self, value) set_node((gpointer *) &LASSO_PROFILE(self)->request, (value))
2280
 
#define LassoLecp_request_set(self, value) set_node((gpointer *) &LASSO_PROFILE(self)->request, (value))
2281
 
 
2282
 
/* response */
2283
 
#define LassoLecp_get_response(self) get_node(LASSO_PROFILE(self)->response)
2284
 
#define LassoLecp_response_get(self) get_node(LASSO_PROFILE(self)->response)
2285
 
#define LassoLecp_set_response(self, value) set_node((gpointer *) &LASSO_PROFILE(self)->response, (value))
2286
 
#define LassoLecp_response_set(self, value) set_node((gpointer *) &LASSO_PROFILE(self)->response, (value))
2287
 
 
2288
 
/* server */
2289
 
#define LassoLecp_get_server(self) get_node(LASSO_PROFILE(self)->server)
2290
 
#define LassoLecp_server_get(self) get_node(LASSO_PROFILE(self)->server)
2291
 
#define LassoLecp_set_server(self, value) set_node((gpointer *) &LASSO_PROFILE(self)->server, (value))
2292
 
#define LassoLecp_server_set(self, value) set_node((gpointer *) &LASSO_PROFILE(self)->server, (value))
2293
 
 
2294
 
/* session */
2295
 
#define LassoLecp_get_session(self) lasso_profile_get_session(LASSO_PROFILE(self))
2296
 
#define LassoLecp_session_get(self) lasso_profile_get_session(LASSO_PROFILE(self))
2297
 
#define LassoLecp_set_session(self, value) set_node((gpointer *) &LASSO_PROFILE(self)->session, (value))
2298
 
#define LassoLecp_session_set(self, value) set_node((gpointer *) &LASSO_PROFILE(self)->session, (value))
2299
 
 
2300
 
/* Constructors, destructors & static methods implementations */
2301
 
 
2302
 
#define new_LassoLecp lasso_lecp_new
2303
 
#define delete_LassoLecp(self) lasso_node_destroy(LASSO_NODE(self))
2304
 
 
2305
 
/* Implementations of methods inherited from Profile */
2306
 
 
2307
 
int LassoLecp_setIdentityFromDump(LassoLecp *self, char *dump) {
2308
 
        return lasso_profile_set_identity_from_dump(LASSO_PROFILE(self), dump);
2309
 
}
2310
 
 
2311
 
int LassoLecp_setSessionFromDump(LassoLecp *self, char *dump) {
2312
 
        return lasso_profile_set_session_from_dump(LASSO_PROFILE(self), dump);
2313
 
}
2314
 
 
2315
 
/* Implementations of methods inherited from Login */
2316
 
 
2317
 
int LassoLecp_buildAssertion(LassoLecp *self, char *authenticationMethod,
2318
 
                char *authenticationInstant, char *reauthenticateOnOrAfter, char *notBefore,
2319
 
                char *notOnOrAfter) {
2320
 
        return lasso_login_build_assertion(LASSO_LOGIN(self), authenticationMethod,
2321
 
                        authenticationInstant, reauthenticateOnOrAfter, notBefore, notOnOrAfter);
2322
 
}
2323
 
 
2324
 
#ifdef LASSO_WSF_ENABLED
2325
 
int LassoLecp_setEncryptedResourceId(LassoLecp *self,
2326
 
                LassoDiscoEncryptedResourceID *encryptedResourceId) {
2327
 
        return lasso_login_set_encryptedResourceId(LASSO_LOGIN(self), encryptedResourceId);
2328
 
}
2329
 
#endif
2330
 
 
2331
 
int LassoLecp_setResourceId(LassoLecp *self, char *content) {
2332
 
        return lasso_login_set_resourceId(LASSO_LOGIN(self), content);
2333
 
}
2334
 
 
2335
 
int LassoLecp_validateRequestMsg(LassoLecp *self, gboolean authenticationResult,
2336
 
                gboolean isConsentObtained) {
2337
 
        return lasso_login_validate_request_msg(LASSO_LOGIN(self), authenticationResult,
2338
 
                        isConsentObtained);
2339
 
}
2340
 
 
2341
 
/* Methods implementations */
2342
 
 
2343
 
#define LassoLecp_buildAuthnRequestEnvelopeMsg lasso_lecp_build_authn_request_envelope_msg
2344
 
#define LassoLecp_buildAuthnRequestMsg lasso_lecp_build_authn_request_msg
2345
 
#define LassoLecp_buildAuthnResponseEnvelopeMsg lasso_lecp_build_authn_response_envelope_msg
2346
 
#define LassoLecp_buildAuthnResponseMsg lasso_lecp_build_authn_response_msg
2347
 
#define LassoLecp_initAuthnRequest lasso_lecp_init_authn_request
2348
 
#define LassoLecp_processAuthnRequestEnvelopeMsg lasso_lecp_process_authn_request_envelope_msg
2349
 
#define LassoLecp_processAuthnRequestMsg lasso_lecp_process_authn_request_msg
2350
 
#define LassoLecp_processAuthnResponseEnvelopeMsg lasso_lecp_process_authn_response_envelope_msg
2351
 
 
2352
 
 
2353
 
 
2354
 
 
2355
 
/* Implementations of attributes inherited from Profile */
2356
 
 
2357
 
/* identity */
2358
 
#define LassoNameIdentifierMapping_get_identity(self) lasso_profile_get_identity(LASSO_PROFILE(self))
2359
 
#define LassoNameIdentifierMapping_identity_get(self) lasso_profile_get_identity(LASSO_PROFILE(self))
2360
 
#define LassoNameIdentifierMapping_set_identity(self, value) set_node((gpointer *) &LASSO_PROFILE(self)->identity, (value))
2361
 
#define LassoNameIdentifierMapping_identity_set(self, value) set_node((gpointer *) &LASSO_PROFILE(self)->identity, (value))
2362
 
 
2363
 
/* isIdentityDirty */
2364
 
#define LassoNameIdentifierMapping_get_isIdentityDirty(self) lasso_profile_is_identity_dirty(LASSO_PROFILE(self))
2365
 
#define LassoNameIdentifierMapping_isIdentityDirty_get(self) lasso_profile_is_identity_dirty(LASSO_PROFILE(self))
2366
 
 
2367
 
/* isSessionDirty */
2368
 
#define LassoNameIdentifierMapping_get_isSessionDirty(self) lasso_profile_is_session_dirty(LASSO_PROFILE(self))
2369
 
#define LassoNameIdentifierMapping_isSessionDirty_get(self) lasso_profile_is_session_dirty(LASSO_PROFILE(self))
2370
 
 
2371
 
/* msgBody */
2372
 
#define LassoNameIdentifierMapping_get_msgBody(self) LASSO_PROFILE(self)->msg_body
2373
 
#define LassoNameIdentifierMapping_msgBody_get(self) LASSO_PROFILE(self)->msg_body
2374
 
 
2375
 
/* msgRelayState */
2376
 
#define LassoNameIdentifierMapping_get_msgRelayState(self) LASSO_PROFILE(self)->msg_relayState
2377
 
#define LassoNameIdentifierMapping_msgRelayState_get(self) LASSO_PROFILE(self)->msg_relayState
2378
 
 
2379
 
/* msgUrl */
2380
 
#define LassoNameIdentifierMapping_get_msgUrl(self) LASSO_PROFILE(self)->msg_url
2381
 
#define LassoNameIdentifierMapping_msgUrl_get(self) LASSO_PROFILE(self)->msg_url
2382
 
 
2383
 
/* nameIdentifier */
2384
 
#define LassoNameIdentifierMapping_get_nameIdentifier(self) get_node(LASSO_PROFILE(self)->nameIdentifier)
2385
 
#define LassoNameIdentifierMapping_nameIdentifier_get(self) get_node(LASSO_PROFILE(self)->nameIdentifier)
2386
 
#define LassoNameIdentifierMapping_set_nameIdentifier(self, value) set_node((gpointer *) &LASSO_PROFILE(self)->nameIdentifier, (value))
2387
 
#define LassoNameIdentifierMapping_nameIdentifier_set(self, value) set_node((gpointer *) &LASSO_PROFILE(self)->nameIdentifier, (value))
2388
 
 
2389
 
/* remoteProviderId */
2390
 
#define LassoNameIdentifierMapping_get_remoteProviderId(self) LASSO_PROFILE(self)->remote_providerID
2391
 
#define LassoNameIdentifierMapping_remoteProviderId_get(self) LASSO_PROFILE(self)->remote_providerID
2392
 
#define LassoNameIdentifierMapping_set_remoteProviderId(self, value) set_string(&LASSO_PROFILE(self)->remote_providerID, (value))
2393
 
#define LassoNameIdentifierMapping_remoteProviderId_set(self, value) set_string(&LASSO_PROFILE(self)->remote_providerID, (value))
2394
 
 
2395
 
/* request */
2396
 
#define LassoNameIdentifierMapping_get_request(self) get_node(LASSO_PROFILE(self)->request)
2397
 
#define LassoNameIdentifierMapping_request_get(self) get_node(LASSO_PROFILE(self)->request)
2398
 
#define LassoNameIdentifierMapping_set_request(self, value) set_node((gpointer *) &LASSO_PROFILE(self)->request, (value))
2399
 
#define LassoNameIdentifierMapping_request_set(self, value) set_node((gpointer *) &LASSO_PROFILE(self)->request, (value))
2400
 
 
2401
 
/* response */
2402
 
#define LassoNameIdentifierMapping_get_response(self) get_node(LASSO_PROFILE(self)->response)
2403
 
#define LassoNameIdentifierMapping_response_get(self) get_node(LASSO_PROFILE(self)->response)
2404
 
#define LassoNameIdentifierMapping_set_response(self, value) set_node((gpointer *) &LASSO_PROFILE(self)->response, (value))
2405
 
#define LassoNameIdentifierMapping_response_set(self, value) set_node((gpointer *) &LASSO_PROFILE(self)->response, (value))
2406
 
 
2407
 
/* server */
2408
 
#define LassoNameIdentifierMapping_get_server(self) get_node(LASSO_PROFILE(self)->server)
2409
 
#define LassoNameIdentifierMapping_server_get(self) get_node(LASSO_PROFILE(self)->server)
2410
 
#define LassoNameIdentifierMapping_set_server(self, value) set_node((gpointer *) &LASSO_PROFILE(self)->server, (value))
2411
 
#define LassoNameIdentifierMapping_server_set(self, value) set_node((gpointer *) &LASSO_PROFILE(self)->server, (value))
2412
 
 
2413
 
/* session */
2414
 
#define LassoNameIdentifierMapping_get_session(self) lasso_profile_get_session(LASSO_PROFILE(self))
2415
 
#define LassoNameIdentifierMapping_session_get(self) lasso_profile_get_session(LASSO_PROFILE(self))
2416
 
#define LassoNameIdentifierMapping_set_session(self, value) set_node((gpointer *) &LASSO_PROFILE(self)->session, (value))
2417
 
#define LassoNameIdentifierMapping_session_set(self, value) set_node((gpointer *) &LASSO_PROFILE(self)->session, (value))
2418
 
 
2419
 
/* Constructors, destructors & static methods implementations */
2420
 
 
2421
 
#define new_LassoNameIdentifierMapping lasso_name_identifier_mapping_new
2422
 
#define delete_LassoNameIdentifierMapping(self) lasso_node_destroy(LASSO_NODE(self))
2423
 
 
2424
 
/* Implementations of methods inherited from Profile */
2425
 
 
2426
 
int LassoNameIdentifierMapping_setIdentityFromDump(LassoNameIdentifierMapping *self, char *dump) {
2427
 
        return lasso_profile_set_identity_from_dump(LASSO_PROFILE(self), dump);
2428
 
}
2429
 
 
2430
 
int LassoNameIdentifierMapping_setSessionFromDump(LassoNameIdentifierMapping *self, char *dump) {
2431
 
        return lasso_profile_set_session_from_dump(LASSO_PROFILE(self), dump);
2432
 
}
2433
 
 
2434
 
/* Methods implementations */
2435
 
 
2436
 
#define LassoNameIdentifierMapping_buildRequestMsg lasso_name_identifier_mapping_build_request_msg
2437
 
#define LassoNameIdentifierMapping_buildResponseMsg lasso_name_identifier_mapping_build_response_msg
2438
 
#define LassoNameIdentifierMapping_initRequest lasso_name_identifier_mapping_init_request
2439
 
#define LassoNameIdentifierMapping_processRequestMsg lasso_name_identifier_mapping_process_request_msg
2440
 
#define LassoNameIdentifierMapping_processResponseMsg lasso_name_identifier_mapping_process_response_msg
2441
 
#define LassoNameIdentifierMapping_validateRequest lasso_name_identifier_mapping_validate_request
2442
 
 
2443
 
 
2444
 
 
2445
 
 
2446
 
/* Implementations of attributes inherited from Profile */
2447
 
 
2448
 
/* identity */
2449
 
#define LassoNameRegistration_get_identity(self) lasso_profile_get_identity(LASSO_PROFILE(self))
2450
 
#define LassoNameRegistration_identity_get(self) lasso_profile_get_identity(LASSO_PROFILE(self))
2451
 
#define LassoNameRegistration_set_identity(self, value) set_node((gpointer *) &LASSO_PROFILE(self)->identity, (value))
2452
 
#define LassoNameRegistration_identity_set(self, value) set_node((gpointer *) &LASSO_PROFILE(self)->identity, (value))
2453
 
 
2454
 
/* isIdentityDirty */
2455
 
#define LassoNameRegistration_get_isIdentityDirty(self) lasso_profile_is_identity_dirty(LASSO_PROFILE(self))
2456
 
#define LassoNameRegistration_isIdentityDirty_get(self) lasso_profile_is_identity_dirty(LASSO_PROFILE(self))
2457
 
 
2458
 
/* isSessionDirty */
2459
 
#define LassoNameRegistration_get_isSessionDirty(self) lasso_profile_is_session_dirty(LASSO_PROFILE(self))
2460
 
#define LassoNameRegistration_isSessionDirty_get(self) lasso_profile_is_session_dirty(LASSO_PROFILE(self))
2461
 
 
2462
 
/* msgBody */
2463
 
#define LassoNameRegistration_get_msgBody(self) LASSO_PROFILE(self)->msg_body
2464
 
#define LassoNameRegistration_msgBody_get(self) LASSO_PROFILE(self)->msg_body
2465
 
 
2466
 
/* msgRelayState */
2467
 
#define LassoNameRegistration_get_msgRelayState(self) LASSO_PROFILE(self)->msg_relayState
2468
 
#define LassoNameRegistration_msgRelayState_get(self) LASSO_PROFILE(self)->msg_relayState
2469
 
 
2470
 
/* msgUrl */
2471
 
#define LassoNameRegistration_get_msgUrl(self) LASSO_PROFILE(self)->msg_url
2472
 
#define LassoNameRegistration_msgUrl_get(self) LASSO_PROFILE(self)->msg_url
2473
 
 
2474
 
/* nameIdentifier */
2475
 
#define LassoNameRegistration_get_nameIdentifier(self) get_node(LASSO_PROFILE(self)->nameIdentifier)
2476
 
#define LassoNameRegistration_nameIdentifier_get(self) get_node(LASSO_PROFILE(self)->nameIdentifier)
2477
 
#define LassoNameRegistration_set_nameIdentifier(self, value) set_node((gpointer *) &LASSO_PROFILE(self)->nameIdentifier, (value))
2478
 
#define LassoNameRegistration_nameIdentifier_set(self, value) set_node((gpointer *) &LASSO_PROFILE(self)->nameIdentifier, (value))
2479
 
 
2480
 
/* remoteProviderId */
2481
 
#define LassoNameRegistration_get_remoteProviderId(self) LASSO_PROFILE(self)->remote_providerID
2482
 
#define LassoNameRegistration_remoteProviderId_get(self) LASSO_PROFILE(self)->remote_providerID
2483
 
#define LassoNameRegistration_set_remoteProviderId(self, value) set_string(&LASSO_PROFILE(self)->remote_providerID, (value))
2484
 
#define LassoNameRegistration_remoteProviderId_set(self, value) set_string(&LASSO_PROFILE(self)->remote_providerID, (value))
2485
 
 
2486
 
/* request */
2487
 
#define LassoNameRegistration_get_request(self) get_node(LASSO_PROFILE(self)->request)
2488
 
#define LassoNameRegistration_request_get(self) get_node(LASSO_PROFILE(self)->request)
2489
 
#define LassoNameRegistration_set_request(self, value) set_node((gpointer *) &LASSO_PROFILE(self)->request, (value))
2490
 
#define LassoNameRegistration_request_set(self, value) set_node((gpointer *) &LASSO_PROFILE(self)->request, (value))
2491
 
 
2492
 
/* response */
2493
 
#define LassoNameRegistration_get_response(self) get_node(LASSO_PROFILE(self)->response)
2494
 
#define LassoNameRegistration_response_get(self) get_node(LASSO_PROFILE(self)->response)
2495
 
#define LassoNameRegistration_set_response(self, value) set_node((gpointer *) &LASSO_PROFILE(self)->response, (value))
2496
 
#define LassoNameRegistration_response_set(self, value) set_node((gpointer *) &LASSO_PROFILE(self)->response, (value))
2497
 
 
2498
 
/* server */
2499
 
#define LassoNameRegistration_get_server(self) get_node(LASSO_PROFILE(self)->server)
2500
 
#define LassoNameRegistration_server_get(self) get_node(LASSO_PROFILE(self)->server)
2501
 
#define LassoNameRegistration_set_server(self, value) set_node((gpointer *) &LASSO_PROFILE(self)->server, (value))
2502
 
#define LassoNameRegistration_server_set(self, value) set_node((gpointer *) &LASSO_PROFILE(self)->server, (value))
2503
 
 
2504
 
/* session */
2505
 
#define LassoNameRegistration_get_session(self) lasso_profile_get_session(LASSO_PROFILE(self))
2506
 
#define LassoNameRegistration_session_get(self) lasso_profile_get_session(LASSO_PROFILE(self))
2507
 
#define LassoNameRegistration_set_session(self, value) set_node((gpointer *) &LASSO_PROFILE(self)->session, (value))
2508
 
#define LassoNameRegistration_session_set(self, value) set_node((gpointer *) &LASSO_PROFILE(self)->session, (value))
2509
 
 
2510
 
/* Attributes implementations */
2511
 
 
2512
 
/* oldNameIdentifier */
2513
 
#define LassoNameRegistration_get_oldNameIdentifier(self) get_node((self)->oldNameIdentifier)
2514
 
#define LassoNameRegistration_oldNameIdentifier_get(self) get_node((self)->oldNameIdentifier)
2515
 
#define LassoNameRegistration_set_oldNameIdentifier(self, value) set_node((gpointer *) &(self)->oldNameIdentifier, (value))
2516
 
#define LassoNameRegistration_oldNameIdentifier_set(self, value) set_node((gpointer *) &(self)->oldNameIdentifier, (value))
2517
 
 
2518
 
/* Constructors, destructors & static methods implementations */
2519
 
 
2520
 
#define new_LassoNameRegistration lasso_name_registration_new
2521
 
#define delete_LassoNameRegistration(self) lasso_node_destroy(LASSO_NODE(self))
2522
 
#ifdef PHP_VERSION
2523
 
#define LassoNameRegistration_newFromDump lasso_name_registration_new_from_dump
2524
 
#else
2525
 
#define NameRegistration_newFromDump lasso_name_registration_new_from_dump
2526
 
#endif
2527
 
 
2528
 
/* Implementations of methods inherited from Profile */
2529
 
 
2530
 
int LassoNameRegistration_setIdentityFromDump(LassoNameRegistration *self, char *dump) {
2531
 
        return lasso_profile_set_identity_from_dump(LASSO_PROFILE(self), dump);
2532
 
}
2533
 
 
2534
 
int LassoNameRegistration_setSessionFromDump(LassoNameRegistration *self, char *dump) {
2535
 
        return lasso_profile_set_session_from_dump(LASSO_PROFILE(self), dump);
2536
 
}
2537
 
 
2538
 
/* Methods implementations */
2539
 
 
2540
 
#define LassoNameRegistration_buildRequestMsg lasso_name_registration_build_request_msg
2541
 
#define LassoNameRegistration_buildResponseMsg lasso_name_registration_build_response_msg
2542
 
#define LassoNameRegistration_dump lasso_name_registration_dump
2543
 
#define LassoNameRegistration_initRequest lasso_name_registration_init_request
2544
 
#define LassoNameRegistration_processRequestMsg lasso_name_registration_process_request_msg
2545
 
#define LassoNameRegistration_processResponseMsg lasso_name_registration_process_response_msg
2546
 
#define LassoNameRegistration_validateRequest lasso_name_registration_validate_request
2547
 
 
2548
 
 
2549
 
 
2550
 
#ifdef __cplusplus
2551
 
extern "C" {
2552
 
#endif
2553
 
 
2554
 
DllExport int SWIGSTDCALL CSharp_get_WSF_SUPPORT() {
2555
 
    int jresult = 0 ;
2556
 
    int result;
2557
 
    
2558
 
    result = (int) 0;
2559
 
    
2560
 
    jresult = result; 
2561
 
    return jresult;
2562
 
}
2563
 
 
2564
 
 
2565
 
DllExport void * SWIGSTDCALL CSharp_downcast_node(void * jarg1) {
2566
 
    void * jresult = 0 ;
2567
 
    LassoNode *arg1 = (LassoNode *) 0 ;
2568
 
    DowncastableNode *result;
2569
 
    
2570
 
    arg1 = (LassoNode *)jarg1; 
2571
 
    result = (DowncastableNode *)downcast_node(arg1);
2572
 
    
2573
 
    {
2574
 
        /* FIXME */
2575
 
        /*      char classPath[256]; */
2576
 
        /*      jclass clazz; */
2577
 
        /*      char *name; */
2578
 
        
2579
 
        /*      name = (char *) G_OBJECT_TYPE_NAME(result); */
2580
 
        /*      name += 5; /\* Skip "Lasso" prefix. *\/ */
2581
 
        /*      sprintf(classPath, "com/entrouvert/lasso/%s", name); */
2582
 
        /*      clazz = (*jenv)->FindClass(jenv, classPath); */
2583
 
        /*      if (clazz) { */
2584
 
        /*              jmethodID mid = (*jenv)->GetMethodID(jenv, clazz, "<init>", "(JZ)V"); */
2585
 
        /*              if (mid) */
2586
 
        /*                      *(void**)&jresult = (*jenv)->NewObject(jenv, clazz, mid, result, false); */
2587
 
        /*      } */
2588
 
    }
2589
 
    return jresult;
2590
 
}
2591
 
 
2592
 
 
2593
 
DllExport char * SWIGSTDCALL CSharp_get_LIB_CONSENT_OBTAINED() {
2594
 
    char * jresult = 0 ;
2595
 
    char *result;
2596
 
    
2597
 
    result = strdup("urn:liberty:consent:obtained");
2598
 
    
2599
 
    jresult = SWIG_csharp_string_callback(result); 
2600
 
    return jresult;
2601
 
}
2602
 
 
2603
 
 
2604
 
DllExport char * SWIGSTDCALL CSharp_get_LIB_CONSENT_OBTAINED_PRIOR() {
2605
 
    char * jresult = 0 ;
2606
 
    char *result;
2607
 
    
2608
 
    result = strdup("urn:liberty:consent:obtained:prior");
2609
 
    
2610
 
    jresult = SWIG_csharp_string_callback(result); 
2611
 
    return jresult;
2612
 
}
2613
 
 
2614
 
 
2615
 
DllExport char * SWIGSTDCALL CSharp_get_LIB_CONSENT_OBTAINED_CURRENT_IMPLICIT() {
2616
 
    char * jresult = 0 ;
2617
 
    char *result;
2618
 
    
2619
 
    result = strdup("urn:liberty:consent:obtained:current:implicit");
2620
 
    
2621
 
    jresult = SWIG_csharp_string_callback(result); 
2622
 
    return jresult;
2623
 
}
2624
 
 
2625
 
 
2626
 
DllExport char * SWIGSTDCALL CSharp_get_LIB_CONSENT_OBTAINED_CURRENT_EXPLICIT() {
2627
 
    char * jresult = 0 ;
2628
 
    char *result;
2629
 
    
2630
 
    result = strdup("urn:liberty:consent:obtained:current:explicit");
2631
 
    
2632
 
    jresult = SWIG_csharp_string_callback(result); 
2633
 
    return jresult;
2634
 
}
2635
 
 
2636
 
 
2637
 
DllExport char * SWIGSTDCALL CSharp_get_LIB_CONSENT_UNAVAILABLE() {
2638
 
    char * jresult = 0 ;
2639
 
    char *result;
2640
 
    
2641
 
    result = strdup("urn:liberty:consent:unavailable");
2642
 
    
2643
 
    jresult = SWIG_csharp_string_callback(result); 
2644
 
    return jresult;
2645
 
}
2646
 
 
2647
 
 
2648
 
DllExport char * SWIGSTDCALL CSharp_get_LIB_CONSENT_INAPPLICABLE() {
2649
 
    char * jresult = 0 ;
2650
 
    char *result;
2651
 
    
2652
 
    result = strdup("urn:liberty:consent:inapplicable");
2653
 
    
2654
 
    jresult = SWIG_csharp_string_callback(result); 
2655
 
    return jresult;
2656
 
}
2657
 
 
2658
 
 
2659
 
DllExport char * SWIGSTDCALL CSharp_get_LIB_NAMEID_POLICY_TYPE_NONE() {
2660
 
    char * jresult = 0 ;
2661
 
    char *result;
2662
 
    
2663
 
    result = strdup("none");
2664
 
    
2665
 
    jresult = SWIG_csharp_string_callback(result); 
2666
 
    return jresult;
2667
 
}
2668
 
 
2669
 
 
2670
 
DllExport char * SWIGSTDCALL CSharp_get_LIB_NAMEID_POLICY_TYPE_ONE_TIME() {
2671
 
    char * jresult = 0 ;
2672
 
    char *result;
2673
 
    
2674
 
    result = strdup("onetime");
2675
 
    
2676
 
    jresult = SWIG_csharp_string_callback(result); 
2677
 
    return jresult;
2678
 
}
2679
 
 
2680
 
 
2681
 
DllExport char * SWIGSTDCALL CSharp_get_LIB_NAMEID_POLICY_TYPE_FEDERATED() {
2682
 
    char * jresult = 0 ;
2683
 
    char *result;
2684
 
    
2685
 
    result = strdup("federated");
2686
 
    
2687
 
    jresult = SWIG_csharp_string_callback(result); 
2688
 
    return jresult;
2689
 
}
2690
 
 
2691
 
 
2692
 
DllExport char * SWIGSTDCALL CSharp_get_LIB_NAMEID_POLICY_TYPE_ANY() {
2693
 
    char * jresult = 0 ;
2694
 
    char *result;
2695
 
    
2696
 
    result = strdup("any");
2697
 
    
2698
 
    jresult = SWIG_csharp_string_callback(result); 
2699
 
    return jresult;
2700
 
}
2701
 
 
2702
 
 
2703
 
DllExport char * SWIGSTDCALL CSharp_get_LIB_PROTOCOL_PROFILE_BRWS_ART() {
2704
 
    char * jresult = 0 ;
2705
 
    char *result;
2706
 
    
2707
 
    result = strdup("http://projectliberty.org/profiles/brws-art");
2708
 
    
2709
 
    jresult = SWIG_csharp_string_callback(result); 
2710
 
    return jresult;
2711
 
}
2712
 
 
2713
 
 
2714
 
DllExport char * SWIGSTDCALL CSharp_get_LIB_PROTOCOL_PROFILE_BRWS_POST() {
2715
 
    char * jresult = 0 ;
2716
 
    char *result;
2717
 
    
2718
 
    result = strdup("http://projectliberty.org/profiles/brws-post");
2719
 
    
2720
 
    jresult = SWIG_csharp_string_callback(result); 
2721
 
    return jresult;
2722
 
}
2723
 
 
2724
 
 
2725
 
DllExport char * SWIGSTDCALL CSharp_get_LIB_PROTOCOL_PROFILE_BRWS_LECP() {
2726
 
    char * jresult = 0 ;
2727
 
    char *result;
2728
 
    
2729
 
    result = strdup("http://projectliberty.org/profiles/lecp");
2730
 
    
2731
 
    jresult = SWIG_csharp_string_callback(result); 
2732
 
    return jresult;
2733
 
}
2734
 
 
2735
 
 
2736
 
DllExport char * SWIGSTDCALL CSharp_get_LIB_PROTOCOL_PROFILE_FED_TERM_IDP_HTTP() {
2737
 
    char * jresult = 0 ;
2738
 
    char *result;
2739
 
    
2740
 
    result = strdup("http://projectliberty.org/profiles/fedterm-idp-http");
2741
 
    
2742
 
    jresult = SWIG_csharp_string_callback(result); 
2743
 
    return jresult;
2744
 
}
2745
 
 
2746
 
 
2747
 
DllExport char * SWIGSTDCALL CSharp_get_LIB_PROTOCOL_PROFILE_FED_TERM_IDP_SOAP() {
2748
 
    char * jresult = 0 ;
2749
 
    char *result;
2750
 
    
2751
 
    result = strdup("http://projectliberty.org/profiles/fedterm-idp-soap");
2752
 
    
2753
 
    jresult = SWIG_csharp_string_callback(result); 
2754
 
    return jresult;
2755
 
}
2756
 
 
2757
 
 
2758
 
DllExport char * SWIGSTDCALL CSharp_get_LIB_PROTOCOL_PROFILE_FED_TERM_SP_HTTP() {
2759
 
    char * jresult = 0 ;
2760
 
    char *result;
2761
 
    
2762
 
    result = strdup("http://projectliberty.org/profiles/fedterm-sp-http");
2763
 
    
2764
 
    jresult = SWIG_csharp_string_callback(result); 
2765
 
    return jresult;
2766
 
}
2767
 
 
2768
 
 
2769
 
DllExport char * SWIGSTDCALL CSharp_get_LIB_PROTOCOL_PROFILE_FED_TERM_SP_SOAP() {
2770
 
    char * jresult = 0 ;
2771
 
    char *result;
2772
 
    
2773
 
    result = strdup("http://projectliberty.org/profiles/fedterm-sp-soap");
2774
 
    
2775
 
    jresult = SWIG_csharp_string_callback(result); 
2776
 
    return jresult;
2777
 
}
2778
 
 
2779
 
 
2780
 
DllExport char * SWIGSTDCALL CSharp_get_LIB_PROTOCOL_PROFILE_RNI_IDP_HTTP() {
2781
 
    char * jresult = 0 ;
2782
 
    char *result;
2783
 
    
2784
 
    result = strdup("http://projectliberty.org/profiles/rni-idp-http");
2785
 
    
2786
 
    jresult = SWIG_csharp_string_callback(result); 
2787
 
    return jresult;
2788
 
}
2789
 
 
2790
 
 
2791
 
DllExport char * SWIGSTDCALL CSharp_get_LIB_PROTOCOL_PROFILE_RNI_IDP_SOAP() {
2792
 
    char * jresult = 0 ;
2793
 
    char *result;
2794
 
    
2795
 
    result = strdup("http://projectliberty.org/profiles/rni-idp-soap");
2796
 
    
2797
 
    jresult = SWIG_csharp_string_callback(result); 
2798
 
    return jresult;
2799
 
}
2800
 
 
2801
 
 
2802
 
DllExport char * SWIGSTDCALL CSharp_get_LIB_PROTOCOL_PROFILE_RNI_SP_HTTP() {
2803
 
    char * jresult = 0 ;
2804
 
    char *result;
2805
 
    
2806
 
    result = strdup("http://projectliberty.org/profiles/rni-sp-http");
2807
 
    
2808
 
    jresult = SWIG_csharp_string_callback(result); 
2809
 
    return jresult;
2810
 
}
2811
 
 
2812
 
 
2813
 
DllExport char * SWIGSTDCALL CSharp_get_LIB_PROTOCOL_PROFILE_RNI_SP_SOAP() {
2814
 
    char * jresult = 0 ;
2815
 
    char *result;
2816
 
    
2817
 
    result = strdup("http://projectliberty.org/profiles/rni-sp-soap");
2818
 
    
2819
 
    jresult = SWIG_csharp_string_callback(result); 
2820
 
    return jresult;
2821
 
}
2822
 
 
2823
 
 
2824
 
DllExport char * SWIGSTDCALL CSharp_get_LIB_PROTOCOL_PROFILE_SLO_IDP_HTTP() {
2825
 
    char * jresult = 0 ;
2826
 
    char *result;
2827
 
    
2828
 
    result = strdup("http://projectliberty.org/profiles/slo-idp-http");
2829
 
    
2830
 
    jresult = SWIG_csharp_string_callback(result); 
2831
 
    return jresult;
2832
 
}
2833
 
 
2834
 
 
2835
 
DllExport char * SWIGSTDCALL CSharp_get_LIB_PROTOCOL_PROFILE_SLO_IDP_SOAP() {
2836
 
    char * jresult = 0 ;
2837
 
    char *result;
2838
 
    
2839
 
    result = strdup("http://projectliberty.org/profiles/slo-idp-soap");
2840
 
    
2841
 
    jresult = SWIG_csharp_string_callback(result); 
2842
 
    return jresult;
2843
 
}
2844
 
 
2845
 
 
2846
 
DllExport char * SWIGSTDCALL CSharp_get_LIB_PROTOCOL_PROFILE_SLO_SP_HTTP() {
2847
 
    char * jresult = 0 ;
2848
 
    char *result;
2849
 
    
2850
 
    result = strdup("http://projectliberty.org/profiles/slo-sp-http");
2851
 
    
2852
 
    jresult = SWIG_csharp_string_callback(result); 
2853
 
    return jresult;
2854
 
}
2855
 
 
2856
 
 
2857
 
DllExport char * SWIGSTDCALL CSharp_get_LIB_PROTOCOL_PROFILE_SLO_SP_SOAP() {
2858
 
    char * jresult = 0 ;
2859
 
    char *result;
2860
 
    
2861
 
    result = strdup("http://projectliberty.org/profiles/slo-sp-soap");
2862
 
    
2863
 
    jresult = SWIG_csharp_string_callback(result); 
2864
 
    return jresult;
2865
 
}
2866
 
 
2867
 
 
2868
 
DllExport char * SWIGSTDCALL CSharp_get_LIB_AUTHN_CONTEXT_CLASS_REF_INTERNET_PROTOCOL() {
2869
 
    char * jresult = 0 ;
2870
 
    char *result;
2871
 
    
2872
 
    result = strdup("http://www.projectliberty.org/schemas/authctx/classes/InternetProtocol");
2873
 
    
2874
 
    jresult = SWIG_csharp_string_callback(result); 
2875
 
    return jresult;
2876
 
}
2877
 
 
2878
 
 
2879
 
DllExport char * SWIGSTDCALL CSharp_get_LIB_AUTHN_CONTEXT_CLASS_REF_INTERNET_PROTOCOL_PASSWORD() {
2880
 
    char * jresult = 0 ;
2881
 
    char *result;
2882
 
    
2883
 
    result = strdup("http://www.projectliberty.org/schemas/authctx/classes/InternetProtocolPassword");
2884
 
    
2885
 
    jresult = SWIG_csharp_string_callback(result); 
2886
 
    return jresult;
2887
 
}
2888
 
 
2889
 
 
2890
 
DllExport char * SWIGSTDCALL CSharp_get_LIB_AUTHN_CONTEXT_CLASS_REF_MOBILE_ONE_FACTOR_UNREGISTERED() {
2891
 
    char * jresult = 0 ;
2892
 
    char *result;
2893
 
    
2894
 
    result = strdup("http://www.projectliberty.org/schemas/authctx/classes/MobileOneFactorUnregistered");
2895
 
    
2896
 
    jresult = SWIG_csharp_string_callback(result); 
2897
 
    return jresult;
2898
 
}
2899
 
 
2900
 
 
2901
 
DllExport char * SWIGSTDCALL CSharp_get_LIB_AUTHN_CONTEXT_CLASS_REF_MOBILE_TWO_FACTOR_UNREGISTERED() {
2902
 
    char * jresult = 0 ;
2903
 
    char *result;
2904
 
    
2905
 
    result = strdup("http://www.projectliberty.org/schemas/authctx/classes/MobileTwoFactorUnregistered");
2906
 
    
2907
 
    jresult = SWIG_csharp_string_callback(result); 
2908
 
    return jresult;
2909
 
}
2910
 
 
2911
 
 
2912
 
DllExport char * SWIGSTDCALL CSharp_get_LIB_AUTHN_CONTEXT_CLASS_REF_MOBILE_ONE_FACTOR_CONTRACT() {
2913
 
    char * jresult = 0 ;
2914
 
    char *result;
2915
 
    
2916
 
    result = strdup("http://www.projectliberty.org/schemas/authctx/classes/MobileOneFactorContract");
2917
 
    
2918
 
    jresult = SWIG_csharp_string_callback(result); 
2919
 
    return jresult;
2920
 
}
2921
 
 
2922
 
 
2923
 
DllExport char * SWIGSTDCALL CSharp_get_LIB_AUTHN_CONTEXT_CLASS_REF_MOBILE_TWO_FACTOR_CONTRACT() {
2924
 
    char * jresult = 0 ;
2925
 
    char *result;
2926
 
    
2927
 
    result = strdup("http://www.projectliberty.org/schemas/authctx/classes/MobileTwoFactorContract");
2928
 
    
2929
 
    jresult = SWIG_csharp_string_callback(result); 
2930
 
    return jresult;
2931
 
}
2932
 
 
2933
 
 
2934
 
DllExport char * SWIGSTDCALL CSharp_get_LIB_AUTHN_CONTEXT_CLASS_REF_PASSWORD() {
2935
 
    char * jresult = 0 ;
2936
 
    char *result;
2937
 
    
2938
 
    result = strdup("http://www.projectliberty.org/schemas/authctx/classes/Password");
2939
 
    
2940
 
    jresult = SWIG_csharp_string_callback(result); 
2941
 
    return jresult;
2942
 
}
2943
 
 
2944
 
 
2945
 
DllExport char * SWIGSTDCALL CSharp_get_LIB_AUTHN_CONTEXT_CLASS_REF_PASSWORD_PROTECTED_TRANSPORT() {
2946
 
    char * jresult = 0 ;
2947
 
    char *result;
2948
 
    
2949
 
    result = strdup("http://www.projectliberty.org/schemas/authctx/classes/PasswordProtectedTransport");
2950
 
    
2951
 
    jresult = SWIG_csharp_string_callback(result); 
2952
 
    return jresult;
2953
 
}
2954
 
 
2955
 
 
2956
 
DllExport char * SWIGSTDCALL CSharp_get_LIB_AUTHN_CONTEXT_CLASS_REF_PREVIOUS_SESSION() {
2957
 
    char * jresult = 0 ;
2958
 
    char *result;
2959
 
    
2960
 
    result = strdup("http://www.projectliberty.org/schemas/authctx/classes/PreviousSession");
2961
 
    
2962
 
    jresult = SWIG_csharp_string_callback(result); 
2963
 
    return jresult;
2964
 
}
2965
 
 
2966
 
 
2967
 
DllExport char * SWIGSTDCALL CSharp_get_LIB_AUTHN_CONTEXT_CLASS_REF_SMARTCARD() {
2968
 
    char * jresult = 0 ;
2969
 
    char *result;
2970
 
    
2971
 
    result = strdup("http://www.projectliberty.org/schemas/authctx/classes/Smartcard");
2972
 
    
2973
 
    jresult = SWIG_csharp_string_callback(result); 
2974
 
    return jresult;
2975
 
}
2976
 
 
2977
 
 
2978
 
DllExport char * SWIGSTDCALL CSharp_get_LIB_AUTHN_CONTEXT_CLASS_REF_SMARTCARD_PKI() {
2979
 
    char * jresult = 0 ;
2980
 
    char *result;
2981
 
    
2982
 
    result = strdup("http://www.projectliberty.org/schemas/authctx/classes/SmartcardPKI");
2983
 
    
2984
 
    jresult = SWIG_csharp_string_callback(result); 
2985
 
    return jresult;
2986
 
}
2987
 
 
2988
 
 
2989
 
DllExport char * SWIGSTDCALL CSharp_get_LIB_AUTHN_CONTEXT_CLASS_REF_SOFTWARE_PKI() {
2990
 
    char * jresult = 0 ;
2991
 
    char *result;
2992
 
    
2993
 
    result = strdup("http://www.projectliberty.org/schemas/authctx/classes/SoftwarePKI");
2994
 
    
2995
 
    jresult = SWIG_csharp_string_callback(result); 
2996
 
    return jresult;
2997
 
}
2998
 
 
2999
 
 
3000
 
DllExport char * SWIGSTDCALL CSharp_get_LIB_AUTHN_CONTEXT_CLASS_REF_TIME_SYNC_TOKEN() {
3001
 
    char * jresult = 0 ;
3002
 
    char *result;
3003
 
    
3004
 
    result = strdup("http://www.projectliberty.org/schemas/authctx/classes/TimeSyncToken");
3005
 
    
3006
 
    jresult = SWIG_csharp_string_callback(result); 
3007
 
    return jresult;
3008
 
}
3009
 
 
3010
 
 
3011
 
DllExport char * SWIGSTDCALL CSharp_get_LIB_AUTHN_CONTEXT_COMPARISON_EXACT() {
3012
 
    char * jresult = 0 ;
3013
 
    char *result;
3014
 
    
3015
 
    result = strdup("exact");
3016
 
    
3017
 
    jresult = SWIG_csharp_string_callback(result); 
3018
 
    return jresult;
3019
 
}
3020
 
 
3021
 
 
3022
 
DllExport char * SWIGSTDCALL CSharp_get_LIB_AUTHN_CONTEXT_COMPARISON_MINIMUM() {
3023
 
    char * jresult = 0 ;
3024
 
    char *result;
3025
 
    
3026
 
    result = strdup("minimum");
3027
 
    
3028
 
    jresult = SWIG_csharp_string_callback(result); 
3029
 
    return jresult;
3030
 
}
3031
 
 
3032
 
 
3033
 
DllExport char * SWIGSTDCALL CSharp_get_LIB_AUTHN_CONTEXT_COMPARISON_MAXIMUM() {
3034
 
    char * jresult = 0 ;
3035
 
    char *result;
3036
 
    
3037
 
    result = strdup("maximum");
3038
 
    
3039
 
    jresult = SWIG_csharp_string_callback(result); 
3040
 
    return jresult;
3041
 
}
3042
 
 
3043
 
 
3044
 
DllExport char * SWIGSTDCALL CSharp_get_LIB_AUTHN_CONTEXT_COMPARISON_BETTER() {
3045
 
    char * jresult = 0 ;
3046
 
    char *result;
3047
 
    
3048
 
    result = strdup("better");
3049
 
    
3050
 
    jresult = SWIG_csharp_string_callback(result); 
3051
 
    return jresult;
3052
 
}
3053
 
 
3054
 
 
3055
 
DllExport char * SWIGSTDCALL CSharp_get_SAML_AUTHENTICATION_METHOD_PASSWORD() {
3056
 
    char * jresult = 0 ;
3057
 
    char *result;
3058
 
    
3059
 
    result = strdup("urn:oasis:names:tc:SAML:1.0:am:password");
3060
 
    
3061
 
    jresult = SWIG_csharp_string_callback(result); 
3062
 
    return jresult;
3063
 
}
3064
 
 
3065
 
 
3066
 
DllExport char * SWIGSTDCALL CSharp_get_SAML_AUTHENTICATION_METHOD_KERBEROS() {
3067
 
    char * jresult = 0 ;
3068
 
    char *result;
3069
 
    
3070
 
    result = strdup("urn:ietf:rfc:1510");
3071
 
    
3072
 
    jresult = SWIG_csharp_string_callback(result); 
3073
 
    return jresult;
3074
 
}
3075
 
 
3076
 
 
3077
 
DllExport char * SWIGSTDCALL CSharp_get_SAML_AUTHENTICATION_METHOD_SECURE_REMOTE_PASSWORD() {
3078
 
    char * jresult = 0 ;
3079
 
    char *result;
3080
 
    
3081
 
    result = strdup("urn:ietf:rfc:2945");
3082
 
    
3083
 
    jresult = SWIG_csharp_string_callback(result); 
3084
 
    return jresult;
3085
 
}
3086
 
 
3087
 
 
3088
 
DllExport char * SWIGSTDCALL CSharp_get_SAML_AUTHENTICATION_METHOD_HARDWARE_TOKEN() {
3089
 
    char * jresult = 0 ;
3090
 
    char *result;
3091
 
    
3092
 
    result = strdup("urn:oasis:names:tc:SAML:1.0:am:HardwareToken");
3093
 
    
3094
 
    jresult = SWIG_csharp_string_callback(result); 
3095
 
    return jresult;
3096
 
}
3097
 
 
3098
 
 
3099
 
DllExport char * SWIGSTDCALL CSharp_get_SAML_AUTHENTICATION_METHOD_SMARTCARD_PKI() {
3100
 
    char * jresult = 0 ;
3101
 
    char *result;
3102
 
    
3103
 
    result = strdup("urn:ietf:rfc:2246");
3104
 
    
3105
 
    jresult = SWIG_csharp_string_callback(result); 
3106
 
    return jresult;
3107
 
}
3108
 
 
3109
 
 
3110
 
DllExport char * SWIGSTDCALL CSharp_get_SAML_AUTHENTICATION_METHOD_SOFTWARE_PKI() {
3111
 
    char * jresult = 0 ;
3112
 
    char *result;
3113
 
    
3114
 
    result = strdup("urn:oasis:names:tc:SAML:1.0:am:X509-PKI");
3115
 
    
3116
 
    jresult = SWIG_csharp_string_callback(result); 
3117
 
    return jresult;
3118
 
}
3119
 
 
3120
 
 
3121
 
DllExport char * SWIGSTDCALL CSharp_get_SAML_AUTHENTICATION_METHOD_PGP() {
3122
 
    char * jresult = 0 ;
3123
 
    char *result;
3124
 
    
3125
 
    result = strdup("urn:oasis:names:tc:SAML:1.0:am:PGP");
3126
 
    
3127
 
    jresult = SWIG_csharp_string_callback(result); 
3128
 
    return jresult;
3129
 
}
3130
 
 
3131
 
 
3132
 
DllExport char * SWIGSTDCALL CSharp_get_SAML_AUTHENTICATION_METHODS_PKI() {
3133
 
    char * jresult = 0 ;
3134
 
    char *result;
3135
 
    
3136
 
    result = strdup("urn:oasis:names:tc:SAML:1.0:am:SPKI");
3137
 
    
3138
 
    jresult = SWIG_csharp_string_callback(result); 
3139
 
    return jresult;
3140
 
}
3141
 
 
3142
 
 
3143
 
DllExport char * SWIGSTDCALL CSharp_get_SAML_AUTHENTICATION_METHOD_XKMS() {
3144
 
    char * jresult = 0 ;
3145
 
    char *result;
3146
 
    
3147
 
    result = strdup("urn:oasis:names:tc:SAML:1.0:am:XKMS");
3148
 
    
3149
 
    jresult = SWIG_csharp_string_callback(result); 
3150
 
    return jresult;
3151
 
}
3152
 
 
3153
 
 
3154
 
DllExport char * SWIGSTDCALL CSharp_get_SAML_AUTHENTICATION_METHOD_XMLD_SIG() {
3155
 
    char * jresult = 0 ;
3156
 
    char *result;
3157
 
    
3158
 
    result = strdup("urn:ietf:rfc:3075");
3159
 
    
3160
 
    jresult = SWIG_csharp_string_callback(result); 
3161
 
    return jresult;
3162
 
}
3163
 
 
3164
 
 
3165
 
DllExport char * SWIGSTDCALL CSharp_get_SAML_AUTHENTICATION_METHOD_UNSPECIFIED() {
3166
 
    char * jresult = 0 ;
3167
 
    char *result;
3168
 
    
3169
 
    result = strdup("urn:oasis:names:tc:SAML:1.0:am:unspecified");
3170
 
    
3171
 
    jresult = SWIG_csharp_string_callback(result); 
3172
 
    return jresult;
3173
 
}
3174
 
 
3175
 
 
3176
 
DllExport char * SWIGSTDCALL CSharp_get_SAML_AUTHENTICATION_METHOD_LIBERTY() {
3177
 
    char * jresult = 0 ;
3178
 
    char *result;
3179
 
    
3180
 
    result = strdup("urn:liberty:ac:2003-08");
3181
 
    
3182
 
    jresult = SWIG_csharp_string_callback(result); 
3183
 
    return jresult;
3184
 
}
3185
 
 
3186
 
 
3187
 
DllExport int SWIGSTDCALL CSharp_get_ERROR_UNDEFINED() {
3188
 
    int jresult = 0 ;
3189
 
    int result;
3190
 
    
3191
 
    result = (int) -1;
3192
 
    
3193
 
    jresult = result; 
3194
 
    return jresult;
3195
 
}
3196
 
 
3197
 
 
3198
 
DllExport int SWIGSTDCALL CSharp_get_XML_ERROR_NODE_NOT_FOUND() {
3199
 
    int jresult = 0 ;
3200
 
    int result;
3201
 
    
3202
 
    result = (int) -10;
3203
 
    
3204
 
    jresult = result; 
3205
 
    return jresult;
3206
 
}
3207
 
 
3208
 
 
3209
 
DllExport int SWIGSTDCALL CSharp_get_XML_ERROR_NODE_CONTENT_NOT_FOUND() {
3210
 
    int jresult = 0 ;
3211
 
    int result;
3212
 
    
3213
 
    result = (int) -11;
3214
 
    
3215
 
    jresult = result; 
3216
 
    return jresult;
3217
 
}
3218
 
 
3219
 
 
3220
 
DllExport int SWIGSTDCALL CSharp_get_XML_ERROR_ATTR_NOT_FOUND() {
3221
 
    int jresult = 0 ;
3222
 
    int result;
3223
 
    
3224
 
    result = (int) -12;
3225
 
    
3226
 
    jresult = result; 
3227
 
    return jresult;
3228
 
}
3229
 
 
3230
 
 
3231
 
DllExport int SWIGSTDCALL CSharp_get_XML_ERROR_ATTR_VALUE_NOT_FOUND() {
3232
 
    int jresult = 0 ;
3233
 
    int result;
3234
 
    
3235
 
    result = (int) -13;
3236
 
    
3237
 
    jresult = result; 
3238
 
    return jresult;
3239
 
}
3240
 
 
3241
 
 
3242
 
DllExport int SWIGSTDCALL CSharp_get_DS_ERROR_SIGNATURE_NOT_FOUND() {
3243
 
    int jresult = 0 ;
3244
 
    int result;
3245
 
    
3246
 
    result = (int) 101;
3247
 
    
3248
 
    jresult = result; 
3249
 
    return jresult;
3250
 
}
3251
 
 
3252
 
 
3253
 
DllExport int SWIGSTDCALL CSharp_get_DS_ERROR_INVALID_SIGNATURE() {
3254
 
    int jresult = 0 ;
3255
 
    int result;
3256
 
    
3257
 
    result = (int) 102;
3258
 
    
3259
 
    jresult = result; 
3260
 
    return jresult;
3261
 
}
3262
 
 
3263
 
 
3264
 
DllExport int SWIGSTDCALL CSharp_get_DS_ERROR_SIGNATURE_TMPL_CREATION_FAILED() {
3265
 
    int jresult = 0 ;
3266
 
    int result;
3267
 
    
3268
 
    result = (int) -103;
3269
 
    
3270
 
    jresult = result; 
3271
 
    return jresult;
3272
 
}
3273
 
 
3274
 
 
3275
 
DllExport int SWIGSTDCALL CSharp_get_DS_ERROR_CONTEXT_CREATION_FAILED() {
3276
 
    int jresult = 0 ;
3277
 
    int result;
3278
 
    
3279
 
    result = (int) -104;
3280
 
    
3281
 
    jresult = result; 
3282
 
    return jresult;
3283
 
}
3284
 
 
3285
 
 
3286
 
DllExport int SWIGSTDCALL CSharp_get_DS_ERROR_PUBLIC_KEY_LOAD_FAILED() {
3287
 
    int jresult = 0 ;
3288
 
    int result;
3289
 
    
3290
 
    result = (int) -105;
3291
 
    
3292
 
    jresult = result; 
3293
 
    return jresult;
3294
 
}
3295
 
 
3296
 
 
3297
 
DllExport int SWIGSTDCALL CSharp_get_DS_ERROR_PRIVATE_KEY_LOAD_FAILED() {
3298
 
    int jresult = 0 ;
3299
 
    int result;
3300
 
    
3301
 
    result = (int) -106;
3302
 
    
3303
 
    jresult = result; 
3304
 
    return jresult;
3305
 
}
3306
 
 
3307
 
 
3308
 
DllExport int SWIGSTDCALL CSharp_get_DS_ERROR_CERTIFICATE_LOAD_FAILED() {
3309
 
    int jresult = 0 ;
3310
 
    int result;
3311
 
    
3312
 
    result = (int) -107;
3313
 
    
3314
 
    jresult = result; 
3315
 
    return jresult;
3316
 
}
3317
 
 
3318
 
 
3319
 
DllExport int SWIGSTDCALL CSharp_get_DS_ERROR_SIGNATURE_FAILED() {
3320
 
    int jresult = 0 ;
3321
 
    int result;
3322
 
    
3323
 
    result = (int) -108;
3324
 
    
3325
 
    jresult = result; 
3326
 
    return jresult;
3327
 
}
3328
 
 
3329
 
 
3330
 
DllExport int SWIGSTDCALL CSharp_get_DS_ERROR_KEYS_MNGR_CREATION_FAILED() {
3331
 
    int jresult = 0 ;
3332
 
    int result;
3333
 
    
3334
 
    result = (int) -109;
3335
 
    
3336
 
    jresult = result; 
3337
 
    return jresult;
3338
 
}
3339
 
 
3340
 
 
3341
 
DllExport int SWIGSTDCALL CSharp_get_DS_ERROR_KEYS_MNGR_INIT_FAILED() {
3342
 
    int jresult = 0 ;
3343
 
    int result;
3344
 
    
3345
 
    result = (int) -110;
3346
 
    
3347
 
    jresult = result; 
3348
 
    return jresult;
3349
 
}
3350
 
 
3351
 
 
3352
 
DllExport int SWIGSTDCALL CSharp_get_DS_ERROR_SIGNATURE_VERIFICATION_FAILED() {
3353
 
    int jresult = 0 ;
3354
 
    int result;
3355
 
    
3356
 
    result = (int) -111;
3357
 
    
3358
 
    jresult = result; 
3359
 
    return jresult;
3360
 
}
3361
 
 
3362
 
 
3363
 
DllExport int SWIGSTDCALL CSharp_get_DS_ERROR_CA_CERT_CHAIN_LOAD_FAILED() {
3364
 
    int jresult = 0 ;
3365
 
    int result;
3366
 
    
3367
 
    result = (int) -112;
3368
 
    
3369
 
    jresult = result; 
3370
 
    return jresult;
3371
 
}
3372
 
 
3373
 
 
3374
 
DllExport int SWIGSTDCALL CSharp_get_DS_ERROR_INVALID_SIGALG() {
3375
 
    int jresult = 0 ;
3376
 
    int result;
3377
 
    
3378
 
    result = (int) -113;
3379
 
    
3380
 
    jresult = result; 
3381
 
    return jresult;
3382
 
}
3383
 
 
3384
 
 
3385
 
DllExport int SWIGSTDCALL CSharp_get_DS_ERROR_DIGEST_COMPUTE_FAILED() {
3386
 
    int jresult = 0 ;
3387
 
    int result;
3388
 
    
3389
 
    result = (int) -114;
3390
 
    
3391
 
    jresult = result; 
3392
 
    return jresult;
3393
 
}
3394
 
 
3395
 
 
3396
 
DllExport int SWIGSTDCALL CSharp_get_LASSO_DS_ERROR_SIGNATURE_TEMPLATE_NOT_FOUND() {
3397
 
    int jresult = 0 ;
3398
 
    int result;
3399
 
    
3400
 
    result = (int) -115;
3401
 
    
3402
 
    jresult = result; 
3403
 
    return jresult;
3404
 
}
3405
 
 
3406
 
 
3407
 
DllExport int SWIGSTDCALL CSharp_get_SERVER_ERROR_PROVIDER_NOT_FOUND() {
3408
 
    int jresult = 0 ;
3409
 
    int result;
3410
 
    
3411
 
    result = (int) -201;
3412
 
    
3413
 
    jresult = result; 
3414
 
    return jresult;
3415
 
}
3416
 
 
3417
 
 
3418
 
DllExport int SWIGSTDCALL CSharp_get_SERVER_ERROR_ADD_PROVIDER_FAILED() {
3419
 
    int jresult = 0 ;
3420
 
    int result;
3421
 
    
3422
 
    result = (int) -202;
3423
 
    
3424
 
    jresult = result; 
3425
 
    return jresult;
3426
 
}
3427
 
 
3428
 
 
3429
 
DllExport int SWIGSTDCALL CSharp_get_LOGOUT_ERROR_UNSUPPORTED_PROFILE() {
3430
 
    int jresult = 0 ;
3431
 
    int result;
3432
 
    
3433
 
    result = (int) -301;
3434
 
    
3435
 
    jresult = result; 
3436
 
    return jresult;
3437
 
}
3438
 
 
3439
 
 
3440
 
DllExport int SWIGSTDCALL CSharp_get_PROFILE_ERROR_INVALID_QUERY() {
3441
 
    int jresult = 0 ;
3442
 
    int result;
3443
 
    
3444
 
    result = (int) -401;
3445
 
    
3446
 
    jresult = result; 
3447
 
    return jresult;
3448
 
}
3449
 
 
3450
 
 
3451
 
DllExport int SWIGSTDCALL CSharp_get_PROFILE_ERROR_INVALID_POST_MSG() {
3452
 
    int jresult = 0 ;
3453
 
    int result;
3454
 
    
3455
 
    result = (int) -402;
3456
 
    
3457
 
    jresult = result; 
3458
 
    return jresult;
3459
 
}
3460
 
 
3461
 
 
3462
 
DllExport int SWIGSTDCALL CSharp_get_PROFILE_ERROR_INVALID_SOAP_MSG() {
3463
 
    int jresult = 0 ;
3464
 
    int result;
3465
 
    
3466
 
    result = (int) -403;
3467
 
    
3468
 
    jresult = result; 
3469
 
    return jresult;
3470
 
}
3471
 
 
3472
 
 
3473
 
DllExport int SWIGSTDCALL CSharp_get_PROFILE_ERROR_MISSING_REQUEST() {
3474
 
    int jresult = 0 ;
3475
 
    int result;
3476
 
    
3477
 
    result = (int) -404;
3478
 
    
3479
 
    jresult = result; 
3480
 
    return jresult;
3481
 
}
3482
 
 
3483
 
 
3484
 
DllExport int SWIGSTDCALL CSharp_get_PROFILE_ERROR_INVALID_HTTP_METHOD() {
3485
 
    int jresult = 0 ;
3486
 
    int result;
3487
 
    
3488
 
    result = (int) -405;
3489
 
    
3490
 
    jresult = result; 
3491
 
    return jresult;
3492
 
}
3493
 
 
3494
 
 
3495
 
DllExport int SWIGSTDCALL CSharp_get_PROFILE_ERROR_INVALID_PROTOCOLPROFILE() {
3496
 
    int jresult = 0 ;
3497
 
    int result;
3498
 
    
3499
 
    result = (int) -406;
3500
 
    
3501
 
    jresult = result; 
3502
 
    return jresult;
3503
 
}
3504
 
 
3505
 
 
3506
 
DllExport int SWIGSTDCALL CSharp_get_PROFILE_ERROR_INVALID_MSG() {
3507
 
    int jresult = 0 ;
3508
 
    int result;
3509
 
    
3510
 
    result = (int) -407;
3511
 
    
3512
 
    jresult = result; 
3513
 
    return jresult;
3514
 
}
3515
 
 
3516
 
 
3517
 
DllExport int SWIGSTDCALL CSharp_get_PROFILE_ERROR_MISSING_REMOTE_PROVIDERID() {
3518
 
    int jresult = 0 ;
3519
 
    int result;
3520
 
    
3521
 
    result = (int) -408;
3522
 
    
3523
 
    jresult = result; 
3524
 
    return jresult;
3525
 
}
3526
 
 
3527
 
 
3528
 
DllExport int SWIGSTDCALL CSharp_get_PROFILE_ERROR_UNSUPPORTED_PROFILE() {
3529
 
    int jresult = 0 ;
3530
 
    int result;
3531
 
    
3532
 
    result = (int) -409;
3533
 
    
3534
 
    jresult = result; 
3535
 
    return jresult;
3536
 
}
3537
 
 
3538
 
 
3539
 
DllExport int SWIGSTDCALL CSharp_get_PROFILE_ERROR_UNKNOWN_PROFILE_URL() {
3540
 
    int jresult = 0 ;
3541
 
    int result;
3542
 
    
3543
 
    result = (int) -410;
3544
 
    
3545
 
    jresult = result; 
3546
 
    return jresult;
3547
 
}
3548
 
 
3549
 
 
3550
 
DllExport int SWIGSTDCALL CSharp_get_PROFILE_ERROR_IDENTITY_NOT_FOUND() {
3551
 
    int jresult = 0 ;
3552
 
    int result;
3553
 
    
3554
 
    result = (int) -411;
3555
 
    
3556
 
    jresult = result; 
3557
 
    return jresult;
3558
 
}
3559
 
 
3560
 
 
3561
 
DllExport int SWIGSTDCALL CSharp_get_PROFILE_ERROR_FEDERATION_NOT_FOUND() {
3562
 
    int jresult = 0 ;
3563
 
    int result;
3564
 
    
3565
 
    result = (int) -412;
3566
 
    
3567
 
    jresult = result; 
3568
 
    return jresult;
3569
 
}
3570
 
 
3571
 
 
3572
 
DllExport int SWIGSTDCALL CSharp_get_PROFILE_ERROR_NAME_IDENTIFIER_NOT_FOUND() {
3573
 
    int jresult = 0 ;
3574
 
    int result;
3575
 
    
3576
 
    result = (int) -413;
3577
 
    
3578
 
    jresult = result; 
3579
 
    return jresult;
3580
 
}
3581
 
 
3582
 
 
3583
 
DllExport int SWIGSTDCALL CSharp_get_PROFILE_ERROR_BUILDING_QUERY_FAILED() {
3584
 
    int jresult = 0 ;
3585
 
    int result;
3586
 
    
3587
 
    result = (int) -414;
3588
 
    
3589
 
    jresult = result; 
3590
 
    return jresult;
3591
 
}
3592
 
 
3593
 
 
3594
 
DllExport int SWIGSTDCALL CSharp_get_PROFILE_ERROR_BUILDING_REQUEST_FAILED() {
3595
 
    int jresult = 0 ;
3596
 
    int result;
3597
 
    
3598
 
    result = (int) -415;
3599
 
    
3600
 
    jresult = result; 
3601
 
    return jresult;
3602
 
}
3603
 
 
3604
 
 
3605
 
DllExport int SWIGSTDCALL CSharp_get_PROFILE_ERROR_BUILDING_MESSAGE_FAILED() {
3606
 
    int jresult = 0 ;
3607
 
    int result;
3608
 
    
3609
 
    result = (int) -416;
3610
 
    
3611
 
    jresult = result; 
3612
 
    return jresult;
3613
 
}
3614
 
 
3615
 
 
3616
 
DllExport int SWIGSTDCALL CSharp_get_PROFILE_ERROR_BUILDING_RESPONSE_FAILED() {
3617
 
    int jresult = 0 ;
3618
 
    int result;
3619
 
    
3620
 
    result = (int) -417;
3621
 
    
3622
 
    jresult = result; 
3623
 
    return jresult;
3624
 
}
3625
 
 
3626
 
 
3627
 
DllExport int SWIGSTDCALL CSharp_get_PROFILE_ERROR_SESSION_NOT_FOUND() {
3628
 
    int jresult = 0 ;
3629
 
    int result;
3630
 
    
3631
 
    result = (int) -418;
3632
 
    
3633
 
    jresult = result; 
3634
 
    return jresult;
3635
 
}
3636
 
 
3637
 
 
3638
 
DllExport int SWIGSTDCALL CSharp_get_PROFILE_ERROR_BAD_IDENTITY_DUMP() {
3639
 
    int jresult = 0 ;
3640
 
    int result;
3641
 
    
3642
 
    result = (int) -419;
3643
 
    
3644
 
    jresult = result; 
3645
 
    return jresult;
3646
 
}
3647
 
 
3648
 
 
3649
 
DllExport int SWIGSTDCALL CSharp_get_PROFILE_ERROR_BAD_SESSION_DUMP() {
3650
 
    int jresult = 0 ;
3651
 
    int result;
3652
 
    
3653
 
    result = (int) -420;
3654
 
    
3655
 
    jresult = result; 
3656
 
    return jresult;
3657
 
}
3658
 
 
3659
 
 
3660
 
DllExport int SWIGSTDCALL CSharp_get_LASSO_PARAM_ERROR_BAD_TYPE_OR_NULL_OBJ() {
3661
 
    int jresult = 0 ;
3662
 
    int result;
3663
 
    
3664
 
    result = (int) -501;
3665
 
    
3666
 
    jresult = result; 
3667
 
    return jresult;
3668
 
}
3669
 
 
3670
 
 
3671
 
DllExport int SWIGSTDCALL CSharp_get_PARAM_ERROR_INVALID_VALUE() {
3672
 
    int jresult = 0 ;
3673
 
    int result;
3674
 
    
3675
 
    result = (int) -502;
3676
 
    
3677
 
    jresult = result; 
3678
 
    return jresult;
3679
 
}
3680
 
 
3681
 
 
3682
 
DllExport int SWIGSTDCALL CSharp_get_LASSO_PARAM_ERROR_CHECK_FAILED() {
3683
 
    int jresult = 0 ;
3684
 
    int result;
3685
 
    
3686
 
    result = (int) -503;
3687
 
    
3688
 
    jresult = result; 
3689
 
    return jresult;
3690
 
}
3691
 
 
3692
 
 
3693
 
DllExport int SWIGSTDCALL CSharp_get_LOGIN_ERROR_FEDERATION_NOT_FOUND() {
3694
 
    int jresult = 0 ;
3695
 
    int result;
3696
 
    
3697
 
    result = (int) 601;
3698
 
    
3699
 
    jresult = result; 
3700
 
    return jresult;
3701
 
}
3702
 
 
3703
 
 
3704
 
DllExport int SWIGSTDCALL CSharp_get_LOGIN_ERROR_CONSENT_NOT_OBTAINED() {
3705
 
    int jresult = 0 ;
3706
 
    int result;
3707
 
    
3708
 
    result = (int) 602;
3709
 
    
3710
 
    jresult = result; 
3711
 
    return jresult;
3712
 
}
3713
 
 
3714
 
 
3715
 
DllExport int SWIGSTDCALL CSharp_get_LASSO_LOGIN_ERROR_INVALID_NAMEIDPOLICY() {
3716
 
    int jresult = 0 ;
3717
 
    int result;
3718
 
    
3719
 
    result = (int) -603;
3720
 
    
3721
 
    jresult = result; 
3722
 
    return jresult;
3723
 
}
3724
 
 
3725
 
 
3726
 
DllExport int SWIGSTDCALL CSharp_get_LASSO_LOGIN_ERROR_REQUEST_DENIED() {
3727
 
    int jresult = 0 ;
3728
 
    int result;
3729
 
    
3730
 
    result = (int) 604;
3731
 
    
3732
 
    jresult = result; 
3733
 
    return jresult;
3734
 
}
3735
 
 
3736
 
 
3737
 
DllExport int SWIGSTDCALL CSharp_get_LOGIN_ERROR_INVALID_SIGNATURE() {
3738
 
    int jresult = 0 ;
3739
 
    int result;
3740
 
    
3741
 
    result = (int) 605;
3742
 
    
3743
 
    jresult = result; 
3744
 
    return jresult;
3745
 
}
3746
 
 
3747
 
 
3748
 
DllExport int SWIGSTDCALL CSharp_get_LOGIN_ERROR_UNSIGNED_AUTHN_REQUEST() {
3749
 
    int jresult = 0 ;
3750
 
    int result;
3751
 
    
3752
 
    result = (int) 606;
3753
 
    
3754
 
    jresult = result; 
3755
 
    return jresult;
3756
 
}
3757
 
 
3758
 
 
3759
 
DllExport int SWIGSTDCALL CSharp_get_LOGIN_ERROR_STATUS_NOT_SUCCESS() {
3760
 
    int jresult = 0 ;
3761
 
    int result;
3762
 
    
3763
 
    result = (int) 607;
3764
 
    
3765
 
    jresult = result; 
3766
 
    return jresult;
3767
 
}
3768
 
 
3769
 
 
3770
 
DllExport int SWIGSTDCALL CSharp_get_DEFEDERATION_ERROR_MISSING_NAME_IDENTIFIER() {
3771
 
    int jresult = 0 ;
3772
 
    int result;
3773
 
    
3774
 
    result = (int) -700;
3775
 
    
3776
 
    jresult = result; 
3777
 
    return jresult;
3778
 
}
3779
 
 
3780
 
 
3781
 
DllExport int SWIGSTDCALL CSharp_init() {
3782
 
    int jresult = 0 ;
3783
 
    int result;
3784
 
    
3785
 
    result = (int)lasso_init();
3786
 
    
3787
 
    jresult = result; 
3788
 
    return jresult;
3789
 
}
3790
 
 
3791
 
 
3792
 
DllExport int SWIGSTDCALL CSharp_shutdown() {
3793
 
    int jresult = 0 ;
3794
 
    int result;
3795
 
    
3796
 
    result = (int)lasso_shutdown();
3797
 
    
3798
 
    jresult = result; 
3799
 
    return jresult;
3800
 
}
3801
 
 
3802
 
 
3803
 
DllExport int SWIGSTDCALL CSharp_checkVersion(int jarg1, int jarg2, int jarg3, int jarg4) {
3804
 
    int jresult = 0 ;
3805
 
    int arg1 ;
3806
 
    int arg2 ;
3807
 
    int arg3 ;
3808
 
    LassoCheckVersionMode arg4 = (LassoCheckVersionMode) LASSO_CHECK_VERSION_NUMERIC ;
3809
 
    int result;
3810
 
    
3811
 
    arg1 = (int)jarg1; 
3812
 
    arg2 = (int)jarg2; 
3813
 
    arg3 = (int)jarg3; 
3814
 
    arg4 = (LassoCheckVersionMode)jarg4; 
3815
 
    result = (int)lasso_check_version(arg1,arg2,arg3,(LassoCheckVersionMode )arg4);
3816
 
    
3817
 
    jresult = result; 
3818
 
    return jresult;
3819
 
}
3820
 
 
3821
 
 
3822
 
DllExport void * SWIGSTDCALL CSharp_new_Node() {
3823
 
    void * jresult = 0 ;
3824
 
    LassoNode *result;
3825
 
    
3826
 
    result = (LassoNode *)new_LassoNode();
3827
 
    
3828
 
    jresult = (void *)result; 
3829
 
    return jresult;
3830
 
}
3831
 
 
3832
 
 
3833
 
DllExport void SWIGSTDCALL CSharp_delete_Node(void * jarg1) {
3834
 
    LassoNode *arg1 = (LassoNode *) 0 ;
3835
 
    
3836
 
    arg1 = (LassoNode *)jarg1; 
3837
 
    delete_LassoNode(arg1);
3838
 
    
3839
 
}
3840
 
 
3841
 
 
3842
 
DllExport char * SWIGSTDCALL CSharp_Node_dump(void * jarg1) {
3843
 
    char * jresult = 0 ;
3844
 
    LassoNode *arg1 = (LassoNode *) 0 ;
3845
 
    char *result;
3846
 
    
3847
 
    arg1 = (LassoNode *)jarg1; 
3848
 
    result = (char *)LassoNode_dump(arg1);
3849
 
    
3850
 
    jresult = SWIG_csharp_string_callback(result); 
3851
 
    free(result);
3852
 
    return jresult;
3853
 
}
3854
 
 
3855
 
 
3856
 
DllExport void * SWIGSTDCALL CSharp_new_NodeList() {
3857
 
    void * jresult = 0 ;
3858
 
    LassoNodeList *result;
3859
 
    
3860
 
    result = (LassoNodeList *)new_LassoNodeList();
3861
 
    
3862
 
    jresult = (void *)result; 
3863
 
    return jresult;
3864
 
}
3865
 
 
3866
 
 
3867
 
DllExport void SWIGSTDCALL CSharp_delete_NodeList(void * jarg1) {
3868
 
    LassoNodeList *arg1 = (LassoNodeList *) 0 ;
3869
 
    
3870
 
    arg1 = (LassoNodeList *)jarg1; 
3871
 
    delete_LassoNodeList(arg1);
3872
 
    
3873
 
}
3874
 
 
3875
 
 
3876
 
DllExport void SWIGSTDCALL CSharp_NodeList_append(void * jarg1, void * jarg2) {
3877
 
    LassoNodeList *arg1 = (LassoNodeList *) 0 ;
3878
 
    LassoNode *arg2 = (LassoNode *) 0 ;
3879
 
    
3880
 
    arg1 = (LassoNodeList *)jarg1; 
3881
 
    arg2 = (LassoNode *)jarg2; 
3882
 
    LassoNodeList_append(arg1,arg2);
3883
 
    
3884
 
}
3885
 
 
3886
 
 
3887
 
DllExport void * SWIGSTDCALL CSharp_NodeList_cast(void * jarg1) {
3888
 
    void * jresult = 0 ;
3889
 
    LassoNodeList *arg1 = (LassoNodeList *) 0 ;
3890
 
    void *result;
3891
 
    
3892
 
    arg1 = (LassoNodeList *)jarg1; 
3893
 
    result = (void *)LassoNodeList_cast(arg1);
3894
 
    
3895
 
    jresult = (void *)result; 
3896
 
    return jresult;
3897
 
}
3898
 
 
3899
 
 
3900
 
DllExport void * SWIGSTDCALL CSharp_NodeList_frompointer(void * jarg1) {
3901
 
    void * jresult = 0 ;
3902
 
    void *arg1 = (void *) 0 ;
3903
 
    LassoNodeList *result;
3904
 
    
3905
 
    arg1 = (void *)jarg1; 
3906
 
    result = (LassoNodeList *)NodeList_frompointer(arg1);
3907
 
    
3908
 
    jresult = (void *)result; 
3909
 
    return jresult;
3910
 
}
3911
 
 
3912
 
 
3913
 
DllExport void * SWIGSTDCALL CSharp_NodeList_getItem(void * jarg1, int jarg2) {
3914
 
    void * jresult = 0 ;
3915
 
    LassoNodeList *arg1 = (LassoNodeList *) 0 ;
3916
 
    int arg2 ;
3917
 
    LassoNode *result;
3918
 
    
3919
 
    arg1 = (LassoNodeList *)jarg1; 
3920
 
    arg2 = (int)jarg2; 
3921
 
    {
3922
 
        if (arg2 < 0 || arg2 >= arg1->len) {
3923
 
            char errorMsg[256];
3924
 
            sprintf(errorMsg, "%d", arg2);
3925
 
            SWIG_exception(SWIG_IndexError, errorMsg);
3926
 
        }
3927
 
        result = (LassoNode *)LassoNodeList_getItem(arg1,arg2);
3928
 
        
3929
 
    }
3930
 
    jresult = (void *)result; 
3931
 
    return jresult;
3932
 
}
3933
 
 
3934
 
 
3935
 
DllExport int SWIGSTDCALL CSharp_NodeList_length(void * jarg1) {
3936
 
    int jresult = 0 ;
3937
 
    LassoNodeList *arg1 = (LassoNodeList *) 0 ;
3938
 
    int result;
3939
 
    
3940
 
    arg1 = (LassoNodeList *)jarg1; 
3941
 
    result = (int)LassoNodeList_length(arg1);
3942
 
    
3943
 
    jresult = result; 
3944
 
    return jresult;
3945
 
}
3946
 
 
3947
 
 
3948
 
DllExport void SWIGSTDCALL CSharp_NodeList_setItem(void * jarg1, int jarg2, void * jarg3) {
3949
 
    LassoNodeList *arg1 = (LassoNodeList *) 0 ;
3950
 
    int arg2 ;
3951
 
    LassoNode *arg3 = (LassoNode *) 0 ;
3952
 
    
3953
 
    arg1 = (LassoNodeList *)jarg1; 
3954
 
    arg2 = (int)jarg2; 
3955
 
    arg3 = (LassoNode *)jarg3; 
3956
 
    {
3957
 
        if (arg2 < 0 || arg2 >= arg1->len) {
3958
 
            char errorMsg[256];
3959
 
            sprintf(errorMsg, "%d", arg2);
3960
 
            SWIG_exception(SWIG_IndexError, errorMsg);
3961
 
        }
3962
 
        LassoNodeList_setItem(arg1,arg2,arg3);
3963
 
        
3964
 
    }
3965
 
}
3966
 
 
3967
 
 
3968
 
DllExport void * SWIGSTDCALL CSharp_new_StringList() {
3969
 
    void * jresult = 0 ;
3970
 
    LassoStringList *result;
3971
 
    
3972
 
    result = (LassoStringList *)new_LassoStringList();
3973
 
    
3974
 
    jresult = (void *)result; 
3975
 
    return jresult;
3976
 
}
3977
 
 
3978
 
 
3979
 
DllExport void SWIGSTDCALL CSharp_delete_StringList(void * jarg1) {
3980
 
    LassoStringList *arg1 = (LassoStringList *) 0 ;
3981
 
    
3982
 
    arg1 = (LassoStringList *)jarg1; 
3983
 
    delete_LassoStringList(arg1);
3984
 
    
3985
 
}
3986
 
 
3987
 
 
3988
 
DllExport void SWIGSTDCALL CSharp_StringList_append(void * jarg1, char * jarg2) {
3989
 
    LassoStringList *arg1 = (LassoStringList *) 0 ;
3990
 
    char *arg2 = (char *) 0 ;
3991
 
    
3992
 
    arg1 = (LassoStringList *)jarg1; 
3993
 
    arg2 = jarg2; 
3994
 
    LassoStringList_append(arg1,arg2);
3995
 
    
3996
 
}
3997
 
 
3998
 
 
3999
 
DllExport void * SWIGSTDCALL CSharp_StringList_cast(void * jarg1) {
4000
 
    void * jresult = 0 ;
4001
 
    LassoStringList *arg1 = (LassoStringList *) 0 ;
4002
 
    void *result;
4003
 
    
4004
 
    arg1 = (LassoStringList *)jarg1; 
4005
 
    result = (void *)LassoStringList_cast(arg1);
4006
 
    
4007
 
    jresult = (void *)result; 
4008
 
    return jresult;
4009
 
}
4010
 
 
4011
 
 
4012
 
DllExport void * SWIGSTDCALL CSharp_StringList_frompointer(void * jarg1) {
4013
 
    void * jresult = 0 ;
4014
 
    void *arg1 = (void *) 0 ;
4015
 
    LassoStringList *result;
4016
 
    
4017
 
    arg1 = (void *)jarg1; 
4018
 
    result = (LassoStringList *)StringList_frompointer(arg1);
4019
 
    
4020
 
    jresult = (void *)result; 
4021
 
    return jresult;
4022
 
}
4023
 
 
4024
 
 
4025
 
DllExport char * SWIGSTDCALL CSharp_StringList_getItem(void * jarg1, int jarg2) {
4026
 
    char * jresult = 0 ;
4027
 
    LassoStringList *arg1 = (LassoStringList *) 0 ;
4028
 
    int arg2 ;
4029
 
    char *result;
4030
 
    
4031
 
    arg1 = (LassoStringList *)jarg1; 
4032
 
    arg2 = (int)jarg2; 
4033
 
    {
4034
 
        if (arg2 < 0 || arg2 >= arg1->len) {
4035
 
            char errorMsg[256];
4036
 
            sprintf(errorMsg, "%d", arg2);
4037
 
            SWIG_exception(SWIG_IndexError, errorMsg);
4038
 
        }
4039
 
        result = (char *)LassoStringList_getItem(arg1,arg2);
4040
 
        
4041
 
    }
4042
 
    jresult = SWIG_csharp_string_callback(result); 
4043
 
    return jresult;
4044
 
}
4045
 
 
4046
 
 
4047
 
DllExport int SWIGSTDCALL CSharp_StringList_length(void * jarg1) {
4048
 
    int jresult = 0 ;
4049
 
    LassoStringList *arg1 = (LassoStringList *) 0 ;
4050
 
    int result;
4051
 
    
4052
 
    arg1 = (LassoStringList *)jarg1; 
4053
 
    result = (int)LassoStringList_length(arg1);
4054
 
    
4055
 
    jresult = result; 
4056
 
    return jresult;
4057
 
}
4058
 
 
4059
 
 
4060
 
DllExport void SWIGSTDCALL CSharp_StringList_setItem(void * jarg1, int jarg2, char * jarg3) {
4061
 
    LassoStringList *arg1 = (LassoStringList *) 0 ;
4062
 
    int arg2 ;
4063
 
    char *arg3 = (char *) 0 ;
4064
 
    
4065
 
    arg1 = (LassoStringList *)jarg1; 
4066
 
    arg2 = (int)jarg2; 
4067
 
    arg3 = jarg3; 
4068
 
    {
4069
 
        if (arg2 < 0 || arg2 >= arg1->len) {
4070
 
            char errorMsg[256];
4071
 
            sprintf(errorMsg, "%d", arg2);
4072
 
            SWIG_exception(SWIG_IndexError, errorMsg);
4073
 
        }
4074
 
        LassoStringList_setItem(arg1,arg2,arg3);
4075
 
        
4076
 
    }
4077
 
}
4078
 
 
4079
 
 
4080
 
DllExport void SWIGSTDCALL CSharp_set_SamlAdvice_assertion(void * jarg1, void * jarg2) {
4081
 
    LassoSamlAdvice *arg1 = (LassoSamlAdvice *) 0 ;
4082
 
    LassoSamlAssertion *arg2 = (LassoSamlAssertion *) 0 ;
4083
 
    
4084
 
    arg1 = (LassoSamlAdvice *)jarg1; 
4085
 
    arg2 = (LassoSamlAssertion *)jarg2; 
4086
 
    LassoSamlAdvice_set_Assertion(arg1,arg2);
4087
 
    
4088
 
}
4089
 
 
4090
 
 
4091
 
DllExport void * SWIGSTDCALL CSharp_get_SamlAdvice_assertion(void * jarg1) {
4092
 
    void * jresult = 0 ;
4093
 
    LassoSamlAdvice *arg1 = (LassoSamlAdvice *) 0 ;
4094
 
    LassoSamlAssertion *result;
4095
 
    
4096
 
    arg1 = (LassoSamlAdvice *)jarg1; 
4097
 
    result = (LassoSamlAssertion *)LassoSamlAdvice_get_Assertion(arg1);
4098
 
    
4099
 
    jresult = (void *)result; 
4100
 
    return jresult;
4101
 
}
4102
 
 
4103
 
 
4104
 
DllExport void SWIGSTDCALL CSharp_set_SamlAdvice_assertionIdReference(void * jarg1, void * jarg2) {
4105
 
    LassoSamlAdvice *arg1 = (LassoSamlAdvice *) 0 ;
4106
 
    LassoStringList *arg2 = (LassoStringList *) 0 ;
4107
 
    
4108
 
    arg1 = (LassoSamlAdvice *)jarg1; 
4109
 
    arg2 = (LassoStringList *)jarg2; 
4110
 
    LassoSamlAdvice_set_assertionIdReference(arg1,arg2);
4111
 
    
4112
 
}
4113
 
 
4114
 
 
4115
 
DllExport void * SWIGSTDCALL CSharp_get_SamlAdvice_assertionIdReference(void * jarg1) {
4116
 
    void * jresult = 0 ;
4117
 
    LassoSamlAdvice *arg1 = (LassoSamlAdvice *) 0 ;
4118
 
    LassoStringList *result;
4119
 
    
4120
 
    arg1 = (LassoSamlAdvice *)jarg1; 
4121
 
    result = (LassoStringList *)LassoSamlAdvice_get_assertionIdReference(arg1);
4122
 
    
4123
 
    jresult = (void *)result; 
4124
 
    return jresult;
4125
 
}
4126
 
 
4127
 
 
4128
 
DllExport void * SWIGSTDCALL CSharp_new_SamlAdvice() {
4129
 
    void * jresult = 0 ;
4130
 
    LassoSamlAdvice *result;
4131
 
    
4132
 
    result = (LassoSamlAdvice *)new_LassoSamlAdvice();
4133
 
    
4134
 
    jresult = (void *)result; 
4135
 
    return jresult;
4136
 
}
4137
 
 
4138
 
 
4139
 
DllExport void SWIGSTDCALL CSharp_delete_SamlAdvice(void * jarg1) {
4140
 
    LassoSamlAdvice *arg1 = (LassoSamlAdvice *) 0 ;
4141
 
    
4142
 
    arg1 = (LassoSamlAdvice *)jarg1; 
4143
 
    delete_LassoSamlAdvice(arg1);
4144
 
    
4145
 
}
4146
 
 
4147
 
 
4148
 
DllExport char * SWIGSTDCALL CSharp_SamlAdvice_dump(void * jarg1) {
4149
 
    char * jresult = 0 ;
4150
 
    LassoSamlAdvice *arg1 = (LassoSamlAdvice *) 0 ;
4151
 
    char *result;
4152
 
    
4153
 
    arg1 = (LassoSamlAdvice *)jarg1; 
4154
 
    result = (char *)LassoSamlAdvice_dump(arg1);
4155
 
    
4156
 
    jresult = SWIG_csharp_string_callback(result); 
4157
 
    free(result);
4158
 
    return jresult;
4159
 
}
4160
 
 
4161
 
 
4162
 
DllExport void SWIGSTDCALL CSharp_set_SamlAssertion_assertionId(void * jarg1, char * jarg2) {
4163
 
    LassoSamlAssertion *arg1 = (LassoSamlAssertion *) 0 ;
4164
 
    char *arg2 = (char *) 0 ;
4165
 
    
4166
 
    arg1 = (LassoSamlAssertion *)jarg1; 
4167
 
    arg2 = jarg2; 
4168
 
    {
4169
 
        if (arg1->AssertionID) free((char*)arg1->AssertionID);
4170
 
        if (arg2) {
4171
 
            arg1->AssertionID = (char *) malloc(strlen(arg2)+1);
4172
 
            strcpy((char*)arg1->AssertionID,arg2);
4173
 
        } else {
4174
 
            arg1->AssertionID = 0;
4175
 
        }
4176
 
    }
4177
 
}
4178
 
 
4179
 
 
4180
 
DllExport char * SWIGSTDCALL CSharp_get_SamlAssertion_assertionId(void * jarg1) {
4181
 
    char * jresult = 0 ;
4182
 
    LassoSamlAssertion *arg1 = (LassoSamlAssertion *) 0 ;
4183
 
    char *result;
4184
 
    
4185
 
    arg1 = (LassoSamlAssertion *)jarg1; 
4186
 
    result = (char *) ((arg1)->AssertionID);
4187
 
    
4188
 
    jresult = SWIG_csharp_string_callback(result); 
4189
 
    return jresult;
4190
 
}
4191
 
 
4192
 
 
4193
 
DllExport void SWIGSTDCALL CSharp_set_SamlAssertion_certificateFile(void * jarg1, char * jarg2) {
4194
 
    LassoSamlAssertion *arg1 = (LassoSamlAssertion *) 0 ;
4195
 
    char *arg2 = (char *) 0 ;
4196
 
    
4197
 
    arg1 = (LassoSamlAssertion *)jarg1; 
4198
 
    arg2 = jarg2; 
4199
 
    {
4200
 
        if (arg1->certificate_file) free((char*)arg1->certificate_file);
4201
 
        if (arg2) {
4202
 
            arg1->certificate_file = (char *) malloc(strlen(arg2)+1);
4203
 
            strcpy((char*)arg1->certificate_file,arg2);
4204
 
        } else {
4205
 
            arg1->certificate_file = 0;
4206
 
        }
4207
 
    }
4208
 
}
4209
 
 
4210
 
 
4211
 
DllExport char * SWIGSTDCALL CSharp_get_SamlAssertion_certificateFile(void * jarg1) {
4212
 
    char * jresult = 0 ;
4213
 
    LassoSamlAssertion *arg1 = (LassoSamlAssertion *) 0 ;
4214
 
    char *result;
4215
 
    
4216
 
    arg1 = (LassoSamlAssertion *)jarg1; 
4217
 
    result = (char *) ((arg1)->certificate_file);
4218
 
    
4219
 
    jresult = SWIG_csharp_string_callback(result); 
4220
 
    return jresult;
4221
 
}
4222
 
 
4223
 
 
4224
 
DllExport void SWIGSTDCALL CSharp_set_SamlAssertion_issueInstant(void * jarg1, char * jarg2) {
4225
 
    LassoSamlAssertion *arg1 = (LassoSamlAssertion *) 0 ;
4226
 
    char *arg2 = (char *) 0 ;
4227
 
    
4228
 
    arg1 = (LassoSamlAssertion *)jarg1; 
4229
 
    arg2 = jarg2; 
4230
 
    {
4231
 
        if (arg1->IssueInstant) free((char*)arg1->IssueInstant);
4232
 
        if (arg2) {
4233
 
            arg1->IssueInstant = (char *) malloc(strlen(arg2)+1);
4234
 
            strcpy((char*)arg1->IssueInstant,arg2);
4235
 
        } else {
4236
 
            arg1->IssueInstant = 0;
4237
 
        }
4238
 
    }
4239
 
}
4240
 
 
4241
 
 
4242
 
DllExport char * SWIGSTDCALL CSharp_get_SamlAssertion_issueInstant(void * jarg1) {
4243
 
    char * jresult = 0 ;
4244
 
    LassoSamlAssertion *arg1 = (LassoSamlAssertion *) 0 ;
4245
 
    char *result;
4246
 
    
4247
 
    arg1 = (LassoSamlAssertion *)jarg1; 
4248
 
    result = (char *) ((arg1)->IssueInstant);
4249
 
    
4250
 
    jresult = SWIG_csharp_string_callback(result); 
4251
 
    return jresult;
4252
 
}
4253
 
 
4254
 
 
4255
 
DllExport void SWIGSTDCALL CSharp_set_SamlAssertion_issuer(void * jarg1, char * jarg2) {
4256
 
    LassoSamlAssertion *arg1 = (LassoSamlAssertion *) 0 ;
4257
 
    char *arg2 = (char *) 0 ;
4258
 
    
4259
 
    arg1 = (LassoSamlAssertion *)jarg1; 
4260
 
    arg2 = jarg2; 
4261
 
    {
4262
 
        if (arg1->Issuer) free((char*)arg1->Issuer);
4263
 
        if (arg2) {
4264
 
            arg1->Issuer = (char *) malloc(strlen(arg2)+1);
4265
 
            strcpy((char*)arg1->Issuer,arg2);
4266
 
        } else {
4267
 
            arg1->Issuer = 0;
4268
 
        }
4269
 
    }
4270
 
}
4271
 
 
4272
 
 
4273
 
DllExport char * SWIGSTDCALL CSharp_get_SamlAssertion_issuer(void * jarg1) {
4274
 
    char * jresult = 0 ;
4275
 
    LassoSamlAssertion *arg1 = (LassoSamlAssertion *) 0 ;
4276
 
    char *result;
4277
 
    
4278
 
    arg1 = (LassoSamlAssertion *)jarg1; 
4279
 
    result = (char *) ((arg1)->Issuer);
4280
 
    
4281
 
    jresult = SWIG_csharp_string_callback(result); 
4282
 
    return jresult;
4283
 
}
4284
 
 
4285
 
 
4286
 
DllExport void SWIGSTDCALL CSharp_set_SamlAssertion_majorVersion(void * jarg1, int jarg2) {
4287
 
    LassoSamlAssertion *arg1 = (LassoSamlAssertion *) 0 ;
4288
 
    int arg2 ;
4289
 
    
4290
 
    arg1 = (LassoSamlAssertion *)jarg1; 
4291
 
    arg2 = (int)jarg2; 
4292
 
    if (arg1) (arg1)->MajorVersion = arg2;
4293
 
    
4294
 
}
4295
 
 
4296
 
 
4297
 
DllExport int SWIGSTDCALL CSharp_get_SamlAssertion_majorVersion(void * jarg1) {
4298
 
    int jresult = 0 ;
4299
 
    LassoSamlAssertion *arg1 = (LassoSamlAssertion *) 0 ;
4300
 
    int result;
4301
 
    
4302
 
    arg1 = (LassoSamlAssertion *)jarg1; 
4303
 
    result = (int) ((arg1)->MajorVersion);
4304
 
    
4305
 
    jresult = result; 
4306
 
    return jresult;
4307
 
}
4308
 
 
4309
 
 
4310
 
DllExport void SWIGSTDCALL CSharp_set_SamlAssertion_minorVersion(void * jarg1, int jarg2) {
4311
 
    LassoSamlAssertion *arg1 = (LassoSamlAssertion *) 0 ;
4312
 
    int arg2 ;
4313
 
    
4314
 
    arg1 = (LassoSamlAssertion *)jarg1; 
4315
 
    arg2 = (int)jarg2; 
4316
 
    if (arg1) (arg1)->MinorVersion = arg2;
4317
 
    
4318
 
}
4319
 
 
4320
 
 
4321
 
DllExport int SWIGSTDCALL CSharp_get_SamlAssertion_minorVersion(void * jarg1) {
4322
 
    int jresult = 0 ;
4323
 
    LassoSamlAssertion *arg1 = (LassoSamlAssertion *) 0 ;
4324
 
    int result;
4325
 
    
4326
 
    arg1 = (LassoSamlAssertion *)jarg1; 
4327
 
    result = (int) ((arg1)->MinorVersion);
4328
 
    
4329
 
    jresult = result; 
4330
 
    return jresult;
4331
 
}
4332
 
 
4333
 
 
4334
 
DllExport void SWIGSTDCALL CSharp_set_SamlAssertion_privateKeyFile(void * jarg1, char * jarg2) {
4335
 
    LassoSamlAssertion *arg1 = (LassoSamlAssertion *) 0 ;
4336
 
    char *arg2 = (char *) 0 ;
4337
 
    
4338
 
    arg1 = (LassoSamlAssertion *)jarg1; 
4339
 
    arg2 = jarg2; 
4340
 
    {
4341
 
        if (arg1->private_key_file) free((char*)arg1->private_key_file);
4342
 
        if (arg2) {
4343
 
            arg1->private_key_file = (char *) malloc(strlen(arg2)+1);
4344
 
            strcpy((char*)arg1->private_key_file,arg2);
4345
 
        } else {
4346
 
            arg1->private_key_file = 0;
4347
 
        }
4348
 
    }
4349
 
}
4350
 
 
4351
 
 
4352
 
DllExport char * SWIGSTDCALL CSharp_get_SamlAssertion_privateKeyFile(void * jarg1) {
4353
 
    char * jresult = 0 ;
4354
 
    LassoSamlAssertion *arg1 = (LassoSamlAssertion *) 0 ;
4355
 
    char *result;
4356
 
    
4357
 
    arg1 = (LassoSamlAssertion *)jarg1; 
4358
 
    result = (char *) ((arg1)->private_key_file);
4359
 
    
4360
 
    jresult = SWIG_csharp_string_callback(result); 
4361
 
    return jresult;
4362
 
}
4363
 
 
4364
 
 
4365
 
DllExport void SWIGSTDCALL CSharp_set_SamlAssertion_signMethod(void * jarg1, int jarg2) {
4366
 
    LassoSamlAssertion *arg1 = (LassoSamlAssertion *) 0 ;
4367
 
    LassoSignatureMethod arg2 ;
4368
 
    
4369
 
    arg1 = (LassoSamlAssertion *)jarg1; 
4370
 
    arg2 = (LassoSignatureMethod)jarg2; 
4371
 
    if (arg1) (arg1)->sign_method = (LassoSignatureMethod )arg2;
4372
 
    
4373
 
}
4374
 
 
4375
 
 
4376
 
DllExport int SWIGSTDCALL CSharp_get_SamlAssertion_signMethod(void * jarg1) {
4377
 
    int jresult = 0 ;
4378
 
    LassoSamlAssertion *arg1 = (LassoSamlAssertion *) 0 ;
4379
 
    LassoSignatureMethod result;
4380
 
    
4381
 
    arg1 = (LassoSamlAssertion *)jarg1; 
4382
 
    result = (LassoSignatureMethod) ((arg1)->sign_method);
4383
 
    
4384
 
    jresult = result; 
4385
 
    return jresult;
4386
 
}
4387
 
 
4388
 
 
4389
 
DllExport void SWIGSTDCALL CSharp_set_SamlAssertion_signType(void * jarg1, void * jarg2) {
4390
 
    LassoSamlAssertion *arg1 = (LassoSamlAssertion *) 0 ;
4391
 
    LassoSignatureType arg2 ;
4392
 
    LassoSignatureType *argp2 ;
4393
 
    
4394
 
    arg1 = (LassoSamlAssertion *)jarg1; 
4395
 
    argp2 = (LassoSignatureType *)jarg2; 
4396
 
    if (!argp2) {
4397
 
        SWIG_CSharpThrowException(SWIG_CSharpNullReferenceException, "Attempt to dereference null LassoSignatureType");
4398
 
    }
4399
 
    arg2 = *argp2; 
4400
 
    if (arg1) (arg1)->sign_type = arg2;
4401
 
    
4402
 
}
4403
 
 
4404
 
 
4405
 
DllExport void * SWIGSTDCALL CSharp_get_SamlAssertion_signType(void * jarg1) {
4406
 
    void * jresult = 0 ;
4407
 
    LassoSamlAssertion *arg1 = (LassoSamlAssertion *) 0 ;
4408
 
    LassoSignatureType result;
4409
 
    
4410
 
    arg1 = (LassoSamlAssertion *)jarg1; 
4411
 
    result =  ((arg1)->sign_type);
4412
 
    
4413
 
    {
4414
 
        LassoSignatureType * resultptr = (LassoSignatureType *) malloc(sizeof(LassoSignatureType));
4415
 
        memmove(resultptr, &result, sizeof(LassoSignatureType));
4416
 
        jresult = resultptr;
4417
 
    }
4418
 
    return jresult;
4419
 
}
4420
 
 
4421
 
 
4422
 
DllExport void SWIGSTDCALL CSharp_set_SamlAssertion_advice(void * jarg1, void * jarg2) {
4423
 
    LassoSamlAssertion *arg1 = (LassoSamlAssertion *) 0 ;
4424
 
    LassoSamlAdvice *arg2 = (LassoSamlAdvice *) 0 ;
4425
 
    
4426
 
    arg1 = (LassoSamlAssertion *)jarg1; 
4427
 
    arg2 = (LassoSamlAdvice *)jarg2; 
4428
 
    LassoSamlAssertion_set_Advice(arg1,arg2);
4429
 
    
4430
 
}
4431
 
 
4432
 
 
4433
 
DllExport void * SWIGSTDCALL CSharp_get_SamlAssertion_advice(void * jarg1) {
4434
 
    void * jresult = 0 ;
4435
 
    LassoSamlAssertion *arg1 = (LassoSamlAssertion *) 0 ;
4436
 
    LassoSamlAdvice *result;
4437
 
    
4438
 
    arg1 = (LassoSamlAssertion *)jarg1; 
4439
 
    result = (LassoSamlAdvice *)LassoSamlAssertion_get_Advice(arg1);
4440
 
    
4441
 
    jresult = (void *)result; 
4442
 
    return jresult;
4443
 
}
4444
 
 
4445
 
 
4446
 
DllExport void SWIGSTDCALL CSharp_set_SamlAssertion_attributeStatement(void * jarg1, void * jarg2) {
4447
 
    LassoSamlAssertion *arg1 = (LassoSamlAssertion *) 0 ;
4448
 
    LassoSamlAttributeStatement *arg2 = (LassoSamlAttributeStatement *) 0 ;
4449
 
    
4450
 
    arg1 = (LassoSamlAssertion *)jarg1; 
4451
 
    arg2 = (LassoSamlAttributeStatement *)jarg2; 
4452
 
    LassoSamlAssertion_set_AttributeStatement(arg1,arg2);
4453
 
    
4454
 
}
4455
 
 
4456
 
 
4457
 
DllExport void * SWIGSTDCALL CSharp_get_SamlAssertion_attributeStatement(void * jarg1) {
4458
 
    void * jresult = 0 ;
4459
 
    LassoSamlAssertion *arg1 = (LassoSamlAssertion *) 0 ;
4460
 
    LassoSamlAttributeStatement *result;
4461
 
    
4462
 
    arg1 = (LassoSamlAssertion *)jarg1; 
4463
 
    result = (LassoSamlAttributeStatement *)LassoSamlAssertion_get_AttributeStatement(arg1);
4464
 
    
4465
 
    jresult = (void *)result; 
4466
 
    return jresult;
4467
 
}
4468
 
 
4469
 
 
4470
 
DllExport void SWIGSTDCALL CSharp_set_SamlAssertion_authenticationStatement(void * jarg1, void * jarg2) {
4471
 
    LassoSamlAssertion *arg1 = (LassoSamlAssertion *) 0 ;
4472
 
    LassoSamlAuthenticationStatement *arg2 = (LassoSamlAuthenticationStatement *) 0 ;
4473
 
    
4474
 
    arg1 = (LassoSamlAssertion *)jarg1; 
4475
 
    arg2 = (LassoSamlAuthenticationStatement *)jarg2; 
4476
 
    LassoSamlAssertion_set_AuthenticationStatement(arg1,arg2);
4477
 
    
4478
 
}
4479
 
 
4480
 
 
4481
 
DllExport void * SWIGSTDCALL CSharp_get_SamlAssertion_authenticationStatement(void * jarg1) {
4482
 
    void * jresult = 0 ;
4483
 
    LassoSamlAssertion *arg1 = (LassoSamlAssertion *) 0 ;
4484
 
    LassoSamlAuthenticationStatement *result;
4485
 
    
4486
 
    arg1 = (LassoSamlAssertion *)jarg1; 
4487
 
    result = (LassoSamlAuthenticationStatement *)LassoSamlAssertion_get_AuthenticationStatement(arg1);
4488
 
    
4489
 
    jresult = (void *)result; 
4490
 
    return jresult;
4491
 
}
4492
 
 
4493
 
 
4494
 
DllExport void SWIGSTDCALL CSharp_set_SamlAssertion_conditions(void * jarg1, void * jarg2) {
4495
 
    LassoSamlAssertion *arg1 = (LassoSamlAssertion *) 0 ;
4496
 
    LassoSamlConditions *arg2 = (LassoSamlConditions *) 0 ;
4497
 
    
4498
 
    arg1 = (LassoSamlAssertion *)jarg1; 
4499
 
    arg2 = (LassoSamlConditions *)jarg2; 
4500
 
    LassoSamlAssertion_set_Conditions(arg1,arg2);
4501
 
    
4502
 
}
4503
 
 
4504
 
 
4505
 
DllExport void * SWIGSTDCALL CSharp_get_SamlAssertion_conditions(void * jarg1) {
4506
 
    void * jresult = 0 ;
4507
 
    LassoSamlAssertion *arg1 = (LassoSamlAssertion *) 0 ;
4508
 
    LassoSamlConditions *result;
4509
 
    
4510
 
    arg1 = (LassoSamlAssertion *)jarg1; 
4511
 
    result = (LassoSamlConditions *)LassoSamlAssertion_get_Conditions(arg1);
4512
 
    
4513
 
    jresult = (void *)result; 
4514
 
    return jresult;
4515
 
}
4516
 
 
4517
 
 
4518
 
DllExport void SWIGSTDCALL CSharp_set_SamlAssertion_subjectStatement(void * jarg1, void * jarg2) {
4519
 
    LassoSamlAssertion *arg1 = (LassoSamlAssertion *) 0 ;
4520
 
    LassoSamlSubjectStatement *arg2 = (LassoSamlSubjectStatement *) 0 ;
4521
 
    
4522
 
    arg1 = (LassoSamlAssertion *)jarg1; 
4523
 
    arg2 = (LassoSamlSubjectStatement *)jarg2; 
4524
 
    LassoSamlAssertion_set_SubjectStatement(arg1,arg2);
4525
 
    
4526
 
}
4527
 
 
4528
 
 
4529
 
DllExport void * SWIGSTDCALL CSharp_get_SamlAssertion_subjectStatement(void * jarg1) {
4530
 
    void * jresult = 0 ;
4531
 
    LassoSamlAssertion *arg1 = (LassoSamlAssertion *) 0 ;
4532
 
    LassoSamlSubjectStatement *result;
4533
 
    
4534
 
    arg1 = (LassoSamlAssertion *)jarg1; 
4535
 
    result = (LassoSamlSubjectStatement *)LassoSamlAssertion_get_SubjectStatement(arg1);
4536
 
    
4537
 
    jresult = (void *)result; 
4538
 
    return jresult;
4539
 
}
4540
 
 
4541
 
 
4542
 
DllExport void * SWIGSTDCALL CSharp_new_SamlAssertion() {
4543
 
    void * jresult = 0 ;
4544
 
    LassoSamlAssertion *result;
4545
 
    
4546
 
    result = (LassoSamlAssertion *)new_LassoSamlAssertion();
4547
 
    
4548
 
    jresult = (void *)result; 
4549
 
    return jresult;
4550
 
}
4551
 
 
4552
 
 
4553
 
DllExport void SWIGSTDCALL CSharp_delete_SamlAssertion(void * jarg1) {
4554
 
    LassoSamlAssertion *arg1 = (LassoSamlAssertion *) 0 ;
4555
 
    
4556
 
    arg1 = (LassoSamlAssertion *)jarg1; 
4557
 
    delete_LassoSamlAssertion(arg1);
4558
 
    
4559
 
}
4560
 
 
4561
 
 
4562
 
DllExport char * SWIGSTDCALL CSharp_SamlAssertion_dump(void * jarg1) {
4563
 
    char * jresult = 0 ;
4564
 
    LassoSamlAssertion *arg1 = (LassoSamlAssertion *) 0 ;
4565
 
    char *result;
4566
 
    
4567
 
    arg1 = (LassoSamlAssertion *)jarg1; 
4568
 
    result = (char *)LassoSamlAssertion_dump(arg1);
4569
 
    
4570
 
    jresult = SWIG_csharp_string_callback(result); 
4571
 
    free(result);
4572
 
    return jresult;
4573
 
}
4574
 
 
4575
 
 
4576
 
DllExport void SWIGSTDCALL CSharp_set_SamlAttribute_attributeName(void * jarg1, char * jarg2) {
4577
 
    LassoSamlAttribute *arg1 = (LassoSamlAttribute *) 0 ;
4578
 
    char *arg2 = (char *) 0 ;
4579
 
    
4580
 
    arg1 = (LassoSamlAttribute *)jarg1; 
4581
 
    arg2 = jarg2; 
4582
 
    LassoSamlAttribute_set_AttributeName(arg1,arg2);
4583
 
    
4584
 
}
4585
 
 
4586
 
 
4587
 
DllExport char * SWIGSTDCALL CSharp_get_SamlAttribute_attributeName(void * jarg1) {
4588
 
    char * jresult = 0 ;
4589
 
    LassoSamlAttribute *arg1 = (LassoSamlAttribute *) 0 ;
4590
 
    char *result;
4591
 
    
4592
 
    arg1 = (LassoSamlAttribute *)jarg1; 
4593
 
    result = (char *)LassoSamlAttribute_get_AttributeName(arg1);
4594
 
    
4595
 
    jresult = SWIG_csharp_string_callback(result); 
4596
 
    return jresult;
4597
 
}
4598
 
 
4599
 
 
4600
 
DllExport void SWIGSTDCALL CSharp_set_SamlAttribute_attributeNamespace(void * jarg1, char * jarg2) {
4601
 
    LassoSamlAttribute *arg1 = (LassoSamlAttribute *) 0 ;
4602
 
    char *arg2 = (char *) 0 ;
4603
 
    
4604
 
    arg1 = (LassoSamlAttribute *)jarg1; 
4605
 
    arg2 = jarg2; 
4606
 
    LassoSamlAttribute_set_AttributeNamespace(arg1,arg2);
4607
 
    
4608
 
}
4609
 
 
4610
 
 
4611
 
DllExport char * SWIGSTDCALL CSharp_get_SamlAttribute_attributeNamespace(void * jarg1) {
4612
 
    char * jresult = 0 ;
4613
 
    LassoSamlAttribute *arg1 = (LassoSamlAttribute *) 0 ;
4614
 
    char *result;
4615
 
    
4616
 
    arg1 = (LassoSamlAttribute *)jarg1; 
4617
 
    result = (char *)LassoSamlAttribute_get_AttributeNamespace(arg1);
4618
 
    
4619
 
    jresult = SWIG_csharp_string_callback(result); 
4620
 
    return jresult;
4621
 
}
4622
 
 
4623
 
 
4624
 
DllExport void SWIGSTDCALL CSharp_set_SamlAttribute_attributeValue(void * jarg1, void * jarg2) {
4625
 
    LassoSamlAttribute *arg1 = (LassoSamlAttribute *) 0 ;
4626
 
    LassoNodeList *arg2 = (LassoNodeList *) 0 ;
4627
 
    
4628
 
    arg1 = (LassoSamlAttribute *)jarg1; 
4629
 
    arg2 = (LassoNodeList *)jarg2; 
4630
 
    LassoSamlAttribute_set_AttributeValue(arg1,arg2);
4631
 
    
4632
 
}
4633
 
 
4634
 
 
4635
 
DllExport void * SWIGSTDCALL CSharp_get_SamlAttribute_attributeValue(void * jarg1) {
4636
 
    void * jresult = 0 ;
4637
 
    LassoSamlAttribute *arg1 = (LassoSamlAttribute *) 0 ;
4638
 
    LassoNodeList *result;
4639
 
    
4640
 
    arg1 = (LassoSamlAttribute *)jarg1; 
4641
 
    result = (LassoNodeList *)LassoSamlAttribute_get_AttributeValue(arg1);
4642
 
    
4643
 
    jresult = (void *)result; 
4644
 
    return jresult;
4645
 
}
4646
 
 
4647
 
 
4648
 
DllExport void * SWIGSTDCALL CSharp_new_SamlAttribute() {
4649
 
    void * jresult = 0 ;
4650
 
    LassoSamlAttribute *result;
4651
 
    
4652
 
    result = (LassoSamlAttribute *)new_LassoSamlAttribute();
4653
 
    
4654
 
    jresult = (void *)result; 
4655
 
    return jresult;
4656
 
}
4657
 
 
4658
 
 
4659
 
DllExport void SWIGSTDCALL CSharp_delete_SamlAttribute(void * jarg1) {
4660
 
    LassoSamlAttribute *arg1 = (LassoSamlAttribute *) 0 ;
4661
 
    
4662
 
    arg1 = (LassoSamlAttribute *)jarg1; 
4663
 
    delete_LassoSamlAttribute(arg1);
4664
 
    
4665
 
}
4666
 
 
4667
 
 
4668
 
DllExport char * SWIGSTDCALL CSharp_SamlAttribute_dump(void * jarg1) {
4669
 
    char * jresult = 0 ;
4670
 
    LassoSamlAttribute *arg1 = (LassoSamlAttribute *) 0 ;
4671
 
    char *result;
4672
 
    
4673
 
    arg1 = (LassoSamlAttribute *)jarg1; 
4674
 
    result = (char *)LassoSamlAttribute_dump(arg1);
4675
 
    
4676
 
    jresult = SWIG_csharp_string_callback(result); 
4677
 
    free(result);
4678
 
    return jresult;
4679
 
}
4680
 
 
4681
 
 
4682
 
DllExport void SWIGSTDCALL CSharp_set_SamlAttributeDesignator_attributeName(void * jarg1, char * jarg2) {
4683
 
    LassoSamlAttributeDesignator *arg1 = (LassoSamlAttributeDesignator *) 0 ;
4684
 
    char *arg2 = (char *) 0 ;
4685
 
    
4686
 
    arg1 = (LassoSamlAttributeDesignator *)jarg1; 
4687
 
    arg2 = jarg2; 
4688
 
    {
4689
 
        if (arg1->AttributeName) free((char*)arg1->AttributeName);
4690
 
        if (arg2) {
4691
 
            arg1->AttributeName = (char *) malloc(strlen(arg2)+1);
4692
 
            strcpy((char*)arg1->AttributeName,arg2);
4693
 
        } else {
4694
 
            arg1->AttributeName = 0;
4695
 
        }
4696
 
    }
4697
 
}
4698
 
 
4699
 
 
4700
 
DllExport char * SWIGSTDCALL CSharp_get_SamlAttributeDesignator_attributeName(void * jarg1) {
4701
 
    char * jresult = 0 ;
4702
 
    LassoSamlAttributeDesignator *arg1 = (LassoSamlAttributeDesignator *) 0 ;
4703
 
    char *result;
4704
 
    
4705
 
    arg1 = (LassoSamlAttributeDesignator *)jarg1; 
4706
 
    result = (char *) ((arg1)->AttributeName);
4707
 
    
4708
 
    jresult = SWIG_csharp_string_callback(result); 
4709
 
    return jresult;
4710
 
}
4711
 
 
4712
 
 
4713
 
DllExport void SWIGSTDCALL CSharp_set_SamlAttributeDesignator_attributeNamespace(void * jarg1, char * jarg2) {
4714
 
    LassoSamlAttributeDesignator *arg1 = (LassoSamlAttributeDesignator *) 0 ;
4715
 
    char *arg2 = (char *) 0 ;
4716
 
    
4717
 
    arg1 = (LassoSamlAttributeDesignator *)jarg1; 
4718
 
    arg2 = jarg2; 
4719
 
    {
4720
 
        if (arg1->AttributeNamespace) free((char*)arg1->AttributeNamespace);
4721
 
        if (arg2) {
4722
 
            arg1->AttributeNamespace = (char *) malloc(strlen(arg2)+1);
4723
 
            strcpy((char*)arg1->AttributeNamespace,arg2);
4724
 
        } else {
4725
 
            arg1->AttributeNamespace = 0;
4726
 
        }
4727
 
    }
4728
 
}
4729
 
 
4730
 
 
4731
 
DllExport char * SWIGSTDCALL CSharp_get_SamlAttributeDesignator_attributeNamespace(void * jarg1) {
4732
 
    char * jresult = 0 ;
4733
 
    LassoSamlAttributeDesignator *arg1 = (LassoSamlAttributeDesignator *) 0 ;
4734
 
    char *result;
4735
 
    
4736
 
    arg1 = (LassoSamlAttributeDesignator *)jarg1; 
4737
 
    result = (char *) ((arg1)->AttributeNamespace);
4738
 
    
4739
 
    jresult = SWIG_csharp_string_callback(result); 
4740
 
    return jresult;
4741
 
}
4742
 
 
4743
 
 
4744
 
DllExport void * SWIGSTDCALL CSharp_new_SamlAttributeDesignator() {
4745
 
    void * jresult = 0 ;
4746
 
    LassoSamlAttributeDesignator *result;
4747
 
    
4748
 
    result = (LassoSamlAttributeDesignator *)new_LassoSamlAttributeDesignator();
4749
 
    
4750
 
    jresult = (void *)result; 
4751
 
    return jresult;
4752
 
}
4753
 
 
4754
 
 
4755
 
DllExport void SWIGSTDCALL CSharp_delete_SamlAttributeDesignator(void * jarg1) {
4756
 
    LassoSamlAttributeDesignator *arg1 = (LassoSamlAttributeDesignator *) 0 ;
4757
 
    
4758
 
    arg1 = (LassoSamlAttributeDesignator *)jarg1; 
4759
 
    delete_LassoSamlAttributeDesignator(arg1);
4760
 
    
4761
 
}
4762
 
 
4763
 
 
4764
 
DllExport char * SWIGSTDCALL CSharp_SamlAttributeDesignator_dump(void * jarg1) {
4765
 
    char * jresult = 0 ;
4766
 
    LassoSamlAttributeDesignator *arg1 = (LassoSamlAttributeDesignator *) 0 ;
4767
 
    char *result;
4768
 
    
4769
 
    arg1 = (LassoSamlAttributeDesignator *)jarg1; 
4770
 
    result = (char *)LassoSamlAttributeDesignator_dump(arg1);
4771
 
    
4772
 
    jresult = SWIG_csharp_string_callback(result); 
4773
 
    free(result);
4774
 
    return jresult;
4775
 
}
4776
 
 
4777
 
 
4778
 
DllExport void SWIGSTDCALL CSharp_set_SamlAttributeStatement_subject(void * jarg1, void * jarg2) {
4779
 
    LassoSamlAttributeStatement *arg1 = (LassoSamlAttributeStatement *) 0 ;
4780
 
    LassoSamlSubject *arg2 = (LassoSamlSubject *) 0 ;
4781
 
    
4782
 
    arg1 = (LassoSamlAttributeStatement *)jarg1; 
4783
 
    arg2 = (LassoSamlSubject *)jarg2; 
4784
 
    LassoSamlAttributeStatement_set_Subject(arg1,arg2);
4785
 
    
4786
 
}
4787
 
 
4788
 
 
4789
 
DllExport void * SWIGSTDCALL CSharp_get_SamlAttributeStatement_subject(void * jarg1) {
4790
 
    void * jresult = 0 ;
4791
 
    LassoSamlAttributeStatement *arg1 = (LassoSamlAttributeStatement *) 0 ;
4792
 
    LassoSamlSubject *result;
4793
 
    
4794
 
    arg1 = (LassoSamlAttributeStatement *)jarg1; 
4795
 
    result = (LassoSamlSubject *)LassoSamlAttributeStatement_get_Subject(arg1);
4796
 
    
4797
 
    jresult = (void *)result; 
4798
 
    return jresult;
4799
 
}
4800
 
 
4801
 
 
4802
 
DllExport void SWIGSTDCALL CSharp_set_SamlAttributeStatement_attribute(void * jarg1, void * jarg2) {
4803
 
    LassoSamlAttributeStatement *arg1 = (LassoSamlAttributeStatement *) 0 ;
4804
 
    LassoNodeList *arg2 = (LassoNodeList *) 0 ;
4805
 
    
4806
 
    arg1 = (LassoSamlAttributeStatement *)jarg1; 
4807
 
    arg2 = (LassoNodeList *)jarg2; 
4808
 
    LassoSamlAttributeStatement_set_Attribute(arg1,arg2);
4809
 
    
4810
 
}
4811
 
 
4812
 
 
4813
 
DllExport void * SWIGSTDCALL CSharp_get_SamlAttributeStatement_attribute(void * jarg1) {
4814
 
    void * jresult = 0 ;
4815
 
    LassoSamlAttributeStatement *arg1 = (LassoSamlAttributeStatement *) 0 ;
4816
 
    LassoNodeList *result;
4817
 
    
4818
 
    arg1 = (LassoSamlAttributeStatement *)jarg1; 
4819
 
    result = (LassoNodeList *)LassoSamlAttributeStatement_get_Attribute(arg1);
4820
 
    
4821
 
    jresult = (void *)result; 
4822
 
    return jresult;
4823
 
}
4824
 
 
4825
 
 
4826
 
DllExport void * SWIGSTDCALL CSharp_new_SamlAttributeStatement() {
4827
 
    void * jresult = 0 ;
4828
 
    LassoSamlAttributeStatement *result;
4829
 
    
4830
 
    result = (LassoSamlAttributeStatement *)new_LassoSamlAttributeStatement();
4831
 
    
4832
 
    jresult = (void *)result; 
4833
 
    return jresult;
4834
 
}
4835
 
 
4836
 
 
4837
 
DllExport void SWIGSTDCALL CSharp_delete_SamlAttributeStatement(void * jarg1) {
4838
 
    LassoSamlAttributeStatement *arg1 = (LassoSamlAttributeStatement *) 0 ;
4839
 
    
4840
 
    arg1 = (LassoSamlAttributeStatement *)jarg1; 
4841
 
    delete_LassoSamlAttributeStatement(arg1);
4842
 
    
4843
 
}
4844
 
 
4845
 
 
4846
 
DllExport char * SWIGSTDCALL CSharp_SamlAttributeStatement_dump(void * jarg1) {
4847
 
    char * jresult = 0 ;
4848
 
    LassoSamlAttributeStatement *arg1 = (LassoSamlAttributeStatement *) 0 ;
4849
 
    char *result;
4850
 
    
4851
 
    arg1 = (LassoSamlAttributeStatement *)jarg1; 
4852
 
    result = (char *)LassoSamlAttributeStatement_dump(arg1);
4853
 
    
4854
 
    jresult = SWIG_csharp_string_callback(result); 
4855
 
    free(result);
4856
 
    return jresult;
4857
 
}
4858
 
 
4859
 
 
4860
 
DllExport void SWIGSTDCALL CSharp_set_SamlAttributeValue_any(void * jarg1, void * jarg2) {
4861
 
    LassoSamlAttributeValue *arg1 = (LassoSamlAttributeValue *) 0 ;
4862
 
    LassoNodeList *arg2 = (LassoNodeList *) 0 ;
4863
 
    
4864
 
    arg1 = (LassoSamlAttributeValue *)jarg1; 
4865
 
    arg2 = (LassoNodeList *)jarg2; 
4866
 
    LassoSamlAttributeValue_set_any(arg1,arg2);
4867
 
    
4868
 
}
4869
 
 
4870
 
 
4871
 
DllExport void * SWIGSTDCALL CSharp_get_SamlAttributeValue_any(void * jarg1) {
4872
 
    void * jresult = 0 ;
4873
 
    LassoSamlAttributeValue *arg1 = (LassoSamlAttributeValue *) 0 ;
4874
 
    LassoNodeList *result;
4875
 
    
4876
 
    arg1 = (LassoSamlAttributeValue *)jarg1; 
4877
 
    result = (LassoNodeList *)LassoSamlAttributeValue_get_any(arg1);
4878
 
    
4879
 
    jresult = (void *)result; 
4880
 
    return jresult;
4881
 
}
4882
 
 
4883
 
 
4884
 
DllExport void * SWIGSTDCALL CSharp_new_SamlAttributeValue() {
4885
 
    void * jresult = 0 ;
4886
 
    LassoSamlAttributeValue *result;
4887
 
    
4888
 
    result = (LassoSamlAttributeValue *)new_LassoSamlAttributeValue();
4889
 
    
4890
 
    jresult = (void *)result; 
4891
 
    return jresult;
4892
 
}
4893
 
 
4894
 
 
4895
 
DllExport void SWIGSTDCALL CSharp_delete_SamlAttributeValue(void * jarg1) {
4896
 
    LassoSamlAttributeValue *arg1 = (LassoSamlAttributeValue *) 0 ;
4897
 
    
4898
 
    arg1 = (LassoSamlAttributeValue *)jarg1; 
4899
 
    delete_LassoSamlAttributeValue(arg1);
4900
 
    
4901
 
}
4902
 
 
4903
 
 
4904
 
DllExport char * SWIGSTDCALL CSharp_SamlAttributeValue_dump(void * jarg1) {
4905
 
    char * jresult = 0 ;
4906
 
    LassoSamlAttributeValue *arg1 = (LassoSamlAttributeValue *) 0 ;
4907
 
    char *result;
4908
 
    
4909
 
    arg1 = (LassoSamlAttributeValue *)jarg1; 
4910
 
    result = (char *)LassoSamlAttributeValue_dump(arg1);
4911
 
    
4912
 
    jresult = SWIG_csharp_string_callback(result); 
4913
 
    free(result);
4914
 
    return jresult;
4915
 
}
4916
 
 
4917
 
 
4918
 
DllExport void SWIGSTDCALL CSharp_set_SamlAudienceRestrictionCondition_audience(void * jarg1, void * jarg2) {
4919
 
    LassoSamlAudienceRestrictionCondition *arg1 = (LassoSamlAudienceRestrictionCondition *) 0 ;
4920
 
    LassoStringList *arg2 = (LassoStringList *) 0 ;
4921
 
    
4922
 
    arg1 = (LassoSamlAudienceRestrictionCondition *)jarg1; 
4923
 
    arg2 = (LassoStringList *)jarg2; 
4924
 
    LassoSamlAudienceRestrictionCondition_set_audience(arg1,arg2);
4925
 
    
4926
 
}
4927
 
 
4928
 
 
4929
 
DllExport void * SWIGSTDCALL CSharp_get_SamlAudienceRestrictionCondition_audience(void * jarg1) {
4930
 
    void * jresult = 0 ;
4931
 
    LassoSamlAudienceRestrictionCondition *arg1 = (LassoSamlAudienceRestrictionCondition *) 0 ;
4932
 
    LassoStringList *result;
4933
 
    
4934
 
    arg1 = (LassoSamlAudienceRestrictionCondition *)jarg1; 
4935
 
    result = (LassoStringList *)LassoSamlAudienceRestrictionCondition_get_audience(arg1);
4936
 
    
4937
 
    jresult = (void *)result; 
4938
 
    return jresult;
4939
 
}
4940
 
 
4941
 
 
4942
 
DllExport void * SWIGSTDCALL CSharp_new_SamlAudienceRestrictionCondition() {
4943
 
    void * jresult = 0 ;
4944
 
    LassoSamlAudienceRestrictionCondition *result;
4945
 
    
4946
 
    result = (LassoSamlAudienceRestrictionCondition *)new_LassoSamlAudienceRestrictionCondition();
4947
 
    
4948
 
    jresult = (void *)result; 
4949
 
    return jresult;
4950
 
}
4951
 
 
4952
 
 
4953
 
DllExport void SWIGSTDCALL CSharp_delete_SamlAudienceRestrictionCondition(void * jarg1) {
4954
 
    LassoSamlAudienceRestrictionCondition *arg1 = (LassoSamlAudienceRestrictionCondition *) 0 ;
4955
 
    
4956
 
    arg1 = (LassoSamlAudienceRestrictionCondition *)jarg1; 
4957
 
    delete_LassoSamlAudienceRestrictionCondition(arg1);
4958
 
    
4959
 
}
4960
 
 
4961
 
 
4962
 
DllExport char * SWIGSTDCALL CSharp_SamlAudienceRestrictionCondition_dump(void * jarg1) {
4963
 
    char * jresult = 0 ;
4964
 
    LassoSamlAudienceRestrictionCondition *arg1 = (LassoSamlAudienceRestrictionCondition *) 0 ;
4965
 
    char *result;
4966
 
    
4967
 
    arg1 = (LassoSamlAudienceRestrictionCondition *)jarg1; 
4968
 
    result = (char *)LassoSamlAudienceRestrictionCondition_dump(arg1);
4969
 
    
4970
 
    jresult = SWIG_csharp_string_callback(result); 
4971
 
    free(result);
4972
 
    return jresult;
4973
 
}
4974
 
 
4975
 
 
4976
 
DllExport void SWIGSTDCALL CSharp_set_SamlAuthenticationStatement_authenticationInstant(void * jarg1, char * jarg2) {
4977
 
    LassoSamlAuthenticationStatement *arg1 = (LassoSamlAuthenticationStatement *) 0 ;
4978
 
    char *arg2 = (char *) 0 ;
4979
 
    
4980
 
    arg1 = (LassoSamlAuthenticationStatement *)jarg1; 
4981
 
    arg2 = jarg2; 
4982
 
    {
4983
 
        if (arg1->AuthenticationInstant) free((char*)arg1->AuthenticationInstant);
4984
 
        if (arg2) {
4985
 
            arg1->AuthenticationInstant = (char *) malloc(strlen(arg2)+1);
4986
 
            strcpy((char*)arg1->AuthenticationInstant,arg2);
4987
 
        } else {
4988
 
            arg1->AuthenticationInstant = 0;
4989
 
        }
4990
 
    }
4991
 
}
4992
 
 
4993
 
 
4994
 
DllExport char * SWIGSTDCALL CSharp_get_SamlAuthenticationStatement_authenticationInstant(void * jarg1) {
4995
 
    char * jresult = 0 ;
4996
 
    LassoSamlAuthenticationStatement *arg1 = (LassoSamlAuthenticationStatement *) 0 ;
4997
 
    char *result;
4998
 
    
4999
 
    arg1 = (LassoSamlAuthenticationStatement *)jarg1; 
5000
 
    result = (char *) ((arg1)->AuthenticationInstant);
5001
 
    
5002
 
    jresult = SWIG_csharp_string_callback(result); 
5003
 
    return jresult;
5004
 
}
5005
 
 
5006
 
 
5007
 
DllExport void SWIGSTDCALL CSharp_set_SamlAuthenticationStatement_authenticationMethod(void * jarg1, char * jarg2) {
5008
 
    LassoSamlAuthenticationStatement *arg1 = (LassoSamlAuthenticationStatement *) 0 ;
5009
 
    char *arg2 = (char *) 0 ;
5010
 
    
5011
 
    arg1 = (LassoSamlAuthenticationStatement *)jarg1; 
5012
 
    arg2 = jarg2; 
5013
 
    {
5014
 
        if (arg1->AuthenticationMethod) free((char*)arg1->AuthenticationMethod);
5015
 
        if (arg2) {
5016
 
            arg1->AuthenticationMethod = (char *) malloc(strlen(arg2)+1);
5017
 
            strcpy((char*)arg1->AuthenticationMethod,arg2);
5018
 
        } else {
5019
 
            arg1->AuthenticationMethod = 0;
5020
 
        }
5021
 
    }
5022
 
}
5023
 
 
5024
 
 
5025
 
DllExport char * SWIGSTDCALL CSharp_get_SamlAuthenticationStatement_authenticationMethod(void * jarg1) {
5026
 
    char * jresult = 0 ;
5027
 
    LassoSamlAuthenticationStatement *arg1 = (LassoSamlAuthenticationStatement *) 0 ;
5028
 
    char *result;
5029
 
    
5030
 
    arg1 = (LassoSamlAuthenticationStatement *)jarg1; 
5031
 
    result = (char *) ((arg1)->AuthenticationMethod);
5032
 
    
5033
 
    jresult = SWIG_csharp_string_callback(result); 
5034
 
    return jresult;
5035
 
}
5036
 
 
5037
 
 
5038
 
DllExport void SWIGSTDCALL CSharp_set_SamlAuthenticationStatement_authorityBinding(void * jarg1, void * jarg2) {
5039
 
    LassoSamlAuthenticationStatement *arg1 = (LassoSamlAuthenticationStatement *) 0 ;
5040
 
    LassoNodeList *arg2 = (LassoNodeList *) 0 ;
5041
 
    
5042
 
    arg1 = (LassoSamlAuthenticationStatement *)jarg1; 
5043
 
    arg2 = (LassoNodeList *)jarg2; 
5044
 
    LassoSamlAuthenticationStatement_set_AuthorityBinding(arg1,arg2);
5045
 
    
5046
 
}
5047
 
 
5048
 
 
5049
 
DllExport void * SWIGSTDCALL CSharp_get_SamlAuthenticationStatement_authorityBinding(void * jarg1) {
5050
 
    void * jresult = 0 ;
5051
 
    LassoSamlAuthenticationStatement *arg1 = (LassoSamlAuthenticationStatement *) 0 ;
5052
 
    LassoNodeList *result;
5053
 
    
5054
 
    arg1 = (LassoSamlAuthenticationStatement *)jarg1; 
5055
 
    result = (LassoNodeList *)LassoSamlAuthenticationStatement_get_AuthorityBinding(arg1);
5056
 
    
5057
 
    jresult = (void *)result; 
5058
 
    return jresult;
5059
 
}
5060
 
 
5061
 
 
5062
 
DllExport void SWIGSTDCALL CSharp_set_SamlAuthenticationStatement_subjectLocality(void * jarg1, void * jarg2) {
5063
 
    LassoSamlAuthenticationStatement *arg1 = (LassoSamlAuthenticationStatement *) 0 ;
5064
 
    LassoSamlSubjectLocality *arg2 = (LassoSamlSubjectLocality *) 0 ;
5065
 
    
5066
 
    arg1 = (LassoSamlAuthenticationStatement *)jarg1; 
5067
 
    arg2 = (LassoSamlSubjectLocality *)jarg2; 
5068
 
    LassoSamlAuthenticationStatement_set_SubjectLocality(arg1,arg2);
5069
 
    
5070
 
}
5071
 
 
5072
 
 
5073
 
DllExport void * SWIGSTDCALL CSharp_get_SamlAuthenticationStatement_subjectLocality(void * jarg1) {
5074
 
    void * jresult = 0 ;
5075
 
    LassoSamlAuthenticationStatement *arg1 = (LassoSamlAuthenticationStatement *) 0 ;
5076
 
    LassoSamlSubjectLocality *result;
5077
 
    
5078
 
    arg1 = (LassoSamlAuthenticationStatement *)jarg1; 
5079
 
    result = (LassoSamlSubjectLocality *)LassoSamlAuthenticationStatement_get_SubjectLocality(arg1);
5080
 
    
5081
 
    jresult = (void *)result; 
5082
 
    return jresult;
5083
 
}
5084
 
 
5085
 
 
5086
 
DllExport void * SWIGSTDCALL CSharp_new_SamlAuthenticationStatement() {
5087
 
    void * jresult = 0 ;
5088
 
    LassoSamlAuthenticationStatement *result;
5089
 
    
5090
 
    result = (LassoSamlAuthenticationStatement *)new_LassoSamlAuthenticationStatement();
5091
 
    
5092
 
    jresult = (void *)result; 
5093
 
    return jresult;
5094
 
}
5095
 
 
5096
 
 
5097
 
DllExport void SWIGSTDCALL CSharp_delete_SamlAuthenticationStatement(void * jarg1) {
5098
 
    LassoSamlAuthenticationStatement *arg1 = (LassoSamlAuthenticationStatement *) 0 ;
5099
 
    
5100
 
    arg1 = (LassoSamlAuthenticationStatement *)jarg1; 
5101
 
    delete_LassoSamlAuthenticationStatement(arg1);
5102
 
    
5103
 
}
5104
 
 
5105
 
 
5106
 
DllExport char * SWIGSTDCALL CSharp_SamlAuthenticationStatement_dump(void * jarg1) {
5107
 
    char * jresult = 0 ;
5108
 
    LassoSamlAuthenticationStatement *arg1 = (LassoSamlAuthenticationStatement *) 0 ;
5109
 
    char *result;
5110
 
    
5111
 
    arg1 = (LassoSamlAuthenticationStatement *)jarg1; 
5112
 
    result = (char *)LassoSamlAuthenticationStatement_dump(arg1);
5113
 
    
5114
 
    jresult = SWIG_csharp_string_callback(result); 
5115
 
    free(result);
5116
 
    return jresult;
5117
 
}
5118
 
 
5119
 
 
5120
 
DllExport void SWIGSTDCALL CSharp_set_SamlAuthorityBinding_authorityKind(void * jarg1, char * jarg2) {
5121
 
    LassoSamlAuthorityBinding *arg1 = (LassoSamlAuthorityBinding *) 0 ;
5122
 
    char *arg2 = (char *) 0 ;
5123
 
    
5124
 
    arg1 = (LassoSamlAuthorityBinding *)jarg1; 
5125
 
    arg2 = jarg2; 
5126
 
    {
5127
 
        if (arg1->AuthorityKind) free((char*)arg1->AuthorityKind);
5128
 
        if (arg2) {
5129
 
            arg1->AuthorityKind = (char *) malloc(strlen(arg2)+1);
5130
 
            strcpy((char*)arg1->AuthorityKind,arg2);
5131
 
        } else {
5132
 
            arg1->AuthorityKind = 0;
5133
 
        }
5134
 
    }
5135
 
}
5136
 
 
5137
 
 
5138
 
DllExport char * SWIGSTDCALL CSharp_get_SamlAuthorityBinding_authorityKind(void * jarg1) {
5139
 
    char * jresult = 0 ;
5140
 
    LassoSamlAuthorityBinding *arg1 = (LassoSamlAuthorityBinding *) 0 ;
5141
 
    char *result;
5142
 
    
5143
 
    arg1 = (LassoSamlAuthorityBinding *)jarg1; 
5144
 
    result = (char *) ((arg1)->AuthorityKind);
5145
 
    
5146
 
    jresult = SWIG_csharp_string_callback(result); 
5147
 
    return jresult;
5148
 
}
5149
 
 
5150
 
 
5151
 
DllExport void SWIGSTDCALL CSharp_set_SamlAuthorityBinding_location(void * jarg1, char * jarg2) {
5152
 
    LassoSamlAuthorityBinding *arg1 = (LassoSamlAuthorityBinding *) 0 ;
5153
 
    char *arg2 = (char *) 0 ;
5154
 
    
5155
 
    arg1 = (LassoSamlAuthorityBinding *)jarg1; 
5156
 
    arg2 = jarg2; 
5157
 
    {
5158
 
        if (arg1->Location) free((char*)arg1->Location);
5159
 
        if (arg2) {
5160
 
            arg1->Location = (char *) malloc(strlen(arg2)+1);
5161
 
            strcpy((char*)arg1->Location,arg2);
5162
 
        } else {
5163
 
            arg1->Location = 0;
5164
 
        }
5165
 
    }
5166
 
}
5167
 
 
5168
 
 
5169
 
DllExport char * SWIGSTDCALL CSharp_get_SamlAuthorityBinding_location(void * jarg1) {
5170
 
    char * jresult = 0 ;
5171
 
    LassoSamlAuthorityBinding *arg1 = (LassoSamlAuthorityBinding *) 0 ;
5172
 
    char *result;
5173
 
    
5174
 
    arg1 = (LassoSamlAuthorityBinding *)jarg1; 
5175
 
    result = (char *) ((arg1)->Location);
5176
 
    
5177
 
    jresult = SWIG_csharp_string_callback(result); 
5178
 
    return jresult;
5179
 
}
5180
 
 
5181
 
 
5182
 
DllExport void SWIGSTDCALL CSharp_set_SamlAuthorityBinding_binding(void * jarg1, char * jarg2) {
5183
 
    LassoSamlAuthorityBinding *arg1 = (LassoSamlAuthorityBinding *) 0 ;
5184
 
    char *arg2 = (char *) 0 ;
5185
 
    
5186
 
    arg1 = (LassoSamlAuthorityBinding *)jarg1; 
5187
 
    arg2 = jarg2; 
5188
 
    {
5189
 
        if (arg1->Binding) free((char*)arg1->Binding);
5190
 
        if (arg2) {
5191
 
            arg1->Binding = (char *) malloc(strlen(arg2)+1);
5192
 
            strcpy((char*)arg1->Binding,arg2);
5193
 
        } else {
5194
 
            arg1->Binding = 0;
5195
 
        }
5196
 
    }
5197
 
}
5198
 
 
5199
 
 
5200
 
DllExport char * SWIGSTDCALL CSharp_get_SamlAuthorityBinding_binding(void * jarg1) {
5201
 
    char * jresult = 0 ;
5202
 
    LassoSamlAuthorityBinding *arg1 = (LassoSamlAuthorityBinding *) 0 ;
5203
 
    char *result;
5204
 
    
5205
 
    arg1 = (LassoSamlAuthorityBinding *)jarg1; 
5206
 
    result = (char *) ((arg1)->Binding);
5207
 
    
5208
 
    jresult = SWIG_csharp_string_callback(result); 
5209
 
    return jresult;
5210
 
}
5211
 
 
5212
 
 
5213
 
DllExport void * SWIGSTDCALL CSharp_new_SamlAuthorityBinding() {
5214
 
    void * jresult = 0 ;
5215
 
    LassoSamlAuthorityBinding *result;
5216
 
    
5217
 
    result = (LassoSamlAuthorityBinding *)new_LassoSamlAuthorityBinding();
5218
 
    
5219
 
    jresult = (void *)result; 
5220
 
    return jresult;
5221
 
}
5222
 
 
5223
 
 
5224
 
DllExport void SWIGSTDCALL CSharp_delete_SamlAuthorityBinding(void * jarg1) {
5225
 
    LassoSamlAuthorityBinding *arg1 = (LassoSamlAuthorityBinding *) 0 ;
5226
 
    
5227
 
    arg1 = (LassoSamlAuthorityBinding *)jarg1; 
5228
 
    delete_LassoSamlAuthorityBinding(arg1);
5229
 
    
5230
 
}
5231
 
 
5232
 
 
5233
 
DllExport char * SWIGSTDCALL CSharp_SamlAuthorityBinding_dump(void * jarg1) {
5234
 
    char * jresult = 0 ;
5235
 
    LassoSamlAuthorityBinding *arg1 = (LassoSamlAuthorityBinding *) 0 ;
5236
 
    char *result;
5237
 
    
5238
 
    arg1 = (LassoSamlAuthorityBinding *)jarg1; 
5239
 
    result = (char *)LassoSamlAuthorityBinding_dump(arg1);
5240
 
    
5241
 
    jresult = SWIG_csharp_string_callback(result); 
5242
 
    free(result);
5243
 
    return jresult;
5244
 
}
5245
 
 
5246
 
 
5247
 
DllExport char * SWIGSTDCALL CSharp_SamlConditionAbstract_dump(void * jarg1) {
5248
 
    char * jresult = 0 ;
5249
 
    LassoSamlConditionAbstract *arg1 = (LassoSamlConditionAbstract *) 0 ;
5250
 
    char *result;
5251
 
    
5252
 
    arg1 = (LassoSamlConditionAbstract *)jarg1; 
5253
 
    result = (char *)LassoSamlConditionAbstract_dump(arg1);
5254
 
    
5255
 
    jresult = SWIG_csharp_string_callback(result); 
5256
 
    free(result);
5257
 
    return jresult;
5258
 
}
5259
 
 
5260
 
 
5261
 
DllExport void SWIGSTDCALL CSharp_set_SamlConditions_notBefore(void * jarg1, char * jarg2) {
5262
 
    LassoSamlConditions *arg1 = (LassoSamlConditions *) 0 ;
5263
 
    char *arg2 = (char *) 0 ;
5264
 
    
5265
 
    arg1 = (LassoSamlConditions *)jarg1; 
5266
 
    arg2 = jarg2; 
5267
 
    {
5268
 
        if (arg1->NotBefore) free((char*)arg1->NotBefore);
5269
 
        if (arg2) {
5270
 
            arg1->NotBefore = (char *) malloc(strlen(arg2)+1);
5271
 
            strcpy((char*)arg1->NotBefore,arg2);
5272
 
        } else {
5273
 
            arg1->NotBefore = 0;
5274
 
        }
5275
 
    }
5276
 
}
5277
 
 
5278
 
 
5279
 
DllExport char * SWIGSTDCALL CSharp_get_SamlConditions_notBefore(void * jarg1) {
5280
 
    char * jresult = 0 ;
5281
 
    LassoSamlConditions *arg1 = (LassoSamlConditions *) 0 ;
5282
 
    char *result;
5283
 
    
5284
 
    arg1 = (LassoSamlConditions *)jarg1; 
5285
 
    result = (char *) ((arg1)->NotBefore);
5286
 
    
5287
 
    jresult = SWIG_csharp_string_callback(result); 
5288
 
    return jresult;
5289
 
}
5290
 
 
5291
 
 
5292
 
DllExport void SWIGSTDCALL CSharp_set_SamlConditions_notOnOrAfter(void * jarg1, char * jarg2) {
5293
 
    LassoSamlConditions *arg1 = (LassoSamlConditions *) 0 ;
5294
 
    char *arg2 = (char *) 0 ;
5295
 
    
5296
 
    arg1 = (LassoSamlConditions *)jarg1; 
5297
 
    arg2 = jarg2; 
5298
 
    {
5299
 
        if (arg1->NotOnOrAfter) free((char*)arg1->NotOnOrAfter);
5300
 
        if (arg2) {
5301
 
            arg1->NotOnOrAfter = (char *) malloc(strlen(arg2)+1);
5302
 
            strcpy((char*)arg1->NotOnOrAfter,arg2);
5303
 
        } else {
5304
 
            arg1->NotOnOrAfter = 0;
5305
 
        }
5306
 
    }
5307
 
}
5308
 
 
5309
 
 
5310
 
DllExport char * SWIGSTDCALL CSharp_get_SamlConditions_notOnOrAfter(void * jarg1) {
5311
 
    char * jresult = 0 ;
5312
 
    LassoSamlConditions *arg1 = (LassoSamlConditions *) 0 ;
5313
 
    char *result;
5314
 
    
5315
 
    arg1 = (LassoSamlConditions *)jarg1; 
5316
 
    result = (char *) ((arg1)->NotOnOrAfter);
5317
 
    
5318
 
    jresult = SWIG_csharp_string_callback(result); 
5319
 
    return jresult;
5320
 
}
5321
 
 
5322
 
 
5323
 
DllExport void SWIGSTDCALL CSharp_set_SamlConditions_audienceRestrictionCondition(void * jarg1, void * jarg2) {
5324
 
    LassoSamlConditions *arg1 = (LassoSamlConditions *) 0 ;
5325
 
    LassoNodeList *arg2 = (LassoNodeList *) 0 ;
5326
 
    
5327
 
    arg1 = (LassoSamlConditions *)jarg1; 
5328
 
    arg2 = (LassoNodeList *)jarg2; 
5329
 
    LassoSamlConditions_set_AudienceRestrictionCondition(arg1,arg2);
5330
 
    
5331
 
}
5332
 
 
5333
 
 
5334
 
DllExport void * SWIGSTDCALL CSharp_get_SamlConditions_audienceRestrictionCondition(void * jarg1) {
5335
 
    void * jresult = 0 ;
5336
 
    LassoSamlConditions *arg1 = (LassoSamlConditions *) 0 ;
5337
 
    LassoNodeList *result;
5338
 
    
5339
 
    arg1 = (LassoSamlConditions *)jarg1; 
5340
 
    result = (LassoNodeList *)LassoSamlConditions_get_AudienceRestrictionCondition(arg1);
5341
 
    
5342
 
    jresult = (void *)result; 
5343
 
    return jresult;
5344
 
}
5345
 
 
5346
 
 
5347
 
DllExport void SWIGSTDCALL CSharp_set_SamlConditions_condition(void * jarg1, void * jarg2) {
5348
 
    LassoSamlConditions *arg1 = (LassoSamlConditions *) 0 ;
5349
 
    LassoNodeList *arg2 = (LassoNodeList *) 0 ;
5350
 
    
5351
 
    arg1 = (LassoSamlConditions *)jarg1; 
5352
 
    arg2 = (LassoNodeList *)jarg2; 
5353
 
    LassoSamlConditions_set_Condition(arg1,arg2);
5354
 
    
5355
 
}
5356
 
 
5357
 
 
5358
 
DllExport void * SWIGSTDCALL CSharp_get_SamlConditions_condition(void * jarg1) {
5359
 
    void * jresult = 0 ;
5360
 
    LassoSamlConditions *arg1 = (LassoSamlConditions *) 0 ;
5361
 
    LassoNodeList *result;
5362
 
    
5363
 
    arg1 = (LassoSamlConditions *)jarg1; 
5364
 
    result = (LassoNodeList *)LassoSamlConditions_get_Condition(arg1);
5365
 
    
5366
 
    jresult = (void *)result; 
5367
 
    return jresult;
5368
 
}
5369
 
 
5370
 
 
5371
 
DllExport void * SWIGSTDCALL CSharp_new_SamlConditions() {
5372
 
    void * jresult = 0 ;
5373
 
    LassoSamlConditions *result;
5374
 
    
5375
 
    result = (LassoSamlConditions *)new_LassoSamlConditions();
5376
 
    
5377
 
    jresult = (void *)result; 
5378
 
    return jresult;
5379
 
}
5380
 
 
5381
 
 
5382
 
DllExport void SWIGSTDCALL CSharp_delete_SamlConditions(void * jarg1) {
5383
 
    LassoSamlConditions *arg1 = (LassoSamlConditions *) 0 ;
5384
 
    
5385
 
    arg1 = (LassoSamlConditions *)jarg1; 
5386
 
    delete_LassoSamlConditions(arg1);
5387
 
    
5388
 
}
5389
 
 
5390
 
 
5391
 
DllExport char * SWIGSTDCALL CSharp_SamlConditions_dump(void * jarg1) {
5392
 
    char * jresult = 0 ;
5393
 
    LassoSamlConditions *arg1 = (LassoSamlConditions *) 0 ;
5394
 
    char *result;
5395
 
    
5396
 
    arg1 = (LassoSamlConditions *)jarg1; 
5397
 
    result = (char *)LassoSamlConditions_dump(arg1);
5398
 
    
5399
 
    jresult = SWIG_csharp_string_callback(result); 
5400
 
    free(result);
5401
 
    return jresult;
5402
 
}
5403
 
 
5404
 
 
5405
 
DllExport void SWIGSTDCALL CSharp_set_SamlNameIdentifier_content(void * jarg1, char * jarg2) {
5406
 
    LassoSamlNameIdentifier *arg1 = (LassoSamlNameIdentifier *) 0 ;
5407
 
    char *arg2 = (char *) 0 ;
5408
 
    
5409
 
    arg1 = (LassoSamlNameIdentifier *)jarg1; 
5410
 
    arg2 = jarg2; 
5411
 
    {
5412
 
        if (arg1->content) free((char*)arg1->content);
5413
 
        if (arg2) {
5414
 
            arg1->content = (char *) malloc(strlen(arg2)+1);
5415
 
            strcpy((char*)arg1->content,arg2);
5416
 
        } else {
5417
 
            arg1->content = 0;
5418
 
        }
5419
 
    }
5420
 
}
5421
 
 
5422
 
 
5423
 
DllExport char * SWIGSTDCALL CSharp_get_SamlNameIdentifier_content(void * jarg1) {
5424
 
    char * jresult = 0 ;
5425
 
    LassoSamlNameIdentifier *arg1 = (LassoSamlNameIdentifier *) 0 ;
5426
 
    char *result;
5427
 
    
5428
 
    arg1 = (LassoSamlNameIdentifier *)jarg1; 
5429
 
    result = (char *) ((arg1)->content);
5430
 
    
5431
 
    jresult = SWIG_csharp_string_callback(result); 
5432
 
    return jresult;
5433
 
}
5434
 
 
5435
 
 
5436
 
DllExport void SWIGSTDCALL CSharp_set_SamlNameIdentifier_format(void * jarg1, char * jarg2) {
5437
 
    LassoSamlNameIdentifier *arg1 = (LassoSamlNameIdentifier *) 0 ;
5438
 
    char *arg2 = (char *) 0 ;
5439
 
    
5440
 
    arg1 = (LassoSamlNameIdentifier *)jarg1; 
5441
 
    arg2 = jarg2; 
5442
 
    {
5443
 
        if (arg1->Format) free((char*)arg1->Format);
5444
 
        if (arg2) {
5445
 
            arg1->Format = (char *) malloc(strlen(arg2)+1);
5446
 
            strcpy((char*)arg1->Format,arg2);
5447
 
        } else {
5448
 
            arg1->Format = 0;
5449
 
        }
5450
 
    }
5451
 
}
5452
 
 
5453
 
 
5454
 
DllExport char * SWIGSTDCALL CSharp_get_SamlNameIdentifier_format(void * jarg1) {
5455
 
    char * jresult = 0 ;
5456
 
    LassoSamlNameIdentifier *arg1 = (LassoSamlNameIdentifier *) 0 ;
5457
 
    char *result;
5458
 
    
5459
 
    arg1 = (LassoSamlNameIdentifier *)jarg1; 
5460
 
    result = (char *) ((arg1)->Format);
5461
 
    
5462
 
    jresult = SWIG_csharp_string_callback(result); 
5463
 
    return jresult;
5464
 
}
5465
 
 
5466
 
 
5467
 
DllExport void SWIGSTDCALL CSharp_set_SamlNameIdentifier_nameQualifier(void * jarg1, char * jarg2) {
5468
 
    LassoSamlNameIdentifier *arg1 = (LassoSamlNameIdentifier *) 0 ;
5469
 
    char *arg2 = (char *) 0 ;
5470
 
    
5471
 
    arg1 = (LassoSamlNameIdentifier *)jarg1; 
5472
 
    arg2 = jarg2; 
5473
 
    {
5474
 
        if (arg1->NameQualifier) free((char*)arg1->NameQualifier);
5475
 
        if (arg2) {
5476
 
            arg1->NameQualifier = (char *) malloc(strlen(arg2)+1);
5477
 
            strcpy((char*)arg1->NameQualifier,arg2);
5478
 
        } else {
5479
 
            arg1->NameQualifier = 0;
5480
 
        }
5481
 
    }
5482
 
}
5483
 
 
5484
 
 
5485
 
DllExport char * SWIGSTDCALL CSharp_get_SamlNameIdentifier_nameQualifier(void * jarg1) {
5486
 
    char * jresult = 0 ;
5487
 
    LassoSamlNameIdentifier *arg1 = (LassoSamlNameIdentifier *) 0 ;
5488
 
    char *result;
5489
 
    
5490
 
    arg1 = (LassoSamlNameIdentifier *)jarg1; 
5491
 
    result = (char *) ((arg1)->NameQualifier);
5492
 
    
5493
 
    jresult = SWIG_csharp_string_callback(result); 
5494
 
    return jresult;
5495
 
}
5496
 
 
5497
 
 
5498
 
DllExport void * SWIGSTDCALL CSharp_new_SamlNameIdentifier() {
5499
 
    void * jresult = 0 ;
5500
 
    LassoSamlNameIdentifier *result;
5501
 
    
5502
 
    result = (LassoSamlNameIdentifier *)new_LassoSamlNameIdentifier();
5503
 
    
5504
 
    jresult = (void *)result; 
5505
 
    return jresult;
5506
 
}
5507
 
 
5508
 
 
5509
 
DllExport void SWIGSTDCALL CSharp_delete_SamlNameIdentifier(void * jarg1) {
5510
 
    LassoSamlNameIdentifier *arg1 = (LassoSamlNameIdentifier *) 0 ;
5511
 
    
5512
 
    arg1 = (LassoSamlNameIdentifier *)jarg1; 
5513
 
    delete_LassoSamlNameIdentifier(arg1);
5514
 
    
5515
 
}
5516
 
 
5517
 
 
5518
 
DllExport char * SWIGSTDCALL CSharp_SamlNameIdentifier_dump(void * jarg1) {
5519
 
    char * jresult = 0 ;
5520
 
    LassoSamlNameIdentifier *arg1 = (LassoSamlNameIdentifier *) 0 ;
5521
 
    char *result;
5522
 
    
5523
 
    arg1 = (LassoSamlNameIdentifier *)jarg1; 
5524
 
    result = (char *)LassoSamlNameIdentifier_dump(arg1);
5525
 
    
5526
 
    jresult = SWIG_csharp_string_callback(result); 
5527
 
    free(result);
5528
 
    return jresult;
5529
 
}
5530
 
 
5531
 
 
5532
 
DllExport char * SWIGSTDCALL CSharp_SamlStatementAbstract_dump(void * jarg1) {
5533
 
    char * jresult = 0 ;
5534
 
    LassoSamlStatementAbstract *arg1 = (LassoSamlStatementAbstract *) 0 ;
5535
 
    char *result;
5536
 
    
5537
 
    arg1 = (LassoSamlStatementAbstract *)jarg1; 
5538
 
    result = (char *)LassoSamlStatementAbstract_dump(arg1);
5539
 
    
5540
 
    jresult = SWIG_csharp_string_callback(result); 
5541
 
    free(result);
5542
 
    return jresult;
5543
 
}
5544
 
 
5545
 
 
5546
 
DllExport void SWIGSTDCALL CSharp_set_SamlSubject_nameIdentifier(void * jarg1, void * jarg2) {
5547
 
    LassoSamlSubject *arg1 = (LassoSamlSubject *) 0 ;
5548
 
    LassoSamlNameIdentifier *arg2 = (LassoSamlNameIdentifier *) 0 ;
5549
 
    
5550
 
    arg1 = (LassoSamlSubject *)jarg1; 
5551
 
    arg2 = (LassoSamlNameIdentifier *)jarg2; 
5552
 
    LassoSamlSubject_set_NameIdentifier(arg1,arg2);
5553
 
    
5554
 
}
5555
 
 
5556
 
 
5557
 
DllExport void * SWIGSTDCALL CSharp_get_SamlSubject_nameIdentifier(void * jarg1) {
5558
 
    void * jresult = 0 ;
5559
 
    LassoSamlSubject *arg1 = (LassoSamlSubject *) 0 ;
5560
 
    LassoSamlNameIdentifier *result;
5561
 
    
5562
 
    arg1 = (LassoSamlSubject *)jarg1; 
5563
 
    result = (LassoSamlNameIdentifier *)LassoSamlSubject_get_NameIdentifier(arg1);
5564
 
    
5565
 
    jresult = (void *)result; 
5566
 
    return jresult;
5567
 
}
5568
 
 
5569
 
 
5570
 
DllExport void SWIGSTDCALL CSharp_set_SamlSubject_subjectConfirmation(void * jarg1, void * jarg2) {
5571
 
    LassoSamlSubject *arg1 = (LassoSamlSubject *) 0 ;
5572
 
    LassoSamlSubjectConfirmation *arg2 = (LassoSamlSubjectConfirmation *) 0 ;
5573
 
    
5574
 
    arg1 = (LassoSamlSubject *)jarg1; 
5575
 
    arg2 = (LassoSamlSubjectConfirmation *)jarg2; 
5576
 
    LassoSamlSubject_set_SubjectConfirmation(arg1,arg2);
5577
 
    
5578
 
}
5579
 
 
5580
 
 
5581
 
DllExport void * SWIGSTDCALL CSharp_get_SamlSubject_subjectConfirmation(void * jarg1) {
5582
 
    void * jresult = 0 ;
5583
 
    LassoSamlSubject *arg1 = (LassoSamlSubject *) 0 ;
5584
 
    LassoSamlSubjectConfirmation *result;
5585
 
    
5586
 
    arg1 = (LassoSamlSubject *)jarg1; 
5587
 
    result = (LassoSamlSubjectConfirmation *)LassoSamlSubject_get_SubjectConfirmation(arg1);
5588
 
    
5589
 
    jresult = (void *)result; 
5590
 
    return jresult;
5591
 
}
5592
 
 
5593
 
 
5594
 
DllExport void * SWIGSTDCALL CSharp_new_SamlSubject() {
5595
 
    void * jresult = 0 ;
5596
 
    LassoSamlSubject *result;
5597
 
    
5598
 
    result = (LassoSamlSubject *)new_LassoSamlSubject();
5599
 
    
5600
 
    jresult = (void *)result; 
5601
 
    return jresult;
5602
 
}
5603
 
 
5604
 
 
5605
 
DllExport void SWIGSTDCALL CSharp_delete_SamlSubject(void * jarg1) {
5606
 
    LassoSamlSubject *arg1 = (LassoSamlSubject *) 0 ;
5607
 
    
5608
 
    arg1 = (LassoSamlSubject *)jarg1; 
5609
 
    delete_LassoSamlSubject(arg1);
5610
 
    
5611
 
}
5612
 
 
5613
 
 
5614
 
DllExport char * SWIGSTDCALL CSharp_SamlSubject_dump(void * jarg1) {
5615
 
    char * jresult = 0 ;
5616
 
    LassoSamlSubject *arg1 = (LassoSamlSubject *) 0 ;
5617
 
    char *result;
5618
 
    
5619
 
    arg1 = (LassoSamlSubject *)jarg1; 
5620
 
    result = (char *)LassoSamlSubject_dump(arg1);
5621
 
    
5622
 
    jresult = SWIG_csharp_string_callback(result); 
5623
 
    free(result);
5624
 
    return jresult;
5625
 
}
5626
 
 
5627
 
 
5628
 
DllExport void SWIGSTDCALL CSharp_set_SamlSubjectConfirmation_subjectConfirmationData(void * jarg1, char * jarg2) {
5629
 
    LassoSamlSubjectConfirmation *arg1 = (LassoSamlSubjectConfirmation *) 0 ;
5630
 
    char *arg2 = (char *) 0 ;
5631
 
    
5632
 
    arg1 = (LassoSamlSubjectConfirmation *)jarg1; 
5633
 
    arg2 = jarg2; 
5634
 
    {
5635
 
        if (arg1->SubjectConfirmationData) free((char*)arg1->SubjectConfirmationData);
5636
 
        if (arg2) {
5637
 
            arg1->SubjectConfirmationData = (char *) malloc(strlen(arg2)+1);
5638
 
            strcpy((char*)arg1->SubjectConfirmationData,arg2);
5639
 
        } else {
5640
 
            arg1->SubjectConfirmationData = 0;
5641
 
        }
5642
 
    }
5643
 
}
5644
 
 
5645
 
 
5646
 
DllExport char * SWIGSTDCALL CSharp_get_SamlSubjectConfirmation_subjectConfirmationData(void * jarg1) {
5647
 
    char * jresult = 0 ;
5648
 
    LassoSamlSubjectConfirmation *arg1 = (LassoSamlSubjectConfirmation *) 0 ;
5649
 
    char *result;
5650
 
    
5651
 
    arg1 = (LassoSamlSubjectConfirmation *)jarg1; 
5652
 
    result = (char *) ((arg1)->SubjectConfirmationData);
5653
 
    
5654
 
    jresult = SWIG_csharp_string_callback(result); 
5655
 
    return jresult;
5656
 
}
5657
 
 
5658
 
 
5659
 
DllExport void SWIGSTDCALL CSharp_set_SamlSubjectConfirmation_confirmationMethod(void * jarg1, void * jarg2) {
5660
 
    LassoSamlSubjectConfirmation *arg1 = (LassoSamlSubjectConfirmation *) 0 ;
5661
 
    LassoStringList *arg2 = (LassoStringList *) 0 ;
5662
 
    
5663
 
    arg1 = (LassoSamlSubjectConfirmation *)jarg1; 
5664
 
    arg2 = (LassoStringList *)jarg2; 
5665
 
    LassoSamlSubjectConfirmation_set_confirmationMethod(arg1,arg2);
5666
 
    
5667
 
}
5668
 
 
5669
 
 
5670
 
DllExport void * SWIGSTDCALL CSharp_get_SamlSubjectConfirmation_confirmationMethod(void * jarg1) {
5671
 
    void * jresult = 0 ;
5672
 
    LassoSamlSubjectConfirmation *arg1 = (LassoSamlSubjectConfirmation *) 0 ;
5673
 
    LassoStringList *result;
5674
 
    
5675
 
    arg1 = (LassoSamlSubjectConfirmation *)jarg1; 
5676
 
    result = (LassoStringList *)LassoSamlSubjectConfirmation_get_confirmationMethod(arg1);
5677
 
    
5678
 
    jresult = (void *)result; 
5679
 
    return jresult;
5680
 
}
5681
 
 
5682
 
 
5683
 
DllExport void * SWIGSTDCALL CSharp_new_SamlSubjectConfirmation() {
5684
 
    void * jresult = 0 ;
5685
 
    LassoSamlSubjectConfirmation *result;
5686
 
    
5687
 
    result = (LassoSamlSubjectConfirmation *)new_LassoSamlSubjectConfirmation();
5688
 
    
5689
 
    jresult = (void *)result; 
5690
 
    return jresult;
5691
 
}
5692
 
 
5693
 
 
5694
 
DllExport void SWIGSTDCALL CSharp_delete_SamlSubjectConfirmation(void * jarg1) {
5695
 
    LassoSamlSubjectConfirmation *arg1 = (LassoSamlSubjectConfirmation *) 0 ;
5696
 
    
5697
 
    arg1 = (LassoSamlSubjectConfirmation *)jarg1; 
5698
 
    delete_LassoSamlSubjectConfirmation(arg1);
5699
 
    
5700
 
}
5701
 
 
5702
 
 
5703
 
DllExport char * SWIGSTDCALL CSharp_SamlSubjectConfirmation_dump(void * jarg1) {
5704
 
    char * jresult = 0 ;
5705
 
    LassoSamlSubjectConfirmation *arg1 = (LassoSamlSubjectConfirmation *) 0 ;
5706
 
    char *result;
5707
 
    
5708
 
    arg1 = (LassoSamlSubjectConfirmation *)jarg1; 
5709
 
    result = (char *)LassoSamlSubjectConfirmation_dump(arg1);
5710
 
    
5711
 
    jresult = SWIG_csharp_string_callback(result); 
5712
 
    free(result);
5713
 
    return jresult;
5714
 
}
5715
 
 
5716
 
 
5717
 
DllExport void SWIGSTDCALL CSharp_set_SamlSubjectLocality_dnsAddress(void * jarg1, char * jarg2) {
5718
 
    LassoSamlSubjectLocality *arg1 = (LassoSamlSubjectLocality *) 0 ;
5719
 
    char *arg2 = (char *) 0 ;
5720
 
    
5721
 
    arg1 = (LassoSamlSubjectLocality *)jarg1; 
5722
 
    arg2 = jarg2; 
5723
 
    {
5724
 
        if (arg1->DNSAddress) free((char*)arg1->DNSAddress);
5725
 
        if (arg2) {
5726
 
            arg1->DNSAddress = (char *) malloc(strlen(arg2)+1);
5727
 
            strcpy((char*)arg1->DNSAddress,arg2);
5728
 
        } else {
5729
 
            arg1->DNSAddress = 0;
5730
 
        }
5731
 
    }
5732
 
}
5733
 
 
5734
 
 
5735
 
DllExport char * SWIGSTDCALL CSharp_get_SamlSubjectLocality_dnsAddress(void * jarg1) {
5736
 
    char * jresult = 0 ;
5737
 
    LassoSamlSubjectLocality *arg1 = (LassoSamlSubjectLocality *) 0 ;
5738
 
    char *result;
5739
 
    
5740
 
    arg1 = (LassoSamlSubjectLocality *)jarg1; 
5741
 
    result = (char *) ((arg1)->DNSAddress);
5742
 
    
5743
 
    jresult = SWIG_csharp_string_callback(result); 
5744
 
    return jresult;
5745
 
}
5746
 
 
5747
 
 
5748
 
DllExport void SWIGSTDCALL CSharp_set_SamlSubjectLocality_ipAddress(void * jarg1, char * jarg2) {
5749
 
    LassoSamlSubjectLocality *arg1 = (LassoSamlSubjectLocality *) 0 ;
5750
 
    char *arg2 = (char *) 0 ;
5751
 
    
5752
 
    arg1 = (LassoSamlSubjectLocality *)jarg1; 
5753
 
    arg2 = jarg2; 
5754
 
    {
5755
 
        if (arg1->IPAddress) free((char*)arg1->IPAddress);
5756
 
        if (arg2) {
5757
 
            arg1->IPAddress = (char *) malloc(strlen(arg2)+1);
5758
 
            strcpy((char*)arg1->IPAddress,arg2);
5759
 
        } else {
5760
 
            arg1->IPAddress = 0;
5761
 
        }
5762
 
    }
5763
 
}
5764
 
 
5765
 
 
5766
 
DllExport char * SWIGSTDCALL CSharp_get_SamlSubjectLocality_ipAddress(void * jarg1) {
5767
 
    char * jresult = 0 ;
5768
 
    LassoSamlSubjectLocality *arg1 = (LassoSamlSubjectLocality *) 0 ;
5769
 
    char *result;
5770
 
    
5771
 
    arg1 = (LassoSamlSubjectLocality *)jarg1; 
5772
 
    result = (char *) ((arg1)->IPAddress);
5773
 
    
5774
 
    jresult = SWIG_csharp_string_callback(result); 
5775
 
    return jresult;
5776
 
}
5777
 
 
5778
 
 
5779
 
DllExport void * SWIGSTDCALL CSharp_new_SamlSubjectLocality() {
5780
 
    void * jresult = 0 ;
5781
 
    LassoSamlSubjectLocality *result;
5782
 
    
5783
 
    result = (LassoSamlSubjectLocality *)new_LassoSamlSubjectLocality();
5784
 
    
5785
 
    jresult = (void *)result; 
5786
 
    return jresult;
5787
 
}
5788
 
 
5789
 
 
5790
 
DllExport void SWIGSTDCALL CSharp_delete_SamlSubjectLocality(void * jarg1) {
5791
 
    LassoSamlSubjectLocality *arg1 = (LassoSamlSubjectLocality *) 0 ;
5792
 
    
5793
 
    arg1 = (LassoSamlSubjectLocality *)jarg1; 
5794
 
    delete_LassoSamlSubjectLocality(arg1);
5795
 
    
5796
 
}
5797
 
 
5798
 
 
5799
 
DllExport char * SWIGSTDCALL CSharp_SamlSubjectLocality_dump(void * jarg1) {
5800
 
    char * jresult = 0 ;
5801
 
    LassoSamlSubjectLocality *arg1 = (LassoSamlSubjectLocality *) 0 ;
5802
 
    char *result;
5803
 
    
5804
 
    arg1 = (LassoSamlSubjectLocality *)jarg1; 
5805
 
    result = (char *)LassoSamlSubjectLocality_dump(arg1);
5806
 
    
5807
 
    jresult = SWIG_csharp_string_callback(result); 
5808
 
    free(result);
5809
 
    return jresult;
5810
 
}
5811
 
 
5812
 
 
5813
 
DllExport void SWIGSTDCALL CSharp_set_SamlSubjectStatement_subject(void * jarg1, void * jarg2) {
5814
 
    LassoSamlSubjectStatement *arg1 = (LassoSamlSubjectStatement *) 0 ;
5815
 
    LassoSamlSubject *arg2 = (LassoSamlSubject *) 0 ;
5816
 
    
5817
 
    arg1 = (LassoSamlSubjectStatement *)jarg1; 
5818
 
    arg2 = (LassoSamlSubject *)jarg2; 
5819
 
    LassoSamlSubjectStatement_set_Subject(arg1,arg2);
5820
 
    
5821
 
}
5822
 
 
5823
 
 
5824
 
DllExport void * SWIGSTDCALL CSharp_get_SamlSubjectStatement_subject(void * jarg1) {
5825
 
    void * jresult = 0 ;
5826
 
    LassoSamlSubjectStatement *arg1 = (LassoSamlSubjectStatement *) 0 ;
5827
 
    LassoSamlSubject *result;
5828
 
    
5829
 
    arg1 = (LassoSamlSubjectStatement *)jarg1; 
5830
 
    result = (LassoSamlSubject *)LassoSamlSubjectStatement_get_Subject(arg1);
5831
 
    
5832
 
    jresult = (void *)result; 
5833
 
    return jresult;
5834
 
}
5835
 
 
5836
 
 
5837
 
DllExport void * SWIGSTDCALL CSharp_new_SamlSubjectStatement() {
5838
 
    void * jresult = 0 ;
5839
 
    LassoSamlSubjectStatement *result;
5840
 
    
5841
 
    result = (LassoSamlSubjectStatement *)new_LassoSamlSubjectStatement();
5842
 
    
5843
 
    jresult = (void *)result; 
5844
 
    return jresult;
5845
 
}
5846
 
 
5847
 
 
5848
 
DllExport void SWIGSTDCALL CSharp_delete_SamlSubjectStatement(void * jarg1) {
5849
 
    LassoSamlSubjectStatement *arg1 = (LassoSamlSubjectStatement *) 0 ;
5850
 
    
5851
 
    arg1 = (LassoSamlSubjectStatement *)jarg1; 
5852
 
    delete_LassoSamlSubjectStatement(arg1);
5853
 
    
5854
 
}
5855
 
 
5856
 
 
5857
 
DllExport char * SWIGSTDCALL CSharp_SamlSubjectStatement_dump(void * jarg1) {
5858
 
    char * jresult = 0 ;
5859
 
    LassoSamlSubjectStatement *arg1 = (LassoSamlSubjectStatement *) 0 ;
5860
 
    char *result;
5861
 
    
5862
 
    arg1 = (LassoSamlSubjectStatement *)jarg1; 
5863
 
    result = (char *)LassoSamlSubjectStatement_dump(arg1);
5864
 
    
5865
 
    jresult = SWIG_csharp_string_callback(result); 
5866
 
    free(result);
5867
 
    return jresult;
5868
 
}
5869
 
 
5870
 
 
5871
 
DllExport void SWIGSTDCALL CSharp_set_SamlSubjectStatementAbstract_subject(void * jarg1, void * jarg2) {
5872
 
    LassoSamlSubjectStatementAbstract *arg1 = (LassoSamlSubjectStatementAbstract *) 0 ;
5873
 
    LassoSamlSubject *arg2 = (LassoSamlSubject *) 0 ;
5874
 
    
5875
 
    arg1 = (LassoSamlSubjectStatementAbstract *)jarg1; 
5876
 
    arg2 = (LassoSamlSubject *)jarg2; 
5877
 
    LassoSamlSubjectStatementAbstract_set_Subject(arg1,arg2);
5878
 
    
5879
 
}
5880
 
 
5881
 
 
5882
 
DllExport void * SWIGSTDCALL CSharp_get_SamlSubjectStatementAbstract_subject(void * jarg1) {
5883
 
    void * jresult = 0 ;
5884
 
    LassoSamlSubjectStatementAbstract *arg1 = (LassoSamlSubjectStatementAbstract *) 0 ;
5885
 
    LassoSamlSubject *result;
5886
 
    
5887
 
    arg1 = (LassoSamlSubjectStatementAbstract *)jarg1; 
5888
 
    result = (LassoSamlSubject *)LassoSamlSubjectStatementAbstract_get_Subject(arg1);
5889
 
    
5890
 
    jresult = (void *)result; 
5891
 
    return jresult;
5892
 
}
5893
 
 
5894
 
 
5895
 
DllExport char * SWIGSTDCALL CSharp_SamlSubjectStatementAbstract_dump(void * jarg1) {
5896
 
    char * jresult = 0 ;
5897
 
    LassoSamlSubjectStatementAbstract *arg1 = (LassoSamlSubjectStatementAbstract *) 0 ;
5898
 
    char *result;
5899
 
    
5900
 
    arg1 = (LassoSamlSubjectStatementAbstract *)jarg1; 
5901
 
    result = (char *)LassoSamlSubjectStatementAbstract_dump(arg1);
5902
 
    
5903
 
    jresult = SWIG_csharp_string_callback(result); 
5904
 
    free(result);
5905
 
    return jresult;
5906
 
}
5907
 
 
5908
 
 
5909
 
DllExport void SWIGSTDCALL CSharp_set_SamlpRequest_assertionArtifact(void * jarg1, char * jarg2) {
5910
 
    LassoSamlpRequest *arg1 = (LassoSamlpRequest *) 0 ;
5911
 
    char *arg2 = (char *) 0 ;
5912
 
    
5913
 
    arg1 = (LassoSamlpRequest *)jarg1; 
5914
 
    arg2 = jarg2; 
5915
 
    {
5916
 
        if (arg1->AssertionArtifact) free((char*)arg1->AssertionArtifact);
5917
 
        if (arg2) {
5918
 
            arg1->AssertionArtifact = (char *) malloc(strlen(arg2)+1);
5919
 
            strcpy((char*)arg1->AssertionArtifact,arg2);
5920
 
        } else {
5921
 
            arg1->AssertionArtifact = 0;
5922
 
        }
5923
 
    }
5924
 
}
5925
 
 
5926
 
 
5927
 
DllExport char * SWIGSTDCALL CSharp_get_SamlpRequest_assertionArtifact(void * jarg1) {
5928
 
    char * jresult = 0 ;
5929
 
    LassoSamlpRequest *arg1 = (LassoSamlpRequest *) 0 ;
5930
 
    char *result;
5931
 
    
5932
 
    arg1 = (LassoSamlpRequest *)jarg1; 
5933
 
    result = (char *) ((arg1)->AssertionArtifact);
5934
 
    
5935
 
    jresult = SWIG_csharp_string_callback(result); 
5936
 
    return jresult;
5937
 
}
5938
 
 
5939
 
 
5940
 
DllExport void SWIGSTDCALL CSharp_set_SamlpRequest_certificateFile(void * jarg1, char * jarg2) {
5941
 
    LassoSamlpRequest *arg1 = (LassoSamlpRequest *) 0 ;
5942
 
    char *arg2 = (char *) 0 ;
5943
 
    
5944
 
    arg1 = (LassoSamlpRequest *)jarg1; 
5945
 
    arg2 = jarg2; 
5946
 
    LassoSamlpRequest_set_certificate_file(arg1,arg2);
5947
 
    
5948
 
}
5949
 
 
5950
 
 
5951
 
DllExport char * SWIGSTDCALL CSharp_get_SamlpRequest_certificateFile(void * jarg1) {
5952
 
    char * jresult = 0 ;
5953
 
    LassoSamlpRequest *arg1 = (LassoSamlpRequest *) 0 ;
5954
 
    char *result;
5955
 
    
5956
 
    arg1 = (LassoSamlpRequest *)jarg1; 
5957
 
    result = (char *)LassoSamlpRequest_get_certificate_file(arg1);
5958
 
    
5959
 
    jresult = SWIG_csharp_string_callback(result); 
5960
 
    return jresult;
5961
 
}
5962
 
 
5963
 
 
5964
 
DllExport void SWIGSTDCALL CSharp_set_SamlpRequest_issueInstant(void * jarg1, char * jarg2) {
5965
 
    LassoSamlpRequest *arg1 = (LassoSamlpRequest *) 0 ;
5966
 
    char *arg2 = (char *) 0 ;
5967
 
    
5968
 
    arg1 = (LassoSamlpRequest *)jarg1; 
5969
 
    arg2 = jarg2; 
5970
 
    LassoSamlpRequest_set_IssueInstant(arg1,arg2);
5971
 
    
5972
 
}
5973
 
 
5974
 
 
5975
 
DllExport char * SWIGSTDCALL CSharp_get_SamlpRequest_issueInstant(void * jarg1) {
5976
 
    char * jresult = 0 ;
5977
 
    LassoSamlpRequest *arg1 = (LassoSamlpRequest *) 0 ;
5978
 
    char *result;
5979
 
    
5980
 
    arg1 = (LassoSamlpRequest *)jarg1; 
5981
 
    result = (char *)LassoSamlpRequest_get_IssueInstant(arg1);
5982
 
    
5983
 
    jresult = SWIG_csharp_string_callback(result); 
5984
 
    return jresult;
5985
 
}
5986
 
 
5987
 
 
5988
 
DllExport void SWIGSTDCALL CSharp_set_SamlpRequest_majorVersion(void * jarg1, int jarg2) {
5989
 
    LassoSamlpRequest *arg1 = (LassoSamlpRequest *) 0 ;
5990
 
    int arg2 ;
5991
 
    
5992
 
    arg1 = (LassoSamlpRequest *)jarg1; 
5993
 
    arg2 = (int)jarg2; 
5994
 
    LassoSamlpRequest_set_MajorVersion(arg1,arg2);
5995
 
    
5996
 
}
5997
 
 
5998
 
 
5999
 
DllExport int SWIGSTDCALL CSharp_get_SamlpRequest_majorVersion(void * jarg1) {
6000
 
    int jresult = 0 ;
6001
 
    LassoSamlpRequest *arg1 = (LassoSamlpRequest *) 0 ;
6002
 
    int result;
6003
 
    
6004
 
    arg1 = (LassoSamlpRequest *)jarg1; 
6005
 
    result = (int)LassoSamlpRequest_get_MajorVersion(arg1);
6006
 
    
6007
 
    jresult = result; 
6008
 
    return jresult;
6009
 
}
6010
 
 
6011
 
 
6012
 
DllExport void SWIGSTDCALL CSharp_set_SamlpRequest_minorVersion(void * jarg1, int jarg2) {
6013
 
    LassoSamlpRequest *arg1 = (LassoSamlpRequest *) 0 ;
6014
 
    int arg2 ;
6015
 
    
6016
 
    arg1 = (LassoSamlpRequest *)jarg1; 
6017
 
    arg2 = (int)jarg2; 
6018
 
    LassoSamlpRequest_set_MinorVersion(arg1,arg2);
6019
 
    
6020
 
}
6021
 
 
6022
 
 
6023
 
DllExport int SWIGSTDCALL CSharp_get_SamlpRequest_minorVersion(void * jarg1) {
6024
 
    int jresult = 0 ;
6025
 
    LassoSamlpRequest *arg1 = (LassoSamlpRequest *) 0 ;
6026
 
    int result;
6027
 
    
6028
 
    arg1 = (LassoSamlpRequest *)jarg1; 
6029
 
    result = (int)LassoSamlpRequest_get_MinorVersion(arg1);
6030
 
    
6031
 
    jresult = result; 
6032
 
    return jresult;
6033
 
}
6034
 
 
6035
 
 
6036
 
DllExport void SWIGSTDCALL CSharp_set_SamlpRequest_privateKeyFile(void * jarg1, char * jarg2) {
6037
 
    LassoSamlpRequest *arg1 = (LassoSamlpRequest *) 0 ;
6038
 
    char *arg2 = (char *) 0 ;
6039
 
    
6040
 
    arg1 = (LassoSamlpRequest *)jarg1; 
6041
 
    arg2 = jarg2; 
6042
 
    LassoSamlpRequest_set_private_key_file(arg1,arg2);
6043
 
    
6044
 
}
6045
 
 
6046
 
 
6047
 
DllExport char * SWIGSTDCALL CSharp_get_SamlpRequest_privateKeyFile(void * jarg1) {
6048
 
    char * jresult = 0 ;
6049
 
    LassoSamlpRequest *arg1 = (LassoSamlpRequest *) 0 ;
6050
 
    char *result;
6051
 
    
6052
 
    arg1 = (LassoSamlpRequest *)jarg1; 
6053
 
    result = (char *)LassoSamlpRequest_get_private_key_file(arg1);
6054
 
    
6055
 
    jresult = SWIG_csharp_string_callback(result); 
6056
 
    return jresult;
6057
 
}
6058
 
 
6059
 
 
6060
 
DllExport void SWIGSTDCALL CSharp_set_SamlpRequest_requestId(void * jarg1, char * jarg2) {
6061
 
    LassoSamlpRequest *arg1 = (LassoSamlpRequest *) 0 ;
6062
 
    char *arg2 = (char *) 0 ;
6063
 
    
6064
 
    arg1 = (LassoSamlpRequest *)jarg1; 
6065
 
    arg2 = jarg2; 
6066
 
    LassoSamlpRequest_set_RequestID(arg1,arg2);
6067
 
    
6068
 
}
6069
 
 
6070
 
 
6071
 
DllExport char * SWIGSTDCALL CSharp_get_SamlpRequest_requestId(void * jarg1) {
6072
 
    char * jresult = 0 ;
6073
 
    LassoSamlpRequest *arg1 = (LassoSamlpRequest *) 0 ;
6074
 
    char *result;
6075
 
    
6076
 
    arg1 = (LassoSamlpRequest *)jarg1; 
6077
 
    result = (char *)LassoSamlpRequest_get_RequestID(arg1);
6078
 
    
6079
 
    jresult = SWIG_csharp_string_callback(result); 
6080
 
    return jresult;
6081
 
}
6082
 
 
6083
 
 
6084
 
DllExport void SWIGSTDCALL CSharp_set_SamlpRequest_respondWith(void * jarg1, void * jarg2) {
6085
 
    LassoSamlpRequest *arg1 = (LassoSamlpRequest *) 0 ;
6086
 
    LassoStringList *arg2 = (LassoStringList *) 0 ;
6087
 
    
6088
 
    arg1 = (LassoSamlpRequest *)jarg1; 
6089
 
    arg2 = (LassoStringList *)jarg2; 
6090
 
    LassoSamlpRequest_set_RespondWith(arg1,arg2);
6091
 
    
6092
 
}
6093
 
 
6094
 
 
6095
 
DllExport void * SWIGSTDCALL CSharp_get_SamlpRequest_respondWith(void * jarg1) {
6096
 
    void * jresult = 0 ;
6097
 
    LassoSamlpRequest *arg1 = (LassoSamlpRequest *) 0 ;
6098
 
    LassoStringList *result;
6099
 
    
6100
 
    arg1 = (LassoSamlpRequest *)jarg1; 
6101
 
    result = (LassoStringList *)LassoSamlpRequest_get_RespondWith(arg1);
6102
 
    
6103
 
    jresult = (void *)result; 
6104
 
    return jresult;
6105
 
}
6106
 
 
6107
 
 
6108
 
DllExport void SWIGSTDCALL CSharp_set_SamlpRequest_signMethod(void * jarg1, int jarg2) {
6109
 
    LassoSamlpRequest *arg1 = (LassoSamlpRequest *) 0 ;
6110
 
    LassoSignatureMethod arg2 ;
6111
 
    
6112
 
    arg1 = (LassoSamlpRequest *)jarg1; 
6113
 
    arg2 = (LassoSignatureMethod)jarg2; 
6114
 
    LassoSamlpRequest_set_sign_method(arg1,(LassoSignatureMethod )arg2);
6115
 
    
6116
 
}
6117
 
 
6118
 
 
6119
 
DllExport int SWIGSTDCALL CSharp_get_SamlpRequest_signMethod(void * jarg1) {
6120
 
    int jresult = 0 ;
6121
 
    LassoSamlpRequest *arg1 = (LassoSamlpRequest *) 0 ;
6122
 
    LassoSignatureMethod result;
6123
 
    
6124
 
    arg1 = (LassoSamlpRequest *)jarg1; 
6125
 
    result = (LassoSignatureMethod)LassoSamlpRequest_get_sign_method(arg1);
6126
 
    
6127
 
    jresult = result; 
6128
 
    return jresult;
6129
 
}
6130
 
 
6131
 
 
6132
 
DllExport void SWIGSTDCALL CSharp_set_SamlpRequest_signType(void * jarg1, void * jarg2) {
6133
 
    LassoSamlpRequest *arg1 = (LassoSamlpRequest *) 0 ;
6134
 
    LassoSignatureType arg2 ;
6135
 
    LassoSignatureType *argp2 ;
6136
 
    
6137
 
    arg1 = (LassoSamlpRequest *)jarg1; 
6138
 
    argp2 = (LassoSignatureType *)jarg2; 
6139
 
    if (!argp2) {
6140
 
        SWIG_CSharpThrowException(SWIG_CSharpNullReferenceException, "Attempt to dereference null LassoSignatureType");
6141
 
    }
6142
 
    arg2 = *argp2; 
6143
 
    LassoSamlpRequest_set_sign_type(arg1,arg2);
6144
 
    
6145
 
}
6146
 
 
6147
 
 
6148
 
DllExport void * SWIGSTDCALL CSharp_get_SamlpRequest_signType(void * jarg1) {
6149
 
    void * jresult = 0 ;
6150
 
    LassoSamlpRequest *arg1 = (LassoSamlpRequest *) 0 ;
6151
 
    LassoSignatureType result;
6152
 
    
6153
 
    arg1 = (LassoSamlpRequest *)jarg1; 
6154
 
    result = LassoSamlpRequest_get_sign_type(arg1);
6155
 
    
6156
 
    {
6157
 
        LassoSignatureType * resultptr = (LassoSignatureType *) malloc(sizeof(LassoSignatureType));
6158
 
        memmove(resultptr, &result, sizeof(LassoSignatureType));
6159
 
        jresult = resultptr;
6160
 
    }
6161
 
    return jresult;
6162
 
}
6163
 
 
6164
 
 
6165
 
DllExport void * SWIGSTDCALL CSharp_new_SamlpRequest() {
6166
 
    void * jresult = 0 ;
6167
 
    LassoSamlpRequest *result;
6168
 
    
6169
 
    result = (LassoSamlpRequest *)new_LassoSamlpRequest();
6170
 
    
6171
 
    jresult = (void *)result; 
6172
 
    return jresult;
6173
 
}
6174
 
 
6175
 
 
6176
 
DllExport void SWIGSTDCALL CSharp_delete_SamlpRequest(void * jarg1) {
6177
 
    LassoSamlpRequest *arg1 = (LassoSamlpRequest *) 0 ;
6178
 
    
6179
 
    arg1 = (LassoSamlpRequest *)jarg1; 
6180
 
    delete_LassoSamlpRequest(arg1);
6181
 
    
6182
 
}
6183
 
 
6184
 
 
6185
 
DllExport char * SWIGSTDCALL CSharp_SamlpRequest_dump(void * jarg1) {
6186
 
    char * jresult = 0 ;
6187
 
    LassoSamlpRequest *arg1 = (LassoSamlpRequest *) 0 ;
6188
 
    char *result;
6189
 
    
6190
 
    arg1 = (LassoSamlpRequest *)jarg1; 
6191
 
    result = (char *)LassoSamlpRequest_dump(arg1);
6192
 
    
6193
 
    jresult = SWIG_csharp_string_callback(result); 
6194
 
    free(result);
6195
 
    return jresult;
6196
 
}
6197
 
 
6198
 
 
6199
 
DllExport void SWIGSTDCALL CSharp_set_SamlpRequestAbstract_certificateFile(void * jarg1, char * jarg2) {
6200
 
    LassoSamlpRequestAbstract *arg1 = (LassoSamlpRequestAbstract *) 0 ;
6201
 
    char *arg2 = (char *) 0 ;
6202
 
    
6203
 
    arg1 = (LassoSamlpRequestAbstract *)jarg1; 
6204
 
    arg2 = jarg2; 
6205
 
    {
6206
 
        if (arg1->certificate_file) free((char*)arg1->certificate_file);
6207
 
        if (arg2) {
6208
 
            arg1->certificate_file = (char *) malloc(strlen(arg2)+1);
6209
 
            strcpy((char*)arg1->certificate_file,arg2);
6210
 
        } else {
6211
 
            arg1->certificate_file = 0;
6212
 
        }
6213
 
    }
6214
 
}
6215
 
 
6216
 
 
6217
 
DllExport char * SWIGSTDCALL CSharp_get_SamlpRequestAbstract_certificateFile(void * jarg1) {
6218
 
    char * jresult = 0 ;
6219
 
    LassoSamlpRequestAbstract *arg1 = (LassoSamlpRequestAbstract *) 0 ;
6220
 
    char *result;
6221
 
    
6222
 
    arg1 = (LassoSamlpRequestAbstract *)jarg1; 
6223
 
    result = (char *) ((arg1)->certificate_file);
6224
 
    
6225
 
    jresult = SWIG_csharp_string_callback(result); 
6226
 
    return jresult;
6227
 
}
6228
 
 
6229
 
 
6230
 
DllExport void SWIGSTDCALL CSharp_set_SamlpRequestAbstract_issueInstant(void * jarg1, char * jarg2) {
6231
 
    LassoSamlpRequestAbstract *arg1 = (LassoSamlpRequestAbstract *) 0 ;
6232
 
    char *arg2 = (char *) 0 ;
6233
 
    
6234
 
    arg1 = (LassoSamlpRequestAbstract *)jarg1; 
6235
 
    arg2 = jarg2; 
6236
 
    {
6237
 
        if (arg1->IssueInstant) free((char*)arg1->IssueInstant);
6238
 
        if (arg2) {
6239
 
            arg1->IssueInstant = (char *) malloc(strlen(arg2)+1);
6240
 
            strcpy((char*)arg1->IssueInstant,arg2);
6241
 
        } else {
6242
 
            arg1->IssueInstant = 0;
6243
 
        }
6244
 
    }
6245
 
}
6246
 
 
6247
 
 
6248
 
DllExport char * SWIGSTDCALL CSharp_get_SamlpRequestAbstract_issueInstant(void * jarg1) {
6249
 
    char * jresult = 0 ;
6250
 
    LassoSamlpRequestAbstract *arg1 = (LassoSamlpRequestAbstract *) 0 ;
6251
 
    char *result;
6252
 
    
6253
 
    arg1 = (LassoSamlpRequestAbstract *)jarg1; 
6254
 
    result = (char *) ((arg1)->IssueInstant);
6255
 
    
6256
 
    jresult = SWIG_csharp_string_callback(result); 
6257
 
    return jresult;
6258
 
}
6259
 
 
6260
 
 
6261
 
DllExport void SWIGSTDCALL CSharp_set_SamlpRequestAbstract_majorVersion(void * jarg1, int jarg2) {
6262
 
    LassoSamlpRequestAbstract *arg1 = (LassoSamlpRequestAbstract *) 0 ;
6263
 
    int arg2 ;
6264
 
    
6265
 
    arg1 = (LassoSamlpRequestAbstract *)jarg1; 
6266
 
    arg2 = (int)jarg2; 
6267
 
    if (arg1) (arg1)->MajorVersion = arg2;
6268
 
    
6269
 
}
6270
 
 
6271
 
 
6272
 
DllExport int SWIGSTDCALL CSharp_get_SamlpRequestAbstract_majorVersion(void * jarg1) {
6273
 
    int jresult = 0 ;
6274
 
    LassoSamlpRequestAbstract *arg1 = (LassoSamlpRequestAbstract *) 0 ;
6275
 
    int result;
6276
 
    
6277
 
    arg1 = (LassoSamlpRequestAbstract *)jarg1; 
6278
 
    result = (int) ((arg1)->MajorVersion);
6279
 
    
6280
 
    jresult = result; 
6281
 
    return jresult;
6282
 
}
6283
 
 
6284
 
 
6285
 
DllExport void SWIGSTDCALL CSharp_set_SamlpRequestAbstract_minorVersion(void * jarg1, int jarg2) {
6286
 
    LassoSamlpRequestAbstract *arg1 = (LassoSamlpRequestAbstract *) 0 ;
6287
 
    int arg2 ;
6288
 
    
6289
 
    arg1 = (LassoSamlpRequestAbstract *)jarg1; 
6290
 
    arg2 = (int)jarg2; 
6291
 
    if (arg1) (arg1)->MinorVersion = arg2;
6292
 
    
6293
 
}
6294
 
 
6295
 
 
6296
 
DllExport int SWIGSTDCALL CSharp_get_SamlpRequestAbstract_minorVersion(void * jarg1) {
6297
 
    int jresult = 0 ;
6298
 
    LassoSamlpRequestAbstract *arg1 = (LassoSamlpRequestAbstract *) 0 ;
6299
 
    int result;
6300
 
    
6301
 
    arg1 = (LassoSamlpRequestAbstract *)jarg1; 
6302
 
    result = (int) ((arg1)->MinorVersion);
6303
 
    
6304
 
    jresult = result; 
6305
 
    return jresult;
6306
 
}
6307
 
 
6308
 
 
6309
 
DllExport void SWIGSTDCALL CSharp_set_SamlpRequestAbstract_privateKeyFile(void * jarg1, char * jarg2) {
6310
 
    LassoSamlpRequestAbstract *arg1 = (LassoSamlpRequestAbstract *) 0 ;
6311
 
    char *arg2 = (char *) 0 ;
6312
 
    
6313
 
    arg1 = (LassoSamlpRequestAbstract *)jarg1; 
6314
 
    arg2 = jarg2; 
6315
 
    {
6316
 
        if (arg1->private_key_file) free((char*)arg1->private_key_file);
6317
 
        if (arg2) {
6318
 
            arg1->private_key_file = (char *) malloc(strlen(arg2)+1);
6319
 
            strcpy((char*)arg1->private_key_file,arg2);
6320
 
        } else {
6321
 
            arg1->private_key_file = 0;
6322
 
        }
6323
 
    }
6324
 
}
6325
 
 
6326
 
 
6327
 
DllExport char * SWIGSTDCALL CSharp_get_SamlpRequestAbstract_privateKeyFile(void * jarg1) {
6328
 
    char * jresult = 0 ;
6329
 
    LassoSamlpRequestAbstract *arg1 = (LassoSamlpRequestAbstract *) 0 ;
6330
 
    char *result;
6331
 
    
6332
 
    arg1 = (LassoSamlpRequestAbstract *)jarg1; 
6333
 
    result = (char *) ((arg1)->private_key_file);
6334
 
    
6335
 
    jresult = SWIG_csharp_string_callback(result); 
6336
 
    return jresult;
6337
 
}
6338
 
 
6339
 
 
6340
 
DllExport void SWIGSTDCALL CSharp_set_SamlpRequestAbstract_requestId(void * jarg1, char * jarg2) {
6341
 
    LassoSamlpRequestAbstract *arg1 = (LassoSamlpRequestAbstract *) 0 ;
6342
 
    char *arg2 = (char *) 0 ;
6343
 
    
6344
 
    arg1 = (LassoSamlpRequestAbstract *)jarg1; 
6345
 
    arg2 = jarg2; 
6346
 
    {
6347
 
        if (arg1->RequestID) free((char*)arg1->RequestID);
6348
 
        if (arg2) {
6349
 
            arg1->RequestID = (char *) malloc(strlen(arg2)+1);
6350
 
            strcpy((char*)arg1->RequestID,arg2);
6351
 
        } else {
6352
 
            arg1->RequestID = 0;
6353
 
        }
6354
 
    }
6355
 
}
6356
 
 
6357
 
 
6358
 
DllExport char * SWIGSTDCALL CSharp_get_SamlpRequestAbstract_requestId(void * jarg1) {
6359
 
    char * jresult = 0 ;
6360
 
    LassoSamlpRequestAbstract *arg1 = (LassoSamlpRequestAbstract *) 0 ;
6361
 
    char *result;
6362
 
    
6363
 
    arg1 = (LassoSamlpRequestAbstract *)jarg1; 
6364
 
    result = (char *) ((arg1)->RequestID);
6365
 
    
6366
 
    jresult = SWIG_csharp_string_callback(result); 
6367
 
    return jresult;
6368
 
}
6369
 
 
6370
 
 
6371
 
DllExport void SWIGSTDCALL CSharp_set_SamlpRequestAbstract_signMethod(void * jarg1, int jarg2) {
6372
 
    LassoSamlpRequestAbstract *arg1 = (LassoSamlpRequestAbstract *) 0 ;
6373
 
    LassoSignatureMethod arg2 ;
6374
 
    
6375
 
    arg1 = (LassoSamlpRequestAbstract *)jarg1; 
6376
 
    arg2 = (LassoSignatureMethod)jarg2; 
6377
 
    if (arg1) (arg1)->sign_method = (LassoSignatureMethod )arg2;
6378
 
    
6379
 
}
6380
 
 
6381
 
 
6382
 
DllExport int SWIGSTDCALL CSharp_get_SamlpRequestAbstract_signMethod(void * jarg1) {
6383
 
    int jresult = 0 ;
6384
 
    LassoSamlpRequestAbstract *arg1 = (LassoSamlpRequestAbstract *) 0 ;
6385
 
    LassoSignatureMethod result;
6386
 
    
6387
 
    arg1 = (LassoSamlpRequestAbstract *)jarg1; 
6388
 
    result = (LassoSignatureMethod) ((arg1)->sign_method);
6389
 
    
6390
 
    jresult = result; 
6391
 
    return jresult;
6392
 
}
6393
 
 
6394
 
 
6395
 
DllExport void SWIGSTDCALL CSharp_set_SamlpRequestAbstract_signType(void * jarg1, void * jarg2) {
6396
 
    LassoSamlpRequestAbstract *arg1 = (LassoSamlpRequestAbstract *) 0 ;
6397
 
    LassoSignatureType arg2 ;
6398
 
    LassoSignatureType *argp2 ;
6399
 
    
6400
 
    arg1 = (LassoSamlpRequestAbstract *)jarg1; 
6401
 
    argp2 = (LassoSignatureType *)jarg2; 
6402
 
    if (!argp2) {
6403
 
        SWIG_CSharpThrowException(SWIG_CSharpNullReferenceException, "Attempt to dereference null LassoSignatureType");
6404
 
    }
6405
 
    arg2 = *argp2; 
6406
 
    if (arg1) (arg1)->sign_type = arg2;
6407
 
    
6408
 
}
6409
 
 
6410
 
 
6411
 
DllExport void * SWIGSTDCALL CSharp_get_SamlpRequestAbstract_signType(void * jarg1) {
6412
 
    void * jresult = 0 ;
6413
 
    LassoSamlpRequestAbstract *arg1 = (LassoSamlpRequestAbstract *) 0 ;
6414
 
    LassoSignatureType result;
6415
 
    
6416
 
    arg1 = (LassoSamlpRequestAbstract *)jarg1; 
6417
 
    result =  ((arg1)->sign_type);
6418
 
    
6419
 
    {
6420
 
        LassoSignatureType * resultptr = (LassoSignatureType *) malloc(sizeof(LassoSignatureType));
6421
 
        memmove(resultptr, &result, sizeof(LassoSignatureType));
6422
 
        jresult = resultptr;
6423
 
    }
6424
 
    return jresult;
6425
 
}
6426
 
 
6427
 
 
6428
 
DllExport void SWIGSTDCALL CSharp_set_SamlpRequestAbstract_respondWith(void * jarg1, void * jarg2) {
6429
 
    LassoSamlpRequestAbstract *arg1 = (LassoSamlpRequestAbstract *) 0 ;
6430
 
    LassoStringList *arg2 = (LassoStringList *) 0 ;
6431
 
    
6432
 
    arg1 = (LassoSamlpRequestAbstract *)jarg1; 
6433
 
    arg2 = (LassoStringList *)jarg2; 
6434
 
    LassoSamlpRequestAbstract_set_RespondWith(arg1,arg2);
6435
 
    
6436
 
}
6437
 
 
6438
 
 
6439
 
DllExport void * SWIGSTDCALL CSharp_get_SamlpRequestAbstract_respondWith(void * jarg1) {
6440
 
    void * jresult = 0 ;
6441
 
    LassoSamlpRequestAbstract *arg1 = (LassoSamlpRequestAbstract *) 0 ;
6442
 
    LassoStringList *result;
6443
 
    
6444
 
    arg1 = (LassoSamlpRequestAbstract *)jarg1; 
6445
 
    result = (LassoStringList *)LassoSamlpRequestAbstract_get_RespondWith(arg1);
6446
 
    
6447
 
    jresult = (void *)result; 
6448
 
    return jresult;
6449
 
}
6450
 
 
6451
 
 
6452
 
DllExport char * SWIGSTDCALL CSharp_SamlpRequestAbstract_dump(void * jarg1) {
6453
 
    char * jresult = 0 ;
6454
 
    LassoSamlpRequestAbstract *arg1 = (LassoSamlpRequestAbstract *) 0 ;
6455
 
    char *result;
6456
 
    
6457
 
    arg1 = (LassoSamlpRequestAbstract *)jarg1; 
6458
 
    result = (char *)LassoSamlpRequestAbstract_dump(arg1);
6459
 
    
6460
 
    jresult = SWIG_csharp_string_callback(result); 
6461
 
    free(result);
6462
 
    return jresult;
6463
 
}
6464
 
 
6465
 
 
6466
 
DllExport void SWIGSTDCALL CSharp_set_SamlpResponse_certificateFile(void * jarg1, char * jarg2) {
6467
 
    LassoSamlpResponse *arg1 = (LassoSamlpResponse *) 0 ;
6468
 
    char *arg2 = (char *) 0 ;
6469
 
    
6470
 
    arg1 = (LassoSamlpResponse *)jarg1; 
6471
 
    arg2 = jarg2; 
6472
 
    LassoSamlpResponse_set_certificate_file(arg1,arg2);
6473
 
    
6474
 
}
6475
 
 
6476
 
 
6477
 
DllExport char * SWIGSTDCALL CSharp_get_SamlpResponse_certificateFile(void * jarg1) {
6478
 
    char * jresult = 0 ;
6479
 
    LassoSamlpResponse *arg1 = (LassoSamlpResponse *) 0 ;
6480
 
    char *result;
6481
 
    
6482
 
    arg1 = (LassoSamlpResponse *)jarg1; 
6483
 
    result = (char *)LassoSamlpResponse_get_certificate_file(arg1);
6484
 
    
6485
 
    jresult = SWIG_csharp_string_callback(result); 
6486
 
    return jresult;
6487
 
}
6488
 
 
6489
 
 
6490
 
DllExport void SWIGSTDCALL CSharp_set_SamlpResponse_inResponseTo(void * jarg1, char * jarg2) {
6491
 
    LassoSamlpResponse *arg1 = (LassoSamlpResponse *) 0 ;
6492
 
    char *arg2 = (char *) 0 ;
6493
 
    
6494
 
    arg1 = (LassoSamlpResponse *)jarg1; 
6495
 
    arg2 = jarg2; 
6496
 
    LassoSamlpResponse_set_InResponseTo(arg1,arg2);
6497
 
    
6498
 
}
6499
 
 
6500
 
 
6501
 
DllExport char * SWIGSTDCALL CSharp_get_SamlpResponse_inResponseTo(void * jarg1) {
6502
 
    char * jresult = 0 ;
6503
 
    LassoSamlpResponse *arg1 = (LassoSamlpResponse *) 0 ;
6504
 
    char *result;
6505
 
    
6506
 
    arg1 = (LassoSamlpResponse *)jarg1; 
6507
 
    result = (char *)LassoSamlpResponse_get_InResponseTo(arg1);
6508
 
    
6509
 
    jresult = SWIG_csharp_string_callback(result); 
6510
 
    return jresult;
6511
 
}
6512
 
 
6513
 
 
6514
 
DllExport void SWIGSTDCALL CSharp_set_SamlpResponse_issueInstant(void * jarg1, char * jarg2) {
6515
 
    LassoSamlpResponse *arg1 = (LassoSamlpResponse *) 0 ;
6516
 
    char *arg2 = (char *) 0 ;
6517
 
    
6518
 
    arg1 = (LassoSamlpResponse *)jarg1; 
6519
 
    arg2 = jarg2; 
6520
 
    LassoSamlpResponse_set_IssueInstant(arg1,arg2);
6521
 
    
6522
 
}
6523
 
 
6524
 
 
6525
 
DllExport char * SWIGSTDCALL CSharp_get_SamlpResponse_issueInstant(void * jarg1) {
6526
 
    char * jresult = 0 ;
6527
 
    LassoSamlpResponse *arg1 = (LassoSamlpResponse *) 0 ;
6528
 
    char *result;
6529
 
    
6530
 
    arg1 = (LassoSamlpResponse *)jarg1; 
6531
 
    result = (char *)LassoSamlpResponse_get_IssueInstant(arg1);
6532
 
    
6533
 
    jresult = SWIG_csharp_string_callback(result); 
6534
 
    return jresult;
6535
 
}
6536
 
 
6537
 
 
6538
 
DllExport void SWIGSTDCALL CSharp_set_SamlpResponse_majorVersion(void * jarg1, int jarg2) {
6539
 
    LassoSamlpResponse *arg1 = (LassoSamlpResponse *) 0 ;
6540
 
    int arg2 ;
6541
 
    
6542
 
    arg1 = (LassoSamlpResponse *)jarg1; 
6543
 
    arg2 = (int)jarg2; 
6544
 
    LassoSamlpResponse_set_MajorVersion(arg1,arg2);
6545
 
    
6546
 
}
6547
 
 
6548
 
 
6549
 
DllExport int SWIGSTDCALL CSharp_get_SamlpResponse_majorVersion(void * jarg1) {
6550
 
    int jresult = 0 ;
6551
 
    LassoSamlpResponse *arg1 = (LassoSamlpResponse *) 0 ;
6552
 
    int result;
6553
 
    
6554
 
    arg1 = (LassoSamlpResponse *)jarg1; 
6555
 
    result = (int)LassoSamlpResponse_get_MajorVersion(arg1);
6556
 
    
6557
 
    jresult = result; 
6558
 
    return jresult;
6559
 
}
6560
 
 
6561
 
 
6562
 
DllExport void SWIGSTDCALL CSharp_set_SamlpResponse_minorVersion(void * jarg1, int jarg2) {
6563
 
    LassoSamlpResponse *arg1 = (LassoSamlpResponse *) 0 ;
6564
 
    int arg2 ;
6565
 
    
6566
 
    arg1 = (LassoSamlpResponse *)jarg1; 
6567
 
    arg2 = (int)jarg2; 
6568
 
    LassoSamlpResponse_set_MinorVersion(arg1,arg2);
6569
 
    
6570
 
}
6571
 
 
6572
 
 
6573
 
DllExport int SWIGSTDCALL CSharp_get_SamlpResponse_minorVersion(void * jarg1) {
6574
 
    int jresult = 0 ;
6575
 
    LassoSamlpResponse *arg1 = (LassoSamlpResponse *) 0 ;
6576
 
    int result;
6577
 
    
6578
 
    arg1 = (LassoSamlpResponse *)jarg1; 
6579
 
    result = (int)LassoSamlpResponse_get_MinorVersion(arg1);
6580
 
    
6581
 
    jresult = result; 
6582
 
    return jresult;
6583
 
}
6584
 
 
6585
 
 
6586
 
DllExport void SWIGSTDCALL CSharp_set_SamlpResponse_privateKeyFile(void * jarg1, char * jarg2) {
6587
 
    LassoSamlpResponse *arg1 = (LassoSamlpResponse *) 0 ;
6588
 
    char *arg2 = (char *) 0 ;
6589
 
    
6590
 
    arg1 = (LassoSamlpResponse *)jarg1; 
6591
 
    arg2 = jarg2; 
6592
 
    LassoSamlpResponse_set_private_key_file(arg1,arg2);
6593
 
    
6594
 
}
6595
 
 
6596
 
 
6597
 
DllExport char * SWIGSTDCALL CSharp_get_SamlpResponse_privateKeyFile(void * jarg1) {
6598
 
    char * jresult = 0 ;
6599
 
    LassoSamlpResponse *arg1 = (LassoSamlpResponse *) 0 ;
6600
 
    char *result;
6601
 
    
6602
 
    arg1 = (LassoSamlpResponse *)jarg1; 
6603
 
    result = (char *)LassoSamlpResponse_get_private_key_file(arg1);
6604
 
    
6605
 
    jresult = SWIG_csharp_string_callback(result); 
6606
 
    return jresult;
6607
 
}
6608
 
 
6609
 
 
6610
 
DllExport void SWIGSTDCALL CSharp_set_SamlpResponse_recipient(void * jarg1, char * jarg2) {
6611
 
    LassoSamlpResponse *arg1 = (LassoSamlpResponse *) 0 ;
6612
 
    char *arg2 = (char *) 0 ;
6613
 
    
6614
 
    arg1 = (LassoSamlpResponse *)jarg1; 
6615
 
    arg2 = jarg2; 
6616
 
    LassoSamlpResponse_set_Recipient(arg1,arg2);
6617
 
    
6618
 
}
6619
 
 
6620
 
 
6621
 
DllExport char * SWIGSTDCALL CSharp_get_SamlpResponse_recipient(void * jarg1) {
6622
 
    char * jresult = 0 ;
6623
 
    LassoSamlpResponse *arg1 = (LassoSamlpResponse *) 0 ;
6624
 
    char *result;
6625
 
    
6626
 
    arg1 = (LassoSamlpResponse *)jarg1; 
6627
 
    result = (char *)LassoSamlpResponse_get_Recipient(arg1);
6628
 
    
6629
 
    jresult = SWIG_csharp_string_callback(result); 
6630
 
    return jresult;
6631
 
}
6632
 
 
6633
 
 
6634
 
DllExport void SWIGSTDCALL CSharp_set_SamlpResponse_responseId(void * jarg1, char * jarg2) {
6635
 
    LassoSamlpResponse *arg1 = (LassoSamlpResponse *) 0 ;
6636
 
    char *arg2 = (char *) 0 ;
6637
 
    
6638
 
    arg1 = (LassoSamlpResponse *)jarg1; 
6639
 
    arg2 = jarg2; 
6640
 
    LassoSamlpResponse_set_ResponseID(arg1,arg2);
6641
 
    
6642
 
}
6643
 
 
6644
 
 
6645
 
DllExport char * SWIGSTDCALL CSharp_get_SamlpResponse_responseId(void * jarg1) {
6646
 
    char * jresult = 0 ;
6647
 
    LassoSamlpResponse *arg1 = (LassoSamlpResponse *) 0 ;
6648
 
    char *result;
6649
 
    
6650
 
    arg1 = (LassoSamlpResponse *)jarg1; 
6651
 
    result = (char *)LassoSamlpResponse_get_ResponseID(arg1);
6652
 
    
6653
 
    jresult = SWIG_csharp_string_callback(result); 
6654
 
    return jresult;
6655
 
}
6656
 
 
6657
 
 
6658
 
DllExport void SWIGSTDCALL CSharp_set_SamlpResponse_signMethod(void * jarg1, int jarg2) {
6659
 
    LassoSamlpResponse *arg1 = (LassoSamlpResponse *) 0 ;
6660
 
    LassoSignatureMethod arg2 ;
6661
 
    
6662
 
    arg1 = (LassoSamlpResponse *)jarg1; 
6663
 
    arg2 = (LassoSignatureMethod)jarg2; 
6664
 
    LassoSamlpResponse_set_sign_method(arg1,(LassoSignatureMethod )arg2);
6665
 
    
6666
 
}
6667
 
 
6668
 
 
6669
 
DllExport int SWIGSTDCALL CSharp_get_SamlpResponse_signMethod(void * jarg1) {
6670
 
    int jresult = 0 ;
6671
 
    LassoSamlpResponse *arg1 = (LassoSamlpResponse *) 0 ;
6672
 
    LassoSignatureMethod result;
6673
 
    
6674
 
    arg1 = (LassoSamlpResponse *)jarg1; 
6675
 
    result = (LassoSignatureMethod)LassoSamlpResponse_get_sign_method(arg1);
6676
 
    
6677
 
    jresult = result; 
6678
 
    return jresult;
6679
 
}
6680
 
 
6681
 
 
6682
 
DllExport void SWIGSTDCALL CSharp_set_SamlpResponse_signType(void * jarg1, void * jarg2) {
6683
 
    LassoSamlpResponse *arg1 = (LassoSamlpResponse *) 0 ;
6684
 
    LassoSignatureType arg2 ;
6685
 
    LassoSignatureType *argp2 ;
6686
 
    
6687
 
    arg1 = (LassoSamlpResponse *)jarg1; 
6688
 
    argp2 = (LassoSignatureType *)jarg2; 
6689
 
    if (!argp2) {
6690
 
        SWIG_CSharpThrowException(SWIG_CSharpNullReferenceException, "Attempt to dereference null LassoSignatureType");
6691
 
    }
6692
 
    arg2 = *argp2; 
6693
 
    LassoSamlpResponse_set_sign_type(arg1,arg2);
6694
 
    
6695
 
}
6696
 
 
6697
 
 
6698
 
DllExport void * SWIGSTDCALL CSharp_get_SamlpResponse_signType(void * jarg1) {
6699
 
    void * jresult = 0 ;
6700
 
    LassoSamlpResponse *arg1 = (LassoSamlpResponse *) 0 ;
6701
 
    LassoSignatureType result;
6702
 
    
6703
 
    arg1 = (LassoSamlpResponse *)jarg1; 
6704
 
    result = LassoSamlpResponse_get_sign_type(arg1);
6705
 
    
6706
 
    {
6707
 
        LassoSignatureType * resultptr = (LassoSignatureType *) malloc(sizeof(LassoSignatureType));
6708
 
        memmove(resultptr, &result, sizeof(LassoSignatureType));
6709
 
        jresult = resultptr;
6710
 
    }
6711
 
    return jresult;
6712
 
}
6713
 
 
6714
 
 
6715
 
DllExport void SWIGSTDCALL CSharp_set_SamlpResponse_assertion(void * jarg1, void * jarg2) {
6716
 
    LassoSamlpResponse *arg1 = (LassoSamlpResponse *) 0 ;
6717
 
    LassoNodeList *arg2 = (LassoNodeList *) 0 ;
6718
 
    
6719
 
    arg1 = (LassoSamlpResponse *)jarg1; 
6720
 
    arg2 = (LassoNodeList *)jarg2; 
6721
 
    LassoSamlpResponse_set_Assertion(arg1,arg2);
6722
 
    
6723
 
}
6724
 
 
6725
 
 
6726
 
DllExport void * SWIGSTDCALL CSharp_get_SamlpResponse_assertion(void * jarg1) {
6727
 
    void * jresult = 0 ;
6728
 
    LassoSamlpResponse *arg1 = (LassoSamlpResponse *) 0 ;
6729
 
    LassoNodeList *result;
6730
 
    
6731
 
    arg1 = (LassoSamlpResponse *)jarg1; 
6732
 
    result = (LassoNodeList *)LassoSamlpResponse_get_Assertion(arg1);
6733
 
    
6734
 
    jresult = (void *)result; 
6735
 
    return jresult;
6736
 
}
6737
 
 
6738
 
 
6739
 
DllExport void SWIGSTDCALL CSharp_set_SamlpResponse_status(void * jarg1, void * jarg2) {
6740
 
    LassoSamlpResponse *arg1 = (LassoSamlpResponse *) 0 ;
6741
 
    LassoSamlpStatus *arg2 = (LassoSamlpStatus *) 0 ;
6742
 
    
6743
 
    arg1 = (LassoSamlpResponse *)jarg1; 
6744
 
    arg2 = (LassoSamlpStatus *)jarg2; 
6745
 
    LassoSamlpResponse_set_Status(arg1,arg2);
6746
 
    
6747
 
}
6748
 
 
6749
 
 
6750
 
DllExport void * SWIGSTDCALL CSharp_get_SamlpResponse_status(void * jarg1) {
6751
 
    void * jresult = 0 ;
6752
 
    LassoSamlpResponse *arg1 = (LassoSamlpResponse *) 0 ;
6753
 
    LassoSamlpStatus *result;
6754
 
    
6755
 
    arg1 = (LassoSamlpResponse *)jarg1; 
6756
 
    result = (LassoSamlpStatus *)LassoSamlpResponse_get_Status(arg1);
6757
 
    
6758
 
    jresult = (void *)result; 
6759
 
    return jresult;
6760
 
}
6761
 
 
6762
 
 
6763
 
DllExport void * SWIGSTDCALL CSharp_new_SamlpResponse() {
6764
 
    void * jresult = 0 ;
6765
 
    LassoSamlpResponse *result;
6766
 
    
6767
 
    result = (LassoSamlpResponse *)new_LassoSamlpResponse();
6768
 
    
6769
 
    jresult = (void *)result; 
6770
 
    return jresult;
6771
 
}
6772
 
 
6773
 
 
6774
 
DllExport void SWIGSTDCALL CSharp_delete_SamlpResponse(void * jarg1) {
6775
 
    LassoSamlpResponse *arg1 = (LassoSamlpResponse *) 0 ;
6776
 
    
6777
 
    arg1 = (LassoSamlpResponse *)jarg1; 
6778
 
    delete_LassoSamlpResponse(arg1);
6779
 
    
6780
 
}
6781
 
 
6782
 
 
6783
 
DllExport char * SWIGSTDCALL CSharp_SamlpResponse_dump(void * jarg1) {
6784
 
    char * jresult = 0 ;
6785
 
    LassoSamlpResponse *arg1 = (LassoSamlpResponse *) 0 ;
6786
 
    char *result;
6787
 
    
6788
 
    arg1 = (LassoSamlpResponse *)jarg1; 
6789
 
    result = (char *)LassoSamlpResponse_dump(arg1);
6790
 
    
6791
 
    jresult = SWIG_csharp_string_callback(result); 
6792
 
    free(result);
6793
 
    return jresult;
6794
 
}
6795
 
 
6796
 
 
6797
 
DllExport void SWIGSTDCALL CSharp_set_SamlpResponseAbstract_certificateFile(void * jarg1, char * jarg2) {
6798
 
    LassoSamlpResponseAbstract *arg1 = (LassoSamlpResponseAbstract *) 0 ;
6799
 
    char *arg2 = (char *) 0 ;
6800
 
    
6801
 
    arg1 = (LassoSamlpResponseAbstract *)jarg1; 
6802
 
    arg2 = jarg2; 
6803
 
    {
6804
 
        if (arg1->certificate_file) free((char*)arg1->certificate_file);
6805
 
        if (arg2) {
6806
 
            arg1->certificate_file = (char *) malloc(strlen(arg2)+1);
6807
 
            strcpy((char*)arg1->certificate_file,arg2);
6808
 
        } else {
6809
 
            arg1->certificate_file = 0;
6810
 
        }
6811
 
    }
6812
 
}
6813
 
 
6814
 
 
6815
 
DllExport char * SWIGSTDCALL CSharp_get_SamlpResponseAbstract_certificateFile(void * jarg1) {
6816
 
    char * jresult = 0 ;
6817
 
    LassoSamlpResponseAbstract *arg1 = (LassoSamlpResponseAbstract *) 0 ;
6818
 
    char *result;
6819
 
    
6820
 
    arg1 = (LassoSamlpResponseAbstract *)jarg1; 
6821
 
    result = (char *) ((arg1)->certificate_file);
6822
 
    
6823
 
    jresult = SWIG_csharp_string_callback(result); 
6824
 
    return jresult;
6825
 
}
6826
 
 
6827
 
 
6828
 
DllExport void SWIGSTDCALL CSharp_set_SamlpResponseAbstract_inResponseTo(void * jarg1, char * jarg2) {
6829
 
    LassoSamlpResponseAbstract *arg1 = (LassoSamlpResponseAbstract *) 0 ;
6830
 
    char *arg2 = (char *) 0 ;
6831
 
    
6832
 
    arg1 = (LassoSamlpResponseAbstract *)jarg1; 
6833
 
    arg2 = jarg2; 
6834
 
    {
6835
 
        if (arg1->InResponseTo) free((char*)arg1->InResponseTo);
6836
 
        if (arg2) {
6837
 
            arg1->InResponseTo = (char *) malloc(strlen(arg2)+1);
6838
 
            strcpy((char*)arg1->InResponseTo,arg2);
6839
 
        } else {
6840
 
            arg1->InResponseTo = 0;
6841
 
        }
6842
 
    }
6843
 
}
6844
 
 
6845
 
 
6846
 
DllExport char * SWIGSTDCALL CSharp_get_SamlpResponseAbstract_inResponseTo(void * jarg1) {
6847
 
    char * jresult = 0 ;
6848
 
    LassoSamlpResponseAbstract *arg1 = (LassoSamlpResponseAbstract *) 0 ;
6849
 
    char *result;
6850
 
    
6851
 
    arg1 = (LassoSamlpResponseAbstract *)jarg1; 
6852
 
    result = (char *) ((arg1)->InResponseTo);
6853
 
    
6854
 
    jresult = SWIG_csharp_string_callback(result); 
6855
 
    return jresult;
6856
 
}
6857
 
 
6858
 
 
6859
 
DllExport void SWIGSTDCALL CSharp_set_SamlpResponseAbstract_issueInstant(void * jarg1, char * jarg2) {
6860
 
    LassoSamlpResponseAbstract *arg1 = (LassoSamlpResponseAbstract *) 0 ;
6861
 
    char *arg2 = (char *) 0 ;
6862
 
    
6863
 
    arg1 = (LassoSamlpResponseAbstract *)jarg1; 
6864
 
    arg2 = jarg2; 
6865
 
    {
6866
 
        if (arg1->IssueInstant) free((char*)arg1->IssueInstant);
6867
 
        if (arg2) {
6868
 
            arg1->IssueInstant = (char *) malloc(strlen(arg2)+1);
6869
 
            strcpy((char*)arg1->IssueInstant,arg2);
6870
 
        } else {
6871
 
            arg1->IssueInstant = 0;
6872
 
        }
6873
 
    }
6874
 
}
6875
 
 
6876
 
 
6877
 
DllExport char * SWIGSTDCALL CSharp_get_SamlpResponseAbstract_issueInstant(void * jarg1) {
6878
 
    char * jresult = 0 ;
6879
 
    LassoSamlpResponseAbstract *arg1 = (LassoSamlpResponseAbstract *) 0 ;
6880
 
    char *result;
6881
 
    
6882
 
    arg1 = (LassoSamlpResponseAbstract *)jarg1; 
6883
 
    result = (char *) ((arg1)->IssueInstant);
6884
 
    
6885
 
    jresult = SWIG_csharp_string_callback(result); 
6886
 
    return jresult;
6887
 
}
6888
 
 
6889
 
 
6890
 
DllExport void SWIGSTDCALL CSharp_set_SamlpResponseAbstract_majorVersion(void * jarg1, int jarg2) {
6891
 
    LassoSamlpResponseAbstract *arg1 = (LassoSamlpResponseAbstract *) 0 ;
6892
 
    int arg2 ;
6893
 
    
6894
 
    arg1 = (LassoSamlpResponseAbstract *)jarg1; 
6895
 
    arg2 = (int)jarg2; 
6896
 
    if (arg1) (arg1)->MajorVersion = arg2;
6897
 
    
6898
 
}
6899
 
 
6900
 
 
6901
 
DllExport int SWIGSTDCALL CSharp_get_SamlpResponseAbstract_majorVersion(void * jarg1) {
6902
 
    int jresult = 0 ;
6903
 
    LassoSamlpResponseAbstract *arg1 = (LassoSamlpResponseAbstract *) 0 ;
6904
 
    int result;
6905
 
    
6906
 
    arg1 = (LassoSamlpResponseAbstract *)jarg1; 
6907
 
    result = (int) ((arg1)->MajorVersion);
6908
 
    
6909
 
    jresult = result; 
6910
 
    return jresult;
6911
 
}
6912
 
 
6913
 
 
6914
 
DllExport void SWIGSTDCALL CSharp_set_SamlpResponseAbstract_minorVersion(void * jarg1, int jarg2) {
6915
 
    LassoSamlpResponseAbstract *arg1 = (LassoSamlpResponseAbstract *) 0 ;
6916
 
    int arg2 ;
6917
 
    
6918
 
    arg1 = (LassoSamlpResponseAbstract *)jarg1; 
6919
 
    arg2 = (int)jarg2; 
6920
 
    if (arg1) (arg1)->MinorVersion = arg2;
6921
 
    
6922
 
}
6923
 
 
6924
 
 
6925
 
DllExport int SWIGSTDCALL CSharp_get_SamlpResponseAbstract_minorVersion(void * jarg1) {
6926
 
    int jresult = 0 ;
6927
 
    LassoSamlpResponseAbstract *arg1 = (LassoSamlpResponseAbstract *) 0 ;
6928
 
    int result;
6929
 
    
6930
 
    arg1 = (LassoSamlpResponseAbstract *)jarg1; 
6931
 
    result = (int) ((arg1)->MinorVersion);
6932
 
    
6933
 
    jresult = result; 
6934
 
    return jresult;
6935
 
}
6936
 
 
6937
 
 
6938
 
DllExport void SWIGSTDCALL CSharp_set_SamlpResponseAbstract_privateKeyFile(void * jarg1, char * jarg2) {
6939
 
    LassoSamlpResponseAbstract *arg1 = (LassoSamlpResponseAbstract *) 0 ;
6940
 
    char *arg2 = (char *) 0 ;
6941
 
    
6942
 
    arg1 = (LassoSamlpResponseAbstract *)jarg1; 
6943
 
    arg2 = jarg2; 
6944
 
    {
6945
 
        if (arg1->private_key_file) free((char*)arg1->private_key_file);
6946
 
        if (arg2) {
6947
 
            arg1->private_key_file = (char *) malloc(strlen(arg2)+1);
6948
 
            strcpy((char*)arg1->private_key_file,arg2);
6949
 
        } else {
6950
 
            arg1->private_key_file = 0;
6951
 
        }
6952
 
    }
6953
 
}
6954
 
 
6955
 
 
6956
 
DllExport char * SWIGSTDCALL CSharp_get_SamlpResponseAbstract_privateKeyFile(void * jarg1) {
6957
 
    char * jresult = 0 ;
6958
 
    LassoSamlpResponseAbstract *arg1 = (LassoSamlpResponseAbstract *) 0 ;
6959
 
    char *result;
6960
 
    
6961
 
    arg1 = (LassoSamlpResponseAbstract *)jarg1; 
6962
 
    result = (char *) ((arg1)->private_key_file);
6963
 
    
6964
 
    jresult = SWIG_csharp_string_callback(result); 
6965
 
    return jresult;
6966
 
}
6967
 
 
6968
 
 
6969
 
DllExport void SWIGSTDCALL CSharp_set_SamlpResponseAbstract_recipient(void * jarg1, char * jarg2) {
6970
 
    LassoSamlpResponseAbstract *arg1 = (LassoSamlpResponseAbstract *) 0 ;
6971
 
    char *arg2 = (char *) 0 ;
6972
 
    
6973
 
    arg1 = (LassoSamlpResponseAbstract *)jarg1; 
6974
 
    arg2 = jarg2; 
6975
 
    {
6976
 
        if (arg1->Recipient) free((char*)arg1->Recipient);
6977
 
        if (arg2) {
6978
 
            arg1->Recipient = (char *) malloc(strlen(arg2)+1);
6979
 
            strcpy((char*)arg1->Recipient,arg2);
6980
 
        } else {
6981
 
            arg1->Recipient = 0;
6982
 
        }
6983
 
    }
6984
 
}
6985
 
 
6986
 
 
6987
 
DllExport char * SWIGSTDCALL CSharp_get_SamlpResponseAbstract_recipient(void * jarg1) {
6988
 
    char * jresult = 0 ;
6989
 
    LassoSamlpResponseAbstract *arg1 = (LassoSamlpResponseAbstract *) 0 ;
6990
 
    char *result;
6991
 
    
6992
 
    arg1 = (LassoSamlpResponseAbstract *)jarg1; 
6993
 
    result = (char *) ((arg1)->Recipient);
6994
 
    
6995
 
    jresult = SWIG_csharp_string_callback(result); 
6996
 
    return jresult;
6997
 
}
6998
 
 
6999
 
 
7000
 
DllExport void SWIGSTDCALL CSharp_set_SamlpResponseAbstract_responseId(void * jarg1, char * jarg2) {
7001
 
    LassoSamlpResponseAbstract *arg1 = (LassoSamlpResponseAbstract *) 0 ;
7002
 
    char *arg2 = (char *) 0 ;
7003
 
    
7004
 
    arg1 = (LassoSamlpResponseAbstract *)jarg1; 
7005
 
    arg2 = jarg2; 
7006
 
    {
7007
 
        if (arg1->ResponseID) free((char*)arg1->ResponseID);
7008
 
        if (arg2) {
7009
 
            arg1->ResponseID = (char *) malloc(strlen(arg2)+1);
7010
 
            strcpy((char*)arg1->ResponseID,arg2);
7011
 
        } else {
7012
 
            arg1->ResponseID = 0;
7013
 
        }
7014
 
    }
7015
 
}
7016
 
 
7017
 
 
7018
 
DllExport char * SWIGSTDCALL CSharp_get_SamlpResponseAbstract_responseId(void * jarg1) {
7019
 
    char * jresult = 0 ;
7020
 
    LassoSamlpResponseAbstract *arg1 = (LassoSamlpResponseAbstract *) 0 ;
7021
 
    char *result;
7022
 
    
7023
 
    arg1 = (LassoSamlpResponseAbstract *)jarg1; 
7024
 
    result = (char *) ((arg1)->ResponseID);
7025
 
    
7026
 
    jresult = SWIG_csharp_string_callback(result); 
7027
 
    return jresult;
7028
 
}
7029
 
 
7030
 
 
7031
 
DllExport void SWIGSTDCALL CSharp_set_SamlpResponseAbstract_signMethod(void * jarg1, int jarg2) {
7032
 
    LassoSamlpResponseAbstract *arg1 = (LassoSamlpResponseAbstract *) 0 ;
7033
 
    LassoSignatureMethod arg2 ;
7034
 
    
7035
 
    arg1 = (LassoSamlpResponseAbstract *)jarg1; 
7036
 
    arg2 = (LassoSignatureMethod)jarg2; 
7037
 
    if (arg1) (arg1)->sign_method = (LassoSignatureMethod )arg2;
7038
 
    
7039
 
}
7040
 
 
7041
 
 
7042
 
DllExport int SWIGSTDCALL CSharp_get_SamlpResponseAbstract_signMethod(void * jarg1) {
7043
 
    int jresult = 0 ;
7044
 
    LassoSamlpResponseAbstract *arg1 = (LassoSamlpResponseAbstract *) 0 ;
7045
 
    LassoSignatureMethod result;
7046
 
    
7047
 
    arg1 = (LassoSamlpResponseAbstract *)jarg1; 
7048
 
    result = (LassoSignatureMethod) ((arg1)->sign_method);
7049
 
    
7050
 
    jresult = result; 
7051
 
    return jresult;
7052
 
}
7053
 
 
7054
 
 
7055
 
DllExport void SWIGSTDCALL CSharp_set_SamlpResponseAbstract_signType(void * jarg1, void * jarg2) {
7056
 
    LassoSamlpResponseAbstract *arg1 = (LassoSamlpResponseAbstract *) 0 ;
7057
 
    LassoSignatureType arg2 ;
7058
 
    LassoSignatureType *argp2 ;
7059
 
    
7060
 
    arg1 = (LassoSamlpResponseAbstract *)jarg1; 
7061
 
    argp2 = (LassoSignatureType *)jarg2; 
7062
 
    if (!argp2) {
7063
 
        SWIG_CSharpThrowException(SWIG_CSharpNullReferenceException, "Attempt to dereference null LassoSignatureType");
7064
 
    }
7065
 
    arg2 = *argp2; 
7066
 
    if (arg1) (arg1)->sign_type = arg2;
7067
 
    
7068
 
}
7069
 
 
7070
 
 
7071
 
DllExport void * SWIGSTDCALL CSharp_get_SamlpResponseAbstract_signType(void * jarg1) {
7072
 
    void * jresult = 0 ;
7073
 
    LassoSamlpResponseAbstract *arg1 = (LassoSamlpResponseAbstract *) 0 ;
7074
 
    LassoSignatureType result;
7075
 
    
7076
 
    arg1 = (LassoSamlpResponseAbstract *)jarg1; 
7077
 
    result =  ((arg1)->sign_type);
7078
 
    
7079
 
    {
7080
 
        LassoSignatureType * resultptr = (LassoSignatureType *) malloc(sizeof(LassoSignatureType));
7081
 
        memmove(resultptr, &result, sizeof(LassoSignatureType));
7082
 
        jresult = resultptr;
7083
 
    }
7084
 
    return jresult;
7085
 
}
7086
 
 
7087
 
 
7088
 
DllExport char * SWIGSTDCALL CSharp_SamlpResponseAbstract_dump(void * jarg1) {
7089
 
    char * jresult = 0 ;
7090
 
    LassoSamlpResponseAbstract *arg1 = (LassoSamlpResponseAbstract *) 0 ;
7091
 
    char *result;
7092
 
    
7093
 
    arg1 = (LassoSamlpResponseAbstract *)jarg1; 
7094
 
    result = (char *)LassoSamlpResponseAbstract_dump(arg1);
7095
 
    
7096
 
    jresult = SWIG_csharp_string_callback(result); 
7097
 
    free(result);
7098
 
    return jresult;
7099
 
}
7100
 
 
7101
 
 
7102
 
DllExport void SWIGSTDCALL CSharp_set_SamlpStatus_statusMessage(void * jarg1, char * jarg2) {
7103
 
    LassoSamlpStatus *arg1 = (LassoSamlpStatus *) 0 ;
7104
 
    char *arg2 = (char *) 0 ;
7105
 
    
7106
 
    arg1 = (LassoSamlpStatus *)jarg1; 
7107
 
    arg2 = jarg2; 
7108
 
    {
7109
 
        if (arg1->StatusMessage) free((char*)arg1->StatusMessage);
7110
 
        if (arg2) {
7111
 
            arg1->StatusMessage = (char *) malloc(strlen(arg2)+1);
7112
 
            strcpy((char*)arg1->StatusMessage,arg2);
7113
 
        } else {
7114
 
            arg1->StatusMessage = 0;
7115
 
        }
7116
 
    }
7117
 
}
7118
 
 
7119
 
 
7120
 
DllExport char * SWIGSTDCALL CSharp_get_SamlpStatus_statusMessage(void * jarg1) {
7121
 
    char * jresult = 0 ;
7122
 
    LassoSamlpStatus *arg1 = (LassoSamlpStatus *) 0 ;
7123
 
    char *result;
7124
 
    
7125
 
    arg1 = (LassoSamlpStatus *)jarg1; 
7126
 
    result = (char *) ((arg1)->StatusMessage);
7127
 
    
7128
 
    jresult = SWIG_csharp_string_callback(result); 
7129
 
    return jresult;
7130
 
}
7131
 
 
7132
 
 
7133
 
DllExport void SWIGSTDCALL CSharp_set_SamlpStatus_statusCode(void * jarg1, void * jarg2) {
7134
 
    LassoSamlpStatus *arg1 = (LassoSamlpStatus *) 0 ;
7135
 
    LassoSamlpStatusCode *arg2 = (LassoSamlpStatusCode *) 0 ;
7136
 
    
7137
 
    arg1 = (LassoSamlpStatus *)jarg1; 
7138
 
    arg2 = (LassoSamlpStatusCode *)jarg2; 
7139
 
    LassoSamlpStatus_set_StatusCode(arg1,arg2);
7140
 
    
7141
 
}
7142
 
 
7143
 
 
7144
 
DllExport void * SWIGSTDCALL CSharp_get_SamlpStatus_statusCode(void * jarg1) {
7145
 
    void * jresult = 0 ;
7146
 
    LassoSamlpStatus *arg1 = (LassoSamlpStatus *) 0 ;
7147
 
    LassoSamlpStatusCode *result;
7148
 
    
7149
 
    arg1 = (LassoSamlpStatus *)jarg1; 
7150
 
    result = (LassoSamlpStatusCode *)LassoSamlpStatus_get_StatusCode(arg1);
7151
 
    
7152
 
    jresult = (void *)result; 
7153
 
    return jresult;
7154
 
}
7155
 
 
7156
 
 
7157
 
DllExport void * SWIGSTDCALL CSharp_new_SamlpStatus() {
7158
 
    void * jresult = 0 ;
7159
 
    LassoSamlpStatus *result;
7160
 
    
7161
 
    result = (LassoSamlpStatus *)new_LassoSamlpStatus();
7162
 
    
7163
 
    jresult = (void *)result; 
7164
 
    return jresult;
7165
 
}
7166
 
 
7167
 
 
7168
 
DllExport void SWIGSTDCALL CSharp_delete_SamlpStatus(void * jarg1) {
7169
 
    LassoSamlpStatus *arg1 = (LassoSamlpStatus *) 0 ;
7170
 
    
7171
 
    arg1 = (LassoSamlpStatus *)jarg1; 
7172
 
    delete_LassoSamlpStatus(arg1);
7173
 
    
7174
 
}
7175
 
 
7176
 
 
7177
 
DllExport char * SWIGSTDCALL CSharp_SamlpStatus_dump(void * jarg1) {
7178
 
    char * jresult = 0 ;
7179
 
    LassoSamlpStatus *arg1 = (LassoSamlpStatus *) 0 ;
7180
 
    char *result;
7181
 
    
7182
 
    arg1 = (LassoSamlpStatus *)jarg1; 
7183
 
    result = (char *)LassoSamlpStatus_dump(arg1);
7184
 
    
7185
 
    jresult = SWIG_csharp_string_callback(result); 
7186
 
    free(result);
7187
 
    return jresult;
7188
 
}
7189
 
 
7190
 
 
7191
 
DllExport void SWIGSTDCALL CSharp_set_SamlpStatusCode_value(void * jarg1, char * jarg2) {
7192
 
    LassoSamlpStatusCode *arg1 = (LassoSamlpStatusCode *) 0 ;
7193
 
    char *arg2 = (char *) 0 ;
7194
 
    
7195
 
    arg1 = (LassoSamlpStatusCode *)jarg1; 
7196
 
    arg2 = jarg2; 
7197
 
    {
7198
 
        if (arg1->Value) free((char*)arg1->Value);
7199
 
        if (arg2) {
7200
 
            arg1->Value = (char *) malloc(strlen(arg2)+1);
7201
 
            strcpy((char*)arg1->Value,arg2);
7202
 
        } else {
7203
 
            arg1->Value = 0;
7204
 
        }
7205
 
    }
7206
 
}
7207
 
 
7208
 
 
7209
 
DllExport char * SWIGSTDCALL CSharp_get_SamlpStatusCode_value(void * jarg1) {
7210
 
    char * jresult = 0 ;
7211
 
    LassoSamlpStatusCode *arg1 = (LassoSamlpStatusCode *) 0 ;
7212
 
    char *result;
7213
 
    
7214
 
    arg1 = (LassoSamlpStatusCode *)jarg1; 
7215
 
    result = (char *) ((arg1)->Value);
7216
 
    
7217
 
    jresult = SWIG_csharp_string_callback(result); 
7218
 
    return jresult;
7219
 
}
7220
 
 
7221
 
 
7222
 
DllExport void SWIGSTDCALL CSharp_set_SamlpStatusCode_statusCode(void * jarg1, void * jarg2) {
7223
 
    LassoSamlpStatusCode *arg1 = (LassoSamlpStatusCode *) 0 ;
7224
 
    LassoSamlpStatusCode *arg2 = (LassoSamlpStatusCode *) 0 ;
7225
 
    
7226
 
    arg1 = (LassoSamlpStatusCode *)jarg1; 
7227
 
    arg2 = (LassoSamlpStatusCode *)jarg2; 
7228
 
    LassoSamlpStatusCode_set_StatusCode(arg1,arg2);
7229
 
    
7230
 
}
7231
 
 
7232
 
 
7233
 
DllExport void * SWIGSTDCALL CSharp_get_SamlpStatusCode_statusCode(void * jarg1) {
7234
 
    void * jresult = 0 ;
7235
 
    LassoSamlpStatusCode *arg1 = (LassoSamlpStatusCode *) 0 ;
7236
 
    LassoSamlpStatusCode *result;
7237
 
    
7238
 
    arg1 = (LassoSamlpStatusCode *)jarg1; 
7239
 
    result = (LassoSamlpStatusCode *)LassoSamlpStatusCode_get_StatusCode(arg1);
7240
 
    
7241
 
    jresult = (void *)result; 
7242
 
    return jresult;
7243
 
}
7244
 
 
7245
 
 
7246
 
DllExport void * SWIGSTDCALL CSharp_new_SamlpStatusCode() {
7247
 
    void * jresult = 0 ;
7248
 
    LassoSamlpStatusCode *result;
7249
 
    
7250
 
    result = (LassoSamlpStatusCode *)new_LassoSamlpStatusCode();
7251
 
    
7252
 
    jresult = (void *)result; 
7253
 
    return jresult;
7254
 
}
7255
 
 
7256
 
 
7257
 
DllExport void SWIGSTDCALL CSharp_delete_SamlpStatusCode(void * jarg1) {
7258
 
    LassoSamlpStatusCode *arg1 = (LassoSamlpStatusCode *) 0 ;
7259
 
    
7260
 
    arg1 = (LassoSamlpStatusCode *)jarg1; 
7261
 
    delete_LassoSamlpStatusCode(arg1);
7262
 
    
7263
 
}
7264
 
 
7265
 
 
7266
 
DllExport char * SWIGSTDCALL CSharp_SamlpStatusCode_dump(void * jarg1) {
7267
 
    char * jresult = 0 ;
7268
 
    LassoSamlpStatusCode *arg1 = (LassoSamlpStatusCode *) 0 ;
7269
 
    char *result;
7270
 
    
7271
 
    arg1 = (LassoSamlpStatusCode *)jarg1; 
7272
 
    result = (char *)LassoSamlpStatusCode_dump(arg1);
7273
 
    
7274
 
    jresult = SWIG_csharp_string_callback(result); 
7275
 
    free(result);
7276
 
    return jresult;
7277
 
}
7278
 
 
7279
 
 
7280
 
DllExport void SWIGSTDCALL CSharp_set_LibAssertion_advice(void * jarg1, void * jarg2) {
7281
 
    LassoLibAssertion *arg1 = (LassoLibAssertion *) 0 ;
7282
 
    LassoSamlAdvice *arg2 = (LassoSamlAdvice *) 0 ;
7283
 
    
7284
 
    arg1 = (LassoLibAssertion *)jarg1; 
7285
 
    arg2 = (LassoSamlAdvice *)jarg2; 
7286
 
    LassoLibAssertion_set_Advice(arg1,arg2);
7287
 
    
7288
 
}
7289
 
 
7290
 
 
7291
 
DllExport void * SWIGSTDCALL CSharp_get_LibAssertion_advice(void * jarg1) {
7292
 
    void * jresult = 0 ;
7293
 
    LassoLibAssertion *arg1 = (LassoLibAssertion *) 0 ;
7294
 
    LassoSamlAdvice *result;
7295
 
    
7296
 
    arg1 = (LassoLibAssertion *)jarg1; 
7297
 
    result = (LassoSamlAdvice *)LassoLibAssertion_get_Advice(arg1);
7298
 
    
7299
 
    jresult = (void *)result; 
7300
 
    return jresult;
7301
 
}
7302
 
 
7303
 
 
7304
 
DllExport void SWIGSTDCALL CSharp_set_LibAssertion_assertionId(void * jarg1, char * jarg2) {
7305
 
    LassoLibAssertion *arg1 = (LassoLibAssertion *) 0 ;
7306
 
    char *arg2 = (char *) 0 ;
7307
 
    
7308
 
    arg1 = (LassoLibAssertion *)jarg1; 
7309
 
    arg2 = jarg2; 
7310
 
    LassoLibAssertion_set_AssertionID(arg1,arg2);
7311
 
    
7312
 
}
7313
 
 
7314
 
 
7315
 
DllExport char * SWIGSTDCALL CSharp_get_LibAssertion_assertionId(void * jarg1) {
7316
 
    char * jresult = 0 ;
7317
 
    LassoLibAssertion *arg1 = (LassoLibAssertion *) 0 ;
7318
 
    char *result;
7319
 
    
7320
 
    arg1 = (LassoLibAssertion *)jarg1; 
7321
 
    result = (char *)LassoLibAssertion_get_AssertionID(arg1);
7322
 
    
7323
 
    jresult = SWIG_csharp_string_callback(result); 
7324
 
    return jresult;
7325
 
}
7326
 
 
7327
 
 
7328
 
DllExport void SWIGSTDCALL CSharp_set_LibAssertion_attributeStatement(void * jarg1, void * jarg2) {
7329
 
    LassoLibAssertion *arg1 = (LassoLibAssertion *) 0 ;
7330
 
    LassoSamlAttributeStatement *arg2 = (LassoSamlAttributeStatement *) 0 ;
7331
 
    
7332
 
    arg1 = (LassoLibAssertion *)jarg1; 
7333
 
    arg2 = (LassoSamlAttributeStatement *)jarg2; 
7334
 
    LassoLibAssertion_set_AttributeStatement(arg1,arg2);
7335
 
    
7336
 
}
7337
 
 
7338
 
 
7339
 
DllExport void * SWIGSTDCALL CSharp_get_LibAssertion_attributeStatement(void * jarg1) {
7340
 
    void * jresult = 0 ;
7341
 
    LassoLibAssertion *arg1 = (LassoLibAssertion *) 0 ;
7342
 
    LassoSamlAttributeStatement *result;
7343
 
    
7344
 
    arg1 = (LassoLibAssertion *)jarg1; 
7345
 
    result = (LassoSamlAttributeStatement *)LassoLibAssertion_get_AttributeStatement(arg1);
7346
 
    
7347
 
    jresult = (void *)result; 
7348
 
    return jresult;
7349
 
}
7350
 
 
7351
 
 
7352
 
DllExport void SWIGSTDCALL CSharp_set_LibAssertion_authenticationStatement(void * jarg1, void * jarg2) {
7353
 
    LassoLibAssertion *arg1 = (LassoLibAssertion *) 0 ;
7354
 
    LassoSamlAuthenticationStatement *arg2 = (LassoSamlAuthenticationStatement *) 0 ;
7355
 
    
7356
 
    arg1 = (LassoLibAssertion *)jarg1; 
7357
 
    arg2 = (LassoSamlAuthenticationStatement *)jarg2; 
7358
 
    LassoLibAssertion_set_AuthenticationStatement(arg1,arg2);
7359
 
    
7360
 
}
7361
 
 
7362
 
 
7363
 
DllExport void * SWIGSTDCALL CSharp_get_LibAssertion_authenticationStatement(void * jarg1) {
7364
 
    void * jresult = 0 ;
7365
 
    LassoLibAssertion *arg1 = (LassoLibAssertion *) 0 ;
7366
 
    LassoSamlAuthenticationStatement *result;
7367
 
    
7368
 
    arg1 = (LassoLibAssertion *)jarg1; 
7369
 
    result = (LassoSamlAuthenticationStatement *)LassoLibAssertion_get_AuthenticationStatement(arg1);
7370
 
    
7371
 
    jresult = (void *)result; 
7372
 
    return jresult;
7373
 
}
7374
 
 
7375
 
 
7376
 
DllExport void SWIGSTDCALL CSharp_set_LibAssertion_certificateFile(void * jarg1, char * jarg2) {
7377
 
    LassoLibAssertion *arg1 = (LassoLibAssertion *) 0 ;
7378
 
    char *arg2 = (char *) 0 ;
7379
 
    
7380
 
    arg1 = (LassoLibAssertion *)jarg1; 
7381
 
    arg2 = jarg2; 
7382
 
    LassoLibAssertion_set_certificate_file(arg1,arg2);
7383
 
    
7384
 
}
7385
 
 
7386
 
 
7387
 
DllExport char * SWIGSTDCALL CSharp_get_LibAssertion_certificateFile(void * jarg1) {
7388
 
    char * jresult = 0 ;
7389
 
    LassoLibAssertion *arg1 = (LassoLibAssertion *) 0 ;
7390
 
    char *result;
7391
 
    
7392
 
    arg1 = (LassoLibAssertion *)jarg1; 
7393
 
    result = (char *)LassoLibAssertion_get_certificate_file(arg1);
7394
 
    
7395
 
    jresult = SWIG_csharp_string_callback(result); 
7396
 
    return jresult;
7397
 
}
7398
 
 
7399
 
 
7400
 
DllExport void SWIGSTDCALL CSharp_set_LibAssertion_conditions(void * jarg1, void * jarg2) {
7401
 
    LassoLibAssertion *arg1 = (LassoLibAssertion *) 0 ;
7402
 
    LassoSamlConditions *arg2 = (LassoSamlConditions *) 0 ;
7403
 
    
7404
 
    arg1 = (LassoLibAssertion *)jarg1; 
7405
 
    arg2 = (LassoSamlConditions *)jarg2; 
7406
 
    LassoLibAssertion_set_Conditions(arg1,arg2);
7407
 
    
7408
 
}
7409
 
 
7410
 
 
7411
 
DllExport void * SWIGSTDCALL CSharp_get_LibAssertion_conditions(void * jarg1) {
7412
 
    void * jresult = 0 ;
7413
 
    LassoLibAssertion *arg1 = (LassoLibAssertion *) 0 ;
7414
 
    LassoSamlConditions *result;
7415
 
    
7416
 
    arg1 = (LassoLibAssertion *)jarg1; 
7417
 
    result = (LassoSamlConditions *)LassoLibAssertion_get_Conditions(arg1);
7418
 
    
7419
 
    jresult = (void *)result; 
7420
 
    return jresult;
7421
 
}
7422
 
 
7423
 
 
7424
 
DllExport void SWIGSTDCALL CSharp_set_LibAssertion_issueInstant(void * jarg1, char * jarg2) {
7425
 
    LassoLibAssertion *arg1 = (LassoLibAssertion *) 0 ;
7426
 
    char *arg2 = (char *) 0 ;
7427
 
    
7428
 
    arg1 = (LassoLibAssertion *)jarg1; 
7429
 
    arg2 = jarg2; 
7430
 
    LassoLibAssertion_set_IssueInstant(arg1,arg2);
7431
 
    
7432
 
}
7433
 
 
7434
 
 
7435
 
DllExport char * SWIGSTDCALL CSharp_get_LibAssertion_issueInstant(void * jarg1) {
7436
 
    char * jresult = 0 ;
7437
 
    LassoLibAssertion *arg1 = (LassoLibAssertion *) 0 ;
7438
 
    char *result;
7439
 
    
7440
 
    arg1 = (LassoLibAssertion *)jarg1; 
7441
 
    result = (char *)LassoLibAssertion_get_IssueInstant(arg1);
7442
 
    
7443
 
    jresult = SWIG_csharp_string_callback(result); 
7444
 
    return jresult;
7445
 
}
7446
 
 
7447
 
 
7448
 
DllExport void SWIGSTDCALL CSharp_set_LibAssertion_issuer(void * jarg1, char * jarg2) {
7449
 
    LassoLibAssertion *arg1 = (LassoLibAssertion *) 0 ;
7450
 
    char *arg2 = (char *) 0 ;
7451
 
    
7452
 
    arg1 = (LassoLibAssertion *)jarg1; 
7453
 
    arg2 = jarg2; 
7454
 
    LassoLibAssertion_set_Issuer(arg1,arg2);
7455
 
    
7456
 
}
7457
 
 
7458
 
 
7459
 
DllExport char * SWIGSTDCALL CSharp_get_LibAssertion_issuer(void * jarg1) {
7460
 
    char * jresult = 0 ;
7461
 
    LassoLibAssertion *arg1 = (LassoLibAssertion *) 0 ;
7462
 
    char *result;
7463
 
    
7464
 
    arg1 = (LassoLibAssertion *)jarg1; 
7465
 
    result = (char *)LassoLibAssertion_get_Issuer(arg1);
7466
 
    
7467
 
    jresult = SWIG_csharp_string_callback(result); 
7468
 
    return jresult;
7469
 
}
7470
 
 
7471
 
 
7472
 
DllExport void SWIGSTDCALL CSharp_set_LibAssertion_majorVersion(void * jarg1, int jarg2) {
7473
 
    LassoLibAssertion *arg1 = (LassoLibAssertion *) 0 ;
7474
 
    int arg2 ;
7475
 
    
7476
 
    arg1 = (LassoLibAssertion *)jarg1; 
7477
 
    arg2 = (int)jarg2; 
7478
 
    LassoLibAssertion_set_MajorVersion(arg1,arg2);
7479
 
    
7480
 
}
7481
 
 
7482
 
 
7483
 
DllExport int SWIGSTDCALL CSharp_get_LibAssertion_majorVersion(void * jarg1) {
7484
 
    int jresult = 0 ;
7485
 
    LassoLibAssertion *arg1 = (LassoLibAssertion *) 0 ;
7486
 
    int result;
7487
 
    
7488
 
    arg1 = (LassoLibAssertion *)jarg1; 
7489
 
    result = (int)LassoLibAssertion_get_MajorVersion(arg1);
7490
 
    
7491
 
    jresult = result; 
7492
 
    return jresult;
7493
 
}
7494
 
 
7495
 
 
7496
 
DllExport void SWIGSTDCALL CSharp_set_LibAssertion_minorVersion(void * jarg1, int jarg2) {
7497
 
    LassoLibAssertion *arg1 = (LassoLibAssertion *) 0 ;
7498
 
    int arg2 ;
7499
 
    
7500
 
    arg1 = (LassoLibAssertion *)jarg1; 
7501
 
    arg2 = (int)jarg2; 
7502
 
    LassoLibAssertion_set_MinorVersion(arg1,arg2);
7503
 
    
7504
 
}
7505
 
 
7506
 
 
7507
 
DllExport int SWIGSTDCALL CSharp_get_LibAssertion_minorVersion(void * jarg1) {
7508
 
    int jresult = 0 ;
7509
 
    LassoLibAssertion *arg1 = (LassoLibAssertion *) 0 ;
7510
 
    int result;
7511
 
    
7512
 
    arg1 = (LassoLibAssertion *)jarg1; 
7513
 
    result = (int)LassoLibAssertion_get_MinorVersion(arg1);
7514
 
    
7515
 
    jresult = result; 
7516
 
    return jresult;
7517
 
}
7518
 
 
7519
 
 
7520
 
DllExport void SWIGSTDCALL CSharp_set_LibAssertion_privateKeyFile(void * jarg1, char * jarg2) {
7521
 
    LassoLibAssertion *arg1 = (LassoLibAssertion *) 0 ;
7522
 
    char *arg2 = (char *) 0 ;
7523
 
    
7524
 
    arg1 = (LassoLibAssertion *)jarg1; 
7525
 
    arg2 = jarg2; 
7526
 
    LassoLibAssertion_set_private_key_file(arg1,arg2);
7527
 
    
7528
 
}
7529
 
 
7530
 
 
7531
 
DllExport char * SWIGSTDCALL CSharp_get_LibAssertion_privateKeyFile(void * jarg1) {
7532
 
    char * jresult = 0 ;
7533
 
    LassoLibAssertion *arg1 = (LassoLibAssertion *) 0 ;
7534
 
    char *result;
7535
 
    
7536
 
    arg1 = (LassoLibAssertion *)jarg1; 
7537
 
    result = (char *)LassoLibAssertion_get_private_key_file(arg1);
7538
 
    
7539
 
    jresult = SWIG_csharp_string_callback(result); 
7540
 
    return jresult;
7541
 
}
7542
 
 
7543
 
 
7544
 
DllExport void SWIGSTDCALL CSharp_set_LibAssertion_signMethod(void * jarg1, int jarg2) {
7545
 
    LassoLibAssertion *arg1 = (LassoLibAssertion *) 0 ;
7546
 
    LassoSignatureMethod arg2 ;
7547
 
    
7548
 
    arg1 = (LassoLibAssertion *)jarg1; 
7549
 
    arg2 = (LassoSignatureMethod)jarg2; 
7550
 
    LassoLibAssertion_set_sign_method(arg1,(LassoSignatureMethod )arg2);
7551
 
    
7552
 
}
7553
 
 
7554
 
 
7555
 
DllExport int SWIGSTDCALL CSharp_get_LibAssertion_signMethod(void * jarg1) {
7556
 
    int jresult = 0 ;
7557
 
    LassoLibAssertion *arg1 = (LassoLibAssertion *) 0 ;
7558
 
    LassoSignatureMethod result;
7559
 
    
7560
 
    arg1 = (LassoLibAssertion *)jarg1; 
7561
 
    result = (LassoSignatureMethod)LassoLibAssertion_get_sign_method(arg1);
7562
 
    
7563
 
    jresult = result; 
7564
 
    return jresult;
7565
 
}
7566
 
 
7567
 
 
7568
 
DllExport void SWIGSTDCALL CSharp_set_LibAssertion_signType(void * jarg1, void * jarg2) {
7569
 
    LassoLibAssertion *arg1 = (LassoLibAssertion *) 0 ;
7570
 
    LassoSignatureType arg2 ;
7571
 
    LassoSignatureType *argp2 ;
7572
 
    
7573
 
    arg1 = (LassoLibAssertion *)jarg1; 
7574
 
    argp2 = (LassoSignatureType *)jarg2; 
7575
 
    if (!argp2) {
7576
 
        SWIG_CSharpThrowException(SWIG_CSharpNullReferenceException, "Attempt to dereference null LassoSignatureType");
7577
 
    }
7578
 
    arg2 = *argp2; 
7579
 
    LassoLibAssertion_set_sign_type(arg1,arg2);
7580
 
    
7581
 
}
7582
 
 
7583
 
 
7584
 
DllExport void * SWIGSTDCALL CSharp_get_LibAssertion_signType(void * jarg1) {
7585
 
    void * jresult = 0 ;
7586
 
    LassoLibAssertion *arg1 = (LassoLibAssertion *) 0 ;
7587
 
    LassoSignatureType result;
7588
 
    
7589
 
    arg1 = (LassoLibAssertion *)jarg1; 
7590
 
    result = LassoLibAssertion_get_sign_type(arg1);
7591
 
    
7592
 
    {
7593
 
        LassoSignatureType * resultptr = (LassoSignatureType *) malloc(sizeof(LassoSignatureType));
7594
 
        memmove(resultptr, &result, sizeof(LassoSignatureType));
7595
 
        jresult = resultptr;
7596
 
    }
7597
 
    return jresult;
7598
 
}
7599
 
 
7600
 
 
7601
 
DllExport void SWIGSTDCALL CSharp_set_LibAssertion_subjectStatement(void * jarg1, void * jarg2) {
7602
 
    LassoLibAssertion *arg1 = (LassoLibAssertion *) 0 ;
7603
 
    LassoSamlSubjectStatement *arg2 = (LassoSamlSubjectStatement *) 0 ;
7604
 
    
7605
 
    arg1 = (LassoLibAssertion *)jarg1; 
7606
 
    arg2 = (LassoSamlSubjectStatement *)jarg2; 
7607
 
    LassoLibAssertion_set_SubjectStatement(arg1,arg2);
7608
 
    
7609
 
}
7610
 
 
7611
 
 
7612
 
DllExport void * SWIGSTDCALL CSharp_get_LibAssertion_subjectStatement(void * jarg1) {
7613
 
    void * jresult = 0 ;
7614
 
    LassoLibAssertion *arg1 = (LassoLibAssertion *) 0 ;
7615
 
    LassoSamlSubjectStatement *result;
7616
 
    
7617
 
    arg1 = (LassoLibAssertion *)jarg1; 
7618
 
    result = (LassoSamlSubjectStatement *)LassoLibAssertion_get_SubjectStatement(arg1);
7619
 
    
7620
 
    jresult = (void *)result; 
7621
 
    return jresult;
7622
 
}
7623
 
 
7624
 
 
7625
 
DllExport void * SWIGSTDCALL CSharp_new_LibAssertion() {
7626
 
    void * jresult = 0 ;
7627
 
    LassoLibAssertion *result;
7628
 
    
7629
 
    result = (LassoLibAssertion *)new_LassoLibAssertion();
7630
 
    
7631
 
    jresult = (void *)result; 
7632
 
    return jresult;
7633
 
}
7634
 
 
7635
 
 
7636
 
DllExport void SWIGSTDCALL CSharp_delete_LibAssertion(void * jarg1) {
7637
 
    LassoLibAssertion *arg1 = (LassoLibAssertion *) 0 ;
7638
 
    
7639
 
    arg1 = (LassoLibAssertion *)jarg1; 
7640
 
    delete_LassoLibAssertion(arg1);
7641
 
    
7642
 
}
7643
 
 
7644
 
 
7645
 
DllExport void * SWIGSTDCALL CSharp_LibAssertion_newFull(char * jarg1, char * jarg2, char * jarg3, char * jarg4, char * jarg5) {
7646
 
    void * jresult = 0 ;
7647
 
    char *arg1 = (char *) 0 ;
7648
 
    char *arg2 = (char *) 0 ;
7649
 
    char *arg3 = (char *) 0 ;
7650
 
    char *arg4 = (char *) 0 ;
7651
 
    char *arg5 = (char *) 0 ;
7652
 
    LassoLibAssertion *result;
7653
 
    
7654
 
    arg1 = jarg1; 
7655
 
    arg2 = jarg2; 
7656
 
    arg3 = jarg3; 
7657
 
    arg4 = jarg4; 
7658
 
    arg5 = jarg5; 
7659
 
    result = (LassoLibAssertion *)LibAssertion_newFull(arg1,arg2,arg3,arg4,arg5);
7660
 
    
7661
 
    jresult = (void *)result; 
7662
 
    return jresult;
7663
 
}
7664
 
 
7665
 
 
7666
 
DllExport char * SWIGSTDCALL CSharp_LibAssertion_dump(void * jarg1) {
7667
 
    char * jresult = 0 ;
7668
 
    LassoLibAssertion *arg1 = (LassoLibAssertion *) 0 ;
7669
 
    char *result;
7670
 
    
7671
 
    arg1 = (LassoLibAssertion *)jarg1; 
7672
 
    result = (char *)LassoLibAssertion_dump(arg1);
7673
 
    
7674
 
    jresult = SWIG_csharp_string_callback(result); 
7675
 
    free(result);
7676
 
    return jresult;
7677
 
}
7678
 
 
7679
 
 
7680
 
DllExport void SWIGSTDCALL CSharp_set_LibAuthnRequest_affiliationId(void * jarg1, char * jarg2) {
7681
 
    LassoLibAuthnRequest *arg1 = (LassoLibAuthnRequest *) 0 ;
7682
 
    char *arg2 = (char *) 0 ;
7683
 
    
7684
 
    arg1 = (LassoLibAuthnRequest *)jarg1; 
7685
 
    arg2 = jarg2; 
7686
 
    {
7687
 
        if (arg1->AffiliationID) free((char*)arg1->AffiliationID);
7688
 
        if (arg2) {
7689
 
            arg1->AffiliationID = (char *) malloc(strlen(arg2)+1);
7690
 
            strcpy((char*)arg1->AffiliationID,arg2);
7691
 
        } else {
7692
 
            arg1->AffiliationID = 0;
7693
 
        }
7694
 
    }
7695
 
}
7696
 
 
7697
 
 
7698
 
DllExport char * SWIGSTDCALL CSharp_get_LibAuthnRequest_affiliationId(void * jarg1) {
7699
 
    char * jresult = 0 ;
7700
 
    LassoLibAuthnRequest *arg1 = (LassoLibAuthnRequest *) 0 ;
7701
 
    char *result;
7702
 
    
7703
 
    arg1 = (LassoLibAuthnRequest *)jarg1; 
7704
 
    result = (char *) ((arg1)->AffiliationID);
7705
 
    
7706
 
    jresult = SWIG_csharp_string_callback(result); 
7707
 
    return jresult;
7708
 
}
7709
 
 
7710
 
 
7711
 
DllExport void SWIGSTDCALL CSharp_set_LibAuthnRequest_assertionConsumerServiceId(void * jarg1, char * jarg2) {
7712
 
    LassoLibAuthnRequest *arg1 = (LassoLibAuthnRequest *) 0 ;
7713
 
    char *arg2 = (char *) 0 ;
7714
 
    
7715
 
    arg1 = (LassoLibAuthnRequest *)jarg1; 
7716
 
    arg2 = jarg2; 
7717
 
    {
7718
 
        if (arg1->AssertionConsumerServiceID) free((char*)arg1->AssertionConsumerServiceID);
7719
 
        if (arg2) {
7720
 
            arg1->AssertionConsumerServiceID = (char *) malloc(strlen(arg2)+1);
7721
 
            strcpy((char*)arg1->AssertionConsumerServiceID,arg2);
7722
 
        } else {
7723
 
            arg1->AssertionConsumerServiceID = 0;
7724
 
        }
7725
 
    }
7726
 
}
7727
 
 
7728
 
 
7729
 
DllExport char * SWIGSTDCALL CSharp_get_LibAuthnRequest_assertionConsumerServiceId(void * jarg1) {
7730
 
    char * jresult = 0 ;
7731
 
    LassoLibAuthnRequest *arg1 = (LassoLibAuthnRequest *) 0 ;
7732
 
    char *result;
7733
 
    
7734
 
    arg1 = (LassoLibAuthnRequest *)jarg1; 
7735
 
    result = (char *) ((arg1)->AssertionConsumerServiceID);
7736
 
    
7737
 
    jresult = SWIG_csharp_string_callback(result); 
7738
 
    return jresult;
7739
 
}
7740
 
 
7741
 
 
7742
 
DllExport void SWIGSTDCALL CSharp_set_LibAuthnRequest_consent(void * jarg1, char * jarg2) {
7743
 
    LassoLibAuthnRequest *arg1 = (LassoLibAuthnRequest *) 0 ;
7744
 
    char *arg2 = (char *) 0 ;
7745
 
    
7746
 
    arg1 = (LassoLibAuthnRequest *)jarg1; 
7747
 
    arg2 = jarg2; 
7748
 
    {
7749
 
        if (arg1->consent) free((char*)arg1->consent);
7750
 
        if (arg2) {
7751
 
            arg1->consent = (char *) malloc(strlen(arg2)+1);
7752
 
            strcpy((char*)arg1->consent,arg2);
7753
 
        } else {
7754
 
            arg1->consent = 0;
7755
 
        }
7756
 
    }
7757
 
}
7758
 
 
7759
 
 
7760
 
DllExport char * SWIGSTDCALL CSharp_get_LibAuthnRequest_consent(void * jarg1) {
7761
 
    char * jresult = 0 ;
7762
 
    LassoLibAuthnRequest *arg1 = (LassoLibAuthnRequest *) 0 ;
7763
 
    char *result;
7764
 
    
7765
 
    arg1 = (LassoLibAuthnRequest *)jarg1; 
7766
 
    result = (char *) ((arg1)->consent);
7767
 
    
7768
 
    jresult = SWIG_csharp_string_callback(result); 
7769
 
    return jresult;
7770
 
}
7771
 
 
7772
 
 
7773
 
DllExport void SWIGSTDCALL CSharp_set_LibAuthnRequest_forceAuthn(void * jarg1, unsigned int jarg2) {
7774
 
    LassoLibAuthnRequest *arg1 = (LassoLibAuthnRequest *) 0 ;
7775
 
    bool arg2 ;
7776
 
    
7777
 
    arg1 = (LassoLibAuthnRequest *)jarg1; 
7778
 
    arg2 = jarg2 ? true : false; 
7779
 
    if (arg1) (arg1)->ForceAuthn = arg2;
7780
 
    
7781
 
}
7782
 
 
7783
 
 
7784
 
DllExport unsigned int SWIGSTDCALL CSharp_get_LibAuthnRequest_forceAuthn(void * jarg1) {
7785
 
    unsigned int jresult = 0 ;
7786
 
    LassoLibAuthnRequest *arg1 = (LassoLibAuthnRequest *) 0 ;
7787
 
    bool result;
7788
 
    
7789
 
    arg1 = (LassoLibAuthnRequest *)jarg1; 
7790
 
    result = (bool) ((arg1)->ForceAuthn);
7791
 
    
7792
 
    jresult = result; 
7793
 
    return jresult;
7794
 
}
7795
 
 
7796
 
 
7797
 
DllExport void SWIGSTDCALL CSharp_set_LibAuthnRequest_isPassive(void * jarg1, unsigned int jarg2) {
7798
 
    LassoLibAuthnRequest *arg1 = (LassoLibAuthnRequest *) 0 ;
7799
 
    bool arg2 ;
7800
 
    
7801
 
    arg1 = (LassoLibAuthnRequest *)jarg1; 
7802
 
    arg2 = jarg2 ? true : false; 
7803
 
    if (arg1) (arg1)->IsPassive = arg2;
7804
 
    
7805
 
}
7806
 
 
7807
 
 
7808
 
DllExport unsigned int SWIGSTDCALL CSharp_get_LibAuthnRequest_isPassive(void * jarg1) {
7809
 
    unsigned int jresult = 0 ;
7810
 
    LassoLibAuthnRequest *arg1 = (LassoLibAuthnRequest *) 0 ;
7811
 
    bool result;
7812
 
    
7813
 
    arg1 = (LassoLibAuthnRequest *)jarg1; 
7814
 
    result = (bool) ((arg1)->IsPassive);
7815
 
    
7816
 
    jresult = result; 
7817
 
    return jresult;
7818
 
}
7819
 
 
7820
 
 
7821
 
DllExport void SWIGSTDCALL CSharp_set_LibAuthnRequest_nameIdPolicy(void * jarg1, char * jarg2) {
7822
 
    LassoLibAuthnRequest *arg1 = (LassoLibAuthnRequest *) 0 ;
7823
 
    char *arg2 = (char *) 0 ;
7824
 
    
7825
 
    arg1 = (LassoLibAuthnRequest *)jarg1; 
7826
 
    arg2 = jarg2; 
7827
 
    {
7828
 
        if (arg1->NameIDPolicy) free((char*)arg1->NameIDPolicy);
7829
 
        if (arg2) {
7830
 
            arg1->NameIDPolicy = (char *) malloc(strlen(arg2)+1);
7831
 
            strcpy((char*)arg1->NameIDPolicy,arg2);
7832
 
        } else {
7833
 
            arg1->NameIDPolicy = 0;
7834
 
        }
7835
 
    }
7836
 
}
7837
 
 
7838
 
 
7839
 
DllExport char * SWIGSTDCALL CSharp_get_LibAuthnRequest_nameIdPolicy(void * jarg1) {
7840
 
    char * jresult = 0 ;
7841
 
    LassoLibAuthnRequest *arg1 = (LassoLibAuthnRequest *) 0 ;
7842
 
    char *result;
7843
 
    
7844
 
    arg1 = (LassoLibAuthnRequest *)jarg1; 
7845
 
    result = (char *) ((arg1)->NameIDPolicy);
7846
 
    
7847
 
    jresult = SWIG_csharp_string_callback(result); 
7848
 
    return jresult;
7849
 
}
7850
 
 
7851
 
 
7852
 
DllExport void SWIGSTDCALL CSharp_set_LibAuthnRequest_protocolProfile(void * jarg1, char * jarg2) {
7853
 
    LassoLibAuthnRequest *arg1 = (LassoLibAuthnRequest *) 0 ;
7854
 
    char *arg2 = (char *) 0 ;
7855
 
    
7856
 
    arg1 = (LassoLibAuthnRequest *)jarg1; 
7857
 
    arg2 = jarg2; 
7858
 
    {
7859
 
        if (arg1->ProtocolProfile) free((char*)arg1->ProtocolProfile);
7860
 
        if (arg2) {
7861
 
            arg1->ProtocolProfile = (char *) malloc(strlen(arg2)+1);
7862
 
            strcpy((char*)arg1->ProtocolProfile,arg2);
7863
 
        } else {
7864
 
            arg1->ProtocolProfile = 0;
7865
 
        }
7866
 
    }
7867
 
}
7868
 
 
7869
 
 
7870
 
DllExport char * SWIGSTDCALL CSharp_get_LibAuthnRequest_protocolProfile(void * jarg1) {
7871
 
    char * jresult = 0 ;
7872
 
    LassoLibAuthnRequest *arg1 = (LassoLibAuthnRequest *) 0 ;
7873
 
    char *result;
7874
 
    
7875
 
    arg1 = (LassoLibAuthnRequest *)jarg1; 
7876
 
    result = (char *) ((arg1)->ProtocolProfile);
7877
 
    
7878
 
    jresult = SWIG_csharp_string_callback(result); 
7879
 
    return jresult;
7880
 
}
7881
 
 
7882
 
 
7883
 
DllExport void SWIGSTDCALL CSharp_set_LibAuthnRequest_providerId(void * jarg1, char * jarg2) {
7884
 
    LassoLibAuthnRequest *arg1 = (LassoLibAuthnRequest *) 0 ;
7885
 
    char *arg2 = (char *) 0 ;
7886
 
    
7887
 
    arg1 = (LassoLibAuthnRequest *)jarg1; 
7888
 
    arg2 = jarg2; 
7889
 
    {
7890
 
        if (arg1->ProviderID) free((char*)arg1->ProviderID);
7891
 
        if (arg2) {
7892
 
            arg1->ProviderID = (char *) malloc(strlen(arg2)+1);
7893
 
            strcpy((char*)arg1->ProviderID,arg2);
7894
 
        } else {
7895
 
            arg1->ProviderID = 0;
7896
 
        }
7897
 
    }
7898
 
}
7899
 
 
7900
 
 
7901
 
DllExport char * SWIGSTDCALL CSharp_get_LibAuthnRequest_providerId(void * jarg1) {
7902
 
    char * jresult = 0 ;
7903
 
    LassoLibAuthnRequest *arg1 = (LassoLibAuthnRequest *) 0 ;
7904
 
    char *result;
7905
 
    
7906
 
    arg1 = (LassoLibAuthnRequest *)jarg1; 
7907
 
    result = (char *) ((arg1)->ProviderID);
7908
 
    
7909
 
    jresult = SWIG_csharp_string_callback(result); 
7910
 
    return jresult;
7911
 
}
7912
 
 
7913
 
 
7914
 
DllExport void SWIGSTDCALL CSharp_set_LibAuthnRequest_relayState(void * jarg1, char * jarg2) {
7915
 
    LassoLibAuthnRequest *arg1 = (LassoLibAuthnRequest *) 0 ;
7916
 
    char *arg2 = (char *) 0 ;
7917
 
    
7918
 
    arg1 = (LassoLibAuthnRequest *)jarg1; 
7919
 
    arg2 = jarg2; 
7920
 
    {
7921
 
        if (arg1->RelayState) free((char*)arg1->RelayState);
7922
 
        if (arg2) {
7923
 
            arg1->RelayState = (char *) malloc(strlen(arg2)+1);
7924
 
            strcpy((char*)arg1->RelayState,arg2);
7925
 
        } else {
7926
 
            arg1->RelayState = 0;
7927
 
        }
7928
 
    }
7929
 
}
7930
 
 
7931
 
 
7932
 
DllExport char * SWIGSTDCALL CSharp_get_LibAuthnRequest_relayState(void * jarg1) {
7933
 
    char * jresult = 0 ;
7934
 
    LassoLibAuthnRequest *arg1 = (LassoLibAuthnRequest *) 0 ;
7935
 
    char *result;
7936
 
    
7937
 
    arg1 = (LassoLibAuthnRequest *)jarg1; 
7938
 
    result = (char *) ((arg1)->RelayState);
7939
 
    
7940
 
    jresult = SWIG_csharp_string_callback(result); 
7941
 
    return jresult;
7942
 
}
7943
 
 
7944
 
 
7945
 
DllExport void SWIGSTDCALL CSharp_set_LibAuthnRequest_certificateFile(void * jarg1, char * jarg2) {
7946
 
    LassoLibAuthnRequest *arg1 = (LassoLibAuthnRequest *) 0 ;
7947
 
    char *arg2 = (char *) 0 ;
7948
 
    
7949
 
    arg1 = (LassoLibAuthnRequest *)jarg1; 
7950
 
    arg2 = jarg2; 
7951
 
    LassoLibAuthnRequest_set_certificate_file(arg1,arg2);
7952
 
    
7953
 
}
7954
 
 
7955
 
 
7956
 
DllExport char * SWIGSTDCALL CSharp_get_LibAuthnRequest_certificateFile(void * jarg1) {
7957
 
    char * jresult = 0 ;
7958
 
    LassoLibAuthnRequest *arg1 = (LassoLibAuthnRequest *) 0 ;
7959
 
    char *result;
7960
 
    
7961
 
    arg1 = (LassoLibAuthnRequest *)jarg1; 
7962
 
    result = (char *)LassoLibAuthnRequest_get_certificate_file(arg1);
7963
 
    
7964
 
    jresult = SWIG_csharp_string_callback(result); 
7965
 
    return jresult;
7966
 
}
7967
 
 
7968
 
 
7969
 
DllExport void SWIGSTDCALL CSharp_set_LibAuthnRequest_issueInstant(void * jarg1, char * jarg2) {
7970
 
    LassoLibAuthnRequest *arg1 = (LassoLibAuthnRequest *) 0 ;
7971
 
    char *arg2 = (char *) 0 ;
7972
 
    
7973
 
    arg1 = (LassoLibAuthnRequest *)jarg1; 
7974
 
    arg2 = jarg2; 
7975
 
    LassoLibAuthnRequest_set_IssueInstant(arg1,arg2);
7976
 
    
7977
 
}
7978
 
 
7979
 
 
7980
 
DllExport char * SWIGSTDCALL CSharp_get_LibAuthnRequest_issueInstant(void * jarg1) {
7981
 
    char * jresult = 0 ;
7982
 
    LassoLibAuthnRequest *arg1 = (LassoLibAuthnRequest *) 0 ;
7983
 
    char *result;
7984
 
    
7985
 
    arg1 = (LassoLibAuthnRequest *)jarg1; 
7986
 
    result = (char *)LassoLibAuthnRequest_get_IssueInstant(arg1);
7987
 
    
7988
 
    jresult = SWIG_csharp_string_callback(result); 
7989
 
    return jresult;
7990
 
}
7991
 
 
7992
 
 
7993
 
DllExport void SWIGSTDCALL CSharp_set_LibAuthnRequest_majorVersion(void * jarg1, int jarg2) {
7994
 
    LassoLibAuthnRequest *arg1 = (LassoLibAuthnRequest *) 0 ;
7995
 
    int arg2 ;
7996
 
    
7997
 
    arg1 = (LassoLibAuthnRequest *)jarg1; 
7998
 
    arg2 = (int)jarg2; 
7999
 
    LassoLibAuthnRequest_set_MajorVersion(arg1,arg2);
8000
 
    
8001
 
}
8002
 
 
8003
 
 
8004
 
DllExport int SWIGSTDCALL CSharp_get_LibAuthnRequest_majorVersion(void * jarg1) {
8005
 
    int jresult = 0 ;
8006
 
    LassoLibAuthnRequest *arg1 = (LassoLibAuthnRequest *) 0 ;
8007
 
    int result;
8008
 
    
8009
 
    arg1 = (LassoLibAuthnRequest *)jarg1; 
8010
 
    result = (int)LassoLibAuthnRequest_get_MajorVersion(arg1);
8011
 
    
8012
 
    jresult = result; 
8013
 
    return jresult;
8014
 
}
8015
 
 
8016
 
 
8017
 
DllExport void SWIGSTDCALL CSharp_set_LibAuthnRequest_minorVersion(void * jarg1, int jarg2) {
8018
 
    LassoLibAuthnRequest *arg1 = (LassoLibAuthnRequest *) 0 ;
8019
 
    int arg2 ;
8020
 
    
8021
 
    arg1 = (LassoLibAuthnRequest *)jarg1; 
8022
 
    arg2 = (int)jarg2; 
8023
 
    LassoLibAuthnRequest_set_MinorVersion(arg1,arg2);
8024
 
    
8025
 
}
8026
 
 
8027
 
 
8028
 
DllExport int SWIGSTDCALL CSharp_get_LibAuthnRequest_minorVersion(void * jarg1) {
8029
 
    int jresult = 0 ;
8030
 
    LassoLibAuthnRequest *arg1 = (LassoLibAuthnRequest *) 0 ;
8031
 
    int result;
8032
 
    
8033
 
    arg1 = (LassoLibAuthnRequest *)jarg1; 
8034
 
    result = (int)LassoLibAuthnRequest_get_MinorVersion(arg1);
8035
 
    
8036
 
    jresult = result; 
8037
 
    return jresult;
8038
 
}
8039
 
 
8040
 
 
8041
 
DllExport void SWIGSTDCALL CSharp_set_LibAuthnRequest_privateKeyFile(void * jarg1, char * jarg2) {
8042
 
    LassoLibAuthnRequest *arg1 = (LassoLibAuthnRequest *) 0 ;
8043
 
    char *arg2 = (char *) 0 ;
8044
 
    
8045
 
    arg1 = (LassoLibAuthnRequest *)jarg1; 
8046
 
    arg2 = jarg2; 
8047
 
    LassoLibAuthnRequest_set_private_key_file(arg1,arg2);
8048
 
    
8049
 
}
8050
 
 
8051
 
 
8052
 
DllExport char * SWIGSTDCALL CSharp_get_LibAuthnRequest_privateKeyFile(void * jarg1) {
8053
 
    char * jresult = 0 ;
8054
 
    LassoLibAuthnRequest *arg1 = (LassoLibAuthnRequest *) 0 ;
8055
 
    char *result;
8056
 
    
8057
 
    arg1 = (LassoLibAuthnRequest *)jarg1; 
8058
 
    result = (char *)LassoLibAuthnRequest_get_private_key_file(arg1);
8059
 
    
8060
 
    jresult = SWIG_csharp_string_callback(result); 
8061
 
    return jresult;
8062
 
}
8063
 
 
8064
 
 
8065
 
DllExport void SWIGSTDCALL CSharp_set_LibAuthnRequest_requestId(void * jarg1, char * jarg2) {
8066
 
    LassoLibAuthnRequest *arg1 = (LassoLibAuthnRequest *) 0 ;
8067
 
    char *arg2 = (char *) 0 ;
8068
 
    
8069
 
    arg1 = (LassoLibAuthnRequest *)jarg1; 
8070
 
    arg2 = jarg2; 
8071
 
    LassoLibAuthnRequest_set_RequestID(arg1,arg2);
8072
 
    
8073
 
}
8074
 
 
8075
 
 
8076
 
DllExport char * SWIGSTDCALL CSharp_get_LibAuthnRequest_requestId(void * jarg1) {
8077
 
    char * jresult = 0 ;
8078
 
    LassoLibAuthnRequest *arg1 = (LassoLibAuthnRequest *) 0 ;
8079
 
    char *result;
8080
 
    
8081
 
    arg1 = (LassoLibAuthnRequest *)jarg1; 
8082
 
    result = (char *)LassoLibAuthnRequest_get_RequestID(arg1);
8083
 
    
8084
 
    jresult = SWIG_csharp_string_callback(result); 
8085
 
    return jresult;
8086
 
}
8087
 
 
8088
 
 
8089
 
DllExport void SWIGSTDCALL CSharp_set_LibAuthnRequest_respondWith(void * jarg1, void * jarg2) {
8090
 
    LassoLibAuthnRequest *arg1 = (LassoLibAuthnRequest *) 0 ;
8091
 
    LassoStringList *arg2 = (LassoStringList *) 0 ;
8092
 
    
8093
 
    arg1 = (LassoLibAuthnRequest *)jarg1; 
8094
 
    arg2 = (LassoStringList *)jarg2; 
8095
 
    LassoLibAuthnRequest_set_RespondWith(arg1,arg2);
8096
 
    
8097
 
}
8098
 
 
8099
 
 
8100
 
DllExport void * SWIGSTDCALL CSharp_get_LibAuthnRequest_respondWith(void * jarg1) {
8101
 
    void * jresult = 0 ;
8102
 
    LassoLibAuthnRequest *arg1 = (LassoLibAuthnRequest *) 0 ;
8103
 
    LassoStringList *result;
8104
 
    
8105
 
    arg1 = (LassoLibAuthnRequest *)jarg1; 
8106
 
    result = (LassoStringList *)LassoLibAuthnRequest_get_RespondWith(arg1);
8107
 
    
8108
 
    jresult = (void *)result; 
8109
 
    return jresult;
8110
 
}
8111
 
 
8112
 
 
8113
 
DllExport void SWIGSTDCALL CSharp_set_LibAuthnRequest_signMethod(void * jarg1, int jarg2) {
8114
 
    LassoLibAuthnRequest *arg1 = (LassoLibAuthnRequest *) 0 ;
8115
 
    LassoSignatureMethod arg2 ;
8116
 
    
8117
 
    arg1 = (LassoLibAuthnRequest *)jarg1; 
8118
 
    arg2 = (LassoSignatureMethod)jarg2; 
8119
 
    LassoLibAuthnRequest_set_sign_method(arg1,(LassoSignatureMethod )arg2);
8120
 
    
8121
 
}
8122
 
 
8123
 
 
8124
 
DllExport int SWIGSTDCALL CSharp_get_LibAuthnRequest_signMethod(void * jarg1) {
8125
 
    int jresult = 0 ;
8126
 
    LassoLibAuthnRequest *arg1 = (LassoLibAuthnRequest *) 0 ;
8127
 
    LassoSignatureMethod result;
8128
 
    
8129
 
    arg1 = (LassoLibAuthnRequest *)jarg1; 
8130
 
    result = (LassoSignatureMethod)LassoLibAuthnRequest_get_sign_method(arg1);
8131
 
    
8132
 
    jresult = result; 
8133
 
    return jresult;
8134
 
}
8135
 
 
8136
 
 
8137
 
DllExport void SWIGSTDCALL CSharp_set_LibAuthnRequest_signType(void * jarg1, void * jarg2) {
8138
 
    LassoLibAuthnRequest *arg1 = (LassoLibAuthnRequest *) 0 ;
8139
 
    LassoSignatureType arg2 ;
8140
 
    LassoSignatureType *argp2 ;
8141
 
    
8142
 
    arg1 = (LassoLibAuthnRequest *)jarg1; 
8143
 
    argp2 = (LassoSignatureType *)jarg2; 
8144
 
    if (!argp2) {
8145
 
        SWIG_CSharpThrowException(SWIG_CSharpNullReferenceException, "Attempt to dereference null LassoSignatureType");
8146
 
    }
8147
 
    arg2 = *argp2; 
8148
 
    LassoLibAuthnRequest_set_sign_type(arg1,arg2);
8149
 
    
8150
 
}
8151
 
 
8152
 
 
8153
 
DllExport void * SWIGSTDCALL CSharp_get_LibAuthnRequest_signType(void * jarg1) {
8154
 
    void * jresult = 0 ;
8155
 
    LassoLibAuthnRequest *arg1 = (LassoLibAuthnRequest *) 0 ;
8156
 
    LassoSignatureType result;
8157
 
    
8158
 
    arg1 = (LassoLibAuthnRequest *)jarg1; 
8159
 
    result = LassoLibAuthnRequest_get_sign_type(arg1);
8160
 
    
8161
 
    {
8162
 
        LassoSignatureType * resultptr = (LassoSignatureType *) malloc(sizeof(LassoSignatureType));
8163
 
        memmove(resultptr, &result, sizeof(LassoSignatureType));
8164
 
        jresult = resultptr;
8165
 
    }
8166
 
    return jresult;
8167
 
}
8168
 
 
8169
 
 
8170
 
DllExport void SWIGSTDCALL CSharp_set_LibAuthnRequest_extension(void * jarg1, void * jarg2) {
8171
 
    LassoLibAuthnRequest *arg1 = (LassoLibAuthnRequest *) 0 ;
8172
 
    LassoStringList *arg2 = (LassoStringList *) 0 ;
8173
 
    
8174
 
    arg1 = (LassoLibAuthnRequest *)jarg1; 
8175
 
    arg2 = (LassoStringList *)jarg2; 
8176
 
    LassoLibAuthnRequest_set_Extension(arg1,arg2);
8177
 
    
8178
 
}
8179
 
 
8180
 
 
8181
 
DllExport void * SWIGSTDCALL CSharp_get_LibAuthnRequest_extension(void * jarg1) {
8182
 
    void * jresult = 0 ;
8183
 
    LassoLibAuthnRequest *arg1 = (LassoLibAuthnRequest *) 0 ;
8184
 
    LassoStringList *result;
8185
 
    
8186
 
    arg1 = (LassoLibAuthnRequest *)jarg1; 
8187
 
    result = (LassoStringList *)LassoLibAuthnRequest_get_Extension(arg1);
8188
 
    
8189
 
    jresult = (void *)result; 
8190
 
    return jresult;
8191
 
}
8192
 
 
8193
 
 
8194
 
DllExport void SWIGSTDCALL CSharp_set_LibAuthnRequest_requestAuthnContext(void * jarg1, void * jarg2) {
8195
 
    LassoLibAuthnRequest *arg1 = (LassoLibAuthnRequest *) 0 ;
8196
 
    LassoLibRequestAuthnContext *arg2 = (LassoLibRequestAuthnContext *) 0 ;
8197
 
    
8198
 
    arg1 = (LassoLibAuthnRequest *)jarg1; 
8199
 
    arg2 = (LassoLibRequestAuthnContext *)jarg2; 
8200
 
    LassoLibAuthnRequest_set_RequestAuthnContext(arg1,arg2);
8201
 
    
8202
 
}
8203
 
 
8204
 
 
8205
 
DllExport void * SWIGSTDCALL CSharp_get_LibAuthnRequest_requestAuthnContext(void * jarg1) {
8206
 
    void * jresult = 0 ;
8207
 
    LassoLibAuthnRequest *arg1 = (LassoLibAuthnRequest *) 0 ;
8208
 
    LassoLibRequestAuthnContext *result;
8209
 
    
8210
 
    arg1 = (LassoLibAuthnRequest *)jarg1; 
8211
 
    result = (LassoLibRequestAuthnContext *)LassoLibAuthnRequest_get_RequestAuthnContext(arg1);
8212
 
    
8213
 
    jresult = (void *)result; 
8214
 
    return jresult;
8215
 
}
8216
 
 
8217
 
 
8218
 
DllExport void * SWIGSTDCALL CSharp_new_LibAuthnRequest() {
8219
 
    void * jresult = 0 ;
8220
 
    LassoLibAuthnRequest *result;
8221
 
    
8222
 
    result = (LassoLibAuthnRequest *)new_LassoLibAuthnRequest();
8223
 
    
8224
 
    jresult = (void *)result; 
8225
 
    return jresult;
8226
 
}
8227
 
 
8228
 
 
8229
 
DllExport void SWIGSTDCALL CSharp_delete_LibAuthnRequest(void * jarg1) {
8230
 
    LassoLibAuthnRequest *arg1 = (LassoLibAuthnRequest *) 0 ;
8231
 
    
8232
 
    arg1 = (LassoLibAuthnRequest *)jarg1; 
8233
 
    delete_LassoLibAuthnRequest(arg1);
8234
 
    
8235
 
}
8236
 
 
8237
 
 
8238
 
DllExport char * SWIGSTDCALL CSharp_LibAuthnRequest_dump(void * jarg1) {
8239
 
    char * jresult = 0 ;
8240
 
    LassoLibAuthnRequest *arg1 = (LassoLibAuthnRequest *) 0 ;
8241
 
    char *result;
8242
 
    
8243
 
    arg1 = (LassoLibAuthnRequest *)jarg1; 
8244
 
    result = (char *)LassoLibAuthnRequest_dump(arg1);
8245
 
    
8246
 
    jresult = SWIG_csharp_string_callback(result); 
8247
 
    free(result);
8248
 
    return jresult;
8249
 
}
8250
 
 
8251
 
 
8252
 
DllExport void SWIGSTDCALL CSharp_set_LibAuthnResponse_consent(void * jarg1, char * jarg2) {
8253
 
    LassoLibAuthnResponse *arg1 = (LassoLibAuthnResponse *) 0 ;
8254
 
    char *arg2 = (char *) 0 ;
8255
 
    
8256
 
    arg1 = (LassoLibAuthnResponse *)jarg1; 
8257
 
    arg2 = jarg2; 
8258
 
    {
8259
 
        if (arg1->consent) free((char*)arg1->consent);
8260
 
        if (arg2) {
8261
 
            arg1->consent = (char *) malloc(strlen(arg2)+1);
8262
 
            strcpy((char*)arg1->consent,arg2);
8263
 
        } else {
8264
 
            arg1->consent = 0;
8265
 
        }
8266
 
    }
8267
 
}
8268
 
 
8269
 
 
8270
 
DllExport char * SWIGSTDCALL CSharp_get_LibAuthnResponse_consent(void * jarg1) {
8271
 
    char * jresult = 0 ;
8272
 
    LassoLibAuthnResponse *arg1 = (LassoLibAuthnResponse *) 0 ;
8273
 
    char *result;
8274
 
    
8275
 
    arg1 = (LassoLibAuthnResponse *)jarg1; 
8276
 
    result = (char *) ((arg1)->consent);
8277
 
    
8278
 
    jresult = SWIG_csharp_string_callback(result); 
8279
 
    return jresult;
8280
 
}
8281
 
 
8282
 
 
8283
 
DllExport void SWIGSTDCALL CSharp_set_LibAuthnResponse_providerId(void * jarg1, char * jarg2) {
8284
 
    LassoLibAuthnResponse *arg1 = (LassoLibAuthnResponse *) 0 ;
8285
 
    char *arg2 = (char *) 0 ;
8286
 
    
8287
 
    arg1 = (LassoLibAuthnResponse *)jarg1; 
8288
 
    arg2 = jarg2; 
8289
 
    {
8290
 
        if (arg1->ProviderID) free((char*)arg1->ProviderID);
8291
 
        if (arg2) {
8292
 
            arg1->ProviderID = (char *) malloc(strlen(arg2)+1);
8293
 
            strcpy((char*)arg1->ProviderID,arg2);
8294
 
        } else {
8295
 
            arg1->ProviderID = 0;
8296
 
        }
8297
 
    }
8298
 
}
8299
 
 
8300
 
 
8301
 
DllExport char * SWIGSTDCALL CSharp_get_LibAuthnResponse_providerId(void * jarg1) {
8302
 
    char * jresult = 0 ;
8303
 
    LassoLibAuthnResponse *arg1 = (LassoLibAuthnResponse *) 0 ;
8304
 
    char *result;
8305
 
    
8306
 
    arg1 = (LassoLibAuthnResponse *)jarg1; 
8307
 
    result = (char *) ((arg1)->ProviderID);
8308
 
    
8309
 
    jresult = SWIG_csharp_string_callback(result); 
8310
 
    return jresult;
8311
 
}
8312
 
 
8313
 
 
8314
 
DllExport void SWIGSTDCALL CSharp_set_LibAuthnResponse_relayState(void * jarg1, char * jarg2) {
8315
 
    LassoLibAuthnResponse *arg1 = (LassoLibAuthnResponse *) 0 ;
8316
 
    char *arg2 = (char *) 0 ;
8317
 
    
8318
 
    arg1 = (LassoLibAuthnResponse *)jarg1; 
8319
 
    arg2 = jarg2; 
8320
 
    {
8321
 
        if (arg1->RelayState) free((char*)arg1->RelayState);
8322
 
        if (arg2) {
8323
 
            arg1->RelayState = (char *) malloc(strlen(arg2)+1);
8324
 
            strcpy((char*)arg1->RelayState,arg2);
8325
 
        } else {
8326
 
            arg1->RelayState = 0;
8327
 
        }
8328
 
    }
8329
 
}
8330
 
 
8331
 
 
8332
 
DllExport char * SWIGSTDCALL CSharp_get_LibAuthnResponse_relayState(void * jarg1) {
8333
 
    char * jresult = 0 ;
8334
 
    LassoLibAuthnResponse *arg1 = (LassoLibAuthnResponse *) 0 ;
8335
 
    char *result;
8336
 
    
8337
 
    arg1 = (LassoLibAuthnResponse *)jarg1; 
8338
 
    result = (char *) ((arg1)->RelayState);
8339
 
    
8340
 
    jresult = SWIG_csharp_string_callback(result); 
8341
 
    return jresult;
8342
 
}
8343
 
 
8344
 
 
8345
 
DllExport void SWIGSTDCALL CSharp_set_LibAuthnResponse_extension(void * jarg1, void * jarg2) {
8346
 
    LassoLibAuthnResponse *arg1 = (LassoLibAuthnResponse *) 0 ;
8347
 
    LassoStringList *arg2 = (LassoStringList *) 0 ;
8348
 
    
8349
 
    arg1 = (LassoLibAuthnResponse *)jarg1; 
8350
 
    arg2 = (LassoStringList *)jarg2; 
8351
 
    LassoLibAuthnResponse_set_Extension(arg1,arg2);
8352
 
    
8353
 
}
8354
 
 
8355
 
 
8356
 
DllExport void * SWIGSTDCALL CSharp_get_LibAuthnResponse_extension(void * jarg1) {
8357
 
    void * jresult = 0 ;
8358
 
    LassoLibAuthnResponse *arg1 = (LassoLibAuthnResponse *) 0 ;
8359
 
    LassoStringList *result;
8360
 
    
8361
 
    arg1 = (LassoLibAuthnResponse *)jarg1; 
8362
 
    result = (LassoStringList *)LassoLibAuthnResponse_get_Extension(arg1);
8363
 
    
8364
 
    jresult = (void *)result; 
8365
 
    return jresult;
8366
 
}
8367
 
 
8368
 
 
8369
 
DllExport void SWIGSTDCALL CSharp_set_LibAuthnResponse_status(void * jarg1, void * jarg2) {
8370
 
    LassoLibAuthnResponse *arg1 = (LassoLibAuthnResponse *) 0 ;
8371
 
    LassoSamlpStatus *arg2 = (LassoSamlpStatus *) 0 ;
8372
 
    
8373
 
    arg1 = (LassoLibAuthnResponse *)jarg1; 
8374
 
    arg2 = (LassoSamlpStatus *)jarg2; 
8375
 
    LassoLibAuthnResponse_set_Status(arg1,arg2);
8376
 
    
8377
 
}
8378
 
 
8379
 
 
8380
 
DllExport void * SWIGSTDCALL CSharp_get_LibAuthnResponse_status(void * jarg1) {
8381
 
    void * jresult = 0 ;
8382
 
    LassoLibAuthnResponse *arg1 = (LassoLibAuthnResponse *) 0 ;
8383
 
    LassoSamlpStatus *result;
8384
 
    
8385
 
    arg1 = (LassoLibAuthnResponse *)jarg1; 
8386
 
    result = (LassoSamlpStatus *)LassoLibAuthnResponse_get_Status(arg1);
8387
 
    
8388
 
    jresult = (void *)result; 
8389
 
    return jresult;
8390
 
}
8391
 
 
8392
 
 
8393
 
DllExport void * SWIGSTDCALL CSharp_new_LibAuthnResponse(char * jarg1, void * jarg2) {
8394
 
    void * jresult = 0 ;
8395
 
    char *arg1 = (char *) 0 ;
8396
 
    LassoLibAuthnRequest *arg2 = (LassoLibAuthnRequest *) 0 ;
8397
 
    LassoLibAuthnResponse *result;
8398
 
    
8399
 
    arg1 = jarg1; 
8400
 
    arg2 = (LassoLibAuthnRequest *)jarg2; 
8401
 
    result = (LassoLibAuthnResponse *)new_LassoLibAuthnResponse(arg1,arg2);
8402
 
    
8403
 
    jresult = (void *)result; 
8404
 
    return jresult;
8405
 
}
8406
 
 
8407
 
 
8408
 
DllExport void SWIGSTDCALL CSharp_delete_LibAuthnResponse(void * jarg1) {
8409
 
    LassoLibAuthnResponse *arg1 = (LassoLibAuthnResponse *) 0 ;
8410
 
    
8411
 
    arg1 = (LassoLibAuthnResponse *)jarg1; 
8412
 
    delete_LassoLibAuthnResponse(arg1);
8413
 
    
8414
 
}
8415
 
 
8416
 
 
8417
 
DllExport char * SWIGSTDCALL CSharp_LibAuthnResponse_dump(void * jarg1) {
8418
 
    char * jresult = 0 ;
8419
 
    LassoLibAuthnResponse *arg1 = (LassoLibAuthnResponse *) 0 ;
8420
 
    char *result;
8421
 
    
8422
 
    arg1 = (LassoLibAuthnResponse *)jarg1; 
8423
 
    result = (char *)LassoLibAuthnResponse_dump(arg1);
8424
 
    
8425
 
    jresult = SWIG_csharp_string_callback(result); 
8426
 
    free(result);
8427
 
    return jresult;
8428
 
}
8429
 
 
8430
 
 
8431
 
DllExport void SWIGSTDCALL CSharp_set_LibFederationTerminationNotification_consent(void * jarg1, char * jarg2) {
8432
 
    LassoLibFederationTerminationNotification *arg1 = (LassoLibFederationTerminationNotification *) 0 ;
8433
 
    char *arg2 = (char *) 0 ;
8434
 
    
8435
 
    arg1 = (LassoLibFederationTerminationNotification *)jarg1; 
8436
 
    arg2 = jarg2; 
8437
 
    {
8438
 
        if (arg1->consent) free((char*)arg1->consent);
8439
 
        if (arg2) {
8440
 
            arg1->consent = (char *) malloc(strlen(arg2)+1);
8441
 
            strcpy((char*)arg1->consent,arg2);
8442
 
        } else {
8443
 
            arg1->consent = 0;
8444
 
        }
8445
 
    }
8446
 
}
8447
 
 
8448
 
 
8449
 
DllExport char * SWIGSTDCALL CSharp_get_LibFederationTerminationNotification_consent(void * jarg1) {
8450
 
    char * jresult = 0 ;
8451
 
    LassoLibFederationTerminationNotification *arg1 = (LassoLibFederationTerminationNotification *) 0 ;
8452
 
    char *result;
8453
 
    
8454
 
    arg1 = (LassoLibFederationTerminationNotification *)jarg1; 
8455
 
    result = (char *) ((arg1)->consent);
8456
 
    
8457
 
    jresult = SWIG_csharp_string_callback(result); 
8458
 
    return jresult;
8459
 
}
8460
 
 
8461
 
 
8462
 
DllExport void SWIGSTDCALL CSharp_set_LibFederationTerminationNotification_providerId(void * jarg1, char * jarg2) {
8463
 
    LassoLibFederationTerminationNotification *arg1 = (LassoLibFederationTerminationNotification *) 0 ;
8464
 
    char *arg2 = (char *) 0 ;
8465
 
    
8466
 
    arg1 = (LassoLibFederationTerminationNotification *)jarg1; 
8467
 
    arg2 = jarg2; 
8468
 
    {
8469
 
        if (arg1->ProviderID) free((char*)arg1->ProviderID);
8470
 
        if (arg2) {
8471
 
            arg1->ProviderID = (char *) malloc(strlen(arg2)+1);
8472
 
            strcpy((char*)arg1->ProviderID,arg2);
8473
 
        } else {
8474
 
            arg1->ProviderID = 0;
8475
 
        }
8476
 
    }
8477
 
}
8478
 
 
8479
 
 
8480
 
DllExport char * SWIGSTDCALL CSharp_get_LibFederationTerminationNotification_providerId(void * jarg1) {
8481
 
    char * jresult = 0 ;
8482
 
    LassoLibFederationTerminationNotification *arg1 = (LassoLibFederationTerminationNotification *) 0 ;
8483
 
    char *result;
8484
 
    
8485
 
    arg1 = (LassoLibFederationTerminationNotification *)jarg1; 
8486
 
    result = (char *) ((arg1)->ProviderID);
8487
 
    
8488
 
    jresult = SWIG_csharp_string_callback(result); 
8489
 
    return jresult;
8490
 
}
8491
 
 
8492
 
 
8493
 
DllExport void SWIGSTDCALL CSharp_set_LibFederationTerminationNotification_relayState(void * jarg1, char * jarg2) {
8494
 
    LassoLibFederationTerminationNotification *arg1 = (LassoLibFederationTerminationNotification *) 0 ;
8495
 
    char *arg2 = (char *) 0 ;
8496
 
    
8497
 
    arg1 = (LassoLibFederationTerminationNotification *)jarg1; 
8498
 
    arg2 = jarg2; 
8499
 
    {
8500
 
        if (arg1->RelayState) free((char*)arg1->RelayState);
8501
 
        if (arg2) {
8502
 
            arg1->RelayState = (char *) malloc(strlen(arg2)+1);
8503
 
            strcpy((char*)arg1->RelayState,arg2);
8504
 
        } else {
8505
 
            arg1->RelayState = 0;
8506
 
        }
8507
 
    }
8508
 
}
8509
 
 
8510
 
 
8511
 
DllExport char * SWIGSTDCALL CSharp_get_LibFederationTerminationNotification_relayState(void * jarg1) {
8512
 
    char * jresult = 0 ;
8513
 
    LassoLibFederationTerminationNotification *arg1 = (LassoLibFederationTerminationNotification *) 0 ;
8514
 
    char *result;
8515
 
    
8516
 
    arg1 = (LassoLibFederationTerminationNotification *)jarg1; 
8517
 
    result = (char *) ((arg1)->RelayState);
8518
 
    
8519
 
    jresult = SWIG_csharp_string_callback(result); 
8520
 
    return jresult;
8521
 
}
8522
 
 
8523
 
 
8524
 
DllExport void SWIGSTDCALL CSharp_set_LibFederationTerminationNotification_certificateFile(void * jarg1, char * jarg2) {
8525
 
    LassoLibFederationTerminationNotification *arg1 = (LassoLibFederationTerminationNotification *) 0 ;
8526
 
    char *arg2 = (char *) 0 ;
8527
 
    
8528
 
    arg1 = (LassoLibFederationTerminationNotification *)jarg1; 
8529
 
    arg2 = jarg2; 
8530
 
    LassoLibFederationTerminationNotification_set_certificate_file(arg1,arg2);
8531
 
    
8532
 
}
8533
 
 
8534
 
 
8535
 
DllExport char * SWIGSTDCALL CSharp_get_LibFederationTerminationNotification_certificateFile(void * jarg1) {
8536
 
    char * jresult = 0 ;
8537
 
    LassoLibFederationTerminationNotification *arg1 = (LassoLibFederationTerminationNotification *) 0 ;
8538
 
    char *result;
8539
 
    
8540
 
    arg1 = (LassoLibFederationTerminationNotification *)jarg1; 
8541
 
    result = (char *)LassoLibFederationTerminationNotification_get_certificate_file(arg1);
8542
 
    
8543
 
    jresult = SWIG_csharp_string_callback(result); 
8544
 
    return jresult;
8545
 
}
8546
 
 
8547
 
 
8548
 
DllExport void SWIGSTDCALL CSharp_set_LibFederationTerminationNotification_issueInstant(void * jarg1, char * jarg2) {
8549
 
    LassoLibFederationTerminationNotification *arg1 = (LassoLibFederationTerminationNotification *) 0 ;
8550
 
    char *arg2 = (char *) 0 ;
8551
 
    
8552
 
    arg1 = (LassoLibFederationTerminationNotification *)jarg1; 
8553
 
    arg2 = jarg2; 
8554
 
    LassoLibFederationTerminationNotification_set_IssueInstant(arg1,arg2);
8555
 
    
8556
 
}
8557
 
 
8558
 
 
8559
 
DllExport char * SWIGSTDCALL CSharp_get_LibFederationTerminationNotification_issueInstant(void * jarg1) {
8560
 
    char * jresult = 0 ;
8561
 
    LassoLibFederationTerminationNotification *arg1 = (LassoLibFederationTerminationNotification *) 0 ;
8562
 
    char *result;
8563
 
    
8564
 
    arg1 = (LassoLibFederationTerminationNotification *)jarg1; 
8565
 
    result = (char *)LassoLibFederationTerminationNotification_get_IssueInstant(arg1);
8566
 
    
8567
 
    jresult = SWIG_csharp_string_callback(result); 
8568
 
    return jresult;
8569
 
}
8570
 
 
8571
 
 
8572
 
DllExport void SWIGSTDCALL CSharp_set_LibFederationTerminationNotification_majorVersion(void * jarg1, int jarg2) {
8573
 
    LassoLibFederationTerminationNotification *arg1 = (LassoLibFederationTerminationNotification *) 0 ;
8574
 
    int arg2 ;
8575
 
    
8576
 
    arg1 = (LassoLibFederationTerminationNotification *)jarg1; 
8577
 
    arg2 = (int)jarg2; 
8578
 
    LassoLibFederationTerminationNotification_set_MajorVersion(arg1,arg2);
8579
 
    
8580
 
}
8581
 
 
8582
 
 
8583
 
DllExport int SWIGSTDCALL CSharp_get_LibFederationTerminationNotification_majorVersion(void * jarg1) {
8584
 
    int jresult = 0 ;
8585
 
    LassoLibFederationTerminationNotification *arg1 = (LassoLibFederationTerminationNotification *) 0 ;
8586
 
    int result;
8587
 
    
8588
 
    arg1 = (LassoLibFederationTerminationNotification *)jarg1; 
8589
 
    result = (int)LassoLibFederationTerminationNotification_get_MajorVersion(arg1);
8590
 
    
8591
 
    jresult = result; 
8592
 
    return jresult;
8593
 
}
8594
 
 
8595
 
 
8596
 
DllExport void SWIGSTDCALL CSharp_set_LibFederationTerminationNotification_minorVersion(void * jarg1, int jarg2) {
8597
 
    LassoLibFederationTerminationNotification *arg1 = (LassoLibFederationTerminationNotification *) 0 ;
8598
 
    int arg2 ;
8599
 
    
8600
 
    arg1 = (LassoLibFederationTerminationNotification *)jarg1; 
8601
 
    arg2 = (int)jarg2; 
8602
 
    LassoLibFederationTerminationNotification_set_MinorVersion(arg1,arg2);
8603
 
    
8604
 
}
8605
 
 
8606
 
 
8607
 
DllExport int SWIGSTDCALL CSharp_get_LibFederationTerminationNotification_minorVersion(void * jarg1) {
8608
 
    int jresult = 0 ;
8609
 
    LassoLibFederationTerminationNotification *arg1 = (LassoLibFederationTerminationNotification *) 0 ;
8610
 
    int result;
8611
 
    
8612
 
    arg1 = (LassoLibFederationTerminationNotification *)jarg1; 
8613
 
    result = (int)LassoLibFederationTerminationNotification_get_MinorVersion(arg1);
8614
 
    
8615
 
    jresult = result; 
8616
 
    return jresult;
8617
 
}
8618
 
 
8619
 
 
8620
 
DllExport void SWIGSTDCALL CSharp_set_LibFederationTerminationNotification_privateKeyFile(void * jarg1, char * jarg2) {
8621
 
    LassoLibFederationTerminationNotification *arg1 = (LassoLibFederationTerminationNotification *) 0 ;
8622
 
    char *arg2 = (char *) 0 ;
8623
 
    
8624
 
    arg1 = (LassoLibFederationTerminationNotification *)jarg1; 
8625
 
    arg2 = jarg2; 
8626
 
    LassoLibFederationTerminationNotification_set_private_key_file(arg1,arg2);
8627
 
    
8628
 
}
8629
 
 
8630
 
 
8631
 
DllExport char * SWIGSTDCALL CSharp_get_LibFederationTerminationNotification_privateKeyFile(void * jarg1) {
8632
 
    char * jresult = 0 ;
8633
 
    LassoLibFederationTerminationNotification *arg1 = (LassoLibFederationTerminationNotification *) 0 ;
8634
 
    char *result;
8635
 
    
8636
 
    arg1 = (LassoLibFederationTerminationNotification *)jarg1; 
8637
 
    result = (char *)LassoLibFederationTerminationNotification_get_private_key_file(arg1);
8638
 
    
8639
 
    jresult = SWIG_csharp_string_callback(result); 
8640
 
    return jresult;
8641
 
}
8642
 
 
8643
 
 
8644
 
DllExport void SWIGSTDCALL CSharp_set_LibFederationTerminationNotification_requestId(void * jarg1, char * jarg2) {
8645
 
    LassoLibFederationTerminationNotification *arg1 = (LassoLibFederationTerminationNotification *) 0 ;
8646
 
    char *arg2 = (char *) 0 ;
8647
 
    
8648
 
    arg1 = (LassoLibFederationTerminationNotification *)jarg1; 
8649
 
    arg2 = jarg2; 
8650
 
    LassoLibFederationTerminationNotification_set_RequestID(arg1,arg2);
8651
 
    
8652
 
}
8653
 
 
8654
 
 
8655
 
DllExport char * SWIGSTDCALL CSharp_get_LibFederationTerminationNotification_requestId(void * jarg1) {
8656
 
    char * jresult = 0 ;
8657
 
    LassoLibFederationTerminationNotification *arg1 = (LassoLibFederationTerminationNotification *) 0 ;
8658
 
    char *result;
8659
 
    
8660
 
    arg1 = (LassoLibFederationTerminationNotification *)jarg1; 
8661
 
    result = (char *)LassoLibFederationTerminationNotification_get_RequestID(arg1);
8662
 
    
8663
 
    jresult = SWIG_csharp_string_callback(result); 
8664
 
    return jresult;
8665
 
}
8666
 
 
8667
 
 
8668
 
DllExport void SWIGSTDCALL CSharp_set_LibFederationTerminationNotification_respondWith(void * jarg1, void * jarg2) {
8669
 
    LassoLibFederationTerminationNotification *arg1 = (LassoLibFederationTerminationNotification *) 0 ;
8670
 
    LassoStringList *arg2 = (LassoStringList *) 0 ;
8671
 
    
8672
 
    arg1 = (LassoLibFederationTerminationNotification *)jarg1; 
8673
 
    arg2 = (LassoStringList *)jarg2; 
8674
 
    LassoLibFederationTerminationNotification_set_RespondWith(arg1,arg2);
8675
 
    
8676
 
}
8677
 
 
8678
 
 
8679
 
DllExport void * SWIGSTDCALL CSharp_get_LibFederationTerminationNotification_respondWith(void * jarg1) {
8680
 
    void * jresult = 0 ;
8681
 
    LassoLibFederationTerminationNotification *arg1 = (LassoLibFederationTerminationNotification *) 0 ;
8682
 
    LassoStringList *result;
8683
 
    
8684
 
    arg1 = (LassoLibFederationTerminationNotification *)jarg1; 
8685
 
    result = (LassoStringList *)LassoLibFederationTerminationNotification_get_RespondWith(arg1);
8686
 
    
8687
 
    jresult = (void *)result; 
8688
 
    return jresult;
8689
 
}
8690
 
 
8691
 
 
8692
 
DllExport void SWIGSTDCALL CSharp_set_LibFederationTerminationNotification_signMethod(void * jarg1, int jarg2) {
8693
 
    LassoLibFederationTerminationNotification *arg1 = (LassoLibFederationTerminationNotification *) 0 ;
8694
 
    LassoSignatureMethod arg2 ;
8695
 
    
8696
 
    arg1 = (LassoLibFederationTerminationNotification *)jarg1; 
8697
 
    arg2 = (LassoSignatureMethod)jarg2; 
8698
 
    LassoLibFederationTerminationNotification_set_sign_method(arg1,(LassoSignatureMethod )arg2);
8699
 
    
8700
 
}
8701
 
 
8702
 
 
8703
 
DllExport int SWIGSTDCALL CSharp_get_LibFederationTerminationNotification_signMethod(void * jarg1) {
8704
 
    int jresult = 0 ;
8705
 
    LassoLibFederationTerminationNotification *arg1 = (LassoLibFederationTerminationNotification *) 0 ;
8706
 
    LassoSignatureMethod result;
8707
 
    
8708
 
    arg1 = (LassoLibFederationTerminationNotification *)jarg1; 
8709
 
    result = (LassoSignatureMethod)LassoLibFederationTerminationNotification_get_sign_method(arg1);
8710
 
    
8711
 
    jresult = result; 
8712
 
    return jresult;
8713
 
}
8714
 
 
8715
 
 
8716
 
DllExport void SWIGSTDCALL CSharp_set_LibFederationTerminationNotification_signType(void * jarg1, void * jarg2) {
8717
 
    LassoLibFederationTerminationNotification *arg1 = (LassoLibFederationTerminationNotification *) 0 ;
8718
 
    LassoSignatureType arg2 ;
8719
 
    LassoSignatureType *argp2 ;
8720
 
    
8721
 
    arg1 = (LassoLibFederationTerminationNotification *)jarg1; 
8722
 
    argp2 = (LassoSignatureType *)jarg2; 
8723
 
    if (!argp2) {
8724
 
        SWIG_CSharpThrowException(SWIG_CSharpNullReferenceException, "Attempt to dereference null LassoSignatureType");
8725
 
    }
8726
 
    arg2 = *argp2; 
8727
 
    LassoLibFederationTerminationNotification_set_sign_type(arg1,arg2);
8728
 
    
8729
 
}
8730
 
 
8731
 
 
8732
 
DllExport void * SWIGSTDCALL CSharp_get_LibFederationTerminationNotification_signType(void * jarg1) {
8733
 
    void * jresult = 0 ;
8734
 
    LassoLibFederationTerminationNotification *arg1 = (LassoLibFederationTerminationNotification *) 0 ;
8735
 
    LassoSignatureType result;
8736
 
    
8737
 
    arg1 = (LassoLibFederationTerminationNotification *)jarg1; 
8738
 
    result = LassoLibFederationTerminationNotification_get_sign_type(arg1);
8739
 
    
8740
 
    {
8741
 
        LassoSignatureType * resultptr = (LassoSignatureType *) malloc(sizeof(LassoSignatureType));
8742
 
        memmove(resultptr, &result, sizeof(LassoSignatureType));
8743
 
        jresult = resultptr;
8744
 
    }
8745
 
    return jresult;
8746
 
}
8747
 
 
8748
 
 
8749
 
DllExport void SWIGSTDCALL CSharp_set_LibFederationTerminationNotification_extension(void * jarg1, void * jarg2) {
8750
 
    LassoLibFederationTerminationNotification *arg1 = (LassoLibFederationTerminationNotification *) 0 ;
8751
 
    LassoStringList *arg2 = (LassoStringList *) 0 ;
8752
 
    
8753
 
    arg1 = (LassoLibFederationTerminationNotification *)jarg1; 
8754
 
    arg2 = (LassoStringList *)jarg2; 
8755
 
    LassoLibFederationTerminationNotification_set_Extension(arg1,arg2);
8756
 
    
8757
 
}
8758
 
 
8759
 
 
8760
 
DllExport void * SWIGSTDCALL CSharp_get_LibFederationTerminationNotification_extension(void * jarg1) {
8761
 
    void * jresult = 0 ;
8762
 
    LassoLibFederationTerminationNotification *arg1 = (LassoLibFederationTerminationNotification *) 0 ;
8763
 
    LassoStringList *result;
8764
 
    
8765
 
    arg1 = (LassoLibFederationTerminationNotification *)jarg1; 
8766
 
    result = (LassoStringList *)LassoLibFederationTerminationNotification_get_Extension(arg1);
8767
 
    
8768
 
    jresult = (void *)result; 
8769
 
    return jresult;
8770
 
}
8771
 
 
8772
 
 
8773
 
DllExport void SWIGSTDCALL CSharp_set_LibFederationTerminationNotification_nameIdentifier(void * jarg1, void * jarg2) {
8774
 
    LassoLibFederationTerminationNotification *arg1 = (LassoLibFederationTerminationNotification *) 0 ;
8775
 
    LassoSamlNameIdentifier *arg2 = (LassoSamlNameIdentifier *) 0 ;
8776
 
    
8777
 
    arg1 = (LassoLibFederationTerminationNotification *)jarg1; 
8778
 
    arg2 = (LassoSamlNameIdentifier *)jarg2; 
8779
 
    LassoLibFederationTerminationNotification_set_NameIdentifier(arg1,arg2);
8780
 
    
8781
 
}
8782
 
 
8783
 
 
8784
 
DllExport void * SWIGSTDCALL CSharp_get_LibFederationTerminationNotification_nameIdentifier(void * jarg1) {
8785
 
    void * jresult = 0 ;
8786
 
    LassoLibFederationTerminationNotification *arg1 = (LassoLibFederationTerminationNotification *) 0 ;
8787
 
    LassoSamlNameIdentifier *result;
8788
 
    
8789
 
    arg1 = (LassoLibFederationTerminationNotification *)jarg1; 
8790
 
    result = (LassoSamlNameIdentifier *)LassoLibFederationTerminationNotification_get_NameIdentifier(arg1);
8791
 
    
8792
 
    jresult = (void *)result; 
8793
 
    return jresult;
8794
 
}
8795
 
 
8796
 
 
8797
 
DllExport void * SWIGSTDCALL CSharp_new_LibFederationTerminationNotification() {
8798
 
    void * jresult = 0 ;
8799
 
    LassoLibFederationTerminationNotification *result;
8800
 
    
8801
 
    result = (LassoLibFederationTerminationNotification *)new_LassoLibFederationTerminationNotification();
8802
 
    
8803
 
    jresult = (void *)result; 
8804
 
    return jresult;
8805
 
}
8806
 
 
8807
 
 
8808
 
DllExport void SWIGSTDCALL CSharp_delete_LibFederationTerminationNotification(void * jarg1) {
8809
 
    LassoLibFederationTerminationNotification *arg1 = (LassoLibFederationTerminationNotification *) 0 ;
8810
 
    
8811
 
    arg1 = (LassoLibFederationTerminationNotification *)jarg1; 
8812
 
    delete_LassoLibFederationTerminationNotification(arg1);
8813
 
    
8814
 
}
8815
 
 
8816
 
 
8817
 
DllExport void * SWIGSTDCALL CSharp_LibFederationTerminationNotification_newFull(char * jarg1, void * jarg2, void * jarg3, int jarg4) {
8818
 
    void * jresult = 0 ;
8819
 
    char *arg1 = (char *) 0 ;
8820
 
    LassoSamlNameIdentifier *arg2 = (LassoSamlNameIdentifier *) 0 ;
8821
 
    LassoSignatureType arg3 ;
8822
 
    LassoSignatureMethod arg4 ;
8823
 
    LassoLibFederationTerminationNotification *result;
8824
 
    LassoSignatureType *argp3 ;
8825
 
    
8826
 
    arg1 = jarg1; 
8827
 
    arg2 = (LassoSamlNameIdentifier *)jarg2; 
8828
 
    argp3 = (LassoSignatureType *)jarg3; 
8829
 
    if (!argp3) {
8830
 
        SWIG_CSharpThrowException(SWIG_CSharpNullReferenceException, "Attempt to dereference null LassoSignatureType");
8831
 
    }
8832
 
    arg3 = *argp3; 
8833
 
    arg4 = (LassoSignatureMethod)jarg4; 
8834
 
    result = (LassoLibFederationTerminationNotification *)LibFederationTerminationNotification_newFull(arg1,arg2,arg3,(LassoSignatureMethod )arg4);
8835
 
    
8836
 
    jresult = (void *)result; 
8837
 
    return jresult;
8838
 
}
8839
 
 
8840
 
 
8841
 
DllExport char * SWIGSTDCALL CSharp_LibFederationTerminationNotification_dump(void * jarg1) {
8842
 
    char * jresult = 0 ;
8843
 
    LassoLibFederationTerminationNotification *arg1 = (LassoLibFederationTerminationNotification *) 0 ;
8844
 
    char *result;
8845
 
    
8846
 
    arg1 = (LassoLibFederationTerminationNotification *)jarg1; 
8847
 
    result = (char *)LassoLibFederationTerminationNotification_dump(arg1);
8848
 
    
8849
 
    jresult = SWIG_csharp_string_callback(result); 
8850
 
    free(result);
8851
 
    return jresult;
8852
 
}
8853
 
 
8854
 
 
8855
 
DllExport void SWIGSTDCALL CSharp_set_LibLogoutRequest_consent(void * jarg1, char * jarg2) {
8856
 
    LassoLibLogoutRequest *arg1 = (LassoLibLogoutRequest *) 0 ;
8857
 
    char *arg2 = (char *) 0 ;
8858
 
    
8859
 
    arg1 = (LassoLibLogoutRequest *)jarg1; 
8860
 
    arg2 = jarg2; 
8861
 
    {
8862
 
        if (arg1->consent) free((char*)arg1->consent);
8863
 
        if (arg2) {
8864
 
            arg1->consent = (char *) malloc(strlen(arg2)+1);
8865
 
            strcpy((char*)arg1->consent,arg2);
8866
 
        } else {
8867
 
            arg1->consent = 0;
8868
 
        }
8869
 
    }
8870
 
}
8871
 
 
8872
 
 
8873
 
DllExport char * SWIGSTDCALL CSharp_get_LibLogoutRequest_consent(void * jarg1) {
8874
 
    char * jresult = 0 ;
8875
 
    LassoLibLogoutRequest *arg1 = (LassoLibLogoutRequest *) 0 ;
8876
 
    char *result;
8877
 
    
8878
 
    arg1 = (LassoLibLogoutRequest *)jarg1; 
8879
 
    result = (char *) ((arg1)->consent);
8880
 
    
8881
 
    jresult = SWIG_csharp_string_callback(result); 
8882
 
    return jresult;
8883
 
}
8884
 
 
8885
 
 
8886
 
DllExport void SWIGSTDCALL CSharp_set_LibLogoutRequest_notOnOrAfter(void * jarg1, char * jarg2) {
8887
 
    LassoLibLogoutRequest *arg1 = (LassoLibLogoutRequest *) 0 ;
8888
 
    char *arg2 = (char *) 0 ;
8889
 
    
8890
 
    arg1 = (LassoLibLogoutRequest *)jarg1; 
8891
 
    arg2 = jarg2; 
8892
 
    {
8893
 
        if (arg1->NotOnOrAfter) free((char*)arg1->NotOnOrAfter);
8894
 
        if (arg2) {
8895
 
            arg1->NotOnOrAfter = (char *) malloc(strlen(arg2)+1);
8896
 
            strcpy((char*)arg1->NotOnOrAfter,arg2);
8897
 
        } else {
8898
 
            arg1->NotOnOrAfter = 0;
8899
 
        }
8900
 
    }
8901
 
}
8902
 
 
8903
 
 
8904
 
DllExport char * SWIGSTDCALL CSharp_get_LibLogoutRequest_notOnOrAfter(void * jarg1) {
8905
 
    char * jresult = 0 ;
8906
 
    LassoLibLogoutRequest *arg1 = (LassoLibLogoutRequest *) 0 ;
8907
 
    char *result;
8908
 
    
8909
 
    arg1 = (LassoLibLogoutRequest *)jarg1; 
8910
 
    result = (char *) ((arg1)->NotOnOrAfter);
8911
 
    
8912
 
    jresult = SWIG_csharp_string_callback(result); 
8913
 
    return jresult;
8914
 
}
8915
 
 
8916
 
 
8917
 
DllExport void SWIGSTDCALL CSharp_set_LibLogoutRequest_providerId(void * jarg1, char * jarg2) {
8918
 
    LassoLibLogoutRequest *arg1 = (LassoLibLogoutRequest *) 0 ;
8919
 
    char *arg2 = (char *) 0 ;
8920
 
    
8921
 
    arg1 = (LassoLibLogoutRequest *)jarg1; 
8922
 
    arg2 = jarg2; 
8923
 
    {
8924
 
        if (arg1->ProviderID) free((char*)arg1->ProviderID);
8925
 
        if (arg2) {
8926
 
            arg1->ProviderID = (char *) malloc(strlen(arg2)+1);
8927
 
            strcpy((char*)arg1->ProviderID,arg2);
8928
 
        } else {
8929
 
            arg1->ProviderID = 0;
8930
 
        }
8931
 
    }
8932
 
}
8933
 
 
8934
 
 
8935
 
DllExport char * SWIGSTDCALL CSharp_get_LibLogoutRequest_providerId(void * jarg1) {
8936
 
    char * jresult = 0 ;
8937
 
    LassoLibLogoutRequest *arg1 = (LassoLibLogoutRequest *) 0 ;
8938
 
    char *result;
8939
 
    
8940
 
    arg1 = (LassoLibLogoutRequest *)jarg1; 
8941
 
    result = (char *) ((arg1)->ProviderID);
8942
 
    
8943
 
    jresult = SWIG_csharp_string_callback(result); 
8944
 
    return jresult;
8945
 
}
8946
 
 
8947
 
 
8948
 
DllExport void SWIGSTDCALL CSharp_set_LibLogoutRequest_relayState(void * jarg1, char * jarg2) {
8949
 
    LassoLibLogoutRequest *arg1 = (LassoLibLogoutRequest *) 0 ;
8950
 
    char *arg2 = (char *) 0 ;
8951
 
    
8952
 
    arg1 = (LassoLibLogoutRequest *)jarg1; 
8953
 
    arg2 = jarg2; 
8954
 
    {
8955
 
        if (arg1->RelayState) free((char*)arg1->RelayState);
8956
 
        if (arg2) {
8957
 
            arg1->RelayState = (char *) malloc(strlen(arg2)+1);
8958
 
            strcpy((char*)arg1->RelayState,arg2);
8959
 
        } else {
8960
 
            arg1->RelayState = 0;
8961
 
        }
8962
 
    }
8963
 
}
8964
 
 
8965
 
 
8966
 
DllExport char * SWIGSTDCALL CSharp_get_LibLogoutRequest_relayState(void * jarg1) {
8967
 
    char * jresult = 0 ;
8968
 
    LassoLibLogoutRequest *arg1 = (LassoLibLogoutRequest *) 0 ;
8969
 
    char *result;
8970
 
    
8971
 
    arg1 = (LassoLibLogoutRequest *)jarg1; 
8972
 
    result = (char *) ((arg1)->RelayState);
8973
 
    
8974
 
    jresult = SWIG_csharp_string_callback(result); 
8975
 
    return jresult;
8976
 
}
8977
 
 
8978
 
 
8979
 
DllExport void SWIGSTDCALL CSharp_set_LibLogoutRequest_sessionIndex(void * jarg1, char * jarg2) {
8980
 
    LassoLibLogoutRequest *arg1 = (LassoLibLogoutRequest *) 0 ;
8981
 
    char *arg2 = (char *) 0 ;
8982
 
    
8983
 
    arg1 = (LassoLibLogoutRequest *)jarg1; 
8984
 
    arg2 = jarg2; 
8985
 
    {
8986
 
        if (arg1->SessionIndex) free((char*)arg1->SessionIndex);
8987
 
        if (arg2) {
8988
 
            arg1->SessionIndex = (char *) malloc(strlen(arg2)+1);
8989
 
            strcpy((char*)arg1->SessionIndex,arg2);
8990
 
        } else {
8991
 
            arg1->SessionIndex = 0;
8992
 
        }
8993
 
    }
8994
 
}
8995
 
 
8996
 
 
8997
 
DllExport char * SWIGSTDCALL CSharp_get_LibLogoutRequest_sessionIndex(void * jarg1) {
8998
 
    char * jresult = 0 ;
8999
 
    LassoLibLogoutRequest *arg1 = (LassoLibLogoutRequest *) 0 ;
9000
 
    char *result;
9001
 
    
9002
 
    arg1 = (LassoLibLogoutRequest *)jarg1; 
9003
 
    result = (char *) ((arg1)->SessionIndex);
9004
 
    
9005
 
    jresult = SWIG_csharp_string_callback(result); 
9006
 
    return jresult;
9007
 
}
9008
 
 
9009
 
 
9010
 
DllExport void SWIGSTDCALL CSharp_set_LibLogoutRequest_certificateFile(void * jarg1, char * jarg2) {
9011
 
    LassoLibLogoutRequest *arg1 = (LassoLibLogoutRequest *) 0 ;
9012
 
    char *arg2 = (char *) 0 ;
9013
 
    
9014
 
    arg1 = (LassoLibLogoutRequest *)jarg1; 
9015
 
    arg2 = jarg2; 
9016
 
    LassoLibLogoutRequest_set_certificate_file(arg1,arg2);
9017
 
    
9018
 
}
9019
 
 
9020
 
 
9021
 
DllExport char * SWIGSTDCALL CSharp_get_LibLogoutRequest_certificateFile(void * jarg1) {
9022
 
    char * jresult = 0 ;
9023
 
    LassoLibLogoutRequest *arg1 = (LassoLibLogoutRequest *) 0 ;
9024
 
    char *result;
9025
 
    
9026
 
    arg1 = (LassoLibLogoutRequest *)jarg1; 
9027
 
    result = (char *)LassoLibLogoutRequest_get_certificate_file(arg1);
9028
 
    
9029
 
    jresult = SWIG_csharp_string_callback(result); 
9030
 
    return jresult;
9031
 
}
9032
 
 
9033
 
 
9034
 
DllExport void SWIGSTDCALL CSharp_set_LibLogoutRequest_issueInstant(void * jarg1, char * jarg2) {
9035
 
    LassoLibLogoutRequest *arg1 = (LassoLibLogoutRequest *) 0 ;
9036
 
    char *arg2 = (char *) 0 ;
9037
 
    
9038
 
    arg1 = (LassoLibLogoutRequest *)jarg1; 
9039
 
    arg2 = jarg2; 
9040
 
    LassoLibLogoutRequest_set_IssueInstant(arg1,arg2);
9041
 
    
9042
 
}
9043
 
 
9044
 
 
9045
 
DllExport char * SWIGSTDCALL CSharp_get_LibLogoutRequest_issueInstant(void * jarg1) {
9046
 
    char * jresult = 0 ;
9047
 
    LassoLibLogoutRequest *arg1 = (LassoLibLogoutRequest *) 0 ;
9048
 
    char *result;
9049
 
    
9050
 
    arg1 = (LassoLibLogoutRequest *)jarg1; 
9051
 
    result = (char *)LassoLibLogoutRequest_get_IssueInstant(arg1);
9052
 
    
9053
 
    jresult = SWIG_csharp_string_callback(result); 
9054
 
    return jresult;
9055
 
}
9056
 
 
9057
 
 
9058
 
DllExport void SWIGSTDCALL CSharp_set_LibLogoutRequest_majorVersion(void * jarg1, int jarg2) {
9059
 
    LassoLibLogoutRequest *arg1 = (LassoLibLogoutRequest *) 0 ;
9060
 
    int arg2 ;
9061
 
    
9062
 
    arg1 = (LassoLibLogoutRequest *)jarg1; 
9063
 
    arg2 = (int)jarg2; 
9064
 
    LassoLibLogoutRequest_set_MajorVersion(arg1,arg2);
9065
 
    
9066
 
}
9067
 
 
9068
 
 
9069
 
DllExport int SWIGSTDCALL CSharp_get_LibLogoutRequest_majorVersion(void * jarg1) {
9070
 
    int jresult = 0 ;
9071
 
    LassoLibLogoutRequest *arg1 = (LassoLibLogoutRequest *) 0 ;
9072
 
    int result;
9073
 
    
9074
 
    arg1 = (LassoLibLogoutRequest *)jarg1; 
9075
 
    result = (int)LassoLibLogoutRequest_get_MajorVersion(arg1);
9076
 
    
9077
 
    jresult = result; 
9078
 
    return jresult;
9079
 
}
9080
 
 
9081
 
 
9082
 
DllExport void SWIGSTDCALL CSharp_set_LibLogoutRequest_minorVersion(void * jarg1, int jarg2) {
9083
 
    LassoLibLogoutRequest *arg1 = (LassoLibLogoutRequest *) 0 ;
9084
 
    int arg2 ;
9085
 
    
9086
 
    arg1 = (LassoLibLogoutRequest *)jarg1; 
9087
 
    arg2 = (int)jarg2; 
9088
 
    LassoLibLogoutRequest_set_MinorVersion(arg1,arg2);
9089
 
    
9090
 
}
9091
 
 
9092
 
 
9093
 
DllExport int SWIGSTDCALL CSharp_get_LibLogoutRequest_minorVersion(void * jarg1) {
9094
 
    int jresult = 0 ;
9095
 
    LassoLibLogoutRequest *arg1 = (LassoLibLogoutRequest *) 0 ;
9096
 
    int result;
9097
 
    
9098
 
    arg1 = (LassoLibLogoutRequest *)jarg1; 
9099
 
    result = (int)LassoLibLogoutRequest_get_MinorVersion(arg1);
9100
 
    
9101
 
    jresult = result; 
9102
 
    return jresult;
9103
 
}
9104
 
 
9105
 
 
9106
 
DllExport void SWIGSTDCALL CSharp_set_LibLogoutRequest_privateKeyFile(void * jarg1, char * jarg2) {
9107
 
    LassoLibLogoutRequest *arg1 = (LassoLibLogoutRequest *) 0 ;
9108
 
    char *arg2 = (char *) 0 ;
9109
 
    
9110
 
    arg1 = (LassoLibLogoutRequest *)jarg1; 
9111
 
    arg2 = jarg2; 
9112
 
    LassoLibLogoutRequest_set_private_key_file(arg1,arg2);
9113
 
    
9114
 
}
9115
 
 
9116
 
 
9117
 
DllExport char * SWIGSTDCALL CSharp_get_LibLogoutRequest_privateKeyFile(void * jarg1) {
9118
 
    char * jresult = 0 ;
9119
 
    LassoLibLogoutRequest *arg1 = (LassoLibLogoutRequest *) 0 ;
9120
 
    char *result;
9121
 
    
9122
 
    arg1 = (LassoLibLogoutRequest *)jarg1; 
9123
 
    result = (char *)LassoLibLogoutRequest_get_private_key_file(arg1);
9124
 
    
9125
 
    jresult = SWIG_csharp_string_callback(result); 
9126
 
    return jresult;
9127
 
}
9128
 
 
9129
 
 
9130
 
DllExport void SWIGSTDCALL CSharp_set_LibLogoutRequest_requestId(void * jarg1, char * jarg2) {
9131
 
    LassoLibLogoutRequest *arg1 = (LassoLibLogoutRequest *) 0 ;
9132
 
    char *arg2 = (char *) 0 ;
9133
 
    
9134
 
    arg1 = (LassoLibLogoutRequest *)jarg1; 
9135
 
    arg2 = jarg2; 
9136
 
    LassoLibLogoutRequest_set_RequestID(arg1,arg2);
9137
 
    
9138
 
}
9139
 
 
9140
 
 
9141
 
DllExport char * SWIGSTDCALL CSharp_get_LibLogoutRequest_requestId(void * jarg1) {
9142
 
    char * jresult = 0 ;
9143
 
    LassoLibLogoutRequest *arg1 = (LassoLibLogoutRequest *) 0 ;
9144
 
    char *result;
9145
 
    
9146
 
    arg1 = (LassoLibLogoutRequest *)jarg1; 
9147
 
    result = (char *)LassoLibLogoutRequest_get_RequestID(arg1);
9148
 
    
9149
 
    jresult = SWIG_csharp_string_callback(result); 
9150
 
    return jresult;
9151
 
}
9152
 
 
9153
 
 
9154
 
DllExport void SWIGSTDCALL CSharp_set_LibLogoutRequest_respondWith(void * jarg1, void * jarg2) {
9155
 
    LassoLibLogoutRequest *arg1 = (LassoLibLogoutRequest *) 0 ;
9156
 
    LassoStringList *arg2 = (LassoStringList *) 0 ;
9157
 
    
9158
 
    arg1 = (LassoLibLogoutRequest *)jarg1; 
9159
 
    arg2 = (LassoStringList *)jarg2; 
9160
 
    LassoLibLogoutRequest_set_RespondWith(arg1,arg2);
9161
 
    
9162
 
}
9163
 
 
9164
 
 
9165
 
DllExport void * SWIGSTDCALL CSharp_get_LibLogoutRequest_respondWith(void * jarg1) {
9166
 
    void * jresult = 0 ;
9167
 
    LassoLibLogoutRequest *arg1 = (LassoLibLogoutRequest *) 0 ;
9168
 
    LassoStringList *result;
9169
 
    
9170
 
    arg1 = (LassoLibLogoutRequest *)jarg1; 
9171
 
    result = (LassoStringList *)LassoLibLogoutRequest_get_RespondWith(arg1);
9172
 
    
9173
 
    jresult = (void *)result; 
9174
 
    return jresult;
9175
 
}
9176
 
 
9177
 
 
9178
 
DllExport void SWIGSTDCALL CSharp_set_LibLogoutRequest_signMethod(void * jarg1, int jarg2) {
9179
 
    LassoLibLogoutRequest *arg1 = (LassoLibLogoutRequest *) 0 ;
9180
 
    LassoSignatureMethod arg2 ;
9181
 
    
9182
 
    arg1 = (LassoLibLogoutRequest *)jarg1; 
9183
 
    arg2 = (LassoSignatureMethod)jarg2; 
9184
 
    LassoLibLogoutRequest_set_sign_method(arg1,(LassoSignatureMethod )arg2);
9185
 
    
9186
 
}
9187
 
 
9188
 
 
9189
 
DllExport int SWIGSTDCALL CSharp_get_LibLogoutRequest_signMethod(void * jarg1) {
9190
 
    int jresult = 0 ;
9191
 
    LassoLibLogoutRequest *arg1 = (LassoLibLogoutRequest *) 0 ;
9192
 
    LassoSignatureMethod result;
9193
 
    
9194
 
    arg1 = (LassoLibLogoutRequest *)jarg1; 
9195
 
    result = (LassoSignatureMethod)LassoLibLogoutRequest_get_sign_method(arg1);
9196
 
    
9197
 
    jresult = result; 
9198
 
    return jresult;
9199
 
}
9200
 
 
9201
 
 
9202
 
DllExport void SWIGSTDCALL CSharp_set_LibLogoutRequest_signType(void * jarg1, void * jarg2) {
9203
 
    LassoLibLogoutRequest *arg1 = (LassoLibLogoutRequest *) 0 ;
9204
 
    LassoSignatureType arg2 ;
9205
 
    LassoSignatureType *argp2 ;
9206
 
    
9207
 
    arg1 = (LassoLibLogoutRequest *)jarg1; 
9208
 
    argp2 = (LassoSignatureType *)jarg2; 
9209
 
    if (!argp2) {
9210
 
        SWIG_CSharpThrowException(SWIG_CSharpNullReferenceException, "Attempt to dereference null LassoSignatureType");
9211
 
    }
9212
 
    arg2 = *argp2; 
9213
 
    LassoLibLogoutRequest_set_sign_type(arg1,arg2);
9214
 
    
9215
 
}
9216
 
 
9217
 
 
9218
 
DllExport void * SWIGSTDCALL CSharp_get_LibLogoutRequest_signType(void * jarg1) {
9219
 
    void * jresult = 0 ;
9220
 
    LassoLibLogoutRequest *arg1 = (LassoLibLogoutRequest *) 0 ;
9221
 
    LassoSignatureType result;
9222
 
    
9223
 
    arg1 = (LassoLibLogoutRequest *)jarg1; 
9224
 
    result = LassoLibLogoutRequest_get_sign_type(arg1);
9225
 
    
9226
 
    {
9227
 
        LassoSignatureType * resultptr = (LassoSignatureType *) malloc(sizeof(LassoSignatureType));
9228
 
        memmove(resultptr, &result, sizeof(LassoSignatureType));
9229
 
        jresult = resultptr;
9230
 
    }
9231
 
    return jresult;
9232
 
}
9233
 
 
9234
 
 
9235
 
DllExport void SWIGSTDCALL CSharp_set_LibLogoutRequest_extension(void * jarg1, void * jarg2) {
9236
 
    LassoLibLogoutRequest *arg1 = (LassoLibLogoutRequest *) 0 ;
9237
 
    LassoStringList *arg2 = (LassoStringList *) 0 ;
9238
 
    
9239
 
    arg1 = (LassoLibLogoutRequest *)jarg1; 
9240
 
    arg2 = (LassoStringList *)jarg2; 
9241
 
    LassoLibLogoutRequest_set_Extension(arg1,arg2);
9242
 
    
9243
 
}
9244
 
 
9245
 
 
9246
 
DllExport void * SWIGSTDCALL CSharp_get_LibLogoutRequest_extension(void * jarg1) {
9247
 
    void * jresult = 0 ;
9248
 
    LassoLibLogoutRequest *arg1 = (LassoLibLogoutRequest *) 0 ;
9249
 
    LassoStringList *result;
9250
 
    
9251
 
    arg1 = (LassoLibLogoutRequest *)jarg1; 
9252
 
    result = (LassoStringList *)LassoLibLogoutRequest_get_Extension(arg1);
9253
 
    
9254
 
    jresult = (void *)result; 
9255
 
    return jresult;
9256
 
}
9257
 
 
9258
 
 
9259
 
DllExport void SWIGSTDCALL CSharp_set_LibLogoutRequest_nameIdentifier(void * jarg1, void * jarg2) {
9260
 
    LassoLibLogoutRequest *arg1 = (LassoLibLogoutRequest *) 0 ;
9261
 
    LassoSamlNameIdentifier *arg2 = (LassoSamlNameIdentifier *) 0 ;
9262
 
    
9263
 
    arg1 = (LassoLibLogoutRequest *)jarg1; 
9264
 
    arg2 = (LassoSamlNameIdentifier *)jarg2; 
9265
 
    LassoLibLogoutRequest_set_NameIdentifier(arg1,arg2);
9266
 
    
9267
 
}
9268
 
 
9269
 
 
9270
 
DllExport void * SWIGSTDCALL CSharp_get_LibLogoutRequest_nameIdentifier(void * jarg1) {
9271
 
    void * jresult = 0 ;
9272
 
    LassoLibLogoutRequest *arg1 = (LassoLibLogoutRequest *) 0 ;
9273
 
    LassoSamlNameIdentifier *result;
9274
 
    
9275
 
    arg1 = (LassoLibLogoutRequest *)jarg1; 
9276
 
    result = (LassoSamlNameIdentifier *)LassoLibLogoutRequest_get_NameIdentifier(arg1);
9277
 
    
9278
 
    jresult = (void *)result; 
9279
 
    return jresult;
9280
 
}
9281
 
 
9282
 
 
9283
 
DllExport void * SWIGSTDCALL CSharp_new_LibLogoutRequest() {
9284
 
    void * jresult = 0 ;
9285
 
    LassoLibLogoutRequest *result;
9286
 
    
9287
 
    result = (LassoLibLogoutRequest *)new_LassoLibLogoutRequest();
9288
 
    
9289
 
    jresult = (void *)result; 
9290
 
    return jresult;
9291
 
}
9292
 
 
9293
 
 
9294
 
DllExport void SWIGSTDCALL CSharp_delete_LibLogoutRequest(void * jarg1) {
9295
 
    LassoLibLogoutRequest *arg1 = (LassoLibLogoutRequest *) 0 ;
9296
 
    
9297
 
    arg1 = (LassoLibLogoutRequest *)jarg1; 
9298
 
    delete_LassoLibLogoutRequest(arg1);
9299
 
    
9300
 
}
9301
 
 
9302
 
 
9303
 
DllExport void * SWIGSTDCALL CSharp_LibLogoutRequest_newFull(char * jarg1, void * jarg2, void * jarg3, int jarg4) {
9304
 
    void * jresult = 0 ;
9305
 
    char *arg1 = (char *) 0 ;
9306
 
    LassoSamlNameIdentifier *arg2 = (LassoSamlNameIdentifier *) 0 ;
9307
 
    LassoSignatureType arg3 ;
9308
 
    LassoSignatureMethod arg4 ;
9309
 
    LassoLibLogoutRequest *result;
9310
 
    LassoSignatureType *argp3 ;
9311
 
    
9312
 
    arg1 = jarg1; 
9313
 
    arg2 = (LassoSamlNameIdentifier *)jarg2; 
9314
 
    argp3 = (LassoSignatureType *)jarg3; 
9315
 
    if (!argp3) {
9316
 
        SWIG_CSharpThrowException(SWIG_CSharpNullReferenceException, "Attempt to dereference null LassoSignatureType");
9317
 
    }
9318
 
    arg3 = *argp3; 
9319
 
    arg4 = (LassoSignatureMethod)jarg4; 
9320
 
    result = (LassoLibLogoutRequest *)LibLogoutRequest_newFull(arg1,arg2,arg3,(LassoSignatureMethod )arg4);
9321
 
    
9322
 
    jresult = (void *)result; 
9323
 
    return jresult;
9324
 
}
9325
 
 
9326
 
 
9327
 
DllExport char * SWIGSTDCALL CSharp_LibLogoutRequest_dump(void * jarg1) {
9328
 
    char * jresult = 0 ;
9329
 
    LassoLibLogoutRequest *arg1 = (LassoLibLogoutRequest *) 0 ;
9330
 
    char *result;
9331
 
    
9332
 
    arg1 = (LassoLibLogoutRequest *)jarg1; 
9333
 
    result = (char *)LassoLibLogoutRequest_dump(arg1);
9334
 
    
9335
 
    jresult = SWIG_csharp_string_callback(result); 
9336
 
    free(result);
9337
 
    return jresult;
9338
 
}
9339
 
 
9340
 
 
9341
 
DllExport void SWIGSTDCALL CSharp_set_LibLogoutResponse_extension(void * jarg1, void * jarg2) {
9342
 
    LassoLibLogoutResponse *arg1 = (LassoLibLogoutResponse *) 0 ;
9343
 
    LassoStringList *arg2 = (LassoStringList *) 0 ;
9344
 
    
9345
 
    arg1 = (LassoLibLogoutResponse *)jarg1; 
9346
 
    arg2 = (LassoStringList *)jarg2; 
9347
 
    LassoLibLogoutResponse_set_Extension(arg1,arg2);
9348
 
    
9349
 
}
9350
 
 
9351
 
 
9352
 
DllExport void * SWIGSTDCALL CSharp_get_LibLogoutResponse_extension(void * jarg1) {
9353
 
    void * jresult = 0 ;
9354
 
    LassoLibLogoutResponse *arg1 = (LassoLibLogoutResponse *) 0 ;
9355
 
    LassoStringList *result;
9356
 
    
9357
 
    arg1 = (LassoLibLogoutResponse *)jarg1; 
9358
 
    result = (LassoStringList *)LassoLibLogoutResponse_get_Extension(arg1);
9359
 
    
9360
 
    jresult = (void *)result; 
9361
 
    return jresult;
9362
 
}
9363
 
 
9364
 
 
9365
 
DllExport void SWIGSTDCALL CSharp_set_LibLogoutResponse_providerId(void * jarg1, char * jarg2) {
9366
 
    LassoLibLogoutResponse *arg1 = (LassoLibLogoutResponse *) 0 ;
9367
 
    char *arg2 = (char *) 0 ;
9368
 
    
9369
 
    arg1 = (LassoLibLogoutResponse *)jarg1; 
9370
 
    arg2 = jarg2; 
9371
 
    LassoLibLogoutResponse_set_ProviderID(arg1,arg2);
9372
 
    
9373
 
}
9374
 
 
9375
 
 
9376
 
DllExport char * SWIGSTDCALL CSharp_get_LibLogoutResponse_providerId(void * jarg1) {
9377
 
    char * jresult = 0 ;
9378
 
    LassoLibLogoutResponse *arg1 = (LassoLibLogoutResponse *) 0 ;
9379
 
    char *result;
9380
 
    
9381
 
    arg1 = (LassoLibLogoutResponse *)jarg1; 
9382
 
    result = (char *)LassoLibLogoutResponse_get_ProviderID(arg1);
9383
 
    
9384
 
    jresult = SWIG_csharp_string_callback(result); 
9385
 
    return jresult;
9386
 
}
9387
 
 
9388
 
 
9389
 
DllExport void SWIGSTDCALL CSharp_set_LibLogoutResponse_relayState(void * jarg1, char * jarg2) {
9390
 
    LassoLibLogoutResponse *arg1 = (LassoLibLogoutResponse *) 0 ;
9391
 
    char *arg2 = (char *) 0 ;
9392
 
    
9393
 
    arg1 = (LassoLibLogoutResponse *)jarg1; 
9394
 
    arg2 = jarg2; 
9395
 
    LassoLibLogoutResponse_set_RelayState(arg1,arg2);
9396
 
    
9397
 
}
9398
 
 
9399
 
 
9400
 
DllExport char * SWIGSTDCALL CSharp_get_LibLogoutResponse_relayState(void * jarg1) {
9401
 
    char * jresult = 0 ;
9402
 
    LassoLibLogoutResponse *arg1 = (LassoLibLogoutResponse *) 0 ;
9403
 
    char *result;
9404
 
    
9405
 
    arg1 = (LassoLibLogoutResponse *)jarg1; 
9406
 
    result = (char *)LassoLibLogoutResponse_get_RelayState(arg1);
9407
 
    
9408
 
    jresult = SWIG_csharp_string_callback(result); 
9409
 
    return jresult;
9410
 
}
9411
 
 
9412
 
 
9413
 
DllExport void SWIGSTDCALL CSharp_set_LibLogoutResponse_status(void * jarg1, void * jarg2) {
9414
 
    LassoLibLogoutResponse *arg1 = (LassoLibLogoutResponse *) 0 ;
9415
 
    LassoSamlpStatus *arg2 = (LassoSamlpStatus *) 0 ;
9416
 
    
9417
 
    arg1 = (LassoLibLogoutResponse *)jarg1; 
9418
 
    arg2 = (LassoSamlpStatus *)jarg2; 
9419
 
    LassoLibLogoutResponse_set_Status(arg1,arg2);
9420
 
    
9421
 
}
9422
 
 
9423
 
 
9424
 
DllExport void * SWIGSTDCALL CSharp_get_LibLogoutResponse_status(void * jarg1) {
9425
 
    void * jresult = 0 ;
9426
 
    LassoLibLogoutResponse *arg1 = (LassoLibLogoutResponse *) 0 ;
9427
 
    LassoSamlpStatus *result;
9428
 
    
9429
 
    arg1 = (LassoLibLogoutResponse *)jarg1; 
9430
 
    result = (LassoSamlpStatus *)LassoLibLogoutResponse_get_Status(arg1);
9431
 
    
9432
 
    jresult = (void *)result; 
9433
 
    return jresult;
9434
 
}
9435
 
 
9436
 
 
9437
 
DllExport void * SWIGSTDCALL CSharp_new_LibLogoutResponse() {
9438
 
    void * jresult = 0 ;
9439
 
    LassoLibLogoutResponse *result;
9440
 
    
9441
 
    result = (LassoLibLogoutResponse *)new_LassoLibLogoutResponse();
9442
 
    
9443
 
    jresult = (void *)result; 
9444
 
    return jresult;
9445
 
}
9446
 
 
9447
 
 
9448
 
DllExport void SWIGSTDCALL CSharp_delete_LibLogoutResponse(void * jarg1) {
9449
 
    LassoLibLogoutResponse *arg1 = (LassoLibLogoutResponse *) 0 ;
9450
 
    
9451
 
    arg1 = (LassoLibLogoutResponse *)jarg1; 
9452
 
    delete_LassoLibLogoutResponse(arg1);
9453
 
    
9454
 
}
9455
 
 
9456
 
 
9457
 
DllExport void * SWIGSTDCALL CSharp_LibLogoutResponse_newFull(char * jarg1, char * jarg2, void * jarg3, void * jarg4, int jarg5) {
9458
 
    void * jresult = 0 ;
9459
 
    char *arg1 = (char *) 0 ;
9460
 
    char *arg2 = (char *) 0 ;
9461
 
    LassoLibLogoutRequest *arg3 = (LassoLibLogoutRequest *) 0 ;
9462
 
    LassoSignatureType arg4 ;
9463
 
    LassoSignatureMethod arg5 ;
9464
 
    LassoLibLogoutResponse *result;
9465
 
    LassoSignatureType *argp4 ;
9466
 
    
9467
 
    arg1 = jarg1; 
9468
 
    arg2 = jarg2; 
9469
 
    arg3 = (LassoLibLogoutRequest *)jarg3; 
9470
 
    argp4 = (LassoSignatureType *)jarg4; 
9471
 
    if (!argp4) {
9472
 
        SWIG_CSharpThrowException(SWIG_CSharpNullReferenceException, "Attempt to dereference null LassoSignatureType");
9473
 
    }
9474
 
    arg4 = *argp4; 
9475
 
    arg5 = (LassoSignatureMethod)jarg5; 
9476
 
    result = (LassoLibLogoutResponse *)LibLogoutResponse_newFull(arg1,(char const *)arg2,arg3,arg4,(LassoSignatureMethod )arg5);
9477
 
    
9478
 
    jresult = (void *)result; 
9479
 
    return jresult;
9480
 
}
9481
 
 
9482
 
 
9483
 
DllExport char * SWIGSTDCALL CSharp_LibLogoutResponse_dump(void * jarg1) {
9484
 
    char * jresult = 0 ;
9485
 
    LassoLibLogoutResponse *arg1 = (LassoLibLogoutResponse *) 0 ;
9486
 
    char *result;
9487
 
    
9488
 
    arg1 = (LassoLibLogoutResponse *)jarg1; 
9489
 
    result = (char *)LassoLibLogoutResponse_dump(arg1);
9490
 
    
9491
 
    jresult = SWIG_csharp_string_callback(result); 
9492
 
    free(result);
9493
 
    return jresult;
9494
 
}
9495
 
 
9496
 
 
9497
 
DllExport void SWIGSTDCALL CSharp_set_LibRegisterNameIdentifierRequest_providerId(void * jarg1, char * jarg2) {
9498
 
    LassoLibRegisterNameIdentifierRequest *arg1 = (LassoLibRegisterNameIdentifierRequest *) 0 ;
9499
 
    char *arg2 = (char *) 0 ;
9500
 
    
9501
 
    arg1 = (LassoLibRegisterNameIdentifierRequest *)jarg1; 
9502
 
    arg2 = jarg2; 
9503
 
    {
9504
 
        if (arg1->ProviderID) free((char*)arg1->ProviderID);
9505
 
        if (arg2) {
9506
 
            arg1->ProviderID = (char *) malloc(strlen(arg2)+1);
9507
 
            strcpy((char*)arg1->ProviderID,arg2);
9508
 
        } else {
9509
 
            arg1->ProviderID = 0;
9510
 
        }
9511
 
    }
9512
 
}
9513
 
 
9514
 
 
9515
 
DllExport char * SWIGSTDCALL CSharp_get_LibRegisterNameIdentifierRequest_providerId(void * jarg1) {
9516
 
    char * jresult = 0 ;
9517
 
    LassoLibRegisterNameIdentifierRequest *arg1 = (LassoLibRegisterNameIdentifierRequest *) 0 ;
9518
 
    char *result;
9519
 
    
9520
 
    arg1 = (LassoLibRegisterNameIdentifierRequest *)jarg1; 
9521
 
    result = (char *) ((arg1)->ProviderID);
9522
 
    
9523
 
    jresult = SWIG_csharp_string_callback(result); 
9524
 
    return jresult;
9525
 
}
9526
 
 
9527
 
 
9528
 
DllExport void SWIGSTDCALL CSharp_set_LibRegisterNameIdentifierRequest_relayState(void * jarg1, char * jarg2) {
9529
 
    LassoLibRegisterNameIdentifierRequest *arg1 = (LassoLibRegisterNameIdentifierRequest *) 0 ;
9530
 
    char *arg2 = (char *) 0 ;
9531
 
    
9532
 
    arg1 = (LassoLibRegisterNameIdentifierRequest *)jarg1; 
9533
 
    arg2 = jarg2; 
9534
 
    {
9535
 
        if (arg1->RelayState) free((char*)arg1->RelayState);
9536
 
        if (arg2) {
9537
 
            arg1->RelayState = (char *) malloc(strlen(arg2)+1);
9538
 
            strcpy((char*)arg1->RelayState,arg2);
9539
 
        } else {
9540
 
            arg1->RelayState = 0;
9541
 
        }
9542
 
    }
9543
 
}
9544
 
 
9545
 
 
9546
 
DllExport char * SWIGSTDCALL CSharp_get_LibRegisterNameIdentifierRequest_relayState(void * jarg1) {
9547
 
    char * jresult = 0 ;
9548
 
    LassoLibRegisterNameIdentifierRequest *arg1 = (LassoLibRegisterNameIdentifierRequest *) 0 ;
9549
 
    char *result;
9550
 
    
9551
 
    arg1 = (LassoLibRegisterNameIdentifierRequest *)jarg1; 
9552
 
    result = (char *) ((arg1)->RelayState);
9553
 
    
9554
 
    jresult = SWIG_csharp_string_callback(result); 
9555
 
    return jresult;
9556
 
}
9557
 
 
9558
 
 
9559
 
DllExport void SWIGSTDCALL CSharp_set_LibRegisterNameIdentifierRequest_certificateFile(void * jarg1, char * jarg2) {
9560
 
    LassoLibRegisterNameIdentifierRequest *arg1 = (LassoLibRegisterNameIdentifierRequest *) 0 ;
9561
 
    char *arg2 = (char *) 0 ;
9562
 
    
9563
 
    arg1 = (LassoLibRegisterNameIdentifierRequest *)jarg1; 
9564
 
    arg2 = jarg2; 
9565
 
    LassoLibRegisterNameIdentifierRequest_set_certificate_file(arg1,arg2);
9566
 
    
9567
 
}
9568
 
 
9569
 
 
9570
 
DllExport char * SWIGSTDCALL CSharp_get_LibRegisterNameIdentifierRequest_certificateFile(void * jarg1) {
9571
 
    char * jresult = 0 ;
9572
 
    LassoLibRegisterNameIdentifierRequest *arg1 = (LassoLibRegisterNameIdentifierRequest *) 0 ;
9573
 
    char *result;
9574
 
    
9575
 
    arg1 = (LassoLibRegisterNameIdentifierRequest *)jarg1; 
9576
 
    result = (char *)LassoLibRegisterNameIdentifierRequest_get_certificate_file(arg1);
9577
 
    
9578
 
    jresult = SWIG_csharp_string_callback(result); 
9579
 
    return jresult;
9580
 
}
9581
 
 
9582
 
 
9583
 
DllExport void SWIGSTDCALL CSharp_set_LibRegisterNameIdentifierRequest_issueInstant(void * jarg1, char * jarg2) {
9584
 
    LassoLibRegisterNameIdentifierRequest *arg1 = (LassoLibRegisterNameIdentifierRequest *) 0 ;
9585
 
    char *arg2 = (char *) 0 ;
9586
 
    
9587
 
    arg1 = (LassoLibRegisterNameIdentifierRequest *)jarg1; 
9588
 
    arg2 = jarg2; 
9589
 
    LassoLibRegisterNameIdentifierRequest_set_IssueInstant(arg1,arg2);
9590
 
    
9591
 
}
9592
 
 
9593
 
 
9594
 
DllExport char * SWIGSTDCALL CSharp_get_LibRegisterNameIdentifierRequest_issueInstant(void * jarg1) {
9595
 
    char * jresult = 0 ;
9596
 
    LassoLibRegisterNameIdentifierRequest *arg1 = (LassoLibRegisterNameIdentifierRequest *) 0 ;
9597
 
    char *result;
9598
 
    
9599
 
    arg1 = (LassoLibRegisterNameIdentifierRequest *)jarg1; 
9600
 
    result = (char *)LassoLibRegisterNameIdentifierRequest_get_IssueInstant(arg1);
9601
 
    
9602
 
    jresult = SWIG_csharp_string_callback(result); 
9603
 
    return jresult;
9604
 
}
9605
 
 
9606
 
 
9607
 
DllExport void SWIGSTDCALL CSharp_set_LibRegisterNameIdentifierRequest_majorVersion(void * jarg1, int jarg2) {
9608
 
    LassoLibRegisterNameIdentifierRequest *arg1 = (LassoLibRegisterNameIdentifierRequest *) 0 ;
9609
 
    int arg2 ;
9610
 
    
9611
 
    arg1 = (LassoLibRegisterNameIdentifierRequest *)jarg1; 
9612
 
    arg2 = (int)jarg2; 
9613
 
    LassoLibRegisterNameIdentifierRequest_set_MajorVersion(arg1,arg2);
9614
 
    
9615
 
}
9616
 
 
9617
 
 
9618
 
DllExport int SWIGSTDCALL CSharp_get_LibRegisterNameIdentifierRequest_majorVersion(void * jarg1) {
9619
 
    int jresult = 0 ;
9620
 
    LassoLibRegisterNameIdentifierRequest *arg1 = (LassoLibRegisterNameIdentifierRequest *) 0 ;
9621
 
    int result;
9622
 
    
9623
 
    arg1 = (LassoLibRegisterNameIdentifierRequest *)jarg1; 
9624
 
    result = (int)LassoLibRegisterNameIdentifierRequest_get_MajorVersion(arg1);
9625
 
    
9626
 
    jresult = result; 
9627
 
    return jresult;
9628
 
}
9629
 
 
9630
 
 
9631
 
DllExport void SWIGSTDCALL CSharp_set_LibRegisterNameIdentifierRequest_minorVersion(void * jarg1, int jarg2) {
9632
 
    LassoLibRegisterNameIdentifierRequest *arg1 = (LassoLibRegisterNameIdentifierRequest *) 0 ;
9633
 
    int arg2 ;
9634
 
    
9635
 
    arg1 = (LassoLibRegisterNameIdentifierRequest *)jarg1; 
9636
 
    arg2 = (int)jarg2; 
9637
 
    LassoLibRegisterNameIdentifierRequest_set_MinorVersion(arg1,arg2);
9638
 
    
9639
 
}
9640
 
 
9641
 
 
9642
 
DllExport int SWIGSTDCALL CSharp_get_LibRegisterNameIdentifierRequest_minorVersion(void * jarg1) {
9643
 
    int jresult = 0 ;
9644
 
    LassoLibRegisterNameIdentifierRequest *arg1 = (LassoLibRegisterNameIdentifierRequest *) 0 ;
9645
 
    int result;
9646
 
    
9647
 
    arg1 = (LassoLibRegisterNameIdentifierRequest *)jarg1; 
9648
 
    result = (int)LassoLibRegisterNameIdentifierRequest_get_MinorVersion(arg1);
9649
 
    
9650
 
    jresult = result; 
9651
 
    return jresult;
9652
 
}
9653
 
 
9654
 
 
9655
 
DllExport void SWIGSTDCALL CSharp_set_LibRegisterNameIdentifierRequest_privateKeyFile(void * jarg1, char * jarg2) {
9656
 
    LassoLibRegisterNameIdentifierRequest *arg1 = (LassoLibRegisterNameIdentifierRequest *) 0 ;
9657
 
    char *arg2 = (char *) 0 ;
9658
 
    
9659
 
    arg1 = (LassoLibRegisterNameIdentifierRequest *)jarg1; 
9660
 
    arg2 = jarg2; 
9661
 
    LassoLibRegisterNameIdentifierRequest_set_private_key_file(arg1,arg2);
9662
 
    
9663
 
}
9664
 
 
9665
 
 
9666
 
DllExport char * SWIGSTDCALL CSharp_get_LibRegisterNameIdentifierRequest_privateKeyFile(void * jarg1) {
9667
 
    char * jresult = 0 ;
9668
 
    LassoLibRegisterNameIdentifierRequest *arg1 = (LassoLibRegisterNameIdentifierRequest *) 0 ;
9669
 
    char *result;
9670
 
    
9671
 
    arg1 = (LassoLibRegisterNameIdentifierRequest *)jarg1; 
9672
 
    result = (char *)LassoLibRegisterNameIdentifierRequest_get_private_key_file(arg1);
9673
 
    
9674
 
    jresult = SWIG_csharp_string_callback(result); 
9675
 
    return jresult;
9676
 
}
9677
 
 
9678
 
 
9679
 
DllExport void SWIGSTDCALL CSharp_set_LibRegisterNameIdentifierRequest_requestId(void * jarg1, char * jarg2) {
9680
 
    LassoLibRegisterNameIdentifierRequest *arg1 = (LassoLibRegisterNameIdentifierRequest *) 0 ;
9681
 
    char *arg2 = (char *) 0 ;
9682
 
    
9683
 
    arg1 = (LassoLibRegisterNameIdentifierRequest *)jarg1; 
9684
 
    arg2 = jarg2; 
9685
 
    LassoLibRegisterNameIdentifierRequest_set_RequestID(arg1,arg2);
9686
 
    
9687
 
}
9688
 
 
9689
 
 
9690
 
DllExport char * SWIGSTDCALL CSharp_get_LibRegisterNameIdentifierRequest_requestId(void * jarg1) {
9691
 
    char * jresult = 0 ;
9692
 
    LassoLibRegisterNameIdentifierRequest *arg1 = (LassoLibRegisterNameIdentifierRequest *) 0 ;
9693
 
    char *result;
9694
 
    
9695
 
    arg1 = (LassoLibRegisterNameIdentifierRequest *)jarg1; 
9696
 
    result = (char *)LassoLibRegisterNameIdentifierRequest_get_RequestID(arg1);
9697
 
    
9698
 
    jresult = SWIG_csharp_string_callback(result); 
9699
 
    return jresult;
9700
 
}
9701
 
 
9702
 
 
9703
 
DllExport void SWIGSTDCALL CSharp_set_LibRegisterNameIdentifierRequest_respondWith(void * jarg1, void * jarg2) {
9704
 
    LassoLibRegisterNameIdentifierRequest *arg1 = (LassoLibRegisterNameIdentifierRequest *) 0 ;
9705
 
    LassoStringList *arg2 = (LassoStringList *) 0 ;
9706
 
    
9707
 
    arg1 = (LassoLibRegisterNameIdentifierRequest *)jarg1; 
9708
 
    arg2 = (LassoStringList *)jarg2; 
9709
 
    LassoLibRegisterNameIdentifierRequest_set_RespondWith(arg1,arg2);
9710
 
    
9711
 
}
9712
 
 
9713
 
 
9714
 
DllExport void * SWIGSTDCALL CSharp_get_LibRegisterNameIdentifierRequest_respondWith(void * jarg1) {
9715
 
    void * jresult = 0 ;
9716
 
    LassoLibRegisterNameIdentifierRequest *arg1 = (LassoLibRegisterNameIdentifierRequest *) 0 ;
9717
 
    LassoStringList *result;
9718
 
    
9719
 
    arg1 = (LassoLibRegisterNameIdentifierRequest *)jarg1; 
9720
 
    result = (LassoStringList *)LassoLibRegisterNameIdentifierRequest_get_RespondWith(arg1);
9721
 
    
9722
 
    jresult = (void *)result; 
9723
 
    return jresult;
9724
 
}
9725
 
 
9726
 
 
9727
 
DllExport void SWIGSTDCALL CSharp_set_LibRegisterNameIdentifierRequest_signMethod(void * jarg1, int jarg2) {
9728
 
    LassoLibRegisterNameIdentifierRequest *arg1 = (LassoLibRegisterNameIdentifierRequest *) 0 ;
9729
 
    LassoSignatureMethod arg2 ;
9730
 
    
9731
 
    arg1 = (LassoLibRegisterNameIdentifierRequest *)jarg1; 
9732
 
    arg2 = (LassoSignatureMethod)jarg2; 
9733
 
    LassoLibRegisterNameIdentifierRequest_set_sign_method(arg1,(LassoSignatureMethod )arg2);
9734
 
    
9735
 
}
9736
 
 
9737
 
 
9738
 
DllExport int SWIGSTDCALL CSharp_get_LibRegisterNameIdentifierRequest_signMethod(void * jarg1) {
9739
 
    int jresult = 0 ;
9740
 
    LassoLibRegisterNameIdentifierRequest *arg1 = (LassoLibRegisterNameIdentifierRequest *) 0 ;
9741
 
    LassoSignatureMethod result;
9742
 
    
9743
 
    arg1 = (LassoLibRegisterNameIdentifierRequest *)jarg1; 
9744
 
    result = (LassoSignatureMethod)LassoLibRegisterNameIdentifierRequest_get_sign_method(arg1);
9745
 
    
9746
 
    jresult = result; 
9747
 
    return jresult;
9748
 
}
9749
 
 
9750
 
 
9751
 
DllExport void SWIGSTDCALL CSharp_set_LibRegisterNameIdentifierRequest_signType(void * jarg1, void * jarg2) {
9752
 
    LassoLibRegisterNameIdentifierRequest *arg1 = (LassoLibRegisterNameIdentifierRequest *) 0 ;
9753
 
    LassoSignatureType arg2 ;
9754
 
    LassoSignatureType *argp2 ;
9755
 
    
9756
 
    arg1 = (LassoLibRegisterNameIdentifierRequest *)jarg1; 
9757
 
    argp2 = (LassoSignatureType *)jarg2; 
9758
 
    if (!argp2) {
9759
 
        SWIG_CSharpThrowException(SWIG_CSharpNullReferenceException, "Attempt to dereference null LassoSignatureType");
9760
 
    }
9761
 
    arg2 = *argp2; 
9762
 
    LassoLibRegisterNameIdentifierRequest_set_sign_type(arg1,arg2);
9763
 
    
9764
 
}
9765
 
 
9766
 
 
9767
 
DllExport void * SWIGSTDCALL CSharp_get_LibRegisterNameIdentifierRequest_signType(void * jarg1) {
9768
 
    void * jresult = 0 ;
9769
 
    LassoLibRegisterNameIdentifierRequest *arg1 = (LassoLibRegisterNameIdentifierRequest *) 0 ;
9770
 
    LassoSignatureType result;
9771
 
    
9772
 
    arg1 = (LassoLibRegisterNameIdentifierRequest *)jarg1; 
9773
 
    result = LassoLibRegisterNameIdentifierRequest_get_sign_type(arg1);
9774
 
    
9775
 
    {
9776
 
        LassoSignatureType * resultptr = (LassoSignatureType *) malloc(sizeof(LassoSignatureType));
9777
 
        memmove(resultptr, &result, sizeof(LassoSignatureType));
9778
 
        jresult = resultptr;
9779
 
    }
9780
 
    return jresult;
9781
 
}
9782
 
 
9783
 
 
9784
 
DllExport void SWIGSTDCALL CSharp_set_LibRegisterNameIdentifierRequest_extension(void * jarg1, void * jarg2) {
9785
 
    LassoLibRegisterNameIdentifierRequest *arg1 = (LassoLibRegisterNameIdentifierRequest *) 0 ;
9786
 
    LassoStringList *arg2 = (LassoStringList *) 0 ;
9787
 
    
9788
 
    arg1 = (LassoLibRegisterNameIdentifierRequest *)jarg1; 
9789
 
    arg2 = (LassoStringList *)jarg2; 
9790
 
    LassoLibRegisterNameIdentifierRequest_set_Extension(arg1,arg2);
9791
 
    
9792
 
}
9793
 
 
9794
 
 
9795
 
DllExport void * SWIGSTDCALL CSharp_get_LibRegisterNameIdentifierRequest_extension(void * jarg1) {
9796
 
    void * jresult = 0 ;
9797
 
    LassoLibRegisterNameIdentifierRequest *arg1 = (LassoLibRegisterNameIdentifierRequest *) 0 ;
9798
 
    LassoStringList *result;
9799
 
    
9800
 
    arg1 = (LassoLibRegisterNameIdentifierRequest *)jarg1; 
9801
 
    result = (LassoStringList *)LassoLibRegisterNameIdentifierRequest_get_Extension(arg1);
9802
 
    
9803
 
    jresult = (void *)result; 
9804
 
    return jresult;
9805
 
}
9806
 
 
9807
 
 
9808
 
DllExport void SWIGSTDCALL CSharp_set_LibRegisterNameIdentifierRequest_idpProvidedNameIdentifier(void * jarg1, void * jarg2) {
9809
 
    LassoLibRegisterNameIdentifierRequest *arg1 = (LassoLibRegisterNameIdentifierRequest *) 0 ;
9810
 
    LassoSamlNameIdentifier *arg2 = (LassoSamlNameIdentifier *) 0 ;
9811
 
    
9812
 
    arg1 = (LassoLibRegisterNameIdentifierRequest *)jarg1; 
9813
 
    arg2 = (LassoSamlNameIdentifier *)jarg2; 
9814
 
    LassoLibRegisterNameIdentifierRequest_set_IDPProvidedNameIdentifier(arg1,arg2);
9815
 
    
9816
 
}
9817
 
 
9818
 
 
9819
 
DllExport void * SWIGSTDCALL CSharp_get_LibRegisterNameIdentifierRequest_idpProvidedNameIdentifier(void * jarg1) {
9820
 
    void * jresult = 0 ;
9821
 
    LassoLibRegisterNameIdentifierRequest *arg1 = (LassoLibRegisterNameIdentifierRequest *) 0 ;
9822
 
    LassoSamlNameIdentifier *result;
9823
 
    
9824
 
    arg1 = (LassoLibRegisterNameIdentifierRequest *)jarg1; 
9825
 
    result = (LassoSamlNameIdentifier *)LassoLibRegisterNameIdentifierRequest_get_IDPProvidedNameIdentifier(arg1);
9826
 
    
9827
 
    jresult = (void *)result; 
9828
 
    return jresult;
9829
 
}
9830
 
 
9831
 
 
9832
 
DllExport void SWIGSTDCALL CSharp_set_LibRegisterNameIdentifierRequest_oldProvidedNameIdentifier(void * jarg1, void * jarg2) {
9833
 
    LassoLibRegisterNameIdentifierRequest *arg1 = (LassoLibRegisterNameIdentifierRequest *) 0 ;
9834
 
    LassoSamlNameIdentifier *arg2 = (LassoSamlNameIdentifier *) 0 ;
9835
 
    
9836
 
    arg1 = (LassoLibRegisterNameIdentifierRequest *)jarg1; 
9837
 
    arg2 = (LassoSamlNameIdentifier *)jarg2; 
9838
 
    LassoLibRegisterNameIdentifierRequest_set_OldProvidedNameIdentifier(arg1,arg2);
9839
 
    
9840
 
}
9841
 
 
9842
 
 
9843
 
DllExport void * SWIGSTDCALL CSharp_get_LibRegisterNameIdentifierRequest_oldProvidedNameIdentifier(void * jarg1) {
9844
 
    void * jresult = 0 ;
9845
 
    LassoLibRegisterNameIdentifierRequest *arg1 = (LassoLibRegisterNameIdentifierRequest *) 0 ;
9846
 
    LassoSamlNameIdentifier *result;
9847
 
    
9848
 
    arg1 = (LassoLibRegisterNameIdentifierRequest *)jarg1; 
9849
 
    result = (LassoSamlNameIdentifier *)LassoLibRegisterNameIdentifierRequest_get_OldProvidedNameIdentifier(arg1);
9850
 
    
9851
 
    jresult = (void *)result; 
9852
 
    return jresult;
9853
 
}
9854
 
 
9855
 
 
9856
 
DllExport void SWIGSTDCALL CSharp_set_LibRegisterNameIdentifierRequest_spProvidedNameIdentifier(void * jarg1, void * jarg2) {
9857
 
    LassoLibRegisterNameIdentifierRequest *arg1 = (LassoLibRegisterNameIdentifierRequest *) 0 ;
9858
 
    LassoSamlNameIdentifier *arg2 = (LassoSamlNameIdentifier *) 0 ;
9859
 
    
9860
 
    arg1 = (LassoLibRegisterNameIdentifierRequest *)jarg1; 
9861
 
    arg2 = (LassoSamlNameIdentifier *)jarg2; 
9862
 
    LassoLibRegisterNameIdentifierRequest_set_SPProvidedNameIdentifier(arg1,arg2);
9863
 
    
9864
 
}
9865
 
 
9866
 
 
9867
 
DllExport void * SWIGSTDCALL CSharp_get_LibRegisterNameIdentifierRequest_spProvidedNameIdentifier(void * jarg1) {
9868
 
    void * jresult = 0 ;
9869
 
    LassoLibRegisterNameIdentifierRequest *arg1 = (LassoLibRegisterNameIdentifierRequest *) 0 ;
9870
 
    LassoSamlNameIdentifier *result;
9871
 
    
9872
 
    arg1 = (LassoLibRegisterNameIdentifierRequest *)jarg1; 
9873
 
    result = (LassoSamlNameIdentifier *)LassoLibRegisterNameIdentifierRequest_get_SPProvidedNameIdentifier(arg1);
9874
 
    
9875
 
    jresult = (void *)result; 
9876
 
    return jresult;
9877
 
}
9878
 
 
9879
 
 
9880
 
DllExport void * SWIGSTDCALL CSharp_new_LibRegisterNameIdentifierRequest() {
9881
 
    void * jresult = 0 ;
9882
 
    LassoLibRegisterNameIdentifierRequest *result;
9883
 
    
9884
 
    result = (LassoLibRegisterNameIdentifierRequest *)new_LassoLibRegisterNameIdentifierRequest();
9885
 
    
9886
 
    jresult = (void *)result; 
9887
 
    return jresult;
9888
 
}
9889
 
 
9890
 
 
9891
 
DllExport void SWIGSTDCALL CSharp_delete_LibRegisterNameIdentifierRequest(void * jarg1) {
9892
 
    LassoLibRegisterNameIdentifierRequest *arg1 = (LassoLibRegisterNameIdentifierRequest *) 0 ;
9893
 
    
9894
 
    arg1 = (LassoLibRegisterNameIdentifierRequest *)jarg1; 
9895
 
    delete_LassoLibRegisterNameIdentifierRequest(arg1);
9896
 
    
9897
 
}
9898
 
 
9899
 
 
9900
 
DllExport void * SWIGSTDCALL CSharp_LibRegisterNameIdentifierRequest_newFull(char * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6) {
9901
 
    void * jresult = 0 ;
9902
 
    char *arg1 = (char *) 0 ;
9903
 
    LassoSamlNameIdentifier *arg2 = (LassoSamlNameIdentifier *) 0 ;
9904
 
    LassoSamlNameIdentifier *arg3 = (LassoSamlNameIdentifier *) 0 ;
9905
 
    LassoSamlNameIdentifier *arg4 = (LassoSamlNameIdentifier *) 0 ;
9906
 
    LassoSignatureType arg5 ;
9907
 
    LassoSignatureMethod arg6 ;
9908
 
    LassoLibRegisterNameIdentifierRequest *result;
9909
 
    LassoSignatureType *argp5 ;
9910
 
    
9911
 
    arg1 = jarg1; 
9912
 
    arg2 = (LassoSamlNameIdentifier *)jarg2; 
9913
 
    arg3 = (LassoSamlNameIdentifier *)jarg3; 
9914
 
    arg4 = (LassoSamlNameIdentifier *)jarg4; 
9915
 
    argp5 = (LassoSignatureType *)jarg5; 
9916
 
    if (!argp5) {
9917
 
        SWIG_CSharpThrowException(SWIG_CSharpNullReferenceException, "Attempt to dereference null LassoSignatureType");
9918
 
    }
9919
 
    arg5 = *argp5; 
9920
 
    arg6 = (LassoSignatureMethod)jarg6; 
9921
 
    result = (LassoLibRegisterNameIdentifierRequest *)LibRegisterNameIdentifierRequest_newFull(arg1,arg2,arg3,arg4,arg5,(LassoSignatureMethod )arg6);
9922
 
    
9923
 
    jresult = (void *)result; 
9924
 
    return jresult;
9925
 
}
9926
 
 
9927
 
 
9928
 
DllExport char * SWIGSTDCALL CSharp_LibRegisterNameIdentifierRequest_dump(void * jarg1) {
9929
 
    char * jresult = 0 ;
9930
 
    LassoLibRegisterNameIdentifierRequest *arg1 = (LassoLibRegisterNameIdentifierRequest *) 0 ;
9931
 
    char *result;
9932
 
    
9933
 
    arg1 = (LassoLibRegisterNameIdentifierRequest *)jarg1; 
9934
 
    result = (char *)LassoLibRegisterNameIdentifierRequest_dump(arg1);
9935
 
    
9936
 
    jresult = SWIG_csharp_string_callback(result); 
9937
 
    free(result);
9938
 
    return jresult;
9939
 
}
9940
 
 
9941
 
 
9942
 
DllExport void SWIGSTDCALL CSharp_set_LibRegisterNameIdentifierResponse_extension(void * jarg1, void * jarg2) {
9943
 
    LassoLibRegisterNameIdentifierResponse *arg1 = (LassoLibRegisterNameIdentifierResponse *) 0 ;
9944
 
    LassoStringList *arg2 = (LassoStringList *) 0 ;
9945
 
    
9946
 
    arg1 = (LassoLibRegisterNameIdentifierResponse *)jarg1; 
9947
 
    arg2 = (LassoStringList *)jarg2; 
9948
 
    LassoLibRegisterNameIdentifierResponse_set_Extension(arg1,arg2);
9949
 
    
9950
 
}
9951
 
 
9952
 
 
9953
 
DllExport void * SWIGSTDCALL CSharp_get_LibRegisterNameIdentifierResponse_extension(void * jarg1) {
9954
 
    void * jresult = 0 ;
9955
 
    LassoLibRegisterNameIdentifierResponse *arg1 = (LassoLibRegisterNameIdentifierResponse *) 0 ;
9956
 
    LassoStringList *result;
9957
 
    
9958
 
    arg1 = (LassoLibRegisterNameIdentifierResponse *)jarg1; 
9959
 
    result = (LassoStringList *)LassoLibRegisterNameIdentifierResponse_get_Extension(arg1);
9960
 
    
9961
 
    jresult = (void *)result; 
9962
 
    return jresult;
9963
 
}
9964
 
 
9965
 
 
9966
 
DllExport void SWIGSTDCALL CSharp_set_LibRegisterNameIdentifierResponse_providerId(void * jarg1, char * jarg2) {
9967
 
    LassoLibRegisterNameIdentifierResponse *arg1 = (LassoLibRegisterNameIdentifierResponse *) 0 ;
9968
 
    char *arg2 = (char *) 0 ;
9969
 
    
9970
 
    arg1 = (LassoLibRegisterNameIdentifierResponse *)jarg1; 
9971
 
    arg2 = jarg2; 
9972
 
    LassoLibRegisterNameIdentifierResponse_set_ProviderID(arg1,arg2);
9973
 
    
9974
 
}
9975
 
 
9976
 
 
9977
 
DllExport char * SWIGSTDCALL CSharp_get_LibRegisterNameIdentifierResponse_providerId(void * jarg1) {
9978
 
    char * jresult = 0 ;
9979
 
    LassoLibRegisterNameIdentifierResponse *arg1 = (LassoLibRegisterNameIdentifierResponse *) 0 ;
9980
 
    char *result;
9981
 
    
9982
 
    arg1 = (LassoLibRegisterNameIdentifierResponse *)jarg1; 
9983
 
    result = (char *)LassoLibRegisterNameIdentifierResponse_get_ProviderID(arg1);
9984
 
    
9985
 
    jresult = SWIG_csharp_string_callback(result); 
9986
 
    return jresult;
9987
 
}
9988
 
 
9989
 
 
9990
 
DllExport void SWIGSTDCALL CSharp_set_LibRegisterNameIdentifierResponse_relayState(void * jarg1, char * jarg2) {
9991
 
    LassoLibRegisterNameIdentifierResponse *arg1 = (LassoLibRegisterNameIdentifierResponse *) 0 ;
9992
 
    char *arg2 = (char *) 0 ;
9993
 
    
9994
 
    arg1 = (LassoLibRegisterNameIdentifierResponse *)jarg1; 
9995
 
    arg2 = jarg2; 
9996
 
    LassoLibRegisterNameIdentifierResponse_set_RelayState(arg1,arg2);
9997
 
    
9998
 
}
9999
 
 
10000
 
 
10001
 
DllExport char * SWIGSTDCALL CSharp_get_LibRegisterNameIdentifierResponse_relayState(void * jarg1) {
10002
 
    char * jresult = 0 ;
10003
 
    LassoLibRegisterNameIdentifierResponse *arg1 = (LassoLibRegisterNameIdentifierResponse *) 0 ;
10004
 
    char *result;
10005
 
    
10006
 
    arg1 = (LassoLibRegisterNameIdentifierResponse *)jarg1; 
10007
 
    result = (char *)LassoLibRegisterNameIdentifierResponse_get_RelayState(arg1);
10008
 
    
10009
 
    jresult = SWIG_csharp_string_callback(result); 
10010
 
    return jresult;
10011
 
}
10012
 
 
10013
 
 
10014
 
DllExport void SWIGSTDCALL CSharp_set_LibRegisterNameIdentifierResponse_status(void * jarg1, void * jarg2) {
10015
 
    LassoLibRegisterNameIdentifierResponse *arg1 = (LassoLibRegisterNameIdentifierResponse *) 0 ;
10016
 
    LassoSamlpStatus *arg2 = (LassoSamlpStatus *) 0 ;
10017
 
    
10018
 
    arg1 = (LassoLibRegisterNameIdentifierResponse *)jarg1; 
10019
 
    arg2 = (LassoSamlpStatus *)jarg2; 
10020
 
    LassoLibRegisterNameIdentifierResponse_set_Status(arg1,arg2);
10021
 
    
10022
 
}
10023
 
 
10024
 
 
10025
 
DllExport void * SWIGSTDCALL CSharp_get_LibRegisterNameIdentifierResponse_status(void * jarg1) {
10026
 
    void * jresult = 0 ;
10027
 
    LassoLibRegisterNameIdentifierResponse *arg1 = (LassoLibRegisterNameIdentifierResponse *) 0 ;
10028
 
    LassoSamlpStatus *result;
10029
 
    
10030
 
    arg1 = (LassoLibRegisterNameIdentifierResponse *)jarg1; 
10031
 
    result = (LassoSamlpStatus *)LassoLibRegisterNameIdentifierResponse_get_Status(arg1);
10032
 
    
10033
 
    jresult = (void *)result; 
10034
 
    return jresult;
10035
 
}
10036
 
 
10037
 
 
10038
 
DllExport void * SWIGSTDCALL CSharp_new_LibRegisterNameIdentifierResponse() {
10039
 
    void * jresult = 0 ;
10040
 
    LassoLibRegisterNameIdentifierResponse *result;
10041
 
    
10042
 
    result = (LassoLibRegisterNameIdentifierResponse *)new_LassoLibRegisterNameIdentifierResponse();
10043
 
    
10044
 
    jresult = (void *)result; 
10045
 
    return jresult;
10046
 
}
10047
 
 
10048
 
 
10049
 
DllExport void SWIGSTDCALL CSharp_delete_LibRegisterNameIdentifierResponse(void * jarg1) {
10050
 
    LassoLibRegisterNameIdentifierResponse *arg1 = (LassoLibRegisterNameIdentifierResponse *) 0 ;
10051
 
    
10052
 
    arg1 = (LassoLibRegisterNameIdentifierResponse *)jarg1; 
10053
 
    delete_LassoLibRegisterNameIdentifierResponse(arg1);
10054
 
    
10055
 
}
10056
 
 
10057
 
 
10058
 
DllExport void * SWIGSTDCALL CSharp_LibRegisterNameIdentifierResponse_newFull(char * jarg1, char * jarg2, void * jarg3, void * jarg4, int jarg5) {
10059
 
    void * jresult = 0 ;
10060
 
    char *arg1 = (char *) 0 ;
10061
 
    char *arg2 = (char *) 0 ;
10062
 
    LassoLibRegisterNameIdentifierRequest *arg3 = (LassoLibRegisterNameIdentifierRequest *) 0 ;
10063
 
    LassoSignatureType arg4 ;
10064
 
    LassoSignatureMethod arg5 ;
10065
 
    LassoLibRegisterNameIdentifierResponse *result;
10066
 
    LassoSignatureType *argp4 ;
10067
 
    
10068
 
    arg1 = jarg1; 
10069
 
    arg2 = jarg2; 
10070
 
    arg3 = (LassoLibRegisterNameIdentifierRequest *)jarg3; 
10071
 
    argp4 = (LassoSignatureType *)jarg4; 
10072
 
    if (!argp4) {
10073
 
        SWIG_CSharpThrowException(SWIG_CSharpNullReferenceException, "Attempt to dereference null LassoSignatureType");
10074
 
    }
10075
 
    arg4 = *argp4; 
10076
 
    arg5 = (LassoSignatureMethod)jarg5; 
10077
 
    result = (LassoLibRegisterNameIdentifierResponse *)LibRegisterNameIdentifierResponse_newFull(arg1,arg2,arg3,arg4,(LassoSignatureMethod )arg5);
10078
 
    
10079
 
    jresult = (void *)result; 
10080
 
    return jresult;
10081
 
}
10082
 
 
10083
 
 
10084
 
DllExport char * SWIGSTDCALL CSharp_LibRegisterNameIdentifierResponse_dump(void * jarg1) {
10085
 
    char * jresult = 0 ;
10086
 
    LassoLibRegisterNameIdentifierResponse *arg1 = (LassoLibRegisterNameIdentifierResponse *) 0 ;
10087
 
    char *result;
10088
 
    
10089
 
    arg1 = (LassoLibRegisterNameIdentifierResponse *)jarg1; 
10090
 
    result = (char *)LassoLibRegisterNameIdentifierResponse_dump(arg1);
10091
 
    
10092
 
    jresult = SWIG_csharp_string_callback(result); 
10093
 
    free(result);
10094
 
    return jresult;
10095
 
}
10096
 
 
10097
 
 
10098
 
DllExport void SWIGSTDCALL CSharp_set_LibRequestAuthnContext_authnContextComparison(void * jarg1, char * jarg2) {
10099
 
    LassoLibRequestAuthnContext *arg1 = (LassoLibRequestAuthnContext *) 0 ;
10100
 
    char *arg2 = (char *) 0 ;
10101
 
    
10102
 
    arg1 = (LassoLibRequestAuthnContext *)jarg1; 
10103
 
    arg2 = jarg2; 
10104
 
    {
10105
 
        if (arg1->AuthnContextComparison) free((char*)arg1->AuthnContextComparison);
10106
 
        if (arg2) {
10107
 
            arg1->AuthnContextComparison = (char *) malloc(strlen(arg2)+1);
10108
 
            strcpy((char*)arg1->AuthnContextComparison,arg2);
10109
 
        } else {
10110
 
            arg1->AuthnContextComparison = 0;
10111
 
        }
10112
 
    }
10113
 
}
10114
 
 
10115
 
 
10116
 
DllExport char * SWIGSTDCALL CSharp_get_LibRequestAuthnContext_authnContextComparison(void * jarg1) {
10117
 
    char * jresult = 0 ;
10118
 
    LassoLibRequestAuthnContext *arg1 = (LassoLibRequestAuthnContext *) 0 ;
10119
 
    char *result;
10120
 
    
10121
 
    arg1 = (LassoLibRequestAuthnContext *)jarg1; 
10122
 
    result = (char *) ((arg1)->AuthnContextComparison);
10123
 
    
10124
 
    jresult = SWIG_csharp_string_callback(result); 
10125
 
    return jresult;
10126
 
}
10127
 
 
10128
 
 
10129
 
DllExport void SWIGSTDCALL CSharp_set_LibRequestAuthnContext_authnContextClassRef(void * jarg1, void * jarg2) {
10130
 
    LassoLibRequestAuthnContext *arg1 = (LassoLibRequestAuthnContext *) 0 ;
10131
 
    LassoStringList *arg2 = (LassoStringList *) 0 ;
10132
 
    
10133
 
    arg1 = (LassoLibRequestAuthnContext *)jarg1; 
10134
 
    arg2 = (LassoStringList *)jarg2; 
10135
 
    LassoLibRequestAuthnContext_set_authnContextClassRef(arg1,arg2);
10136
 
    
10137
 
}
10138
 
 
10139
 
 
10140
 
DllExport void * SWIGSTDCALL CSharp_get_LibRequestAuthnContext_authnContextClassRef(void * jarg1) {
10141
 
    void * jresult = 0 ;
10142
 
    LassoLibRequestAuthnContext *arg1 = (LassoLibRequestAuthnContext *) 0 ;
10143
 
    LassoStringList *result;
10144
 
    
10145
 
    arg1 = (LassoLibRequestAuthnContext *)jarg1; 
10146
 
    result = (LassoStringList *)LassoLibRequestAuthnContext_get_authnContextClassRef(arg1);
10147
 
    
10148
 
    jresult = (void *)result; 
10149
 
    return jresult;
10150
 
}
10151
 
 
10152
 
 
10153
 
DllExport void SWIGSTDCALL CSharp_set_LibRequestAuthnContext_authnContextStatementRef(void * jarg1, void * jarg2) {
10154
 
    LassoLibRequestAuthnContext *arg1 = (LassoLibRequestAuthnContext *) 0 ;
10155
 
    LassoStringList *arg2 = (LassoStringList *) 0 ;
10156
 
    
10157
 
    arg1 = (LassoLibRequestAuthnContext *)jarg1; 
10158
 
    arg2 = (LassoStringList *)jarg2; 
10159
 
    LassoLibRequestAuthnContext_set_authnContextStatementRef(arg1,arg2);
10160
 
    
10161
 
}
10162
 
 
10163
 
 
10164
 
DllExport void * SWIGSTDCALL CSharp_get_LibRequestAuthnContext_authnContextStatementRef(void * jarg1) {
10165
 
    void * jresult = 0 ;
10166
 
    LassoLibRequestAuthnContext *arg1 = (LassoLibRequestAuthnContext *) 0 ;
10167
 
    LassoStringList *result;
10168
 
    
10169
 
    arg1 = (LassoLibRequestAuthnContext *)jarg1; 
10170
 
    result = (LassoStringList *)LassoLibRequestAuthnContext_get_authnContextStatementRef(arg1);
10171
 
    
10172
 
    jresult = (void *)result; 
10173
 
    return jresult;
10174
 
}
10175
 
 
10176
 
 
10177
 
DllExport void * SWIGSTDCALL CSharp_new_LibRequestAuthnContext() {
10178
 
    void * jresult = 0 ;
10179
 
    LassoLibRequestAuthnContext *result;
10180
 
    
10181
 
    result = (LassoLibRequestAuthnContext *)new_LassoLibRequestAuthnContext();
10182
 
    
10183
 
    jresult = (void *)result; 
10184
 
    return jresult;
10185
 
}
10186
 
 
10187
 
 
10188
 
DllExport void SWIGSTDCALL CSharp_delete_LibRequestAuthnContext(void * jarg1) {
10189
 
    LassoLibRequestAuthnContext *arg1 = (LassoLibRequestAuthnContext *) 0 ;
10190
 
    
10191
 
    arg1 = (LassoLibRequestAuthnContext *)jarg1; 
10192
 
    delete_LassoLibRequestAuthnContext(arg1);
10193
 
    
10194
 
}
10195
 
 
10196
 
 
10197
 
DllExport char * SWIGSTDCALL CSharp_LibRequestAuthnContext_dump(void * jarg1) {
10198
 
    char * jresult = 0 ;
10199
 
    LassoLibRequestAuthnContext *arg1 = (LassoLibRequestAuthnContext *) 0 ;
10200
 
    char *result;
10201
 
    
10202
 
    arg1 = (LassoLibRequestAuthnContext *)jarg1; 
10203
 
    result = (char *)LassoLibRequestAuthnContext_dump(arg1);
10204
 
    
10205
 
    jresult = SWIG_csharp_string_callback(result); 
10206
 
    free(result);
10207
 
    return jresult;
10208
 
}
10209
 
 
10210
 
 
10211
 
DllExport void SWIGSTDCALL CSharp_set_LibStatusResponse_providerId(void * jarg1, char * jarg2) {
10212
 
    LassoLibStatusResponse *arg1 = (LassoLibStatusResponse *) 0 ;
10213
 
    char *arg2 = (char *) 0 ;
10214
 
    
10215
 
    arg1 = (LassoLibStatusResponse *)jarg1; 
10216
 
    arg2 = jarg2; 
10217
 
    {
10218
 
        if (arg1->ProviderID) free((char*)arg1->ProviderID);
10219
 
        if (arg2) {
10220
 
            arg1->ProviderID = (char *) malloc(strlen(arg2)+1);
10221
 
            strcpy((char*)arg1->ProviderID,arg2);
10222
 
        } else {
10223
 
            arg1->ProviderID = 0;
10224
 
        }
10225
 
    }
10226
 
}
10227
 
 
10228
 
 
10229
 
DllExport char * SWIGSTDCALL CSharp_get_LibStatusResponse_providerId(void * jarg1) {
10230
 
    char * jresult = 0 ;
10231
 
    LassoLibStatusResponse *arg1 = (LassoLibStatusResponse *) 0 ;
10232
 
    char *result;
10233
 
    
10234
 
    arg1 = (LassoLibStatusResponse *)jarg1; 
10235
 
    result = (char *) ((arg1)->ProviderID);
10236
 
    
10237
 
    jresult = SWIG_csharp_string_callback(result); 
10238
 
    return jresult;
10239
 
}
10240
 
 
10241
 
 
10242
 
DllExport void SWIGSTDCALL CSharp_set_LibStatusResponse_relayState(void * jarg1, char * jarg2) {
10243
 
    LassoLibStatusResponse *arg1 = (LassoLibStatusResponse *) 0 ;
10244
 
    char *arg2 = (char *) 0 ;
10245
 
    
10246
 
    arg1 = (LassoLibStatusResponse *)jarg1; 
10247
 
    arg2 = jarg2; 
10248
 
    {
10249
 
        if (arg1->RelayState) free((char*)arg1->RelayState);
10250
 
        if (arg2) {
10251
 
            arg1->RelayState = (char *) malloc(strlen(arg2)+1);
10252
 
            strcpy((char*)arg1->RelayState,arg2);
10253
 
        } else {
10254
 
            arg1->RelayState = 0;
10255
 
        }
10256
 
    }
10257
 
}
10258
 
 
10259
 
 
10260
 
DllExport char * SWIGSTDCALL CSharp_get_LibStatusResponse_relayState(void * jarg1) {
10261
 
    char * jresult = 0 ;
10262
 
    LassoLibStatusResponse *arg1 = (LassoLibStatusResponse *) 0 ;
10263
 
    char *result;
10264
 
    
10265
 
    arg1 = (LassoLibStatusResponse *)jarg1; 
10266
 
    result = (char *) ((arg1)->RelayState);
10267
 
    
10268
 
    jresult = SWIG_csharp_string_callback(result); 
10269
 
    return jresult;
10270
 
}
10271
 
 
10272
 
 
10273
 
DllExport void SWIGSTDCALL CSharp_set_LibStatusResponse_extension(void * jarg1, void * jarg2) {
10274
 
    LassoLibStatusResponse *arg1 = (LassoLibStatusResponse *) 0 ;
10275
 
    LassoStringList *arg2 = (LassoStringList *) 0 ;
10276
 
    
10277
 
    arg1 = (LassoLibStatusResponse *)jarg1; 
10278
 
    arg2 = (LassoStringList *)jarg2; 
10279
 
    LassoLibStatusResponse_set_Extension(arg1,arg2);
10280
 
    
10281
 
}
10282
 
 
10283
 
 
10284
 
DllExport void * SWIGSTDCALL CSharp_get_LibStatusResponse_extension(void * jarg1) {
10285
 
    void * jresult = 0 ;
10286
 
    LassoLibStatusResponse *arg1 = (LassoLibStatusResponse *) 0 ;
10287
 
    LassoStringList *result;
10288
 
    
10289
 
    arg1 = (LassoLibStatusResponse *)jarg1; 
10290
 
    result = (LassoStringList *)LassoLibStatusResponse_get_Extension(arg1);
10291
 
    
10292
 
    jresult = (void *)result; 
10293
 
    return jresult;
10294
 
}
10295
 
 
10296
 
 
10297
 
DllExport void SWIGSTDCALL CSharp_set_LibStatusResponse_status(void * jarg1, void * jarg2) {
10298
 
    LassoLibStatusResponse *arg1 = (LassoLibStatusResponse *) 0 ;
10299
 
    LassoSamlpStatus *arg2 = (LassoSamlpStatus *) 0 ;
10300
 
    
10301
 
    arg1 = (LassoLibStatusResponse *)jarg1; 
10302
 
    arg2 = (LassoSamlpStatus *)jarg2; 
10303
 
    LassoLibStatusResponse_set_Status(arg1,arg2);
10304
 
    
10305
 
}
10306
 
 
10307
 
 
10308
 
DllExport void * SWIGSTDCALL CSharp_get_LibStatusResponse_status(void * jarg1) {
10309
 
    void * jresult = 0 ;
10310
 
    LassoLibStatusResponse *arg1 = (LassoLibStatusResponse *) 0 ;
10311
 
    LassoSamlpStatus *result;
10312
 
    
10313
 
    arg1 = (LassoLibStatusResponse *)jarg1; 
10314
 
    result = (LassoSamlpStatus *)LassoLibStatusResponse_get_Status(arg1);
10315
 
    
10316
 
    jresult = (void *)result; 
10317
 
    return jresult;
10318
 
}
10319
 
 
10320
 
 
10321
 
DllExport void * SWIGSTDCALL CSharp_new_LibStatusResponse() {
10322
 
    void * jresult = 0 ;
10323
 
    LassoLibStatusResponse *result;
10324
 
    
10325
 
    result = (LassoLibStatusResponse *)new_LassoLibStatusResponse();
10326
 
    
10327
 
    jresult = (void *)result; 
10328
 
    return jresult;
10329
 
}
10330
 
 
10331
 
 
10332
 
DllExport void SWIGSTDCALL CSharp_delete_LibStatusResponse(void * jarg1) {
10333
 
    LassoLibStatusResponse *arg1 = (LassoLibStatusResponse *) 0 ;
10334
 
    
10335
 
    arg1 = (LassoLibStatusResponse *)jarg1; 
10336
 
    delete_LassoLibStatusResponse(arg1);
10337
 
    
10338
 
}
10339
 
 
10340
 
 
10341
 
DllExport char * SWIGSTDCALL CSharp_LibStatusResponse_dump(void * jarg1) {
10342
 
    char * jresult = 0 ;
10343
 
    LassoLibStatusResponse *arg1 = (LassoLibStatusResponse *) 0 ;
10344
 
    char *result;
10345
 
    
10346
 
    arg1 = (LassoLibStatusResponse *)jarg1; 
10347
 
    result = (char *)LassoLibStatusResponse_dump(arg1);
10348
 
    
10349
 
    jresult = SWIG_csharp_string_callback(result); 
10350
 
    free(result);
10351
 
    return jresult;
10352
 
}
10353
 
 
10354
 
 
10355
 
DllExport void SWIGSTDCALL CSharp_set_Provider_caCertChain(void * jarg1, char * jarg2) {
10356
 
    LassoProvider *arg1 = (LassoProvider *) 0 ;
10357
 
    char *arg2 = (char *) 0 ;
10358
 
    
10359
 
    arg1 = (LassoProvider *)jarg1; 
10360
 
    arg2 = jarg2; 
10361
 
    {
10362
 
        if (arg1->ca_cert_chain) free((char*)arg1->ca_cert_chain);
10363
 
        if (arg2) {
10364
 
            arg1->ca_cert_chain = (char *) malloc(strlen(arg2)+1);
10365
 
            strcpy((char*)arg1->ca_cert_chain,arg2);
10366
 
        } else {
10367
 
            arg1->ca_cert_chain = 0;
10368
 
        }
10369
 
    }
10370
 
}
10371
 
 
10372
 
 
10373
 
DllExport char * SWIGSTDCALL CSharp_get_Provider_caCertChain(void * jarg1) {
10374
 
    char * jresult = 0 ;
10375
 
    LassoProvider *arg1 = (LassoProvider *) 0 ;
10376
 
    char *result;
10377
 
    
10378
 
    arg1 = (LassoProvider *)jarg1; 
10379
 
    result = (char *) ((arg1)->ca_cert_chain);
10380
 
    
10381
 
    jresult = SWIG_csharp_string_callback(result); 
10382
 
    return jresult;
10383
 
}
10384
 
 
10385
 
 
10386
 
DllExport void SWIGSTDCALL CSharp_set_Provider_metadataFilename(void * jarg1, char * jarg2) {
10387
 
    LassoProvider *arg1 = (LassoProvider *) 0 ;
10388
 
    char *arg2 = (char *) 0 ;
10389
 
    
10390
 
    arg1 = (LassoProvider *)jarg1; 
10391
 
    arg2 = jarg2; 
10392
 
    {
10393
 
        if (arg1->metadata_filename) free((char*)arg1->metadata_filename);
10394
 
        if (arg2) {
10395
 
            arg1->metadata_filename = (char *) malloc(strlen(arg2)+1);
10396
 
            strcpy((char*)arg1->metadata_filename,arg2);
10397
 
        } else {
10398
 
            arg1->metadata_filename = 0;
10399
 
        }
10400
 
    }
10401
 
}
10402
 
 
10403
 
 
10404
 
DllExport char * SWIGSTDCALL CSharp_get_Provider_metadataFilename(void * jarg1) {
10405
 
    char * jresult = 0 ;
10406
 
    LassoProvider *arg1 = (LassoProvider *) 0 ;
10407
 
    char *result;
10408
 
    
10409
 
    arg1 = (LassoProvider *)jarg1; 
10410
 
    result = (char *) ((arg1)->metadata_filename);
10411
 
    
10412
 
    jresult = SWIG_csharp_string_callback(result); 
10413
 
    return jresult;
10414
 
}
10415
 
 
10416
 
 
10417
 
DllExport void SWIGSTDCALL CSharp_set_Provider_providerId(void * jarg1, char * jarg2) {
10418
 
    LassoProvider *arg1 = (LassoProvider *) 0 ;
10419
 
    char *arg2 = (char *) 0 ;
10420
 
    
10421
 
    arg1 = (LassoProvider *)jarg1; 
10422
 
    arg2 = jarg2; 
10423
 
    {
10424
 
        if (arg1->ProviderID) free((char*)arg1->ProviderID);
10425
 
        if (arg2) {
10426
 
            arg1->ProviderID = (char *) malloc(strlen(arg2)+1);
10427
 
            strcpy((char*)arg1->ProviderID,arg2);
10428
 
        } else {
10429
 
            arg1->ProviderID = 0;
10430
 
        }
10431
 
    }
10432
 
}
10433
 
 
10434
 
 
10435
 
DllExport char * SWIGSTDCALL CSharp_get_Provider_providerId(void * jarg1) {
10436
 
    char * jresult = 0 ;
10437
 
    LassoProvider *arg1 = (LassoProvider *) 0 ;
10438
 
    char *result;
10439
 
    
10440
 
    arg1 = (LassoProvider *)jarg1; 
10441
 
    result = (char *) ((arg1)->ProviderID);
10442
 
    
10443
 
    jresult = SWIG_csharp_string_callback(result); 
10444
 
    return jresult;
10445
 
}
10446
 
 
10447
 
 
10448
 
DllExport void SWIGSTDCALL CSharp_set_Provider_publicKey(void * jarg1, char * jarg2) {
10449
 
    LassoProvider *arg1 = (LassoProvider *) 0 ;
10450
 
    char *arg2 = (char *) 0 ;
10451
 
    
10452
 
    arg1 = (LassoProvider *)jarg1; 
10453
 
    arg2 = jarg2; 
10454
 
    {
10455
 
        if (arg1->public_key) free((char*)arg1->public_key);
10456
 
        if (arg2) {
10457
 
            arg1->public_key = (char *) malloc(strlen(arg2)+1);
10458
 
            strcpy((char*)arg1->public_key,arg2);
10459
 
        } else {
10460
 
            arg1->public_key = 0;
10461
 
        }
10462
 
    }
10463
 
}
10464
 
 
10465
 
 
10466
 
DllExport char * SWIGSTDCALL CSharp_get_Provider_publicKey(void * jarg1) {
10467
 
    char * jresult = 0 ;
10468
 
    LassoProvider *arg1 = (LassoProvider *) 0 ;
10469
 
    char *result;
10470
 
    
10471
 
    arg1 = (LassoProvider *)jarg1; 
10472
 
    result = (char *) ((arg1)->public_key);
10473
 
    
10474
 
    jresult = SWIG_csharp_string_callback(result); 
10475
 
    return jresult;
10476
 
}
10477
 
 
10478
 
 
10479
 
DllExport void SWIGSTDCALL CSharp_set_Provider_role(void * jarg1, int jarg2) {
10480
 
    LassoProvider *arg1 = (LassoProvider *) 0 ;
10481
 
    LassoProviderRole arg2 ;
10482
 
    
10483
 
    arg1 = (LassoProvider *)jarg1; 
10484
 
    arg2 = (LassoProviderRole)jarg2; 
10485
 
    if (arg1) (arg1)->role = (LassoProviderRole )arg2;
10486
 
    
10487
 
}
10488
 
 
10489
 
 
10490
 
DllExport int SWIGSTDCALL CSharp_get_Provider_role(void * jarg1) {
10491
 
    int jresult = 0 ;
10492
 
    LassoProvider *arg1 = (LassoProvider *) 0 ;
10493
 
    LassoProviderRole result;
10494
 
    
10495
 
    arg1 = (LassoProvider *)jarg1; 
10496
 
    result = (LassoProviderRole) ((arg1)->role);
10497
 
    
10498
 
    jresult = result; 
10499
 
    return jresult;
10500
 
}
10501
 
 
10502
 
 
10503
 
DllExport void * SWIGSTDCALL CSharp_new_Provider(int jarg1, char * jarg2, char * jarg3, char * jarg4) {
10504
 
    void * jresult = 0 ;
10505
 
    LassoProviderRole arg1 ;
10506
 
    char *arg2 = (char *) 0 ;
10507
 
    char *arg3 = (char *) 0 ;
10508
 
    char *arg4 = (char *) 0 ;
10509
 
    LassoProvider *result;
10510
 
    
10511
 
    arg1 = (LassoProviderRole)jarg1; 
10512
 
    arg2 = jarg2; 
10513
 
    arg3 = jarg3; 
10514
 
    arg4 = jarg4; 
10515
 
    result = (LassoProvider *)new_LassoProvider((LassoProviderRole )arg1,(char const *)arg2,(char const *)arg3,(char const *)arg4);
10516
 
    
10517
 
    jresult = (void *)result; 
10518
 
    return jresult;
10519
 
}
10520
 
 
10521
 
 
10522
 
DllExport void SWIGSTDCALL CSharp_delete_Provider(void * jarg1) {
10523
 
    LassoProvider *arg1 = (LassoProvider *) 0 ;
10524
 
    
10525
 
    arg1 = (LassoProvider *)jarg1; 
10526
 
    delete_LassoProvider(arg1);
10527
 
    
10528
 
}
10529
 
 
10530
 
 
10531
 
DllExport void * SWIGSTDCALL CSharp_Provider_newFromDump(char * jarg1) {
10532
 
    void * jresult = 0 ;
10533
 
    char *arg1 = (char *) 0 ;
10534
 
    LassoProvider *result;
10535
 
    
10536
 
    arg1 = jarg1; 
10537
 
    result = (LassoProvider *)Provider_newFromDump(arg1);
10538
 
    
10539
 
    jresult = (void *)result; 
10540
 
    return jresult;
10541
 
}
10542
 
 
10543
 
 
10544
 
DllExport char * SWIGSTDCALL CSharp_Provider_dump(void * jarg1) {
10545
 
    char * jresult = 0 ;
10546
 
    LassoProvider *arg1 = (LassoProvider *) 0 ;
10547
 
    char *result;
10548
 
    
10549
 
    arg1 = (LassoProvider *)jarg1; 
10550
 
    result = (char *)LassoProvider_dump(arg1);
10551
 
    
10552
 
    jresult = SWIG_csharp_string_callback(result); 
10553
 
    free(result);
10554
 
    return jresult;
10555
 
}
10556
 
 
10557
 
 
10558
 
DllExport unsigned int SWIGSTDCALL CSharp_Provider_acceptHttpMethod(void * jarg1, void * jarg2, void * jarg3, int jarg4, unsigned int jarg5) {
10559
 
    unsigned int jresult = 0 ;
10560
 
    LassoProvider *arg1 = (LassoProvider *) 0 ;
10561
 
    LassoProvider *arg2 = (LassoProvider *) 0 ;
10562
 
    LassoMdProtocolType arg3 ;
10563
 
    LassoHttpMethod arg4 ;
10564
 
    bool arg5 ;
10565
 
    bool result;
10566
 
    LassoMdProtocolType *argp3 ;
10567
 
    
10568
 
    arg1 = (LassoProvider *)jarg1; 
10569
 
    arg2 = (LassoProvider *)jarg2; 
10570
 
    argp3 = (LassoMdProtocolType *)jarg3; 
10571
 
    if (!argp3) {
10572
 
        SWIG_CSharpThrowException(SWIG_CSharpNullReferenceException, "Attempt to dereference null LassoMdProtocolType");
10573
 
    }
10574
 
    arg3 = *argp3; 
10575
 
    arg4 = (LassoHttpMethod)jarg4; 
10576
 
    arg5 = jarg5 ? true : false; 
10577
 
    result = (bool)LassoProvider_acceptHttpMethod(arg1,arg2,arg3,(LassoHttpMethod )arg4,arg5);
10578
 
    
10579
 
    jresult = result; 
10580
 
    return jresult;
10581
 
}
10582
 
 
10583
 
 
10584
 
DllExport char * SWIGSTDCALL CSharp_Provider_getAssertionConsumerServiceUrl(void * jarg1, char * jarg2) {
10585
 
    char * jresult = 0 ;
10586
 
    LassoProvider *arg1 = (LassoProvider *) 0 ;
10587
 
    char *arg2 = (char *) 0 ;
10588
 
    char *result;
10589
 
    
10590
 
    arg1 = (LassoProvider *)jarg1; 
10591
 
    arg2 = jarg2; 
10592
 
    result = (char *)LassoProvider_getAssertionConsumerServiceUrl(arg1,arg2);
10593
 
    
10594
 
    jresult = SWIG_csharp_string_callback(result); 
10595
 
    free(result);
10596
 
    return jresult;
10597
 
}
10598
 
 
10599
 
 
10600
 
DllExport char * SWIGSTDCALL CSharp_Provider_getBase64SuccinctId(void * jarg1) {
10601
 
    char * jresult = 0 ;
10602
 
    LassoProvider *arg1 = (LassoProvider *) 0 ;
10603
 
    char *result;
10604
 
    
10605
 
    arg1 = (LassoProvider *)jarg1; 
10606
 
    result = (char *)LassoProvider_getBase64SuccinctId(arg1);
10607
 
    
10608
 
    jresult = SWIG_csharp_string_callback(result); 
10609
 
    free(result);
10610
 
    return jresult;
10611
 
}
10612
 
 
10613
 
 
10614
 
DllExport char * SWIGSTDCALL CSharp_Provider_getOrganization(void * jarg1) {
10615
 
    char * jresult = 0 ;
10616
 
    LassoProvider *arg1 = (LassoProvider *) 0 ;
10617
 
    char *result;
10618
 
    
10619
 
    arg1 = (LassoProvider *)jarg1; 
10620
 
    result = (char *)LassoProvider_getOrganization(arg1);
10621
 
    
10622
 
    jresult = SWIG_csharp_string_callback(result); 
10623
 
    free(result);
10624
 
    return jresult;
10625
 
}
10626
 
 
10627
 
 
10628
 
DllExport int SWIGSTDCALL CSharp_Provider_getFirstHttpMethod(void * jarg1, void * jarg2, void * jarg3) {
10629
 
    int jresult = 0 ;
10630
 
    LassoProvider *arg1 = (LassoProvider *) 0 ;
10631
 
    LassoProvider *arg2 = (LassoProvider *) 0 ;
10632
 
    LassoMdProtocolType arg3 ;
10633
 
    LassoHttpMethod result;
10634
 
    LassoMdProtocolType *argp3 ;
10635
 
    
10636
 
    arg1 = (LassoProvider *)jarg1; 
10637
 
    arg2 = (LassoProvider *)jarg2; 
10638
 
    argp3 = (LassoMdProtocolType *)jarg3; 
10639
 
    if (!argp3) {
10640
 
        SWIG_CSharpThrowException(SWIG_CSharpNullReferenceException, "Attempt to dereference null LassoMdProtocolType");
10641
 
    }
10642
 
    arg3 = *argp3; 
10643
 
    result = (LassoHttpMethod)LassoProvider_getFirstHttpMethod(arg1,arg2,arg3);
10644
 
    
10645
 
    jresult = result; 
10646
 
    return jresult;
10647
 
}
10648
 
 
10649
 
 
10650
 
DllExport char * SWIGSTDCALL CSharp_Provider_getMetadataOne(void * jarg1, char * jarg2) {
10651
 
    char * jresult = 0 ;
10652
 
    LassoProvider *arg1 = (LassoProvider *) 0 ;
10653
 
    char *arg2 = (char *) 0 ;
10654
 
    char *result;
10655
 
    
10656
 
    arg1 = (LassoProvider *)jarg1; 
10657
 
    arg2 = jarg2; 
10658
 
    result = (char *)LassoProvider_getMetadataOne(arg1,arg2);
10659
 
    
10660
 
    jresult = SWIG_csharp_string_callback(result); 
10661
 
    free(result);
10662
 
    return jresult;
10663
 
}
10664
 
 
10665
 
 
10666
 
DllExport unsigned int SWIGSTDCALL CSharp_Provider_hasProtocolProfile(void * jarg1, void * jarg2, char * jarg3) {
10667
 
    unsigned int jresult = 0 ;
10668
 
    LassoProvider *arg1 = (LassoProvider *) 0 ;
10669
 
    LassoMdProtocolType arg2 ;
10670
 
    char *arg3 = (char *) 0 ;
10671
 
    bool result;
10672
 
    LassoMdProtocolType *argp2 ;
10673
 
    
10674
 
    arg1 = (LassoProvider *)jarg1; 
10675
 
    argp2 = (LassoMdProtocolType *)jarg2; 
10676
 
    if (!argp2) {
10677
 
        SWIG_CSharpThrowException(SWIG_CSharpNullReferenceException, "Attempt to dereference null LassoMdProtocolType");
10678
 
    }
10679
 
    arg2 = *argp2; 
10680
 
    arg3 = jarg3; 
10681
 
    result = (bool)LassoProvider_hasProtocolProfile(arg1,arg2,arg3);
10682
 
    
10683
 
    jresult = result; 
10684
 
    return jresult;
10685
 
}
10686
 
 
10687
 
 
10688
 
DllExport void SWIGSTDCALL CSharp_set_Server_certificate(void * jarg1, char * jarg2) {
10689
 
    LassoServer *arg1 = (LassoServer *) 0 ;
10690
 
    char *arg2 = (char *) 0 ;
10691
 
    
10692
 
    arg1 = (LassoServer *)jarg1; 
10693
 
    arg2 = jarg2; 
10694
 
    {
10695
 
        if (arg1->certificate) free((char*)arg1->certificate);
10696
 
        if (arg2) {
10697
 
            arg1->certificate = (char *) malloc(strlen(arg2)+1);
10698
 
            strcpy((char*)arg1->certificate,arg2);
10699
 
        } else {
10700
 
            arg1->certificate = 0;
10701
 
        }
10702
 
    }
10703
 
}
10704
 
 
10705
 
 
10706
 
DllExport char * SWIGSTDCALL CSharp_get_Server_certificate(void * jarg1) {
10707
 
    char * jresult = 0 ;
10708
 
    LassoServer *arg1 = (LassoServer *) 0 ;
10709
 
    char *result;
10710
 
    
10711
 
    arg1 = (LassoServer *)jarg1; 
10712
 
    result = (char *) ((arg1)->certificate);
10713
 
    
10714
 
    jresult = SWIG_csharp_string_callback(result); 
10715
 
    return jresult;
10716
 
}
10717
 
 
10718
 
 
10719
 
DllExport void SWIGSTDCALL CSharp_set_Server_privateKey(void * jarg1, char * jarg2) {
10720
 
    LassoServer *arg1 = (LassoServer *) 0 ;
10721
 
    char *arg2 = (char *) 0 ;
10722
 
    
10723
 
    arg1 = (LassoServer *)jarg1; 
10724
 
    arg2 = jarg2; 
10725
 
    {
10726
 
        if (arg1->private_key) free((char*)arg1->private_key);
10727
 
        if (arg2) {
10728
 
            arg1->private_key = (char *) malloc(strlen(arg2)+1);
10729
 
            strcpy((char*)arg1->private_key,arg2);
10730
 
        } else {
10731
 
            arg1->private_key = 0;
10732
 
        }
10733
 
    }
10734
 
}
10735
 
 
10736
 
 
10737
 
DllExport char * SWIGSTDCALL CSharp_get_Server_privateKey(void * jarg1) {
10738
 
    char * jresult = 0 ;
10739
 
    LassoServer *arg1 = (LassoServer *) 0 ;
10740
 
    char *result;
10741
 
    
10742
 
    arg1 = (LassoServer *)jarg1; 
10743
 
    result = (char *) ((arg1)->private_key);
10744
 
    
10745
 
    jresult = SWIG_csharp_string_callback(result); 
10746
 
    return jresult;
10747
 
}
10748
 
 
10749
 
 
10750
 
DllExport void SWIGSTDCALL CSharp_set_Server_privateKeyPassword(void * jarg1, char * jarg2) {
10751
 
    LassoServer *arg1 = (LassoServer *) 0 ;
10752
 
    char *arg2 = (char *) 0 ;
10753
 
    
10754
 
    arg1 = (LassoServer *)jarg1; 
10755
 
    arg2 = jarg2; 
10756
 
    {
10757
 
        if (arg1->private_key_password) free((char*)arg1->private_key_password);
10758
 
        if (arg2) {
10759
 
            arg1->private_key_password = (char *) malloc(strlen(arg2)+1);
10760
 
            strcpy((char*)arg1->private_key_password,arg2);
10761
 
        } else {
10762
 
            arg1->private_key_password = 0;
10763
 
        }
10764
 
    }
10765
 
}
10766
 
 
10767
 
 
10768
 
DllExport char * SWIGSTDCALL CSharp_get_Server_privateKeyPassword(void * jarg1) {
10769
 
    char * jresult = 0 ;
10770
 
    LassoServer *arg1 = (LassoServer *) 0 ;
10771
 
    char *result;
10772
 
    
10773
 
    arg1 = (LassoServer *)jarg1; 
10774
 
    result = (char *) ((arg1)->private_key_password);
10775
 
    
10776
 
    jresult = SWIG_csharp_string_callback(result); 
10777
 
    return jresult;
10778
 
}
10779
 
 
10780
 
 
10781
 
DllExport void SWIGSTDCALL CSharp_set_Server_signatureMethod(void * jarg1, int jarg2) {
10782
 
    LassoServer *arg1 = (LassoServer *) 0 ;
10783
 
    LassoSignatureMethod arg2 ;
10784
 
    
10785
 
    arg1 = (LassoServer *)jarg1; 
10786
 
    arg2 = (LassoSignatureMethod)jarg2; 
10787
 
    if (arg1) (arg1)->signature_method = (LassoSignatureMethod )arg2;
10788
 
    
10789
 
}
10790
 
 
10791
 
 
10792
 
DllExport int SWIGSTDCALL CSharp_get_Server_signatureMethod(void * jarg1) {
10793
 
    int jresult = 0 ;
10794
 
    LassoServer *arg1 = (LassoServer *) 0 ;
10795
 
    LassoSignatureMethod result;
10796
 
    
10797
 
    arg1 = (LassoServer *)jarg1; 
10798
 
    result = (LassoSignatureMethod) ((arg1)->signature_method);
10799
 
    
10800
 
    jresult = result; 
10801
 
    return jresult;
10802
 
}
10803
 
 
10804
 
 
10805
 
DllExport void SWIGSTDCALL CSharp_set_Server_caCertChain(void * jarg1, char * jarg2) {
10806
 
    LassoServer *arg1 = (LassoServer *) 0 ;
10807
 
    char *arg2 = (char *) 0 ;
10808
 
    
10809
 
    arg1 = (LassoServer *)jarg1; 
10810
 
    arg2 = jarg2; 
10811
 
    LassoServer_set_ca_cert_chain(arg1,arg2);
10812
 
    
10813
 
}
10814
 
 
10815
 
 
10816
 
DllExport char * SWIGSTDCALL CSharp_get_Server_caCertChain(void * jarg1) {
10817
 
    char * jresult = 0 ;
10818
 
    LassoServer *arg1 = (LassoServer *) 0 ;
10819
 
    char *result;
10820
 
    
10821
 
    arg1 = (LassoServer *)jarg1; 
10822
 
    result = (char *)LassoServer_get_ca_cert_chain(arg1);
10823
 
    
10824
 
    jresult = SWIG_csharp_string_callback(result); 
10825
 
    return jresult;
10826
 
}
10827
 
 
10828
 
 
10829
 
DllExport void SWIGSTDCALL CSharp_set_Server_metadataFilename(void * jarg1, char * jarg2) {
10830
 
    LassoServer *arg1 = (LassoServer *) 0 ;
10831
 
    char *arg2 = (char *) 0 ;
10832
 
    
10833
 
    arg1 = (LassoServer *)jarg1; 
10834
 
    arg2 = jarg2; 
10835
 
    LassoServer_set_metadata_filename(arg1,arg2);
10836
 
    
10837
 
}
10838
 
 
10839
 
 
10840
 
DllExport char * SWIGSTDCALL CSharp_get_Server_metadataFilename(void * jarg1) {
10841
 
    char * jresult = 0 ;
10842
 
    LassoServer *arg1 = (LassoServer *) 0 ;
10843
 
    char *result;
10844
 
    
10845
 
    arg1 = (LassoServer *)jarg1; 
10846
 
    result = (char *)LassoServer_get_metadata_filename(arg1);
10847
 
    
10848
 
    jresult = SWIG_csharp_string_callback(result); 
10849
 
    return jresult;
10850
 
}
10851
 
 
10852
 
 
10853
 
DllExport void SWIGSTDCALL CSharp_set_Server_providerId(void * jarg1, char * jarg2) {
10854
 
    LassoServer *arg1 = (LassoServer *) 0 ;
10855
 
    char *arg2 = (char *) 0 ;
10856
 
    
10857
 
    arg1 = (LassoServer *)jarg1; 
10858
 
    arg2 = jarg2; 
10859
 
    LassoServer_set_ProviderID(arg1,arg2);
10860
 
    
10861
 
}
10862
 
 
10863
 
 
10864
 
DllExport char * SWIGSTDCALL CSharp_get_Server_providerId(void * jarg1) {
10865
 
    char * jresult = 0 ;
10866
 
    LassoServer *arg1 = (LassoServer *) 0 ;
10867
 
    char *result;
10868
 
    
10869
 
    arg1 = (LassoServer *)jarg1; 
10870
 
    result = (char *)LassoServer_get_ProviderID(arg1);
10871
 
    
10872
 
    jresult = SWIG_csharp_string_callback(result); 
10873
 
    return jresult;
10874
 
}
10875
 
 
10876
 
 
10877
 
DllExport void SWIGSTDCALL CSharp_set_Server_publicKey(void * jarg1, char * jarg2) {
10878
 
    LassoServer *arg1 = (LassoServer *) 0 ;
10879
 
    char *arg2 = (char *) 0 ;
10880
 
    
10881
 
    arg1 = (LassoServer *)jarg1; 
10882
 
    arg2 = jarg2; 
10883
 
    LassoServer_set_public_key(arg1,arg2);
10884
 
    
10885
 
}
10886
 
 
10887
 
 
10888
 
DllExport char * SWIGSTDCALL CSharp_get_Server_publicKey(void * jarg1) {
10889
 
    char * jresult = 0 ;
10890
 
    LassoServer *arg1 = (LassoServer *) 0 ;
10891
 
    char *result;
10892
 
    
10893
 
    arg1 = (LassoServer *)jarg1; 
10894
 
    result = (char *)LassoServer_get_public_key(arg1);
10895
 
    
10896
 
    jresult = SWIG_csharp_string_callback(result); 
10897
 
    return jresult;
10898
 
}
10899
 
 
10900
 
 
10901
 
DllExport void * SWIGSTDCALL CSharp_get_Server_providerIds(void * jarg1) {
10902
 
    void * jresult = 0 ;
10903
 
    LassoServer *arg1 = (LassoServer *) 0 ;
10904
 
    LassoStringList *result;
10905
 
    
10906
 
    arg1 = (LassoServer *)jarg1; 
10907
 
    result = (LassoStringList *)LassoServer_get_providerIds(arg1);
10908
 
    
10909
 
    jresult = (void *)result; 
10910
 
    return jresult;
10911
 
}
10912
 
 
10913
 
 
10914
 
DllExport void * SWIGSTDCALL CSharp_new_Server(char * jarg1, char * jarg2, char * jarg3, char * jarg4) {
10915
 
    void * jresult = 0 ;
10916
 
    char *arg1 = (char *) NULL ;
10917
 
    char *arg2 = (char *) NULL ;
10918
 
    char *arg3 = (char *) NULL ;
10919
 
    char *arg4 = (char *) NULL ;
10920
 
    LassoServer *result;
10921
 
    
10922
 
    arg1 = jarg1; 
10923
 
    arg2 = jarg2; 
10924
 
    arg3 = jarg3; 
10925
 
    arg4 = jarg4; 
10926
 
    result = (LassoServer *)new_LassoServer(arg1,arg2,arg3,arg4);
10927
 
    
10928
 
    jresult = (void *)result; 
10929
 
    return jresult;
10930
 
}
10931
 
 
10932
 
 
10933
 
DllExport void SWIGSTDCALL CSharp_delete_Server(void * jarg1) {
10934
 
    LassoServer *arg1 = (LassoServer *) 0 ;
10935
 
    
10936
 
    arg1 = (LassoServer *)jarg1; 
10937
 
    delete_LassoServer(arg1);
10938
 
    
10939
 
}
10940
 
 
10941
 
 
10942
 
DllExport void * SWIGSTDCALL CSharp_Server_newFromDump(char * jarg1) {
10943
 
    void * jresult = 0 ;
10944
 
    char *arg1 = (char *) 0 ;
10945
 
    LassoServer *result;
10946
 
    
10947
 
    arg1 = jarg1; 
10948
 
    result = (LassoServer *)Server_newFromDump(arg1);
10949
 
    
10950
 
    jresult = (void *)result; 
10951
 
    return jresult;
10952
 
}
10953
 
 
10954
 
 
10955
 
DllExport unsigned int SWIGSTDCALL CSharp_Server_acceptHttpMethod(void * jarg1, void * jarg2, void * jarg3, int jarg4, unsigned int jarg5) {
10956
 
    unsigned int jresult = 0 ;
10957
 
    LassoServer *arg1 = (LassoServer *) 0 ;
10958
 
    LassoProvider *arg2 = (LassoProvider *) 0 ;
10959
 
    LassoMdProtocolType arg3 ;
10960
 
    LassoHttpMethod arg4 ;
10961
 
    bool arg5 ;
10962
 
    bool result;
10963
 
    LassoMdProtocolType *argp3 ;
10964
 
    
10965
 
    arg1 = (LassoServer *)jarg1; 
10966
 
    arg2 = (LassoProvider *)jarg2; 
10967
 
    argp3 = (LassoMdProtocolType *)jarg3; 
10968
 
    if (!argp3) {
10969
 
        SWIG_CSharpThrowException(SWIG_CSharpNullReferenceException, "Attempt to dereference null LassoMdProtocolType");
10970
 
    }
10971
 
    arg3 = *argp3; 
10972
 
    arg4 = (LassoHttpMethod)jarg4; 
10973
 
    arg5 = jarg5 ? true : false; 
10974
 
    result = (bool)LassoServer_acceptHttpMethod(arg1,arg2,arg3,(LassoHttpMethod )arg4,arg5);
10975
 
    
10976
 
    jresult = result; 
10977
 
    return jresult;
10978
 
}
10979
 
 
10980
 
 
10981
 
DllExport char * SWIGSTDCALL CSharp_Server_getAssertionConsumerServiceUrl(void * jarg1, char * jarg2) {
10982
 
    char * jresult = 0 ;
10983
 
    LassoServer *arg1 = (LassoServer *) 0 ;
10984
 
    char *arg2 = (char *) 0 ;
10985
 
    char *result;
10986
 
    
10987
 
    arg1 = (LassoServer *)jarg1; 
10988
 
    arg2 = jarg2; 
10989
 
    result = (char *)LassoServer_getAssertionConsumerServiceUrl(arg1,arg2);
10990
 
    
10991
 
    jresult = SWIG_csharp_string_callback(result); 
10992
 
    free(result);
10993
 
    return jresult;
10994
 
}
10995
 
 
10996
 
 
10997
 
DllExport char * SWIGSTDCALL CSharp_Server_getBase64SuccinctId(void * jarg1) {
10998
 
    char * jresult = 0 ;
10999
 
    LassoServer *arg1 = (LassoServer *) 0 ;
11000
 
    char *result;
11001
 
    
11002
 
    arg1 = (LassoServer *)jarg1; 
11003
 
    result = (char *)LassoServer_getBase64SuccinctId(arg1);
11004
 
    
11005
 
    jresult = SWIG_csharp_string_callback(result); 
11006
 
    free(result);
11007
 
    return jresult;
11008
 
}
11009
 
 
11010
 
 
11011
 
DllExport char * SWIGSTDCALL CSharp_Server_getOrganization(void * jarg1) {
11012
 
    char * jresult = 0 ;
11013
 
    LassoServer *arg1 = (LassoServer *) 0 ;
11014
 
    char *result;
11015
 
    
11016
 
    arg1 = (LassoServer *)jarg1; 
11017
 
    result = (char *)LassoServer_getOrganization(arg1);
11018
 
    
11019
 
    jresult = SWIG_csharp_string_callback(result); 
11020
 
    free(result);
11021
 
    return jresult;
11022
 
}
11023
 
 
11024
 
 
11025
 
DllExport int SWIGSTDCALL CSharp_Server_getFirstHttpMethod(void * jarg1, void * jarg2, void * jarg3) {
11026
 
    int jresult = 0 ;
11027
 
    LassoServer *arg1 = (LassoServer *) 0 ;
11028
 
    LassoProvider *arg2 = (LassoProvider *) 0 ;
11029
 
    LassoMdProtocolType arg3 ;
11030
 
    LassoHttpMethod result;
11031
 
    LassoMdProtocolType *argp3 ;
11032
 
    
11033
 
    arg1 = (LassoServer *)jarg1; 
11034
 
    arg2 = (LassoProvider *)jarg2; 
11035
 
    argp3 = (LassoMdProtocolType *)jarg3; 
11036
 
    if (!argp3) {
11037
 
        SWIG_CSharpThrowException(SWIG_CSharpNullReferenceException, "Attempt to dereference null LassoMdProtocolType");
11038
 
    }
11039
 
    arg3 = *argp3; 
11040
 
    result = (LassoHttpMethod)LassoServer_getFirstHttpMethod(arg1,arg2,arg3);
11041
 
    
11042
 
    jresult = result; 
11043
 
    return jresult;
11044
 
}
11045
 
 
11046
 
 
11047
 
DllExport char * SWIGSTDCALL CSharp_Server_getMetadataOne(void * jarg1, char * jarg2) {
11048
 
    char * jresult = 0 ;
11049
 
    LassoServer *arg1 = (LassoServer *) 0 ;
11050
 
    char *arg2 = (char *) 0 ;
11051
 
    char *result;
11052
 
    
11053
 
    arg1 = (LassoServer *)jarg1; 
11054
 
    arg2 = jarg2; 
11055
 
    result = (char *)LassoServer_getMetadataOne(arg1,arg2);
11056
 
    
11057
 
    jresult = SWIG_csharp_string_callback(result); 
11058
 
    free(result);
11059
 
    return jresult;
11060
 
}
11061
 
 
11062
 
 
11063
 
DllExport unsigned int SWIGSTDCALL CSharp_Server_hasProtocolProfile(void * jarg1, void * jarg2, char * jarg3) {
11064
 
    unsigned int jresult = 0 ;
11065
 
    LassoServer *arg1 = (LassoServer *) 0 ;
11066
 
    LassoMdProtocolType arg2 ;
11067
 
    char *arg3 = (char *) 0 ;
11068
 
    bool result;
11069
 
    LassoMdProtocolType *argp2 ;
11070
 
    
11071
 
    arg1 = (LassoServer *)jarg1; 
11072
 
    argp2 = (LassoMdProtocolType *)jarg2; 
11073
 
    if (!argp2) {
11074
 
        SWIG_CSharpThrowException(SWIG_CSharpNullReferenceException, "Attempt to dereference null LassoMdProtocolType");
11075
 
    }
11076
 
    arg2 = *argp2; 
11077
 
    arg3 = jarg3; 
11078
 
    result = (bool)LassoServer_hasProtocolProfile(arg1,arg2,arg3);
11079
 
    
11080
 
    jresult = result; 
11081
 
    return jresult;
11082
 
}
11083
 
 
11084
 
 
11085
 
DllExport int SWIGSTDCALL CSharp_Server_addProvider(void * jarg1, int jarg2, char * jarg3, char * jarg4, char * jarg5) {
11086
 
    int jresult = 0 ;
11087
 
    LassoServer *arg1 = (LassoServer *) 0 ;
11088
 
    LassoProviderRole arg2 ;
11089
 
    char *arg3 = (char *) 0 ;
11090
 
    char *arg4 = (char *) NULL ;
11091
 
    char *arg5 = (char *) NULL ;
11092
 
    int result;
11093
 
    
11094
 
    arg1 = (LassoServer *)jarg1; 
11095
 
    arg2 = (LassoProviderRole)jarg2; 
11096
 
    arg3 = jarg3; 
11097
 
    arg4 = jarg4; 
11098
 
    arg5 = jarg5; 
11099
 
    {
11100
 
        int errorCode;
11101
 
        errorCode = result = (int)LassoServer_addProvider(arg1,(LassoProviderRole )arg2,arg3,arg4,arg5);
11102
 
        
11103
 
        if (errorCode) {
11104
 
            char errorMsg[256];
11105
 
            build_exception_msg(errorCode, errorMsg);
11106
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
11107
 
        }
11108
 
    }
11109
 
    jresult = result; 
11110
 
    return jresult;
11111
 
}
11112
 
 
11113
 
 
11114
 
DllExport char * SWIGSTDCALL CSharp_Server_dump(void * jarg1) {
11115
 
    char * jresult = 0 ;
11116
 
    LassoServer *arg1 = (LassoServer *) 0 ;
11117
 
    char *result;
11118
 
    
11119
 
    arg1 = (LassoServer *)jarg1; 
11120
 
    result = (char *)LassoServer_dump(arg1);
11121
 
    
11122
 
    jresult = SWIG_csharp_string_callback(result); 
11123
 
    free(result);
11124
 
    return jresult;
11125
 
}
11126
 
 
11127
 
 
11128
 
DllExport void * SWIGSTDCALL CSharp_Server_getProvider(void * jarg1, char * jarg2) {
11129
 
    void * jresult = 0 ;
11130
 
    LassoServer *arg1 = (LassoServer *) 0 ;
11131
 
    char *arg2 = (char *) 0 ;
11132
 
    LassoProvider *result;
11133
 
    
11134
 
    arg1 = (LassoServer *)jarg1; 
11135
 
    arg2 = jarg2; 
11136
 
    result = (LassoProvider *)LassoServer_getProvider(arg1,arg2);
11137
 
    
11138
 
    jresult = (void *)result; 
11139
 
    return jresult;
11140
 
}
11141
 
 
11142
 
 
11143
 
DllExport void SWIGSTDCALL CSharp_set_Federation_remoteProviderId(void * jarg1, char * jarg2) {
11144
 
    LassoFederation *arg1 = (LassoFederation *) 0 ;
11145
 
    char *arg2 = (char *) 0 ;
11146
 
    
11147
 
    arg1 = (LassoFederation *)jarg1; 
11148
 
    arg2 = jarg2; 
11149
 
    {
11150
 
        if (arg1->remote_providerID) free((char*)arg1->remote_providerID);
11151
 
        if (arg2) {
11152
 
            arg1->remote_providerID = (char *) malloc(strlen(arg2)+1);
11153
 
            strcpy((char*)arg1->remote_providerID,arg2);
11154
 
        } else {
11155
 
            arg1->remote_providerID = 0;
11156
 
        }
11157
 
    }
11158
 
}
11159
 
 
11160
 
 
11161
 
DllExport char * SWIGSTDCALL CSharp_get_Federation_remoteProviderId(void * jarg1) {
11162
 
    char * jresult = 0 ;
11163
 
    LassoFederation *arg1 = (LassoFederation *) 0 ;
11164
 
    char *result;
11165
 
    
11166
 
    arg1 = (LassoFederation *)jarg1; 
11167
 
    result = (char *) ((arg1)->remote_providerID);
11168
 
    
11169
 
    jresult = SWIG_csharp_string_callback(result); 
11170
 
    return jresult;
11171
 
}
11172
 
 
11173
 
 
11174
 
DllExport void SWIGSTDCALL CSharp_set_Federation_localNameIdentifier(void * jarg1, void * jarg2) {
11175
 
    LassoFederation *arg1 = (LassoFederation *) 0 ;
11176
 
    LassoSamlNameIdentifier *arg2 = (LassoSamlNameIdentifier *) 0 ;
11177
 
    
11178
 
    arg1 = (LassoFederation *)jarg1; 
11179
 
    arg2 = (LassoSamlNameIdentifier *)jarg2; 
11180
 
    LassoFederation_set_local_nameIdentifier(arg1,arg2);
11181
 
    
11182
 
}
11183
 
 
11184
 
 
11185
 
DllExport void * SWIGSTDCALL CSharp_get_Federation_localNameIdentifier(void * jarg1) {
11186
 
    void * jresult = 0 ;
11187
 
    LassoFederation *arg1 = (LassoFederation *) 0 ;
11188
 
    LassoSamlNameIdentifier *result;
11189
 
    
11190
 
    arg1 = (LassoFederation *)jarg1; 
11191
 
    result = (LassoSamlNameIdentifier *)LassoFederation_get_local_nameIdentifier(arg1);
11192
 
    
11193
 
    jresult = (void *)result; 
11194
 
    return jresult;
11195
 
}
11196
 
 
11197
 
 
11198
 
DllExport void SWIGSTDCALL CSharp_set_Federation_remoteNameIdentifier(void * jarg1, void * jarg2) {
11199
 
    LassoFederation *arg1 = (LassoFederation *) 0 ;
11200
 
    LassoSamlNameIdentifier *arg2 = (LassoSamlNameIdentifier *) 0 ;
11201
 
    
11202
 
    arg1 = (LassoFederation *)jarg1; 
11203
 
    arg2 = (LassoSamlNameIdentifier *)jarg2; 
11204
 
    LassoFederation_set_remote_nameIdentifier(arg1,arg2);
11205
 
    
11206
 
}
11207
 
 
11208
 
 
11209
 
DllExport void * SWIGSTDCALL CSharp_get_Federation_remoteNameIdentifier(void * jarg1) {
11210
 
    void * jresult = 0 ;
11211
 
    LassoFederation *arg1 = (LassoFederation *) 0 ;
11212
 
    LassoSamlNameIdentifier *result;
11213
 
    
11214
 
    arg1 = (LassoFederation *)jarg1; 
11215
 
    result = (LassoSamlNameIdentifier *)LassoFederation_get_remote_nameIdentifier(arg1);
11216
 
    
11217
 
    jresult = (void *)result; 
11218
 
    return jresult;
11219
 
}
11220
 
 
11221
 
 
11222
 
DllExport void * SWIGSTDCALL CSharp_new_Federation(char * jarg1) {
11223
 
    void * jresult = 0 ;
11224
 
    char *arg1 = (char *) 0 ;
11225
 
    LassoFederation *result;
11226
 
    
11227
 
    arg1 = jarg1; 
11228
 
    result = (LassoFederation *)new_LassoFederation(arg1);
11229
 
    
11230
 
    jresult = (void *)result; 
11231
 
    return jresult;
11232
 
}
11233
 
 
11234
 
 
11235
 
DllExport void SWIGSTDCALL CSharp_delete_Federation(void * jarg1) {
11236
 
    LassoFederation *arg1 = (LassoFederation *) 0 ;
11237
 
    
11238
 
    arg1 = (LassoFederation *)jarg1; 
11239
 
    delete_LassoFederation(arg1);
11240
 
    
11241
 
}
11242
 
 
11243
 
 
11244
 
DllExport char * SWIGSTDCALL CSharp_Federation_dump(void * jarg1) {
11245
 
    char * jresult = 0 ;
11246
 
    LassoFederation *arg1 = (LassoFederation *) 0 ;
11247
 
    char *result;
11248
 
    
11249
 
    arg1 = (LassoFederation *)jarg1; 
11250
 
    result = (char *)LassoFederation_dump(arg1);
11251
 
    
11252
 
    jresult = SWIG_csharp_string_callback(result); 
11253
 
    free(result);
11254
 
    return jresult;
11255
 
}
11256
 
 
11257
 
 
11258
 
DllExport void SWIGSTDCALL CSharp_Federation_buildLocalNameIdentifier(void * jarg1, char * jarg2, char * jarg3, char * jarg4) {
11259
 
    LassoFederation *arg1 = (LassoFederation *) 0 ;
11260
 
    char *arg2 = (char *) 0 ;
11261
 
    char *arg3 = (char *) 0 ;
11262
 
    char *arg4 = (char *) 0 ;
11263
 
    
11264
 
    arg1 = (LassoFederation *)jarg1; 
11265
 
    arg2 = jarg2; 
11266
 
    arg3 = jarg3; 
11267
 
    arg4 = jarg4; 
11268
 
    LassoFederation_buildLocalNameIdentifier(arg1,arg2,arg3,arg4);
11269
 
    
11270
 
}
11271
 
 
11272
 
 
11273
 
DllExport unsigned int SWIGSTDCALL CSharp_Federation_verifyNameIdentifier(void * jarg1, void * jarg2) {
11274
 
    unsigned int jresult = 0 ;
11275
 
    LassoFederation *arg1 = (LassoFederation *) 0 ;
11276
 
    LassoSamlNameIdentifier *arg2 = (LassoSamlNameIdentifier *) 0 ;
11277
 
    bool result;
11278
 
    
11279
 
    arg1 = (LassoFederation *)jarg1; 
11280
 
    arg2 = (LassoSamlNameIdentifier *)jarg2; 
11281
 
    result = (bool)LassoFederation_verifyNameIdentifier(arg1,arg2);
11282
 
    
11283
 
    jresult = result; 
11284
 
    return jresult;
11285
 
}
11286
 
 
11287
 
 
11288
 
DllExport unsigned int SWIGSTDCALL CSharp_get_Identity_isDirty(void * jarg1) {
11289
 
    unsigned int jresult = 0 ;
11290
 
    LassoIdentity *arg1 = (LassoIdentity *) 0 ;
11291
 
    bool result;
11292
 
    
11293
 
    arg1 = (LassoIdentity *)jarg1; 
11294
 
    result = (bool) ((arg1)->is_dirty);
11295
 
    
11296
 
    jresult = result; 
11297
 
    return jresult;
11298
 
}
11299
 
 
11300
 
 
11301
 
DllExport void * SWIGSTDCALL CSharp_get_Identity_providerIds(void * jarg1) {
11302
 
    void * jresult = 0 ;
11303
 
    LassoIdentity *arg1 = (LassoIdentity *) 0 ;
11304
 
    LassoStringList *result;
11305
 
    
11306
 
    arg1 = (LassoIdentity *)jarg1; 
11307
 
    result = (LassoStringList *)LassoIdentity_get_providerIds(arg1);
11308
 
    
11309
 
    jresult = (void *)result; 
11310
 
    return jresult;
11311
 
}
11312
 
 
11313
 
 
11314
 
DllExport void * SWIGSTDCALL CSharp_new_Identity() {
11315
 
    void * jresult = 0 ;
11316
 
    LassoIdentity *result;
11317
 
    
11318
 
    result = (LassoIdentity *)new_LassoIdentity();
11319
 
    
11320
 
    jresult = (void *)result; 
11321
 
    return jresult;
11322
 
}
11323
 
 
11324
 
 
11325
 
DllExport void SWIGSTDCALL CSharp_delete_Identity(void * jarg1) {
11326
 
    LassoIdentity *arg1 = (LassoIdentity *) 0 ;
11327
 
    
11328
 
    arg1 = (LassoIdentity *)jarg1; 
11329
 
    delete_LassoIdentity(arg1);
11330
 
    
11331
 
}
11332
 
 
11333
 
 
11334
 
DllExport void * SWIGSTDCALL CSharp_Identity_newFromDump(char * jarg1) {
11335
 
    void * jresult = 0 ;
11336
 
    char *arg1 = (char *) 0 ;
11337
 
    LassoIdentity *result;
11338
 
    
11339
 
    arg1 = jarg1; 
11340
 
    result = (LassoIdentity *)Identity_newFromDump(arg1);
11341
 
    
11342
 
    jresult = (void *)result; 
11343
 
    return jresult;
11344
 
}
11345
 
 
11346
 
 
11347
 
DllExport char * SWIGSTDCALL CSharp_Identity_dump(void * jarg1) {
11348
 
    char * jresult = 0 ;
11349
 
    LassoIdentity *arg1 = (LassoIdentity *) 0 ;
11350
 
    char *result;
11351
 
    
11352
 
    arg1 = (LassoIdentity *)jarg1; 
11353
 
    result = (char *)LassoIdentity_dump(arg1);
11354
 
    
11355
 
    jresult = SWIG_csharp_string_callback(result); 
11356
 
    free(result);
11357
 
    return jresult;
11358
 
}
11359
 
 
11360
 
 
11361
 
DllExport void * SWIGSTDCALL CSharp_Identity_getFederation(void * jarg1, char * jarg2) {
11362
 
    void * jresult = 0 ;
11363
 
    LassoIdentity *arg1 = (LassoIdentity *) 0 ;
11364
 
    char *arg2 = (char *) 0 ;
11365
 
    LassoFederation *result;
11366
 
    
11367
 
    arg1 = (LassoIdentity *)jarg1; 
11368
 
    arg2 = jarg2; 
11369
 
    result = (LassoFederation *)LassoIdentity_getFederation(arg1,arg2);
11370
 
    
11371
 
    jresult = (void *)result; 
11372
 
    return jresult;
11373
 
}
11374
 
 
11375
 
 
11376
 
DllExport unsigned int SWIGSTDCALL CSharp_get_Session_isDirty(void * jarg1) {
11377
 
    unsigned int jresult = 0 ;
11378
 
    LassoSession *arg1 = (LassoSession *) 0 ;
11379
 
    bool result;
11380
 
    
11381
 
    arg1 = (LassoSession *)jarg1; 
11382
 
    result = (bool) ((arg1)->is_dirty);
11383
 
    
11384
 
    jresult = result; 
11385
 
    return jresult;
11386
 
}
11387
 
 
11388
 
 
11389
 
DllExport void * SWIGSTDCALL CSharp_get_Session_providerIds(void * jarg1) {
11390
 
    void * jresult = 0 ;
11391
 
    LassoSession *arg1 = (LassoSession *) 0 ;
11392
 
    LassoStringList *result;
11393
 
    
11394
 
    arg1 = (LassoSession *)jarg1; 
11395
 
    result = (LassoStringList *)LassoSession_get_providerIds(arg1);
11396
 
    
11397
 
    jresult = (void *)result; 
11398
 
    return jresult;
11399
 
}
11400
 
 
11401
 
 
11402
 
DllExport void * SWIGSTDCALL CSharp_new_Session() {
11403
 
    void * jresult = 0 ;
11404
 
    LassoSession *result;
11405
 
    
11406
 
    result = (LassoSession *)new_LassoSession();
11407
 
    
11408
 
    jresult = (void *)result; 
11409
 
    return jresult;
11410
 
}
11411
 
 
11412
 
 
11413
 
DllExport void SWIGSTDCALL CSharp_delete_Session(void * jarg1) {
11414
 
    LassoSession *arg1 = (LassoSession *) 0 ;
11415
 
    
11416
 
    arg1 = (LassoSession *)jarg1; 
11417
 
    delete_LassoSession(arg1);
11418
 
    
11419
 
}
11420
 
 
11421
 
 
11422
 
DllExport void * SWIGSTDCALL CSharp_Session_newFromDump(char * jarg1) {
11423
 
    void * jresult = 0 ;
11424
 
    char *arg1 = (char *) 0 ;
11425
 
    LassoSession *result;
11426
 
    
11427
 
    arg1 = jarg1; 
11428
 
    result = (LassoSession *)Session_newFromDump(arg1);
11429
 
    
11430
 
    jresult = (void *)result; 
11431
 
    return jresult;
11432
 
}
11433
 
 
11434
 
 
11435
 
DllExport char * SWIGSTDCALL CSharp_Session_dump(void * jarg1) {
11436
 
    char * jresult = 0 ;
11437
 
    LassoSession *arg1 = (LassoSession *) 0 ;
11438
 
    char *result;
11439
 
    
11440
 
    arg1 = (LassoSession *)jarg1; 
11441
 
    result = (char *)LassoSession_dump(arg1);
11442
 
    
11443
 
    jresult = SWIG_csharp_string_callback(result); 
11444
 
    free(result);
11445
 
    return jresult;
11446
 
}
11447
 
 
11448
 
 
11449
 
DllExport void * SWIGSTDCALL CSharp_Session_getAssertions(void * jarg1, char * jarg2) {
11450
 
    void * jresult = 0 ;
11451
 
    LassoSession *arg1 = (LassoSession *) 0 ;
11452
 
    char *arg2 = (char *) 0 ;
11453
 
    LassoNodeList *result;
11454
 
    
11455
 
    arg1 = (LassoSession *)jarg1; 
11456
 
    arg2 = jarg2; 
11457
 
    result = (LassoNodeList *)LassoSession_getAssertions(arg1,arg2);
11458
 
    
11459
 
    jresult = (void *)result; 
11460
 
    return jresult;
11461
 
}
11462
 
 
11463
 
 
11464
 
DllExport int SWIGSTDCALL CSharp_getRequestTypeFromSoapMsg(char * jarg1) {
11465
 
    int jresult = 0 ;
11466
 
    char *arg1 = (char *) 0 ;
11467
 
    LassoRequestType result;
11468
 
    
11469
 
    arg1 = jarg1; 
11470
 
    result = (LassoRequestType)lasso_profile_get_request_type_from_soap_msg(arg1);
11471
 
    
11472
 
    jresult = result; 
11473
 
    return jresult;
11474
 
}
11475
 
 
11476
 
 
11477
 
DllExport unsigned int SWIGSTDCALL CSharp_isLibertyQuery(char * jarg1) {
11478
 
    unsigned int jresult = 0 ;
11479
 
    char *arg1 = (char *) 0 ;
11480
 
    bool result;
11481
 
    
11482
 
    arg1 = jarg1; 
11483
 
    result = (bool)lasso_profile_is_liberty_query(arg1);
11484
 
    
11485
 
    jresult = result; 
11486
 
    return jresult;
11487
 
}
11488
 
 
11489
 
 
11490
 
DllExport void SWIGSTDCALL CSharp_set_Defederation_identity(void * jarg1, void * jarg2) {
11491
 
    LassoDefederation *arg1 = (LassoDefederation *) 0 ;
11492
 
    LassoIdentity *arg2 = (LassoIdentity *) 0 ;
11493
 
    
11494
 
    arg1 = (LassoDefederation *)jarg1; 
11495
 
    arg2 = (LassoIdentity *)jarg2; 
11496
 
    LassoDefederation_set_identity(arg1,arg2);
11497
 
    
11498
 
}
11499
 
 
11500
 
 
11501
 
DllExport void * SWIGSTDCALL CSharp_get_Defederation_identity(void * jarg1) {
11502
 
    void * jresult = 0 ;
11503
 
    LassoDefederation *arg1 = (LassoDefederation *) 0 ;
11504
 
    LassoIdentity *result;
11505
 
    
11506
 
    arg1 = (LassoDefederation *)jarg1; 
11507
 
    result = (LassoIdentity *)LassoDefederation_get_identity(arg1);
11508
 
    
11509
 
    jresult = (void *)result; 
11510
 
    return jresult;
11511
 
}
11512
 
 
11513
 
 
11514
 
DllExport unsigned int SWIGSTDCALL CSharp_get_Defederation_isIdentityDirty(void * jarg1) {
11515
 
    unsigned int jresult = 0 ;
11516
 
    LassoDefederation *arg1 = (LassoDefederation *) 0 ;
11517
 
    bool result;
11518
 
    
11519
 
    arg1 = (LassoDefederation *)jarg1; 
11520
 
    result = (bool)LassoDefederation_get_isIdentityDirty(arg1);
11521
 
    
11522
 
    jresult = result; 
11523
 
    return jresult;
11524
 
}
11525
 
 
11526
 
 
11527
 
DllExport unsigned int SWIGSTDCALL CSharp_get_Defederation_isSessionDirty(void * jarg1) {
11528
 
    unsigned int jresult = 0 ;
11529
 
    LassoDefederation *arg1 = (LassoDefederation *) 0 ;
11530
 
    bool result;
11531
 
    
11532
 
    arg1 = (LassoDefederation *)jarg1; 
11533
 
    result = (bool)LassoDefederation_get_isSessionDirty(arg1);
11534
 
    
11535
 
    jresult = result; 
11536
 
    return jresult;
11537
 
}
11538
 
 
11539
 
 
11540
 
DllExport char * SWIGSTDCALL CSharp_get_Defederation_msgBody(void * jarg1) {
11541
 
    char * jresult = 0 ;
11542
 
    LassoDefederation *arg1 = (LassoDefederation *) 0 ;
11543
 
    char *result;
11544
 
    
11545
 
    arg1 = (LassoDefederation *)jarg1; 
11546
 
    result = (char *)LassoDefederation_get_msgBody(arg1);
11547
 
    
11548
 
    jresult = SWIG_csharp_string_callback(result); 
11549
 
    return jresult;
11550
 
}
11551
 
 
11552
 
 
11553
 
DllExport char * SWIGSTDCALL CSharp_get_Defederation_msgRelayState(void * jarg1) {
11554
 
    char * jresult = 0 ;
11555
 
    LassoDefederation *arg1 = (LassoDefederation *) 0 ;
11556
 
    char *result;
11557
 
    
11558
 
    arg1 = (LassoDefederation *)jarg1; 
11559
 
    result = (char *)LassoDefederation_get_msgRelayState(arg1);
11560
 
    
11561
 
    jresult = SWIG_csharp_string_callback(result); 
11562
 
    return jresult;
11563
 
}
11564
 
 
11565
 
 
11566
 
DllExport char * SWIGSTDCALL CSharp_get_Defederation_msgUrl(void * jarg1) {
11567
 
    char * jresult = 0 ;
11568
 
    LassoDefederation *arg1 = (LassoDefederation *) 0 ;
11569
 
    char *result;
11570
 
    
11571
 
    arg1 = (LassoDefederation *)jarg1; 
11572
 
    result = (char *)LassoDefederation_get_msgUrl(arg1);
11573
 
    
11574
 
    jresult = SWIG_csharp_string_callback(result); 
11575
 
    return jresult;
11576
 
}
11577
 
 
11578
 
 
11579
 
DllExport void SWIGSTDCALL CSharp_set_Defederation_nameIdentifier(void * jarg1, void * jarg2) {
11580
 
    LassoDefederation *arg1 = (LassoDefederation *) 0 ;
11581
 
    LassoSamlNameIdentifier *arg2 = (LassoSamlNameIdentifier *) 0 ;
11582
 
    
11583
 
    arg1 = (LassoDefederation *)jarg1; 
11584
 
    arg2 = (LassoSamlNameIdentifier *)jarg2; 
11585
 
    LassoDefederation_set_nameIdentifier(arg1,arg2);
11586
 
    
11587
 
}
11588
 
 
11589
 
 
11590
 
DllExport void * SWIGSTDCALL CSharp_get_Defederation_nameIdentifier(void * jarg1) {
11591
 
    void * jresult = 0 ;
11592
 
    LassoDefederation *arg1 = (LassoDefederation *) 0 ;
11593
 
    LassoSamlNameIdentifier *result;
11594
 
    
11595
 
    arg1 = (LassoDefederation *)jarg1; 
11596
 
    result = (LassoSamlNameIdentifier *)LassoDefederation_get_nameIdentifier(arg1);
11597
 
    
11598
 
    jresult = (void *)result; 
11599
 
    return jresult;
11600
 
}
11601
 
 
11602
 
 
11603
 
DllExport void SWIGSTDCALL CSharp_set_Defederation_remoteProviderId(void * jarg1, char * jarg2) {
11604
 
    LassoDefederation *arg1 = (LassoDefederation *) 0 ;
11605
 
    char *arg2 = (char *) 0 ;
11606
 
    
11607
 
    arg1 = (LassoDefederation *)jarg1; 
11608
 
    arg2 = jarg2; 
11609
 
    LassoDefederation_set_remoteProviderId(arg1,arg2);
11610
 
    
11611
 
}
11612
 
 
11613
 
 
11614
 
DllExport char * SWIGSTDCALL CSharp_get_Defederation_remoteProviderId(void * jarg1) {
11615
 
    char * jresult = 0 ;
11616
 
    LassoDefederation *arg1 = (LassoDefederation *) 0 ;
11617
 
    char *result;
11618
 
    
11619
 
    arg1 = (LassoDefederation *)jarg1; 
11620
 
    result = (char *)LassoDefederation_get_remoteProviderId(arg1);
11621
 
    
11622
 
    jresult = SWIG_csharp_string_callback(result); 
11623
 
    return jresult;
11624
 
}
11625
 
 
11626
 
 
11627
 
DllExport void SWIGSTDCALL CSharp_set_Defederation_request(void * jarg1, void * jarg2) {
11628
 
    LassoDefederation *arg1 = (LassoDefederation *) 0 ;
11629
 
    LassoSamlpRequestAbstract *arg2 = (LassoSamlpRequestAbstract *) 0 ;
11630
 
    
11631
 
    arg1 = (LassoDefederation *)jarg1; 
11632
 
    arg2 = (LassoSamlpRequestAbstract *)jarg2; 
11633
 
    LassoDefederation_set_request(arg1,arg2);
11634
 
    
11635
 
}
11636
 
 
11637
 
 
11638
 
DllExport void * SWIGSTDCALL CSharp_get_Defederation_request(void * jarg1) {
11639
 
    void * jresult = 0 ;
11640
 
    LassoDefederation *arg1 = (LassoDefederation *) 0 ;
11641
 
    LassoSamlpRequestAbstract *result;
11642
 
    
11643
 
    arg1 = (LassoDefederation *)jarg1; 
11644
 
    result = (LassoSamlpRequestAbstract *)LassoDefederation_get_request(arg1);
11645
 
    
11646
 
    jresult = (void *)result; 
11647
 
    return jresult;
11648
 
}
11649
 
 
11650
 
 
11651
 
DllExport void SWIGSTDCALL CSharp_set_Defederation_response(void * jarg1, void * jarg2) {
11652
 
    LassoDefederation *arg1 = (LassoDefederation *) 0 ;
11653
 
    LassoSamlpResponseAbstract *arg2 = (LassoSamlpResponseAbstract *) 0 ;
11654
 
    
11655
 
    arg1 = (LassoDefederation *)jarg1; 
11656
 
    arg2 = (LassoSamlpResponseAbstract *)jarg2; 
11657
 
    LassoDefederation_set_response(arg1,arg2);
11658
 
    
11659
 
}
11660
 
 
11661
 
 
11662
 
DllExport void * SWIGSTDCALL CSharp_get_Defederation_response(void * jarg1) {
11663
 
    void * jresult = 0 ;
11664
 
    LassoDefederation *arg1 = (LassoDefederation *) 0 ;
11665
 
    LassoSamlpResponseAbstract *result;
11666
 
    
11667
 
    arg1 = (LassoDefederation *)jarg1; 
11668
 
    result = (LassoSamlpResponseAbstract *)LassoDefederation_get_response(arg1);
11669
 
    
11670
 
    jresult = (void *)result; 
11671
 
    return jresult;
11672
 
}
11673
 
 
11674
 
 
11675
 
DllExport void SWIGSTDCALL CSharp_set_Defederation_server(void * jarg1, void * jarg2) {
11676
 
    LassoDefederation *arg1 = (LassoDefederation *) 0 ;
11677
 
    LassoServer *arg2 = (LassoServer *) 0 ;
11678
 
    
11679
 
    arg1 = (LassoDefederation *)jarg1; 
11680
 
    arg2 = (LassoServer *)jarg2; 
11681
 
    LassoDefederation_set_server(arg1,arg2);
11682
 
    
11683
 
}
11684
 
 
11685
 
 
11686
 
DllExport void * SWIGSTDCALL CSharp_get_Defederation_server(void * jarg1) {
11687
 
    void * jresult = 0 ;
11688
 
    LassoDefederation *arg1 = (LassoDefederation *) 0 ;
11689
 
    LassoServer *result;
11690
 
    
11691
 
    arg1 = (LassoDefederation *)jarg1; 
11692
 
    result = (LassoServer *)LassoDefederation_get_server(arg1);
11693
 
    
11694
 
    jresult = (void *)result; 
11695
 
    return jresult;
11696
 
}
11697
 
 
11698
 
 
11699
 
DllExport void SWIGSTDCALL CSharp_set_Defederation_session(void * jarg1, void * jarg2) {
11700
 
    LassoDefederation *arg1 = (LassoDefederation *) 0 ;
11701
 
    LassoSession *arg2 = (LassoSession *) 0 ;
11702
 
    
11703
 
    arg1 = (LassoDefederation *)jarg1; 
11704
 
    arg2 = (LassoSession *)jarg2; 
11705
 
    LassoDefederation_set_session(arg1,arg2);
11706
 
    
11707
 
}
11708
 
 
11709
 
 
11710
 
DllExport void * SWIGSTDCALL CSharp_get_Defederation_session(void * jarg1) {
11711
 
    void * jresult = 0 ;
11712
 
    LassoDefederation *arg1 = (LassoDefederation *) 0 ;
11713
 
    LassoSession *result;
11714
 
    
11715
 
    arg1 = (LassoDefederation *)jarg1; 
11716
 
    result = (LassoSession *)LassoDefederation_get_session(arg1);
11717
 
    
11718
 
    jresult = (void *)result; 
11719
 
    return jresult;
11720
 
}
11721
 
 
11722
 
 
11723
 
DllExport void * SWIGSTDCALL CSharp_new_Defederation(void * jarg1) {
11724
 
    void * jresult = 0 ;
11725
 
    LassoServer *arg1 = (LassoServer *) 0 ;
11726
 
    LassoDefederation *result;
11727
 
    
11728
 
    arg1 = (LassoServer *)jarg1; 
11729
 
    result = (LassoDefederation *)new_LassoDefederation(arg1);
11730
 
    
11731
 
    jresult = (void *)result; 
11732
 
    return jresult;
11733
 
}
11734
 
 
11735
 
 
11736
 
DllExport void SWIGSTDCALL CSharp_delete_Defederation(void * jarg1) {
11737
 
    LassoDefederation *arg1 = (LassoDefederation *) 0 ;
11738
 
    
11739
 
    arg1 = (LassoDefederation *)jarg1; 
11740
 
    delete_LassoDefederation(arg1);
11741
 
    
11742
 
}
11743
 
 
11744
 
 
11745
 
DllExport int SWIGSTDCALL CSharp_Defederation_setIdentityFromDump(void * jarg1, char * jarg2) {
11746
 
    int jresult = 0 ;
11747
 
    LassoDefederation *arg1 = (LassoDefederation *) 0 ;
11748
 
    char *arg2 = (char *) 0 ;
11749
 
    int result;
11750
 
    
11751
 
    arg1 = (LassoDefederation *)jarg1; 
11752
 
    arg2 = jarg2; 
11753
 
    {
11754
 
        int errorCode;
11755
 
        errorCode = result = (int)LassoDefederation_setIdentityFromDump(arg1,arg2);
11756
 
        
11757
 
        if (errorCode) {
11758
 
            char errorMsg[256];
11759
 
            build_exception_msg(errorCode, errorMsg);
11760
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
11761
 
        }
11762
 
    }
11763
 
    jresult = result; 
11764
 
    return jresult;
11765
 
}
11766
 
 
11767
 
 
11768
 
DllExport int SWIGSTDCALL CSharp_Defederation_setSessionFromDump(void * jarg1, char * jarg2) {
11769
 
    int jresult = 0 ;
11770
 
    LassoDefederation *arg1 = (LassoDefederation *) 0 ;
11771
 
    char *arg2 = (char *) 0 ;
11772
 
    int result;
11773
 
    
11774
 
    arg1 = (LassoDefederation *)jarg1; 
11775
 
    arg2 = jarg2; 
11776
 
    {
11777
 
        int errorCode;
11778
 
        errorCode = result = (int)LassoDefederation_setSessionFromDump(arg1,arg2);
11779
 
        
11780
 
        if (errorCode) {
11781
 
            char errorMsg[256];
11782
 
            build_exception_msg(errorCode, errorMsg);
11783
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
11784
 
        }
11785
 
    }
11786
 
    jresult = result; 
11787
 
    return jresult;
11788
 
}
11789
 
 
11790
 
 
11791
 
DllExport int SWIGSTDCALL CSharp_Defederation_buildNotificationMsg(void * jarg1) {
11792
 
    int jresult = 0 ;
11793
 
    LassoDefederation *arg1 = (LassoDefederation *) 0 ;
11794
 
    int result;
11795
 
    
11796
 
    arg1 = (LassoDefederation *)jarg1; 
11797
 
    {
11798
 
        int errorCode;
11799
 
        errorCode = result = (int)LassoDefederation_buildNotificationMsg(arg1);
11800
 
        
11801
 
        if (errorCode) {
11802
 
            char errorMsg[256];
11803
 
            build_exception_msg(errorCode, errorMsg);
11804
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
11805
 
        }
11806
 
    }
11807
 
    jresult = result; 
11808
 
    return jresult;
11809
 
}
11810
 
 
11811
 
 
11812
 
DllExport int SWIGSTDCALL CSharp_Defederation_initNotification(void * jarg1, char * jarg2, int jarg3) {
11813
 
    int jresult = 0 ;
11814
 
    LassoDefederation *arg1 = (LassoDefederation *) 0 ;
11815
 
    char *arg2 = (char *) NULL ;
11816
 
    LassoHttpMethod arg3 = (LassoHttpMethod) LASSO_HTTP_METHOD_ANY ;
11817
 
    int result;
11818
 
    
11819
 
    arg1 = (LassoDefederation *)jarg1; 
11820
 
    arg2 = jarg2; 
11821
 
    arg3 = (LassoHttpMethod)jarg3; 
11822
 
    {
11823
 
        int errorCode;
11824
 
        errorCode = result = (int)LassoDefederation_initNotification(arg1,arg2,(LassoHttpMethod )arg3);
11825
 
        
11826
 
        if (errorCode) {
11827
 
            char errorMsg[256];
11828
 
            build_exception_msg(errorCode, errorMsg);
11829
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
11830
 
        }
11831
 
    }
11832
 
    jresult = result; 
11833
 
    return jresult;
11834
 
}
11835
 
 
11836
 
 
11837
 
DllExport int SWIGSTDCALL CSharp_Defederation_processNotificationMsg(void * jarg1, char * jarg2) {
11838
 
    int jresult = 0 ;
11839
 
    LassoDefederation *arg1 = (LassoDefederation *) 0 ;
11840
 
    char *arg2 = (char *) 0 ;
11841
 
    int result;
11842
 
    
11843
 
    arg1 = (LassoDefederation *)jarg1; 
11844
 
    arg2 = jarg2; 
11845
 
    {
11846
 
        int errorCode;
11847
 
        errorCode = result = (int)LassoDefederation_processNotificationMsg(arg1,arg2);
11848
 
        
11849
 
        if (errorCode) {
11850
 
            char errorMsg[256];
11851
 
            build_exception_msg(errorCode, errorMsg);
11852
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
11853
 
        }
11854
 
    }
11855
 
    jresult = result; 
11856
 
    return jresult;
11857
 
}
11858
 
 
11859
 
 
11860
 
DllExport int SWIGSTDCALL CSharp_Defederation_validateNotification(void * jarg1) {
11861
 
    int jresult = 0 ;
11862
 
    LassoDefederation *arg1 = (LassoDefederation *) 0 ;
11863
 
    int result;
11864
 
    
11865
 
    arg1 = (LassoDefederation *)jarg1; 
11866
 
    {
11867
 
        int errorCode;
11868
 
        errorCode = result = (int)LassoDefederation_validateNotification(arg1);
11869
 
        
11870
 
        if (errorCode) {
11871
 
            char errorMsg[256];
11872
 
            build_exception_msg(errorCode, errorMsg);
11873
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
11874
 
        }
11875
 
    }
11876
 
    jresult = result; 
11877
 
    return jresult;
11878
 
}
11879
 
 
11880
 
 
11881
 
DllExport char * SWIGSTDCALL CSharp_get_Login_assertionArtifact(void * jarg1) {
11882
 
    char * jresult = 0 ;
11883
 
    LassoLogin *arg1 = (LassoLogin *) 0 ;
11884
 
    char *result;
11885
 
    
11886
 
    arg1 = (LassoLogin *)jarg1; 
11887
 
    result = (char *) ((arg1)->assertionArtifact);
11888
 
    
11889
 
    jresult = SWIG_csharp_string_callback(result); 
11890
 
    return jresult;
11891
 
}
11892
 
 
11893
 
 
11894
 
DllExport int SWIGSTDCALL CSharp_get_Login_protocolProfile(void * jarg1) {
11895
 
    int jresult = 0 ;
11896
 
    LassoLogin *arg1 = (LassoLogin *) 0 ;
11897
 
    LassoLoginProtocolProfile result;
11898
 
    
11899
 
    arg1 = (LassoLogin *)jarg1; 
11900
 
    result = (LassoLoginProtocolProfile) ((arg1)->protocolProfile);
11901
 
    
11902
 
    jresult = result; 
11903
 
    return jresult;
11904
 
}
11905
 
 
11906
 
 
11907
 
DllExport void SWIGSTDCALL CSharp_set_Login_identity(void * jarg1, void * jarg2) {
11908
 
    LassoLogin *arg1 = (LassoLogin *) 0 ;
11909
 
    LassoIdentity *arg2 = (LassoIdentity *) 0 ;
11910
 
    
11911
 
    arg1 = (LassoLogin *)jarg1; 
11912
 
    arg2 = (LassoIdentity *)jarg2; 
11913
 
    LassoLogin_set_identity(arg1,arg2);
11914
 
    
11915
 
}
11916
 
 
11917
 
 
11918
 
DllExport void * SWIGSTDCALL CSharp_get_Login_identity(void * jarg1) {
11919
 
    void * jresult = 0 ;
11920
 
    LassoLogin *arg1 = (LassoLogin *) 0 ;
11921
 
    LassoIdentity *result;
11922
 
    
11923
 
    arg1 = (LassoLogin *)jarg1; 
11924
 
    result = (LassoIdentity *)LassoLogin_get_identity(arg1);
11925
 
    
11926
 
    jresult = (void *)result; 
11927
 
    return jresult;
11928
 
}
11929
 
 
11930
 
 
11931
 
DllExport unsigned int SWIGSTDCALL CSharp_get_Login_isIdentityDirty(void * jarg1) {
11932
 
    unsigned int jresult = 0 ;
11933
 
    LassoLogin *arg1 = (LassoLogin *) 0 ;
11934
 
    bool result;
11935
 
    
11936
 
    arg1 = (LassoLogin *)jarg1; 
11937
 
    result = (bool)LassoLogin_get_isIdentityDirty(arg1);
11938
 
    
11939
 
    jresult = result; 
11940
 
    return jresult;
11941
 
}
11942
 
 
11943
 
 
11944
 
DllExport unsigned int SWIGSTDCALL CSharp_get_Login_isSessionDirty(void * jarg1) {
11945
 
    unsigned int jresult = 0 ;
11946
 
    LassoLogin *arg1 = (LassoLogin *) 0 ;
11947
 
    bool result;
11948
 
    
11949
 
    arg1 = (LassoLogin *)jarg1; 
11950
 
    result = (bool)LassoLogin_get_isSessionDirty(arg1);
11951
 
    
11952
 
    jresult = result; 
11953
 
    return jresult;
11954
 
}
11955
 
 
11956
 
 
11957
 
DllExport char * SWIGSTDCALL CSharp_get_Login_msgBody(void * jarg1) {
11958
 
    char * jresult = 0 ;
11959
 
    LassoLogin *arg1 = (LassoLogin *) 0 ;
11960
 
    char *result;
11961
 
    
11962
 
    arg1 = (LassoLogin *)jarg1; 
11963
 
    result = (char *)LassoLogin_get_msgBody(arg1);
11964
 
    
11965
 
    jresult = SWIG_csharp_string_callback(result); 
11966
 
    return jresult;
11967
 
}
11968
 
 
11969
 
 
11970
 
DllExport char * SWIGSTDCALL CSharp_get_Login_msgRelayState(void * jarg1) {
11971
 
    char * jresult = 0 ;
11972
 
    LassoLogin *arg1 = (LassoLogin *) 0 ;
11973
 
    char *result;
11974
 
    
11975
 
    arg1 = (LassoLogin *)jarg1; 
11976
 
    result = (char *)LassoLogin_get_msgRelayState(arg1);
11977
 
    
11978
 
    jresult = SWIG_csharp_string_callback(result); 
11979
 
    return jresult;
11980
 
}
11981
 
 
11982
 
 
11983
 
DllExport char * SWIGSTDCALL CSharp_get_Login_msgUrl(void * jarg1) {
11984
 
    char * jresult = 0 ;
11985
 
    LassoLogin *arg1 = (LassoLogin *) 0 ;
11986
 
    char *result;
11987
 
    
11988
 
    arg1 = (LassoLogin *)jarg1; 
11989
 
    result = (char *)LassoLogin_get_msgUrl(arg1);
11990
 
    
11991
 
    jresult = SWIG_csharp_string_callback(result); 
11992
 
    return jresult;
11993
 
}
11994
 
 
11995
 
 
11996
 
DllExport void SWIGSTDCALL CSharp_set_Login_nameIdentifier(void * jarg1, void * jarg2) {
11997
 
    LassoLogin *arg1 = (LassoLogin *) 0 ;
11998
 
    LassoSamlNameIdentifier *arg2 = (LassoSamlNameIdentifier *) 0 ;
11999
 
    
12000
 
    arg1 = (LassoLogin *)jarg1; 
12001
 
    arg2 = (LassoSamlNameIdentifier *)jarg2; 
12002
 
    LassoLogin_set_nameIdentifier(arg1,arg2);
12003
 
    
12004
 
}
12005
 
 
12006
 
 
12007
 
DllExport void * SWIGSTDCALL CSharp_get_Login_nameIdentifier(void * jarg1) {
12008
 
    void * jresult = 0 ;
12009
 
    LassoLogin *arg1 = (LassoLogin *) 0 ;
12010
 
    LassoSamlNameIdentifier *result;
12011
 
    
12012
 
    arg1 = (LassoLogin *)jarg1; 
12013
 
    result = (LassoSamlNameIdentifier *)LassoLogin_get_nameIdentifier(arg1);
12014
 
    
12015
 
    jresult = (void *)result; 
12016
 
    return jresult;
12017
 
}
12018
 
 
12019
 
 
12020
 
DllExport void SWIGSTDCALL CSharp_set_Login_remoteProviderId(void * jarg1, char * jarg2) {
12021
 
    LassoLogin *arg1 = (LassoLogin *) 0 ;
12022
 
    char *arg2 = (char *) 0 ;
12023
 
    
12024
 
    arg1 = (LassoLogin *)jarg1; 
12025
 
    arg2 = jarg2; 
12026
 
    LassoLogin_set_remoteProviderId(arg1,arg2);
12027
 
    
12028
 
}
12029
 
 
12030
 
 
12031
 
DllExport char * SWIGSTDCALL CSharp_get_Login_remoteProviderId(void * jarg1) {
12032
 
    char * jresult = 0 ;
12033
 
    LassoLogin *arg1 = (LassoLogin *) 0 ;
12034
 
    char *result;
12035
 
    
12036
 
    arg1 = (LassoLogin *)jarg1; 
12037
 
    result = (char *)LassoLogin_get_remoteProviderId(arg1);
12038
 
    
12039
 
    jresult = SWIG_csharp_string_callback(result); 
12040
 
    return jresult;
12041
 
}
12042
 
 
12043
 
 
12044
 
DllExport void SWIGSTDCALL CSharp_set_Login_request(void * jarg1, void * jarg2) {
12045
 
    LassoLogin *arg1 = (LassoLogin *) 0 ;
12046
 
    LassoSamlpRequestAbstract *arg2 = (LassoSamlpRequestAbstract *) 0 ;
12047
 
    
12048
 
    arg1 = (LassoLogin *)jarg1; 
12049
 
    arg2 = (LassoSamlpRequestAbstract *)jarg2; 
12050
 
    LassoLogin_set_request(arg1,arg2);
12051
 
    
12052
 
}
12053
 
 
12054
 
 
12055
 
DllExport void * SWIGSTDCALL CSharp_get_Login_request(void * jarg1) {
12056
 
    void * jresult = 0 ;
12057
 
    LassoLogin *arg1 = (LassoLogin *) 0 ;
12058
 
    LassoSamlpRequestAbstract *result;
12059
 
    
12060
 
    arg1 = (LassoLogin *)jarg1; 
12061
 
    result = (LassoSamlpRequestAbstract *)LassoLogin_get_request(arg1);
12062
 
    
12063
 
    jresult = (void *)result; 
12064
 
    return jresult;
12065
 
}
12066
 
 
12067
 
 
12068
 
DllExport void SWIGSTDCALL CSharp_set_Login_response(void * jarg1, void * jarg2) {
12069
 
    LassoLogin *arg1 = (LassoLogin *) 0 ;
12070
 
    LassoSamlpResponseAbstract *arg2 = (LassoSamlpResponseAbstract *) 0 ;
12071
 
    
12072
 
    arg1 = (LassoLogin *)jarg1; 
12073
 
    arg2 = (LassoSamlpResponseAbstract *)jarg2; 
12074
 
    LassoLogin_set_response(arg1,arg2);
12075
 
    
12076
 
}
12077
 
 
12078
 
 
12079
 
DllExport void * SWIGSTDCALL CSharp_get_Login_response(void * jarg1) {
12080
 
    void * jresult = 0 ;
12081
 
    LassoLogin *arg1 = (LassoLogin *) 0 ;
12082
 
    LassoSamlpResponseAbstract *result;
12083
 
    
12084
 
    arg1 = (LassoLogin *)jarg1; 
12085
 
    result = (LassoSamlpResponseAbstract *)LassoLogin_get_response(arg1);
12086
 
    
12087
 
    jresult = (void *)result; 
12088
 
    return jresult;
12089
 
}
12090
 
 
12091
 
 
12092
 
DllExport void SWIGSTDCALL CSharp_set_Login_server(void * jarg1, void * jarg2) {
12093
 
    LassoLogin *arg1 = (LassoLogin *) 0 ;
12094
 
    LassoServer *arg2 = (LassoServer *) 0 ;
12095
 
    
12096
 
    arg1 = (LassoLogin *)jarg1; 
12097
 
    arg2 = (LassoServer *)jarg2; 
12098
 
    LassoLogin_set_server(arg1,arg2);
12099
 
    
12100
 
}
12101
 
 
12102
 
 
12103
 
DllExport void * SWIGSTDCALL CSharp_get_Login_server(void * jarg1) {
12104
 
    void * jresult = 0 ;
12105
 
    LassoLogin *arg1 = (LassoLogin *) 0 ;
12106
 
    LassoServer *result;
12107
 
    
12108
 
    arg1 = (LassoLogin *)jarg1; 
12109
 
    result = (LassoServer *)LassoLogin_get_server(arg1);
12110
 
    
12111
 
    jresult = (void *)result; 
12112
 
    return jresult;
12113
 
}
12114
 
 
12115
 
 
12116
 
DllExport void SWIGSTDCALL CSharp_set_Login_session(void * jarg1, void * jarg2) {
12117
 
    LassoLogin *arg1 = (LassoLogin *) 0 ;
12118
 
    LassoSession *arg2 = (LassoSession *) 0 ;
12119
 
    
12120
 
    arg1 = (LassoLogin *)jarg1; 
12121
 
    arg2 = (LassoSession *)jarg2; 
12122
 
    LassoLogin_set_session(arg1,arg2);
12123
 
    
12124
 
}
12125
 
 
12126
 
 
12127
 
DllExport void * SWIGSTDCALL CSharp_get_Login_session(void * jarg1) {
12128
 
    void * jresult = 0 ;
12129
 
    LassoLogin *arg1 = (LassoLogin *) 0 ;
12130
 
    LassoSession *result;
12131
 
    
12132
 
    arg1 = (LassoLogin *)jarg1; 
12133
 
    result = (LassoSession *)LassoLogin_get_session(arg1);
12134
 
    
12135
 
    jresult = (void *)result; 
12136
 
    return jresult;
12137
 
}
12138
 
 
12139
 
 
12140
 
DllExport void * SWIGSTDCALL CSharp_new_Login(void * jarg1) {
12141
 
    void * jresult = 0 ;
12142
 
    LassoServer *arg1 = (LassoServer *) 0 ;
12143
 
    LassoLogin *result;
12144
 
    
12145
 
    arg1 = (LassoServer *)jarg1; 
12146
 
    result = (LassoLogin *)new_LassoLogin(arg1);
12147
 
    
12148
 
    jresult = (void *)result; 
12149
 
    return jresult;
12150
 
}
12151
 
 
12152
 
 
12153
 
DllExport void SWIGSTDCALL CSharp_delete_Login(void * jarg1) {
12154
 
    LassoLogin *arg1 = (LassoLogin *) 0 ;
12155
 
    
12156
 
    arg1 = (LassoLogin *)jarg1; 
12157
 
    delete_LassoLogin(arg1);
12158
 
    
12159
 
}
12160
 
 
12161
 
 
12162
 
DllExport void * SWIGSTDCALL CSharp_Login_newFromDump(void * jarg1, char * jarg2) {
12163
 
    void * jresult = 0 ;
12164
 
    LassoServer *arg1 = (LassoServer *) 0 ;
12165
 
    char *arg2 = (char *) 0 ;
12166
 
    LassoLogin *result;
12167
 
    
12168
 
    arg1 = (LassoServer *)jarg1; 
12169
 
    arg2 = jarg2; 
12170
 
    result = (LassoLogin *)Login_newFromDump(arg1,arg2);
12171
 
    
12172
 
    jresult = (void *)result; 
12173
 
    return jresult;
12174
 
}
12175
 
 
12176
 
 
12177
 
DllExport int SWIGSTDCALL CSharp_Login_setIdentityFromDump(void * jarg1, char * jarg2) {
12178
 
    int jresult = 0 ;
12179
 
    LassoLogin *arg1 = (LassoLogin *) 0 ;
12180
 
    char *arg2 = (char *) 0 ;
12181
 
    int result;
12182
 
    
12183
 
    arg1 = (LassoLogin *)jarg1; 
12184
 
    arg2 = jarg2; 
12185
 
    {
12186
 
        int errorCode;
12187
 
        errorCode = result = (int)LassoLogin_setIdentityFromDump(arg1,arg2);
12188
 
        
12189
 
        if (errorCode) {
12190
 
            char errorMsg[256];
12191
 
            build_exception_msg(errorCode, errorMsg);
12192
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
12193
 
        }
12194
 
    }
12195
 
    jresult = result; 
12196
 
    return jresult;
12197
 
}
12198
 
 
12199
 
 
12200
 
DllExport int SWIGSTDCALL CSharp_Login_setSessionFromDump(void * jarg1, char * jarg2) {
12201
 
    int jresult = 0 ;
12202
 
    LassoLogin *arg1 = (LassoLogin *) 0 ;
12203
 
    char *arg2 = (char *) 0 ;
12204
 
    int result;
12205
 
    
12206
 
    arg1 = (LassoLogin *)jarg1; 
12207
 
    arg2 = jarg2; 
12208
 
    {
12209
 
        int errorCode;
12210
 
        errorCode = result = (int)LassoLogin_setSessionFromDump(arg1,arg2);
12211
 
        
12212
 
        if (errorCode) {
12213
 
            char errorMsg[256];
12214
 
            build_exception_msg(errorCode, errorMsg);
12215
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
12216
 
        }
12217
 
    }
12218
 
    jresult = result; 
12219
 
    return jresult;
12220
 
}
12221
 
 
12222
 
 
12223
 
DllExport int SWIGSTDCALL CSharp_Login_acceptSso(void * jarg1) {
12224
 
    int jresult = 0 ;
12225
 
    LassoLogin *arg1 = (LassoLogin *) 0 ;
12226
 
    int result;
12227
 
    
12228
 
    arg1 = (LassoLogin *)jarg1; 
12229
 
    {
12230
 
        int errorCode;
12231
 
        errorCode = result = (int)LassoLogin_acceptSso(arg1);
12232
 
        
12233
 
        if (errorCode) {
12234
 
            char errorMsg[256];
12235
 
            build_exception_msg(errorCode, errorMsg);
12236
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
12237
 
        }
12238
 
    }
12239
 
    jresult = result; 
12240
 
    return jresult;
12241
 
}
12242
 
 
12243
 
 
12244
 
DllExport int SWIGSTDCALL CSharp_Login_buildArtifactMsg(void * jarg1, int jarg2) {
12245
 
    int jresult = 0 ;
12246
 
    LassoLogin *arg1 = (LassoLogin *) 0 ;
12247
 
    LassoHttpMethod arg2 ;
12248
 
    int result;
12249
 
    
12250
 
    arg1 = (LassoLogin *)jarg1; 
12251
 
    arg2 = (LassoHttpMethod)jarg2; 
12252
 
    {
12253
 
        int errorCode;
12254
 
        errorCode = result = (int)LassoLogin_buildArtifactMsg(arg1,(LassoHttpMethod )arg2);
12255
 
        
12256
 
        if (errorCode) {
12257
 
            char errorMsg[256];
12258
 
            build_exception_msg(errorCode, errorMsg);
12259
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
12260
 
        }
12261
 
    }
12262
 
    jresult = result; 
12263
 
    return jresult;
12264
 
}
12265
 
 
12266
 
 
12267
 
DllExport int SWIGSTDCALL CSharp_Login_buildAssertion(void * jarg1, char * jarg2, char * jarg3, char * jarg4, char * jarg5, char * jarg6) {
12268
 
    int jresult = 0 ;
12269
 
    LassoLogin *arg1 = (LassoLogin *) 0 ;
12270
 
    char *arg2 = (char *) 0 ;
12271
 
    char *arg3 = (char *) 0 ;
12272
 
    char *arg4 = (char *) 0 ;
12273
 
    char *arg5 = (char *) 0 ;
12274
 
    char *arg6 = (char *) 0 ;
12275
 
    int result;
12276
 
    
12277
 
    arg1 = (LassoLogin *)jarg1; 
12278
 
    arg2 = jarg2; 
12279
 
    arg3 = jarg3; 
12280
 
    arg4 = jarg4; 
12281
 
    arg5 = jarg5; 
12282
 
    arg6 = jarg6; 
12283
 
    {
12284
 
        int errorCode;
12285
 
        errorCode = result = (int)LassoLogin_buildAssertion(arg1,arg2,arg3,arg4,arg5,arg6);
12286
 
        
12287
 
        if (errorCode) {
12288
 
            char errorMsg[256];
12289
 
            build_exception_msg(errorCode, errorMsg);
12290
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
12291
 
        }
12292
 
    }
12293
 
    jresult = result; 
12294
 
    return jresult;
12295
 
}
12296
 
 
12297
 
 
12298
 
DllExport int SWIGSTDCALL CSharp_Login_buildAuthnRequestMsg(void * jarg1) {
12299
 
    int jresult = 0 ;
12300
 
    LassoLogin *arg1 = (LassoLogin *) 0 ;
12301
 
    int result;
12302
 
    
12303
 
    arg1 = (LassoLogin *)jarg1; 
12304
 
    {
12305
 
        int errorCode;
12306
 
        errorCode = result = (int)LassoLogin_buildAuthnRequestMsg(arg1);
12307
 
        
12308
 
        if (errorCode) {
12309
 
            char errorMsg[256];
12310
 
            build_exception_msg(errorCode, errorMsg);
12311
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
12312
 
        }
12313
 
    }
12314
 
    jresult = result; 
12315
 
    return jresult;
12316
 
}
12317
 
 
12318
 
 
12319
 
DllExport int SWIGSTDCALL CSharp_Login_buildAuthnResponseMsg(void * jarg1) {
12320
 
    int jresult = 0 ;
12321
 
    LassoLogin *arg1 = (LassoLogin *) 0 ;
12322
 
    int result;
12323
 
    
12324
 
    arg1 = (LassoLogin *)jarg1; 
12325
 
    {
12326
 
        int errorCode;
12327
 
        errorCode = result = (int)LassoLogin_buildAuthnResponseMsg(arg1);
12328
 
        
12329
 
        if (errorCode) {
12330
 
            char errorMsg[256];
12331
 
            build_exception_msg(errorCode, errorMsg);
12332
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
12333
 
        }
12334
 
    }
12335
 
    jresult = result; 
12336
 
    return jresult;
12337
 
}
12338
 
 
12339
 
 
12340
 
DllExport int SWIGSTDCALL CSharp_Login_buildRequestMsg(void * jarg1) {
12341
 
    int jresult = 0 ;
12342
 
    LassoLogin *arg1 = (LassoLogin *) 0 ;
12343
 
    int result;
12344
 
    
12345
 
    arg1 = (LassoLogin *)jarg1; 
12346
 
    {
12347
 
        int errorCode;
12348
 
        errorCode = result = (int)LassoLogin_buildRequestMsg(arg1);
12349
 
        
12350
 
        if (errorCode) {
12351
 
            char errorMsg[256];
12352
 
            build_exception_msg(errorCode, errorMsg);
12353
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
12354
 
        }
12355
 
    }
12356
 
    jresult = result; 
12357
 
    return jresult;
12358
 
}
12359
 
 
12360
 
 
12361
 
DllExport int SWIGSTDCALL CSharp_Login_buildResponseMsg(void * jarg1, char * jarg2) {
12362
 
    int jresult = 0 ;
12363
 
    LassoLogin *arg1 = (LassoLogin *) 0 ;
12364
 
    char *arg2 = (char *) 0 ;
12365
 
    int result;
12366
 
    
12367
 
    arg1 = (LassoLogin *)jarg1; 
12368
 
    arg2 = jarg2; 
12369
 
    {
12370
 
        int errorCode;
12371
 
        errorCode = result = (int)LassoLogin_buildResponseMsg(arg1,arg2);
12372
 
        
12373
 
        if (errorCode) {
12374
 
            char errorMsg[256];
12375
 
            build_exception_msg(errorCode, errorMsg);
12376
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
12377
 
        }
12378
 
    }
12379
 
    jresult = result; 
12380
 
    return jresult;
12381
 
}
12382
 
 
12383
 
 
12384
 
DllExport char * SWIGSTDCALL CSharp_Login_dump(void * jarg1) {
12385
 
    char * jresult = 0 ;
12386
 
    LassoLogin *arg1 = (LassoLogin *) 0 ;
12387
 
    char *result;
12388
 
    
12389
 
    arg1 = (LassoLogin *)jarg1; 
12390
 
    result = (char *)LassoLogin_dump(arg1);
12391
 
    
12392
 
    jresult = SWIG_csharp_string_callback(result); 
12393
 
    free(result);
12394
 
    return jresult;
12395
 
}
12396
 
 
12397
 
 
12398
 
DllExport int SWIGSTDCALL CSharp_Login_initAuthnRequest(void * jarg1, char * jarg2, int jarg3) {
12399
 
    int jresult = 0 ;
12400
 
    LassoLogin *arg1 = (LassoLogin *) 0 ;
12401
 
    char *arg2 = (char *) NULL ;
12402
 
    LassoHttpMethod arg3 = (LassoHttpMethod) LASSO_HTTP_METHOD_REDIRECT ;
12403
 
    int result;
12404
 
    
12405
 
    arg1 = (LassoLogin *)jarg1; 
12406
 
    arg2 = jarg2; 
12407
 
    arg3 = (LassoHttpMethod)jarg3; 
12408
 
    {
12409
 
        int errorCode;
12410
 
        errorCode = result = (int)LassoLogin_initAuthnRequest(arg1,arg2,(LassoHttpMethod )arg3);
12411
 
        
12412
 
        if (errorCode) {
12413
 
            char errorMsg[256];
12414
 
            build_exception_msg(errorCode, errorMsg);
12415
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
12416
 
        }
12417
 
    }
12418
 
    jresult = result; 
12419
 
    return jresult;
12420
 
}
12421
 
 
12422
 
 
12423
 
DllExport int SWIGSTDCALL CSharp_Login_initRequest(void * jarg1, char * jarg2, int jarg3) {
12424
 
    int jresult = 0 ;
12425
 
    LassoLogin *arg1 = (LassoLogin *) 0 ;
12426
 
    char *arg2 = (char *) 0 ;
12427
 
    LassoHttpMethod arg3 = (LassoHttpMethod) LASSO_HTTP_METHOD_REDIRECT ;
12428
 
    int result;
12429
 
    
12430
 
    arg1 = (LassoLogin *)jarg1; 
12431
 
    arg2 = jarg2; 
12432
 
    arg3 = (LassoHttpMethod)jarg3; 
12433
 
    {
12434
 
        int errorCode;
12435
 
        errorCode = result = (int)LassoLogin_initRequest(arg1,arg2,(LassoHttpMethod )arg3);
12436
 
        
12437
 
        if (errorCode) {
12438
 
            char errorMsg[256];
12439
 
            build_exception_msg(errorCode, errorMsg);
12440
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
12441
 
        }
12442
 
    }
12443
 
    jresult = result; 
12444
 
    return jresult;
12445
 
}
12446
 
 
12447
 
 
12448
 
DllExport int SWIGSTDCALL CSharp_Login_initIdpInitiatedAuthnRequest(void * jarg1, char * jarg2) {
12449
 
    int jresult = 0 ;
12450
 
    LassoLogin *arg1 = (LassoLogin *) 0 ;
12451
 
    char *arg2 = (char *) NULL ;
12452
 
    int result;
12453
 
    
12454
 
    arg1 = (LassoLogin *)jarg1; 
12455
 
    arg2 = jarg2; 
12456
 
    {
12457
 
        int errorCode;
12458
 
        errorCode = result = (int)LassoLogin_initIdpInitiatedAuthnRequest(arg1,arg2);
12459
 
        
12460
 
        if (errorCode) {
12461
 
            char errorMsg[256];
12462
 
            build_exception_msg(errorCode, errorMsg);
12463
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
12464
 
        }
12465
 
    }
12466
 
    jresult = result; 
12467
 
    return jresult;
12468
 
}
12469
 
 
12470
 
 
12471
 
DllExport unsigned int SWIGSTDCALL CSharp_Login_mustAskForConsent(void * jarg1) {
12472
 
    unsigned int jresult = 0 ;
12473
 
    LassoLogin *arg1 = (LassoLogin *) 0 ;
12474
 
    bool result;
12475
 
    
12476
 
    arg1 = (LassoLogin *)jarg1; 
12477
 
    result = (bool)LassoLogin_mustAskForConsent(arg1);
12478
 
    
12479
 
    jresult = result; 
12480
 
    return jresult;
12481
 
}
12482
 
 
12483
 
 
12484
 
DllExport unsigned int SWIGSTDCALL CSharp_Login_mustAuthenticate(void * jarg1) {
12485
 
    unsigned int jresult = 0 ;
12486
 
    LassoLogin *arg1 = (LassoLogin *) 0 ;
12487
 
    bool result;
12488
 
    
12489
 
    arg1 = (LassoLogin *)jarg1; 
12490
 
    result = (bool)LassoLogin_mustAuthenticate(arg1);
12491
 
    
12492
 
    jresult = result; 
12493
 
    return jresult;
12494
 
}
12495
 
 
12496
 
 
12497
 
DllExport int SWIGSTDCALL CSharp_Login_processAuthnRequestMsg(void * jarg1, char * jarg2) {
12498
 
    int jresult = 0 ;
12499
 
    LassoLogin *arg1 = (LassoLogin *) 0 ;
12500
 
    char *arg2 = (char *) 0 ;
12501
 
    int result;
12502
 
    
12503
 
    arg1 = (LassoLogin *)jarg1; 
12504
 
    arg2 = jarg2; 
12505
 
    {
12506
 
        int errorCode;
12507
 
        errorCode = result = (int)LassoLogin_processAuthnRequestMsg(arg1,arg2);
12508
 
        
12509
 
        if (errorCode) {
12510
 
            char errorMsg[256];
12511
 
            build_exception_msg(errorCode, errorMsg);
12512
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
12513
 
        }
12514
 
    }
12515
 
    jresult = result; 
12516
 
    return jresult;
12517
 
}
12518
 
 
12519
 
 
12520
 
DllExport int SWIGSTDCALL CSharp_Login_processAuthnResponseMsg(void * jarg1, char * jarg2) {
12521
 
    int jresult = 0 ;
12522
 
    LassoLogin *arg1 = (LassoLogin *) 0 ;
12523
 
    char *arg2 = (char *) 0 ;
12524
 
    int result;
12525
 
    
12526
 
    arg1 = (LassoLogin *)jarg1; 
12527
 
    arg2 = jarg2; 
12528
 
    {
12529
 
        int errorCode;
12530
 
        errorCode = result = (int)LassoLogin_processAuthnResponseMsg(arg1,arg2);
12531
 
        
12532
 
        if (errorCode) {
12533
 
            char errorMsg[256];
12534
 
            build_exception_msg(errorCode, errorMsg);
12535
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
12536
 
        }
12537
 
    }
12538
 
    jresult = result; 
12539
 
    return jresult;
12540
 
}
12541
 
 
12542
 
 
12543
 
DllExport int SWIGSTDCALL CSharp_Login_processRequestMsg(void * jarg1, char * jarg2) {
12544
 
    int jresult = 0 ;
12545
 
    LassoLogin *arg1 = (LassoLogin *) 0 ;
12546
 
    char *arg2 = (char *) 0 ;
12547
 
    int result;
12548
 
    
12549
 
    arg1 = (LassoLogin *)jarg1; 
12550
 
    arg2 = jarg2; 
12551
 
    {
12552
 
        int errorCode;
12553
 
        errorCode = result = (int)LassoLogin_processRequestMsg(arg1,arg2);
12554
 
        
12555
 
        if (errorCode) {
12556
 
            char errorMsg[256];
12557
 
            build_exception_msg(errorCode, errorMsg);
12558
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
12559
 
        }
12560
 
    }
12561
 
    jresult = result; 
12562
 
    return jresult;
12563
 
}
12564
 
 
12565
 
 
12566
 
DllExport int SWIGSTDCALL CSharp_Login_processResponseMsg(void * jarg1, char * jarg2) {
12567
 
    int jresult = 0 ;
12568
 
    LassoLogin *arg1 = (LassoLogin *) 0 ;
12569
 
    char *arg2 = (char *) 0 ;
12570
 
    int result;
12571
 
    
12572
 
    arg1 = (LassoLogin *)jarg1; 
12573
 
    arg2 = jarg2; 
12574
 
    {
12575
 
        int errorCode;
12576
 
        errorCode = result = (int)LassoLogin_processResponseMsg(arg1,arg2);
12577
 
        
12578
 
        if (errorCode) {
12579
 
            char errorMsg[256];
12580
 
            build_exception_msg(errorCode, errorMsg);
12581
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
12582
 
        }
12583
 
    }
12584
 
    jresult = result; 
12585
 
    return jresult;
12586
 
}
12587
 
 
12588
 
 
12589
 
DllExport int SWIGSTDCALL CSharp_Login_setResourceId(void * jarg1, char * jarg2) {
12590
 
    int jresult = 0 ;
12591
 
    LassoLogin *arg1 = (LassoLogin *) 0 ;
12592
 
    char *arg2 = (char *) 0 ;
12593
 
    int result;
12594
 
    
12595
 
    arg1 = (LassoLogin *)jarg1; 
12596
 
    arg2 = jarg2; 
12597
 
    {
12598
 
        int errorCode;
12599
 
        errorCode = result = (int)LassoLogin_setResourceId(arg1,arg2);
12600
 
        
12601
 
        if (errorCode) {
12602
 
            char errorMsg[256];
12603
 
            build_exception_msg(errorCode, errorMsg);
12604
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
12605
 
        }
12606
 
    }
12607
 
    jresult = result; 
12608
 
    return jresult;
12609
 
}
12610
 
 
12611
 
 
12612
 
DllExport int SWIGSTDCALL CSharp_Login_validateRequestMsg(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
12613
 
    int jresult = 0 ;
12614
 
    LassoLogin *arg1 = (LassoLogin *) 0 ;
12615
 
    bool arg2 ;
12616
 
    bool arg3 ;
12617
 
    int result;
12618
 
    
12619
 
    arg1 = (LassoLogin *)jarg1; 
12620
 
    arg2 = jarg2 ? true : false; 
12621
 
    arg3 = jarg3 ? true : false; 
12622
 
    {
12623
 
        int errorCode;
12624
 
        errorCode = result = (int)LassoLogin_validateRequestMsg(arg1,arg2,arg3);
12625
 
        
12626
 
        if (errorCode) {
12627
 
            char errorMsg[256];
12628
 
            build_exception_msg(errorCode, errorMsg);
12629
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
12630
 
        }
12631
 
    }
12632
 
    jresult = result; 
12633
 
    return jresult;
12634
 
}
12635
 
 
12636
 
 
12637
 
DllExport void SWIGSTDCALL CSharp_set_Logout_identity(void * jarg1, void * jarg2) {
12638
 
    LassoLogout *arg1 = (LassoLogout *) 0 ;
12639
 
    LassoIdentity *arg2 = (LassoIdentity *) 0 ;
12640
 
    
12641
 
    arg1 = (LassoLogout *)jarg1; 
12642
 
    arg2 = (LassoIdentity *)jarg2; 
12643
 
    LassoLogout_set_identity(arg1,arg2);
12644
 
    
12645
 
}
12646
 
 
12647
 
 
12648
 
DllExport void * SWIGSTDCALL CSharp_get_Logout_identity(void * jarg1) {
12649
 
    void * jresult = 0 ;
12650
 
    LassoLogout *arg1 = (LassoLogout *) 0 ;
12651
 
    LassoIdentity *result;
12652
 
    
12653
 
    arg1 = (LassoLogout *)jarg1; 
12654
 
    result = (LassoIdentity *)LassoLogout_get_identity(arg1);
12655
 
    
12656
 
    jresult = (void *)result; 
12657
 
    return jresult;
12658
 
}
12659
 
 
12660
 
 
12661
 
DllExport unsigned int SWIGSTDCALL CSharp_get_Logout_isIdentityDirty(void * jarg1) {
12662
 
    unsigned int jresult = 0 ;
12663
 
    LassoLogout *arg1 = (LassoLogout *) 0 ;
12664
 
    bool result;
12665
 
    
12666
 
    arg1 = (LassoLogout *)jarg1; 
12667
 
    result = (bool)LassoLogout_get_isIdentityDirty(arg1);
12668
 
    
12669
 
    jresult = result; 
12670
 
    return jresult;
12671
 
}
12672
 
 
12673
 
 
12674
 
DllExport unsigned int SWIGSTDCALL CSharp_get_Logout_isSessionDirty(void * jarg1) {
12675
 
    unsigned int jresult = 0 ;
12676
 
    LassoLogout *arg1 = (LassoLogout *) 0 ;
12677
 
    bool result;
12678
 
    
12679
 
    arg1 = (LassoLogout *)jarg1; 
12680
 
    result = (bool)LassoLogout_get_isSessionDirty(arg1);
12681
 
    
12682
 
    jresult = result; 
12683
 
    return jresult;
12684
 
}
12685
 
 
12686
 
 
12687
 
DllExport char * SWIGSTDCALL CSharp_get_Logout_msgBody(void * jarg1) {
12688
 
    char * jresult = 0 ;
12689
 
    LassoLogout *arg1 = (LassoLogout *) 0 ;
12690
 
    char *result;
12691
 
    
12692
 
    arg1 = (LassoLogout *)jarg1; 
12693
 
    result = (char *)LassoLogout_get_msgBody(arg1);
12694
 
    
12695
 
    jresult = SWIG_csharp_string_callback(result); 
12696
 
    return jresult;
12697
 
}
12698
 
 
12699
 
 
12700
 
DllExport char * SWIGSTDCALL CSharp_get_Logout_msgRelayState(void * jarg1) {
12701
 
    char * jresult = 0 ;
12702
 
    LassoLogout *arg1 = (LassoLogout *) 0 ;
12703
 
    char *result;
12704
 
    
12705
 
    arg1 = (LassoLogout *)jarg1; 
12706
 
    result = (char *)LassoLogout_get_msgRelayState(arg1);
12707
 
    
12708
 
    jresult = SWIG_csharp_string_callback(result); 
12709
 
    return jresult;
12710
 
}
12711
 
 
12712
 
 
12713
 
DllExport char * SWIGSTDCALL CSharp_get_Logout_msgUrl(void * jarg1) {
12714
 
    char * jresult = 0 ;
12715
 
    LassoLogout *arg1 = (LassoLogout *) 0 ;
12716
 
    char *result;
12717
 
    
12718
 
    arg1 = (LassoLogout *)jarg1; 
12719
 
    result = (char *)LassoLogout_get_msgUrl(arg1);
12720
 
    
12721
 
    jresult = SWIG_csharp_string_callback(result); 
12722
 
    return jresult;
12723
 
}
12724
 
 
12725
 
 
12726
 
DllExport void SWIGSTDCALL CSharp_set_Logout_nameIdentifier(void * jarg1, void * jarg2) {
12727
 
    LassoLogout *arg1 = (LassoLogout *) 0 ;
12728
 
    LassoSamlNameIdentifier *arg2 = (LassoSamlNameIdentifier *) 0 ;
12729
 
    
12730
 
    arg1 = (LassoLogout *)jarg1; 
12731
 
    arg2 = (LassoSamlNameIdentifier *)jarg2; 
12732
 
    LassoLogout_set_nameIdentifier(arg1,arg2);
12733
 
    
12734
 
}
12735
 
 
12736
 
 
12737
 
DllExport void * SWIGSTDCALL CSharp_get_Logout_nameIdentifier(void * jarg1) {
12738
 
    void * jresult = 0 ;
12739
 
    LassoLogout *arg1 = (LassoLogout *) 0 ;
12740
 
    LassoSamlNameIdentifier *result;
12741
 
    
12742
 
    arg1 = (LassoLogout *)jarg1; 
12743
 
    result = (LassoSamlNameIdentifier *)LassoLogout_get_nameIdentifier(arg1);
12744
 
    
12745
 
    jresult = (void *)result; 
12746
 
    return jresult;
12747
 
}
12748
 
 
12749
 
 
12750
 
DllExport void SWIGSTDCALL CSharp_set_Logout_remoteProviderId(void * jarg1, char * jarg2) {
12751
 
    LassoLogout *arg1 = (LassoLogout *) 0 ;
12752
 
    char *arg2 = (char *) 0 ;
12753
 
    
12754
 
    arg1 = (LassoLogout *)jarg1; 
12755
 
    arg2 = jarg2; 
12756
 
    LassoLogout_set_remoteProviderId(arg1,arg2);
12757
 
    
12758
 
}
12759
 
 
12760
 
 
12761
 
DllExport char * SWIGSTDCALL CSharp_get_Logout_remoteProviderId(void * jarg1) {
12762
 
    char * jresult = 0 ;
12763
 
    LassoLogout *arg1 = (LassoLogout *) 0 ;
12764
 
    char *result;
12765
 
    
12766
 
    arg1 = (LassoLogout *)jarg1; 
12767
 
    result = (char *)LassoLogout_get_remoteProviderId(arg1);
12768
 
    
12769
 
    jresult = SWIG_csharp_string_callback(result); 
12770
 
    return jresult;
12771
 
}
12772
 
 
12773
 
 
12774
 
DllExport void SWIGSTDCALL CSharp_set_Logout_request(void * jarg1, void * jarg2) {
12775
 
    LassoLogout *arg1 = (LassoLogout *) 0 ;
12776
 
    LassoSamlpRequestAbstract *arg2 = (LassoSamlpRequestAbstract *) 0 ;
12777
 
    
12778
 
    arg1 = (LassoLogout *)jarg1; 
12779
 
    arg2 = (LassoSamlpRequestAbstract *)jarg2; 
12780
 
    LassoLogout_set_request(arg1,arg2);
12781
 
    
12782
 
}
12783
 
 
12784
 
 
12785
 
DllExport void * SWIGSTDCALL CSharp_get_Logout_request(void * jarg1) {
12786
 
    void * jresult = 0 ;
12787
 
    LassoLogout *arg1 = (LassoLogout *) 0 ;
12788
 
    LassoSamlpRequestAbstract *result;
12789
 
    
12790
 
    arg1 = (LassoLogout *)jarg1; 
12791
 
    result = (LassoSamlpRequestAbstract *)LassoLogout_get_request(arg1);
12792
 
    
12793
 
    jresult = (void *)result; 
12794
 
    return jresult;
12795
 
}
12796
 
 
12797
 
 
12798
 
DllExport void SWIGSTDCALL CSharp_set_Logout_response(void * jarg1, void * jarg2) {
12799
 
    LassoLogout *arg1 = (LassoLogout *) 0 ;
12800
 
    LassoSamlpResponseAbstract *arg2 = (LassoSamlpResponseAbstract *) 0 ;
12801
 
    
12802
 
    arg1 = (LassoLogout *)jarg1; 
12803
 
    arg2 = (LassoSamlpResponseAbstract *)jarg2; 
12804
 
    LassoLogout_set_response(arg1,arg2);
12805
 
    
12806
 
}
12807
 
 
12808
 
 
12809
 
DllExport void * SWIGSTDCALL CSharp_get_Logout_response(void * jarg1) {
12810
 
    void * jresult = 0 ;
12811
 
    LassoLogout *arg1 = (LassoLogout *) 0 ;
12812
 
    LassoSamlpResponseAbstract *result;
12813
 
    
12814
 
    arg1 = (LassoLogout *)jarg1; 
12815
 
    result = (LassoSamlpResponseAbstract *)LassoLogout_get_response(arg1);
12816
 
    
12817
 
    jresult = (void *)result; 
12818
 
    return jresult;
12819
 
}
12820
 
 
12821
 
 
12822
 
DllExport void SWIGSTDCALL CSharp_set_Logout_server(void * jarg1, void * jarg2) {
12823
 
    LassoLogout *arg1 = (LassoLogout *) 0 ;
12824
 
    LassoServer *arg2 = (LassoServer *) 0 ;
12825
 
    
12826
 
    arg1 = (LassoLogout *)jarg1; 
12827
 
    arg2 = (LassoServer *)jarg2; 
12828
 
    LassoLogout_set_server(arg1,arg2);
12829
 
    
12830
 
}
12831
 
 
12832
 
 
12833
 
DllExport void * SWIGSTDCALL CSharp_get_Logout_server(void * jarg1) {
12834
 
    void * jresult = 0 ;
12835
 
    LassoLogout *arg1 = (LassoLogout *) 0 ;
12836
 
    LassoServer *result;
12837
 
    
12838
 
    arg1 = (LassoLogout *)jarg1; 
12839
 
    result = (LassoServer *)LassoLogout_get_server(arg1);
12840
 
    
12841
 
    jresult = (void *)result; 
12842
 
    return jresult;
12843
 
}
12844
 
 
12845
 
 
12846
 
DllExport void SWIGSTDCALL CSharp_set_Logout_session(void * jarg1, void * jarg2) {
12847
 
    LassoLogout *arg1 = (LassoLogout *) 0 ;
12848
 
    LassoSession *arg2 = (LassoSession *) 0 ;
12849
 
    
12850
 
    arg1 = (LassoLogout *)jarg1; 
12851
 
    arg2 = (LassoSession *)jarg2; 
12852
 
    LassoLogout_set_session(arg1,arg2);
12853
 
    
12854
 
}
12855
 
 
12856
 
 
12857
 
DllExport void * SWIGSTDCALL CSharp_get_Logout_session(void * jarg1) {
12858
 
    void * jresult = 0 ;
12859
 
    LassoLogout *arg1 = (LassoLogout *) 0 ;
12860
 
    LassoSession *result;
12861
 
    
12862
 
    arg1 = (LassoLogout *)jarg1; 
12863
 
    result = (LassoSession *)LassoLogout_get_session(arg1);
12864
 
    
12865
 
    jresult = (void *)result; 
12866
 
    return jresult;
12867
 
}
12868
 
 
12869
 
 
12870
 
DllExport void * SWIGSTDCALL CSharp_new_Logout(void * jarg1) {
12871
 
    void * jresult = 0 ;
12872
 
    LassoServer *arg1 = (LassoServer *) 0 ;
12873
 
    LassoLogout *result;
12874
 
    
12875
 
    arg1 = (LassoServer *)jarg1; 
12876
 
    result = (LassoLogout *)new_LassoLogout(arg1);
12877
 
    
12878
 
    jresult = (void *)result; 
12879
 
    return jresult;
12880
 
}
12881
 
 
12882
 
 
12883
 
DllExport void SWIGSTDCALL CSharp_delete_Logout(void * jarg1) {
12884
 
    LassoLogout *arg1 = (LassoLogout *) 0 ;
12885
 
    
12886
 
    arg1 = (LassoLogout *)jarg1; 
12887
 
    delete_LassoLogout(arg1);
12888
 
    
12889
 
}
12890
 
 
12891
 
 
12892
 
DllExport void * SWIGSTDCALL CSharp_Logout_newFromDump(void * jarg1, char * jarg2) {
12893
 
    void * jresult = 0 ;
12894
 
    LassoServer *arg1 = (LassoServer *) 0 ;
12895
 
    char *arg2 = (char *) 0 ;
12896
 
    LassoLogout *result;
12897
 
    
12898
 
    arg1 = (LassoServer *)jarg1; 
12899
 
    arg2 = jarg2; 
12900
 
    result = (LassoLogout *)Logout_newFromDump(arg1,arg2);
12901
 
    
12902
 
    jresult = (void *)result; 
12903
 
    return jresult;
12904
 
}
12905
 
 
12906
 
 
12907
 
DllExport int SWIGSTDCALL CSharp_Logout_setIdentityFromDump(void * jarg1, char * jarg2) {
12908
 
    int jresult = 0 ;
12909
 
    LassoLogout *arg1 = (LassoLogout *) 0 ;
12910
 
    char *arg2 = (char *) 0 ;
12911
 
    int result;
12912
 
    
12913
 
    arg1 = (LassoLogout *)jarg1; 
12914
 
    arg2 = jarg2; 
12915
 
    {
12916
 
        int errorCode;
12917
 
        errorCode = result = (int)LassoLogout_setIdentityFromDump(arg1,arg2);
12918
 
        
12919
 
        if (errorCode) {
12920
 
            char errorMsg[256];
12921
 
            build_exception_msg(errorCode, errorMsg);
12922
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
12923
 
        }
12924
 
    }
12925
 
    jresult = result; 
12926
 
    return jresult;
12927
 
}
12928
 
 
12929
 
 
12930
 
DllExport int SWIGSTDCALL CSharp_Logout_setSessionFromDump(void * jarg1, char * jarg2) {
12931
 
    int jresult = 0 ;
12932
 
    LassoLogout *arg1 = (LassoLogout *) 0 ;
12933
 
    char *arg2 = (char *) 0 ;
12934
 
    int result;
12935
 
    
12936
 
    arg1 = (LassoLogout *)jarg1; 
12937
 
    arg2 = jarg2; 
12938
 
    {
12939
 
        int errorCode;
12940
 
        errorCode = result = (int)LassoLogout_setSessionFromDump(arg1,arg2);
12941
 
        
12942
 
        if (errorCode) {
12943
 
            char errorMsg[256];
12944
 
            build_exception_msg(errorCode, errorMsg);
12945
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
12946
 
        }
12947
 
    }
12948
 
    jresult = result; 
12949
 
    return jresult;
12950
 
}
12951
 
 
12952
 
 
12953
 
DllExport int SWIGSTDCALL CSharp_Logout_buildRequestMsg(void * jarg1) {
12954
 
    int jresult = 0 ;
12955
 
    LassoLogout *arg1 = (LassoLogout *) 0 ;
12956
 
    int result;
12957
 
    
12958
 
    arg1 = (LassoLogout *)jarg1; 
12959
 
    {
12960
 
        int errorCode;
12961
 
        errorCode = result = (int)LassoLogout_buildRequestMsg(arg1);
12962
 
        
12963
 
        if (errorCode) {
12964
 
            char errorMsg[256];
12965
 
            build_exception_msg(errorCode, errorMsg);
12966
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
12967
 
        }
12968
 
    }
12969
 
    jresult = result; 
12970
 
    return jresult;
12971
 
}
12972
 
 
12973
 
 
12974
 
DllExport int SWIGSTDCALL CSharp_Logout_buildResponseMsg(void * jarg1) {
12975
 
    int jresult = 0 ;
12976
 
    LassoLogout *arg1 = (LassoLogout *) 0 ;
12977
 
    int result;
12978
 
    
12979
 
    arg1 = (LassoLogout *)jarg1; 
12980
 
    {
12981
 
        int errorCode;
12982
 
        errorCode = result = (int)LassoLogout_buildResponseMsg(arg1);
12983
 
        
12984
 
        if (errorCode) {
12985
 
            char errorMsg[256];
12986
 
            build_exception_msg(errorCode, errorMsg);
12987
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
12988
 
        }
12989
 
    }
12990
 
    jresult = result; 
12991
 
    return jresult;
12992
 
}
12993
 
 
12994
 
 
12995
 
DllExport char * SWIGSTDCALL CSharp_Logout_dump(void * jarg1) {
12996
 
    char * jresult = 0 ;
12997
 
    LassoLogout *arg1 = (LassoLogout *) 0 ;
12998
 
    char *result;
12999
 
    
13000
 
    arg1 = (LassoLogout *)jarg1; 
13001
 
    result = (char *)LassoLogout_dump(arg1);
13002
 
    
13003
 
    jresult = SWIG_csharp_string_callback(result); 
13004
 
    free(result);
13005
 
    return jresult;
13006
 
}
13007
 
 
13008
 
 
13009
 
DllExport char * SWIGSTDCALL CSharp_Logout_getNextProviderId(void * jarg1) {
13010
 
    char * jresult = 0 ;
13011
 
    LassoLogout *arg1 = (LassoLogout *) 0 ;
13012
 
    char *result;
13013
 
    
13014
 
    arg1 = (LassoLogout *)jarg1; 
13015
 
    result = (char *)LassoLogout_getNextProviderId(arg1);
13016
 
    
13017
 
    jresult = SWIG_csharp_string_callback(result); 
13018
 
    free(result);
13019
 
    return jresult;
13020
 
}
13021
 
 
13022
 
 
13023
 
DllExport int SWIGSTDCALL CSharp_Logout_initRequest(void * jarg1, char * jarg2, int jarg3) {
13024
 
    int jresult = 0 ;
13025
 
    LassoLogout *arg1 = (LassoLogout *) 0 ;
13026
 
    char *arg2 = (char *) NULL ;
13027
 
    LassoHttpMethod arg3 = (LassoHttpMethod) LASSO_HTTP_METHOD_ANY ;
13028
 
    int result;
13029
 
    
13030
 
    arg1 = (LassoLogout *)jarg1; 
13031
 
    arg2 = jarg2; 
13032
 
    arg3 = (LassoHttpMethod)jarg3; 
13033
 
    {
13034
 
        int errorCode;
13035
 
        errorCode = result = (int)LassoLogout_initRequest(arg1,arg2,(LassoHttpMethod )arg3);
13036
 
        
13037
 
        if (errorCode) {
13038
 
            char errorMsg[256];
13039
 
            build_exception_msg(errorCode, errorMsg);
13040
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
13041
 
        }
13042
 
    }
13043
 
    jresult = result; 
13044
 
    return jresult;
13045
 
}
13046
 
 
13047
 
 
13048
 
DllExport int SWIGSTDCALL CSharp_Logout_processRequestMsg(void * jarg1, char * jarg2) {
13049
 
    int jresult = 0 ;
13050
 
    LassoLogout *arg1 = (LassoLogout *) 0 ;
13051
 
    char *arg2 = (char *) 0 ;
13052
 
    int result;
13053
 
    
13054
 
    arg1 = (LassoLogout *)jarg1; 
13055
 
    arg2 = jarg2; 
13056
 
    {
13057
 
        int errorCode;
13058
 
        errorCode = result = (int)LassoLogout_processRequestMsg(arg1,arg2);
13059
 
        
13060
 
        if (errorCode) {
13061
 
            char errorMsg[256];
13062
 
            build_exception_msg(errorCode, errorMsg);
13063
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
13064
 
        }
13065
 
    }
13066
 
    jresult = result; 
13067
 
    return jresult;
13068
 
}
13069
 
 
13070
 
 
13071
 
DllExport int SWIGSTDCALL CSharp_Logout_processResponseMsg(void * jarg1, char * jarg2) {
13072
 
    int jresult = 0 ;
13073
 
    LassoLogout *arg1 = (LassoLogout *) 0 ;
13074
 
    char *arg2 = (char *) 0 ;
13075
 
    int result;
13076
 
    
13077
 
    arg1 = (LassoLogout *)jarg1; 
13078
 
    arg2 = jarg2; 
13079
 
    {
13080
 
        int errorCode;
13081
 
        errorCode = result = (int)LassoLogout_processResponseMsg(arg1,arg2);
13082
 
        
13083
 
        if (errorCode) {
13084
 
            char errorMsg[256];
13085
 
            build_exception_msg(errorCode, errorMsg);
13086
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
13087
 
        }
13088
 
    }
13089
 
    jresult = result; 
13090
 
    return jresult;
13091
 
}
13092
 
 
13093
 
 
13094
 
DllExport int SWIGSTDCALL CSharp_Logout_resetProviderIdIndex(void * jarg1) {
13095
 
    int jresult = 0 ;
13096
 
    LassoLogout *arg1 = (LassoLogout *) 0 ;
13097
 
    int result;
13098
 
    
13099
 
    arg1 = (LassoLogout *)jarg1; 
13100
 
    {
13101
 
        int errorCode;
13102
 
        errorCode = result = (int)LassoLogout_resetProviderIdIndex(arg1);
13103
 
        
13104
 
        if (errorCode) {
13105
 
            char errorMsg[256];
13106
 
            build_exception_msg(errorCode, errorMsg);
13107
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
13108
 
        }
13109
 
    }
13110
 
    jresult = result; 
13111
 
    return jresult;
13112
 
}
13113
 
 
13114
 
 
13115
 
DllExport int SWIGSTDCALL CSharp_Logout_validateRequest(void * jarg1) {
13116
 
    int jresult = 0 ;
13117
 
    LassoLogout *arg1 = (LassoLogout *) 0 ;
13118
 
    int result;
13119
 
    
13120
 
    arg1 = (LassoLogout *)jarg1; 
13121
 
    {
13122
 
        int errorCode;
13123
 
        errorCode = result = (int)LassoLogout_validateRequest(arg1);
13124
 
        
13125
 
        if (errorCode) {
13126
 
            char errorMsg[256];
13127
 
            build_exception_msg(errorCode, errorMsg);
13128
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
13129
 
        }
13130
 
    }
13131
 
    jresult = result; 
13132
 
    return jresult;
13133
 
}
13134
 
 
13135
 
 
13136
 
DllExport void SWIGSTDCALL CSharp_set_Lecp_identity(void * jarg1, void * jarg2) {
13137
 
    LassoLecp *arg1 = (LassoLecp *) 0 ;
13138
 
    LassoIdentity *arg2 = (LassoIdentity *) 0 ;
13139
 
    
13140
 
    arg1 = (LassoLecp *)jarg1; 
13141
 
    arg2 = (LassoIdentity *)jarg2; 
13142
 
    LassoLecp_set_identity(arg1,arg2);
13143
 
    
13144
 
}
13145
 
 
13146
 
 
13147
 
DllExport void * SWIGSTDCALL CSharp_get_Lecp_identity(void * jarg1) {
13148
 
    void * jresult = 0 ;
13149
 
    LassoLecp *arg1 = (LassoLecp *) 0 ;
13150
 
    LassoIdentity *result;
13151
 
    
13152
 
    arg1 = (LassoLecp *)jarg1; 
13153
 
    result = (LassoIdentity *)LassoLecp_get_identity(arg1);
13154
 
    
13155
 
    jresult = (void *)result; 
13156
 
    return jresult;
13157
 
}
13158
 
 
13159
 
 
13160
 
DllExport unsigned int SWIGSTDCALL CSharp_get_Lecp_isIdentityDirty(void * jarg1) {
13161
 
    unsigned int jresult = 0 ;
13162
 
    LassoLecp *arg1 = (LassoLecp *) 0 ;
13163
 
    bool result;
13164
 
    
13165
 
    arg1 = (LassoLecp *)jarg1; 
13166
 
    result = (bool)LassoLecp_get_isIdentityDirty(arg1);
13167
 
    
13168
 
    jresult = result; 
13169
 
    return jresult;
13170
 
}
13171
 
 
13172
 
 
13173
 
DllExport unsigned int SWIGSTDCALL CSharp_get_Lecp_isSessionDirty(void * jarg1) {
13174
 
    unsigned int jresult = 0 ;
13175
 
    LassoLecp *arg1 = (LassoLecp *) 0 ;
13176
 
    bool result;
13177
 
    
13178
 
    arg1 = (LassoLecp *)jarg1; 
13179
 
    result = (bool)LassoLecp_get_isSessionDirty(arg1);
13180
 
    
13181
 
    jresult = result; 
13182
 
    return jresult;
13183
 
}
13184
 
 
13185
 
 
13186
 
DllExport char * SWIGSTDCALL CSharp_get_Lecp_msgBody(void * jarg1) {
13187
 
    char * jresult = 0 ;
13188
 
    LassoLecp *arg1 = (LassoLecp *) 0 ;
13189
 
    char *result;
13190
 
    
13191
 
    arg1 = (LassoLecp *)jarg1; 
13192
 
    result = (char *)LassoLecp_get_msgBody(arg1);
13193
 
    
13194
 
    jresult = SWIG_csharp_string_callback(result); 
13195
 
    return jresult;
13196
 
}
13197
 
 
13198
 
 
13199
 
DllExport char * SWIGSTDCALL CSharp_get_Lecp_msgRelayState(void * jarg1) {
13200
 
    char * jresult = 0 ;
13201
 
    LassoLecp *arg1 = (LassoLecp *) 0 ;
13202
 
    char *result;
13203
 
    
13204
 
    arg1 = (LassoLecp *)jarg1; 
13205
 
    result = (char *)LassoLecp_get_msgRelayState(arg1);
13206
 
    
13207
 
    jresult = SWIG_csharp_string_callback(result); 
13208
 
    return jresult;
13209
 
}
13210
 
 
13211
 
 
13212
 
DllExport char * SWIGSTDCALL CSharp_get_Lecp_msgUrl(void * jarg1) {
13213
 
    char * jresult = 0 ;
13214
 
    LassoLecp *arg1 = (LassoLecp *) 0 ;
13215
 
    char *result;
13216
 
    
13217
 
    arg1 = (LassoLecp *)jarg1; 
13218
 
    result = (char *)LassoLecp_get_msgUrl(arg1);
13219
 
    
13220
 
    jresult = SWIG_csharp_string_callback(result); 
13221
 
    return jresult;
13222
 
}
13223
 
 
13224
 
 
13225
 
DllExport void SWIGSTDCALL CSharp_set_Lecp_nameIdentifier(void * jarg1, void * jarg2) {
13226
 
    LassoLecp *arg1 = (LassoLecp *) 0 ;
13227
 
    LassoSamlNameIdentifier *arg2 = (LassoSamlNameIdentifier *) 0 ;
13228
 
    
13229
 
    arg1 = (LassoLecp *)jarg1; 
13230
 
    arg2 = (LassoSamlNameIdentifier *)jarg2; 
13231
 
    LassoLecp_set_nameIdentifier(arg1,arg2);
13232
 
    
13233
 
}
13234
 
 
13235
 
 
13236
 
DllExport void * SWIGSTDCALL CSharp_get_Lecp_nameIdentifier(void * jarg1) {
13237
 
    void * jresult = 0 ;
13238
 
    LassoLecp *arg1 = (LassoLecp *) 0 ;
13239
 
    LassoSamlNameIdentifier *result;
13240
 
    
13241
 
    arg1 = (LassoLecp *)jarg1; 
13242
 
    result = (LassoSamlNameIdentifier *)LassoLecp_get_nameIdentifier(arg1);
13243
 
    
13244
 
    jresult = (void *)result; 
13245
 
    return jresult;
13246
 
}
13247
 
 
13248
 
 
13249
 
DllExport void SWIGSTDCALL CSharp_set_Lecp_remoteProviderId(void * jarg1, char * jarg2) {
13250
 
    LassoLecp *arg1 = (LassoLecp *) 0 ;
13251
 
    char *arg2 = (char *) 0 ;
13252
 
    
13253
 
    arg1 = (LassoLecp *)jarg1; 
13254
 
    arg2 = jarg2; 
13255
 
    LassoLecp_set_remoteProviderId(arg1,arg2);
13256
 
    
13257
 
}
13258
 
 
13259
 
 
13260
 
DllExport char * SWIGSTDCALL CSharp_get_Lecp_remoteProviderId(void * jarg1) {
13261
 
    char * jresult = 0 ;
13262
 
    LassoLecp *arg1 = (LassoLecp *) 0 ;
13263
 
    char *result;
13264
 
    
13265
 
    arg1 = (LassoLecp *)jarg1; 
13266
 
    result = (char *)LassoLecp_get_remoteProviderId(arg1);
13267
 
    
13268
 
    jresult = SWIG_csharp_string_callback(result); 
13269
 
    return jresult;
13270
 
}
13271
 
 
13272
 
 
13273
 
DllExport void SWIGSTDCALL CSharp_set_Lecp_request(void * jarg1, void * jarg2) {
13274
 
    LassoLecp *arg1 = (LassoLecp *) 0 ;
13275
 
    LassoSamlpRequestAbstract *arg2 = (LassoSamlpRequestAbstract *) 0 ;
13276
 
    
13277
 
    arg1 = (LassoLecp *)jarg1; 
13278
 
    arg2 = (LassoSamlpRequestAbstract *)jarg2; 
13279
 
    LassoLecp_set_request(arg1,arg2);
13280
 
    
13281
 
}
13282
 
 
13283
 
 
13284
 
DllExport void * SWIGSTDCALL CSharp_get_Lecp_request(void * jarg1) {
13285
 
    void * jresult = 0 ;
13286
 
    LassoLecp *arg1 = (LassoLecp *) 0 ;
13287
 
    LassoSamlpRequestAbstract *result;
13288
 
    
13289
 
    arg1 = (LassoLecp *)jarg1; 
13290
 
    result = (LassoSamlpRequestAbstract *)LassoLecp_get_request(arg1);
13291
 
    
13292
 
    jresult = (void *)result; 
13293
 
    return jresult;
13294
 
}
13295
 
 
13296
 
 
13297
 
DllExport void SWIGSTDCALL CSharp_set_Lecp_response(void * jarg1, void * jarg2) {
13298
 
    LassoLecp *arg1 = (LassoLecp *) 0 ;
13299
 
    LassoSamlpResponseAbstract *arg2 = (LassoSamlpResponseAbstract *) 0 ;
13300
 
    
13301
 
    arg1 = (LassoLecp *)jarg1; 
13302
 
    arg2 = (LassoSamlpResponseAbstract *)jarg2; 
13303
 
    LassoLecp_set_response(arg1,arg2);
13304
 
    
13305
 
}
13306
 
 
13307
 
 
13308
 
DllExport void * SWIGSTDCALL CSharp_get_Lecp_response(void * jarg1) {
13309
 
    void * jresult = 0 ;
13310
 
    LassoLecp *arg1 = (LassoLecp *) 0 ;
13311
 
    LassoSamlpResponseAbstract *result;
13312
 
    
13313
 
    arg1 = (LassoLecp *)jarg1; 
13314
 
    result = (LassoSamlpResponseAbstract *)LassoLecp_get_response(arg1);
13315
 
    
13316
 
    jresult = (void *)result; 
13317
 
    return jresult;
13318
 
}
13319
 
 
13320
 
 
13321
 
DllExport void SWIGSTDCALL CSharp_set_Lecp_server(void * jarg1, void * jarg2) {
13322
 
    LassoLecp *arg1 = (LassoLecp *) 0 ;
13323
 
    LassoServer *arg2 = (LassoServer *) 0 ;
13324
 
    
13325
 
    arg1 = (LassoLecp *)jarg1; 
13326
 
    arg2 = (LassoServer *)jarg2; 
13327
 
    LassoLecp_set_server(arg1,arg2);
13328
 
    
13329
 
}
13330
 
 
13331
 
 
13332
 
DllExport void * SWIGSTDCALL CSharp_get_Lecp_server(void * jarg1) {
13333
 
    void * jresult = 0 ;
13334
 
    LassoLecp *arg1 = (LassoLecp *) 0 ;
13335
 
    LassoServer *result;
13336
 
    
13337
 
    arg1 = (LassoLecp *)jarg1; 
13338
 
    result = (LassoServer *)LassoLecp_get_server(arg1);
13339
 
    
13340
 
    jresult = (void *)result; 
13341
 
    return jresult;
13342
 
}
13343
 
 
13344
 
 
13345
 
DllExport void SWIGSTDCALL CSharp_set_Lecp_session(void * jarg1, void * jarg2) {
13346
 
    LassoLecp *arg1 = (LassoLecp *) 0 ;
13347
 
    LassoSession *arg2 = (LassoSession *) 0 ;
13348
 
    
13349
 
    arg1 = (LassoLecp *)jarg1; 
13350
 
    arg2 = (LassoSession *)jarg2; 
13351
 
    LassoLecp_set_session(arg1,arg2);
13352
 
    
13353
 
}
13354
 
 
13355
 
 
13356
 
DllExport void * SWIGSTDCALL CSharp_get_Lecp_session(void * jarg1) {
13357
 
    void * jresult = 0 ;
13358
 
    LassoLecp *arg1 = (LassoLecp *) 0 ;
13359
 
    LassoSession *result;
13360
 
    
13361
 
    arg1 = (LassoLecp *)jarg1; 
13362
 
    result = (LassoSession *)LassoLecp_get_session(arg1);
13363
 
    
13364
 
    jresult = (void *)result; 
13365
 
    return jresult;
13366
 
}
13367
 
 
13368
 
 
13369
 
DllExport void * SWIGSTDCALL CSharp_new_Lecp(void * jarg1) {
13370
 
    void * jresult = 0 ;
13371
 
    LassoServer *arg1 = (LassoServer *) 0 ;
13372
 
    LassoLecp *result;
13373
 
    
13374
 
    arg1 = (LassoServer *)jarg1; 
13375
 
    result = (LassoLecp *)new_LassoLecp(arg1);
13376
 
    
13377
 
    jresult = (void *)result; 
13378
 
    return jresult;
13379
 
}
13380
 
 
13381
 
 
13382
 
DllExport void SWIGSTDCALL CSharp_delete_Lecp(void * jarg1) {
13383
 
    LassoLecp *arg1 = (LassoLecp *) 0 ;
13384
 
    
13385
 
    arg1 = (LassoLecp *)jarg1; 
13386
 
    delete_LassoLecp(arg1);
13387
 
    
13388
 
}
13389
 
 
13390
 
 
13391
 
DllExport int SWIGSTDCALL CSharp_Lecp_setIdentityFromDump(void * jarg1, char * jarg2) {
13392
 
    int jresult = 0 ;
13393
 
    LassoLecp *arg1 = (LassoLecp *) 0 ;
13394
 
    char *arg2 = (char *) 0 ;
13395
 
    int result;
13396
 
    
13397
 
    arg1 = (LassoLecp *)jarg1; 
13398
 
    arg2 = jarg2; 
13399
 
    {
13400
 
        int errorCode;
13401
 
        errorCode = result = (int)LassoLecp_setIdentityFromDump(arg1,arg2);
13402
 
        
13403
 
        if (errorCode) {
13404
 
            char errorMsg[256];
13405
 
            build_exception_msg(errorCode, errorMsg);
13406
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
13407
 
        }
13408
 
    }
13409
 
    jresult = result; 
13410
 
    return jresult;
13411
 
}
13412
 
 
13413
 
 
13414
 
DllExport int SWIGSTDCALL CSharp_Lecp_setSessionFromDump(void * jarg1, char * jarg2) {
13415
 
    int jresult = 0 ;
13416
 
    LassoLecp *arg1 = (LassoLecp *) 0 ;
13417
 
    char *arg2 = (char *) 0 ;
13418
 
    int result;
13419
 
    
13420
 
    arg1 = (LassoLecp *)jarg1; 
13421
 
    arg2 = jarg2; 
13422
 
    {
13423
 
        int errorCode;
13424
 
        errorCode = result = (int)LassoLecp_setSessionFromDump(arg1,arg2);
13425
 
        
13426
 
        if (errorCode) {
13427
 
            char errorMsg[256];
13428
 
            build_exception_msg(errorCode, errorMsg);
13429
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
13430
 
        }
13431
 
    }
13432
 
    jresult = result; 
13433
 
    return jresult;
13434
 
}
13435
 
 
13436
 
 
13437
 
DllExport int SWIGSTDCALL CSharp_Lecp_buildAssertion(void * jarg1, char * jarg2, char * jarg3, char * jarg4, char * jarg5, char * jarg6) {
13438
 
    int jresult = 0 ;
13439
 
    LassoLecp *arg1 = (LassoLecp *) 0 ;
13440
 
    char *arg2 = (char *) 0 ;
13441
 
    char *arg3 = (char *) 0 ;
13442
 
    char *arg4 = (char *) 0 ;
13443
 
    char *arg5 = (char *) 0 ;
13444
 
    char *arg6 = (char *) 0 ;
13445
 
    int result;
13446
 
    
13447
 
    arg1 = (LassoLecp *)jarg1; 
13448
 
    arg2 = jarg2; 
13449
 
    arg3 = jarg3; 
13450
 
    arg4 = jarg4; 
13451
 
    arg5 = jarg5; 
13452
 
    arg6 = jarg6; 
13453
 
    {
13454
 
        int errorCode;
13455
 
        errorCode = result = (int)LassoLecp_buildAssertion(arg1,arg2,arg3,arg4,arg5,arg6);
13456
 
        
13457
 
        if (errorCode) {
13458
 
            char errorMsg[256];
13459
 
            build_exception_msg(errorCode, errorMsg);
13460
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
13461
 
        }
13462
 
    }
13463
 
    jresult = result; 
13464
 
    return jresult;
13465
 
}
13466
 
 
13467
 
 
13468
 
DllExport int SWIGSTDCALL CSharp_Lecp_setResourceId(void * jarg1, char * jarg2) {
13469
 
    int jresult = 0 ;
13470
 
    LassoLecp *arg1 = (LassoLecp *) 0 ;
13471
 
    char *arg2 = (char *) 0 ;
13472
 
    int result;
13473
 
    
13474
 
    arg1 = (LassoLecp *)jarg1; 
13475
 
    arg2 = jarg2; 
13476
 
    {
13477
 
        int errorCode;
13478
 
        errorCode = result = (int)LassoLecp_setResourceId(arg1,arg2);
13479
 
        
13480
 
        if (errorCode) {
13481
 
            char errorMsg[256];
13482
 
            build_exception_msg(errorCode, errorMsg);
13483
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
13484
 
        }
13485
 
    }
13486
 
    jresult = result; 
13487
 
    return jresult;
13488
 
}
13489
 
 
13490
 
 
13491
 
DllExport int SWIGSTDCALL CSharp_Lecp_validateRequestMsg(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
13492
 
    int jresult = 0 ;
13493
 
    LassoLecp *arg1 = (LassoLecp *) 0 ;
13494
 
    bool arg2 ;
13495
 
    bool arg3 ;
13496
 
    int result;
13497
 
    
13498
 
    arg1 = (LassoLecp *)jarg1; 
13499
 
    arg2 = jarg2 ? true : false; 
13500
 
    arg3 = jarg3 ? true : false; 
13501
 
    {
13502
 
        int errorCode;
13503
 
        errorCode = result = (int)LassoLecp_validateRequestMsg(arg1,arg2,arg3);
13504
 
        
13505
 
        if (errorCode) {
13506
 
            char errorMsg[256];
13507
 
            build_exception_msg(errorCode, errorMsg);
13508
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
13509
 
        }
13510
 
    }
13511
 
    jresult = result; 
13512
 
    return jresult;
13513
 
}
13514
 
 
13515
 
 
13516
 
DllExport int SWIGSTDCALL CSharp_Lecp_buildAuthnRequestEnvelopeMsg(void * jarg1) {
13517
 
    int jresult = 0 ;
13518
 
    LassoLecp *arg1 = (LassoLecp *) 0 ;
13519
 
    int result;
13520
 
    
13521
 
    arg1 = (LassoLecp *)jarg1; 
13522
 
    {
13523
 
        int errorCode;
13524
 
        errorCode = result = (int)LassoLecp_buildAuthnRequestEnvelopeMsg(arg1);
13525
 
        
13526
 
        if (errorCode) {
13527
 
            char errorMsg[256];
13528
 
            build_exception_msg(errorCode, errorMsg);
13529
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
13530
 
        }
13531
 
    }
13532
 
    jresult = result; 
13533
 
    return jresult;
13534
 
}
13535
 
 
13536
 
 
13537
 
DllExport int SWIGSTDCALL CSharp_Lecp_buildAuthnRequestMsg(void * jarg1) {
13538
 
    int jresult = 0 ;
13539
 
    LassoLecp *arg1 = (LassoLecp *) 0 ;
13540
 
    int result;
13541
 
    
13542
 
    arg1 = (LassoLecp *)jarg1; 
13543
 
    {
13544
 
        int errorCode;
13545
 
        errorCode = result = (int)LassoLecp_buildAuthnRequestMsg(arg1);
13546
 
        
13547
 
        if (errorCode) {
13548
 
            char errorMsg[256];
13549
 
            build_exception_msg(errorCode, errorMsg);
13550
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
13551
 
        }
13552
 
    }
13553
 
    jresult = result; 
13554
 
    return jresult;
13555
 
}
13556
 
 
13557
 
 
13558
 
DllExport int SWIGSTDCALL CSharp_Lecp_buildAuthnResponseEnvelopeMsg(void * jarg1) {
13559
 
    int jresult = 0 ;
13560
 
    LassoLecp *arg1 = (LassoLecp *) 0 ;
13561
 
    int result;
13562
 
    
13563
 
    arg1 = (LassoLecp *)jarg1; 
13564
 
    {
13565
 
        int errorCode;
13566
 
        errorCode = result = (int)LassoLecp_buildAuthnResponseEnvelopeMsg(arg1);
13567
 
        
13568
 
        if (errorCode) {
13569
 
            char errorMsg[256];
13570
 
            build_exception_msg(errorCode, errorMsg);
13571
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
13572
 
        }
13573
 
    }
13574
 
    jresult = result; 
13575
 
    return jresult;
13576
 
}
13577
 
 
13578
 
 
13579
 
DllExport int SWIGSTDCALL CSharp_Lecp_buildAuthnResponseMsg(void * jarg1) {
13580
 
    int jresult = 0 ;
13581
 
    LassoLecp *arg1 = (LassoLecp *) 0 ;
13582
 
    int result;
13583
 
    
13584
 
    arg1 = (LassoLecp *)jarg1; 
13585
 
    {
13586
 
        int errorCode;
13587
 
        errorCode = result = (int)LassoLecp_buildAuthnResponseMsg(arg1);
13588
 
        
13589
 
        if (errorCode) {
13590
 
            char errorMsg[256];
13591
 
            build_exception_msg(errorCode, errorMsg);
13592
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
13593
 
        }
13594
 
    }
13595
 
    jresult = result; 
13596
 
    return jresult;
13597
 
}
13598
 
 
13599
 
 
13600
 
DllExport int SWIGSTDCALL CSharp_Lecp_initAuthnRequest(void * jarg1, char * jarg2) {
13601
 
    int jresult = 0 ;
13602
 
    LassoLecp *arg1 = (LassoLecp *) 0 ;
13603
 
    char *arg2 = (char *) NULL ;
13604
 
    int result;
13605
 
    
13606
 
    arg1 = (LassoLecp *)jarg1; 
13607
 
    arg2 = jarg2; 
13608
 
    {
13609
 
        int errorCode;
13610
 
        errorCode = result = (int)LassoLecp_initAuthnRequest(arg1,arg2);
13611
 
        
13612
 
        if (errorCode) {
13613
 
            char errorMsg[256];
13614
 
            build_exception_msg(errorCode, errorMsg);
13615
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
13616
 
        }
13617
 
    }
13618
 
    jresult = result; 
13619
 
    return jresult;
13620
 
}
13621
 
 
13622
 
 
13623
 
DllExport int SWIGSTDCALL CSharp_Lecp_processAuthnRequestEnvelopeMsg(void * jarg1, char * jarg2) {
13624
 
    int jresult = 0 ;
13625
 
    LassoLecp *arg1 = (LassoLecp *) 0 ;
13626
 
    char *arg2 = (char *) 0 ;
13627
 
    int result;
13628
 
    
13629
 
    arg1 = (LassoLecp *)jarg1; 
13630
 
    arg2 = jarg2; 
13631
 
    {
13632
 
        int errorCode;
13633
 
        errorCode = result = (int)LassoLecp_processAuthnRequestEnvelopeMsg(arg1,arg2);
13634
 
        
13635
 
        if (errorCode) {
13636
 
            char errorMsg[256];
13637
 
            build_exception_msg(errorCode, errorMsg);
13638
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
13639
 
        }
13640
 
    }
13641
 
    jresult = result; 
13642
 
    return jresult;
13643
 
}
13644
 
 
13645
 
 
13646
 
DllExport int SWIGSTDCALL CSharp_Lecp_processAuthnRequestMsg(void * jarg1, char * jarg2) {
13647
 
    int jresult = 0 ;
13648
 
    LassoLecp *arg1 = (LassoLecp *) 0 ;
13649
 
    char *arg2 = (char *) 0 ;
13650
 
    int result;
13651
 
    
13652
 
    arg1 = (LassoLecp *)jarg1; 
13653
 
    arg2 = jarg2; 
13654
 
    {
13655
 
        int errorCode;
13656
 
        errorCode = result = (int)LassoLecp_processAuthnRequestMsg(arg1,arg2);
13657
 
        
13658
 
        if (errorCode) {
13659
 
            char errorMsg[256];
13660
 
            build_exception_msg(errorCode, errorMsg);
13661
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
13662
 
        }
13663
 
    }
13664
 
    jresult = result; 
13665
 
    return jresult;
13666
 
}
13667
 
 
13668
 
 
13669
 
DllExport int SWIGSTDCALL CSharp_Lecp_processAuthnResponseEnvelopeMsg(void * jarg1, char * jarg2) {
13670
 
    int jresult = 0 ;
13671
 
    LassoLecp *arg1 = (LassoLecp *) 0 ;
13672
 
    char *arg2 = (char *) 0 ;
13673
 
    int result;
13674
 
    
13675
 
    arg1 = (LassoLecp *)jarg1; 
13676
 
    arg2 = jarg2; 
13677
 
    {
13678
 
        int errorCode;
13679
 
        errorCode = result = (int)LassoLecp_processAuthnResponseEnvelopeMsg(arg1,arg2);
13680
 
        
13681
 
        if (errorCode) {
13682
 
            char errorMsg[256];
13683
 
            build_exception_msg(errorCode, errorMsg);
13684
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
13685
 
        }
13686
 
    }
13687
 
    jresult = result; 
13688
 
    return jresult;
13689
 
}
13690
 
 
13691
 
 
13692
 
DllExport char * SWIGSTDCALL CSharp_get_NameIdentifierMapping_targetNameIdentifier(void * jarg1) {
13693
 
    char * jresult = 0 ;
13694
 
    LassoNameIdentifierMapping *arg1 = (LassoNameIdentifierMapping *) 0 ;
13695
 
    char *result;
13696
 
    
13697
 
    arg1 = (LassoNameIdentifierMapping *)jarg1; 
13698
 
    result = (char *) ((arg1)->targetNameIdentifier);
13699
 
    
13700
 
    jresult = SWIG_csharp_string_callback(result); 
13701
 
    return jresult;
13702
 
}
13703
 
 
13704
 
 
13705
 
DllExport void SWIGSTDCALL CSharp_set_NameIdentifierMapping_identity(void * jarg1, void * jarg2) {
13706
 
    LassoNameIdentifierMapping *arg1 = (LassoNameIdentifierMapping *) 0 ;
13707
 
    LassoIdentity *arg2 = (LassoIdentity *) 0 ;
13708
 
    
13709
 
    arg1 = (LassoNameIdentifierMapping *)jarg1; 
13710
 
    arg2 = (LassoIdentity *)jarg2; 
13711
 
    LassoNameIdentifierMapping_set_identity(arg1,arg2);
13712
 
    
13713
 
}
13714
 
 
13715
 
 
13716
 
DllExport void * SWIGSTDCALL CSharp_get_NameIdentifierMapping_identity(void * jarg1) {
13717
 
    void * jresult = 0 ;
13718
 
    LassoNameIdentifierMapping *arg1 = (LassoNameIdentifierMapping *) 0 ;
13719
 
    LassoIdentity *result;
13720
 
    
13721
 
    arg1 = (LassoNameIdentifierMapping *)jarg1; 
13722
 
    result = (LassoIdentity *)LassoNameIdentifierMapping_get_identity(arg1);
13723
 
    
13724
 
    jresult = (void *)result; 
13725
 
    return jresult;
13726
 
}
13727
 
 
13728
 
 
13729
 
DllExport unsigned int SWIGSTDCALL CSharp_get_NameIdentifierMapping_isIdentityDirty(void * jarg1) {
13730
 
    unsigned int jresult = 0 ;
13731
 
    LassoNameIdentifierMapping *arg1 = (LassoNameIdentifierMapping *) 0 ;
13732
 
    bool result;
13733
 
    
13734
 
    arg1 = (LassoNameIdentifierMapping *)jarg1; 
13735
 
    result = (bool)LassoNameIdentifierMapping_get_isIdentityDirty(arg1);
13736
 
    
13737
 
    jresult = result; 
13738
 
    return jresult;
13739
 
}
13740
 
 
13741
 
 
13742
 
DllExport unsigned int SWIGSTDCALL CSharp_get_NameIdentifierMapping_isSessionDirty(void * jarg1) {
13743
 
    unsigned int jresult = 0 ;
13744
 
    LassoNameIdentifierMapping *arg1 = (LassoNameIdentifierMapping *) 0 ;
13745
 
    bool result;
13746
 
    
13747
 
    arg1 = (LassoNameIdentifierMapping *)jarg1; 
13748
 
    result = (bool)LassoNameIdentifierMapping_get_isSessionDirty(arg1);
13749
 
    
13750
 
    jresult = result; 
13751
 
    return jresult;
13752
 
}
13753
 
 
13754
 
 
13755
 
DllExport char * SWIGSTDCALL CSharp_get_NameIdentifierMapping_msgBody(void * jarg1) {
13756
 
    char * jresult = 0 ;
13757
 
    LassoNameIdentifierMapping *arg1 = (LassoNameIdentifierMapping *) 0 ;
13758
 
    char *result;
13759
 
    
13760
 
    arg1 = (LassoNameIdentifierMapping *)jarg1; 
13761
 
    result = (char *)LassoNameIdentifierMapping_get_msgBody(arg1);
13762
 
    
13763
 
    jresult = SWIG_csharp_string_callback(result); 
13764
 
    return jresult;
13765
 
}
13766
 
 
13767
 
 
13768
 
DllExport char * SWIGSTDCALL CSharp_get_NameIdentifierMapping_msgUrl(void * jarg1) {
13769
 
    char * jresult = 0 ;
13770
 
    LassoNameIdentifierMapping *arg1 = (LassoNameIdentifierMapping *) 0 ;
13771
 
    char *result;
13772
 
    
13773
 
    arg1 = (LassoNameIdentifierMapping *)jarg1; 
13774
 
    result = (char *)LassoNameIdentifierMapping_get_msgUrl(arg1);
13775
 
    
13776
 
    jresult = SWIG_csharp_string_callback(result); 
13777
 
    return jresult;
13778
 
}
13779
 
 
13780
 
 
13781
 
DllExport void SWIGSTDCALL CSharp_set_NameIdentifierMapping_nameIdentifier(void * jarg1, void * jarg2) {
13782
 
    LassoNameIdentifierMapping *arg1 = (LassoNameIdentifierMapping *) 0 ;
13783
 
    LassoSamlNameIdentifier *arg2 = (LassoSamlNameIdentifier *) 0 ;
13784
 
    
13785
 
    arg1 = (LassoNameIdentifierMapping *)jarg1; 
13786
 
    arg2 = (LassoSamlNameIdentifier *)jarg2; 
13787
 
    LassoNameIdentifierMapping_set_nameIdentifier(arg1,arg2);
13788
 
    
13789
 
}
13790
 
 
13791
 
 
13792
 
DllExport void * SWIGSTDCALL CSharp_get_NameIdentifierMapping_nameIdentifier(void * jarg1) {
13793
 
    void * jresult = 0 ;
13794
 
    LassoNameIdentifierMapping *arg1 = (LassoNameIdentifierMapping *) 0 ;
13795
 
    LassoSamlNameIdentifier *result;
13796
 
    
13797
 
    arg1 = (LassoNameIdentifierMapping *)jarg1; 
13798
 
    result = (LassoSamlNameIdentifier *)LassoNameIdentifierMapping_get_nameIdentifier(arg1);
13799
 
    
13800
 
    jresult = (void *)result; 
13801
 
    return jresult;
13802
 
}
13803
 
 
13804
 
 
13805
 
DllExport void SWIGSTDCALL CSharp_set_NameIdentifierMapping_remoteProviderId(void * jarg1, char * jarg2) {
13806
 
    LassoNameIdentifierMapping *arg1 = (LassoNameIdentifierMapping *) 0 ;
13807
 
    char *arg2 = (char *) 0 ;
13808
 
    
13809
 
    arg1 = (LassoNameIdentifierMapping *)jarg1; 
13810
 
    arg2 = jarg2; 
13811
 
    LassoNameIdentifierMapping_set_remoteProviderId(arg1,arg2);
13812
 
    
13813
 
}
13814
 
 
13815
 
 
13816
 
DllExport char * SWIGSTDCALL CSharp_get_NameIdentifierMapping_remoteProviderId(void * jarg1) {
13817
 
    char * jresult = 0 ;
13818
 
    LassoNameIdentifierMapping *arg1 = (LassoNameIdentifierMapping *) 0 ;
13819
 
    char *result;
13820
 
    
13821
 
    arg1 = (LassoNameIdentifierMapping *)jarg1; 
13822
 
    result = (char *)LassoNameIdentifierMapping_get_remoteProviderId(arg1);
13823
 
    
13824
 
    jresult = SWIG_csharp_string_callback(result); 
13825
 
    return jresult;
13826
 
}
13827
 
 
13828
 
 
13829
 
DllExport void SWIGSTDCALL CSharp_set_NameIdentifierMapping_request(void * jarg1, void * jarg2) {
13830
 
    LassoNameIdentifierMapping *arg1 = (LassoNameIdentifierMapping *) 0 ;
13831
 
    LassoSamlpRequestAbstract *arg2 = (LassoSamlpRequestAbstract *) 0 ;
13832
 
    
13833
 
    arg1 = (LassoNameIdentifierMapping *)jarg1; 
13834
 
    arg2 = (LassoSamlpRequestAbstract *)jarg2; 
13835
 
    LassoNameIdentifierMapping_set_request(arg1,arg2);
13836
 
    
13837
 
}
13838
 
 
13839
 
 
13840
 
DllExport void * SWIGSTDCALL CSharp_get_NameIdentifierMapping_request(void * jarg1) {
13841
 
    void * jresult = 0 ;
13842
 
    LassoNameIdentifierMapping *arg1 = (LassoNameIdentifierMapping *) 0 ;
13843
 
    LassoSamlpRequestAbstract *result;
13844
 
    
13845
 
    arg1 = (LassoNameIdentifierMapping *)jarg1; 
13846
 
    result = (LassoSamlpRequestAbstract *)LassoNameIdentifierMapping_get_request(arg1);
13847
 
    
13848
 
    jresult = (void *)result; 
13849
 
    return jresult;
13850
 
}
13851
 
 
13852
 
 
13853
 
DllExport void SWIGSTDCALL CSharp_set_NameIdentifierMapping_response(void * jarg1, void * jarg2) {
13854
 
    LassoNameIdentifierMapping *arg1 = (LassoNameIdentifierMapping *) 0 ;
13855
 
    LassoSamlpResponseAbstract *arg2 = (LassoSamlpResponseAbstract *) 0 ;
13856
 
    
13857
 
    arg1 = (LassoNameIdentifierMapping *)jarg1; 
13858
 
    arg2 = (LassoSamlpResponseAbstract *)jarg2; 
13859
 
    LassoNameIdentifierMapping_set_response(arg1,arg2);
13860
 
    
13861
 
}
13862
 
 
13863
 
 
13864
 
DllExport void * SWIGSTDCALL CSharp_get_NameIdentifierMapping_response(void * jarg1) {
13865
 
    void * jresult = 0 ;
13866
 
    LassoNameIdentifierMapping *arg1 = (LassoNameIdentifierMapping *) 0 ;
13867
 
    LassoSamlpResponseAbstract *result;
13868
 
    
13869
 
    arg1 = (LassoNameIdentifierMapping *)jarg1; 
13870
 
    result = (LassoSamlpResponseAbstract *)LassoNameIdentifierMapping_get_response(arg1);
13871
 
    
13872
 
    jresult = (void *)result; 
13873
 
    return jresult;
13874
 
}
13875
 
 
13876
 
 
13877
 
DllExport void SWIGSTDCALL CSharp_set_NameIdentifierMapping_server(void * jarg1, void * jarg2) {
13878
 
    LassoNameIdentifierMapping *arg1 = (LassoNameIdentifierMapping *) 0 ;
13879
 
    LassoServer *arg2 = (LassoServer *) 0 ;
13880
 
    
13881
 
    arg1 = (LassoNameIdentifierMapping *)jarg1; 
13882
 
    arg2 = (LassoServer *)jarg2; 
13883
 
    LassoNameIdentifierMapping_set_server(arg1,arg2);
13884
 
    
13885
 
}
13886
 
 
13887
 
 
13888
 
DllExport void * SWIGSTDCALL CSharp_get_NameIdentifierMapping_server(void * jarg1) {
13889
 
    void * jresult = 0 ;
13890
 
    LassoNameIdentifierMapping *arg1 = (LassoNameIdentifierMapping *) 0 ;
13891
 
    LassoServer *result;
13892
 
    
13893
 
    arg1 = (LassoNameIdentifierMapping *)jarg1; 
13894
 
    result = (LassoServer *)LassoNameIdentifierMapping_get_server(arg1);
13895
 
    
13896
 
    jresult = (void *)result; 
13897
 
    return jresult;
13898
 
}
13899
 
 
13900
 
 
13901
 
DllExport void SWIGSTDCALL CSharp_set_NameIdentifierMapping_session(void * jarg1, void * jarg2) {
13902
 
    LassoNameIdentifierMapping *arg1 = (LassoNameIdentifierMapping *) 0 ;
13903
 
    LassoSession *arg2 = (LassoSession *) 0 ;
13904
 
    
13905
 
    arg1 = (LassoNameIdentifierMapping *)jarg1; 
13906
 
    arg2 = (LassoSession *)jarg2; 
13907
 
    LassoNameIdentifierMapping_set_session(arg1,arg2);
13908
 
    
13909
 
}
13910
 
 
13911
 
 
13912
 
DllExport void * SWIGSTDCALL CSharp_get_NameIdentifierMapping_session(void * jarg1) {
13913
 
    void * jresult = 0 ;
13914
 
    LassoNameIdentifierMapping *arg1 = (LassoNameIdentifierMapping *) 0 ;
13915
 
    LassoSession *result;
13916
 
    
13917
 
    arg1 = (LassoNameIdentifierMapping *)jarg1; 
13918
 
    result = (LassoSession *)LassoNameIdentifierMapping_get_session(arg1);
13919
 
    
13920
 
    jresult = (void *)result; 
13921
 
    return jresult;
13922
 
}
13923
 
 
13924
 
 
13925
 
DllExport void * SWIGSTDCALL CSharp_new_NameIdentifierMapping(void * jarg1) {
13926
 
    void * jresult = 0 ;
13927
 
    LassoServer *arg1 = (LassoServer *) 0 ;
13928
 
    LassoNameIdentifierMapping *result;
13929
 
    
13930
 
    arg1 = (LassoServer *)jarg1; 
13931
 
    result = (LassoNameIdentifierMapping *)new_LassoNameIdentifierMapping(arg1);
13932
 
    
13933
 
    jresult = (void *)result; 
13934
 
    return jresult;
13935
 
}
13936
 
 
13937
 
 
13938
 
DllExport void SWIGSTDCALL CSharp_delete_NameIdentifierMapping(void * jarg1) {
13939
 
    LassoNameIdentifierMapping *arg1 = (LassoNameIdentifierMapping *) 0 ;
13940
 
    
13941
 
    arg1 = (LassoNameIdentifierMapping *)jarg1; 
13942
 
    delete_LassoNameIdentifierMapping(arg1);
13943
 
    
13944
 
}
13945
 
 
13946
 
 
13947
 
DllExport int SWIGSTDCALL CSharp_NameIdentifierMapping_setIdentityFromDump(void * jarg1, char * jarg2) {
13948
 
    int jresult = 0 ;
13949
 
    LassoNameIdentifierMapping *arg1 = (LassoNameIdentifierMapping *) 0 ;
13950
 
    char *arg2 = (char *) 0 ;
13951
 
    int result;
13952
 
    
13953
 
    arg1 = (LassoNameIdentifierMapping *)jarg1; 
13954
 
    arg2 = jarg2; 
13955
 
    {
13956
 
        int errorCode;
13957
 
        errorCode = result = (int)LassoNameIdentifierMapping_setIdentityFromDump(arg1,arg2);
13958
 
        
13959
 
        if (errorCode) {
13960
 
            char errorMsg[256];
13961
 
            build_exception_msg(errorCode, errorMsg);
13962
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
13963
 
        }
13964
 
    }
13965
 
    jresult = result; 
13966
 
    return jresult;
13967
 
}
13968
 
 
13969
 
 
13970
 
DllExport int SWIGSTDCALL CSharp_NameIdentifierMapping_setSessionFromDump(void * jarg1, char * jarg2) {
13971
 
    int jresult = 0 ;
13972
 
    LassoNameIdentifierMapping *arg1 = (LassoNameIdentifierMapping *) 0 ;
13973
 
    char *arg2 = (char *) 0 ;
13974
 
    int result;
13975
 
    
13976
 
    arg1 = (LassoNameIdentifierMapping *)jarg1; 
13977
 
    arg2 = jarg2; 
13978
 
    {
13979
 
        int errorCode;
13980
 
        errorCode = result = (int)LassoNameIdentifierMapping_setSessionFromDump(arg1,arg2);
13981
 
        
13982
 
        if (errorCode) {
13983
 
            char errorMsg[256];
13984
 
            build_exception_msg(errorCode, errorMsg);
13985
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
13986
 
        }
13987
 
    }
13988
 
    jresult = result; 
13989
 
    return jresult;
13990
 
}
13991
 
 
13992
 
 
13993
 
DllExport int SWIGSTDCALL CSharp_NameIdentifierMapping_buildRequestMsg(void * jarg1) {
13994
 
    int jresult = 0 ;
13995
 
    LassoNameIdentifierMapping *arg1 = (LassoNameIdentifierMapping *) 0 ;
13996
 
    int result;
13997
 
    
13998
 
    arg1 = (LassoNameIdentifierMapping *)jarg1; 
13999
 
    {
14000
 
        int errorCode;
14001
 
        errorCode = result = (int)LassoNameIdentifierMapping_buildRequestMsg(arg1);
14002
 
        
14003
 
        if (errorCode) {
14004
 
            char errorMsg[256];
14005
 
            build_exception_msg(errorCode, errorMsg);
14006
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
14007
 
        }
14008
 
    }
14009
 
    jresult = result; 
14010
 
    return jresult;
14011
 
}
14012
 
 
14013
 
 
14014
 
DllExport int SWIGSTDCALL CSharp_NameIdentifierMapping_buildResponseMsg(void * jarg1) {
14015
 
    int jresult = 0 ;
14016
 
    LassoNameIdentifierMapping *arg1 = (LassoNameIdentifierMapping *) 0 ;
14017
 
    int result;
14018
 
    
14019
 
    arg1 = (LassoNameIdentifierMapping *)jarg1; 
14020
 
    {
14021
 
        int errorCode;
14022
 
        errorCode = result = (int)LassoNameIdentifierMapping_buildResponseMsg(arg1);
14023
 
        
14024
 
        if (errorCode) {
14025
 
            char errorMsg[256];
14026
 
            build_exception_msg(errorCode, errorMsg);
14027
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
14028
 
        }
14029
 
    }
14030
 
    jresult = result; 
14031
 
    return jresult;
14032
 
}
14033
 
 
14034
 
 
14035
 
DllExport int SWIGSTDCALL CSharp_NameIdentifierMapping_initRequest(void * jarg1, char * jarg2, char * jarg3) {
14036
 
    int jresult = 0 ;
14037
 
    LassoNameIdentifierMapping *arg1 = (LassoNameIdentifierMapping *) 0 ;
14038
 
    char *arg2 = (char *) 0 ;
14039
 
    char *arg3 = (char *) NULL ;
14040
 
    int result;
14041
 
    
14042
 
    arg1 = (LassoNameIdentifierMapping *)jarg1; 
14043
 
    arg2 = jarg2; 
14044
 
    arg3 = jarg3; 
14045
 
    {
14046
 
        int errorCode;
14047
 
        errorCode = result = (int)LassoNameIdentifierMapping_initRequest(arg1,arg2,arg3);
14048
 
        
14049
 
        if (errorCode) {
14050
 
            char errorMsg[256];
14051
 
            build_exception_msg(errorCode, errorMsg);
14052
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
14053
 
        }
14054
 
    }
14055
 
    jresult = result; 
14056
 
    return jresult;
14057
 
}
14058
 
 
14059
 
 
14060
 
DllExport int SWIGSTDCALL CSharp_NameIdentifierMapping_processRequestMsg(void * jarg1, char * jarg2) {
14061
 
    int jresult = 0 ;
14062
 
    LassoNameIdentifierMapping *arg1 = (LassoNameIdentifierMapping *) 0 ;
14063
 
    char *arg2 = (char *) 0 ;
14064
 
    int result;
14065
 
    
14066
 
    arg1 = (LassoNameIdentifierMapping *)jarg1; 
14067
 
    arg2 = jarg2; 
14068
 
    {
14069
 
        int errorCode;
14070
 
        errorCode = result = (int)LassoNameIdentifierMapping_processRequestMsg(arg1,arg2);
14071
 
        
14072
 
        if (errorCode) {
14073
 
            char errorMsg[256];
14074
 
            build_exception_msg(errorCode, errorMsg);
14075
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
14076
 
        }
14077
 
    }
14078
 
    jresult = result; 
14079
 
    return jresult;
14080
 
}
14081
 
 
14082
 
 
14083
 
DllExport int SWIGSTDCALL CSharp_NameIdentifierMapping_processResponseMsg(void * jarg1, char * jarg2) {
14084
 
    int jresult = 0 ;
14085
 
    LassoNameIdentifierMapping *arg1 = (LassoNameIdentifierMapping *) 0 ;
14086
 
    char *arg2 = (char *) 0 ;
14087
 
    int result;
14088
 
    
14089
 
    arg1 = (LassoNameIdentifierMapping *)jarg1; 
14090
 
    arg2 = jarg2; 
14091
 
    {
14092
 
        int errorCode;
14093
 
        errorCode = result = (int)LassoNameIdentifierMapping_processResponseMsg(arg1,arg2);
14094
 
        
14095
 
        if (errorCode) {
14096
 
            char errorMsg[256];
14097
 
            build_exception_msg(errorCode, errorMsg);
14098
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
14099
 
        }
14100
 
    }
14101
 
    jresult = result; 
14102
 
    return jresult;
14103
 
}
14104
 
 
14105
 
 
14106
 
DllExport int SWIGSTDCALL CSharp_NameIdentifierMapping_validateRequest(void * jarg1) {
14107
 
    int jresult = 0 ;
14108
 
    LassoNameIdentifierMapping *arg1 = (LassoNameIdentifierMapping *) 0 ;
14109
 
    int result;
14110
 
    
14111
 
    arg1 = (LassoNameIdentifierMapping *)jarg1; 
14112
 
    {
14113
 
        int errorCode;
14114
 
        errorCode = result = (int)LassoNameIdentifierMapping_validateRequest(arg1);
14115
 
        
14116
 
        if (errorCode) {
14117
 
            char errorMsg[256];
14118
 
            build_exception_msg(errorCode, errorMsg);
14119
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
14120
 
        }
14121
 
    }
14122
 
    jresult = result; 
14123
 
    return jresult;
14124
 
}
14125
 
 
14126
 
 
14127
 
DllExport void SWIGSTDCALL CSharp_set_NameRegistration_identity(void * jarg1, void * jarg2) {
14128
 
    LassoNameRegistration *arg1 = (LassoNameRegistration *) 0 ;
14129
 
    LassoIdentity *arg2 = (LassoIdentity *) 0 ;
14130
 
    
14131
 
    arg1 = (LassoNameRegistration *)jarg1; 
14132
 
    arg2 = (LassoIdentity *)jarg2; 
14133
 
    LassoNameRegistration_set_identity(arg1,arg2);
14134
 
    
14135
 
}
14136
 
 
14137
 
 
14138
 
DllExport void * SWIGSTDCALL CSharp_get_NameRegistration_identity(void * jarg1) {
14139
 
    void * jresult = 0 ;
14140
 
    LassoNameRegistration *arg1 = (LassoNameRegistration *) 0 ;
14141
 
    LassoIdentity *result;
14142
 
    
14143
 
    arg1 = (LassoNameRegistration *)jarg1; 
14144
 
    result = (LassoIdentity *)LassoNameRegistration_get_identity(arg1);
14145
 
    
14146
 
    jresult = (void *)result; 
14147
 
    return jresult;
14148
 
}
14149
 
 
14150
 
 
14151
 
DllExport unsigned int SWIGSTDCALL CSharp_get_NameRegistration_isIdentityDirty(void * jarg1) {
14152
 
    unsigned int jresult = 0 ;
14153
 
    LassoNameRegistration *arg1 = (LassoNameRegistration *) 0 ;
14154
 
    bool result;
14155
 
    
14156
 
    arg1 = (LassoNameRegistration *)jarg1; 
14157
 
    result = (bool)LassoNameRegistration_get_isIdentityDirty(arg1);
14158
 
    
14159
 
    jresult = result; 
14160
 
    return jresult;
14161
 
}
14162
 
 
14163
 
 
14164
 
DllExport unsigned int SWIGSTDCALL CSharp_get_NameRegistration_isSessionDirty(void * jarg1) {
14165
 
    unsigned int jresult = 0 ;
14166
 
    LassoNameRegistration *arg1 = (LassoNameRegistration *) 0 ;
14167
 
    bool result;
14168
 
    
14169
 
    arg1 = (LassoNameRegistration *)jarg1; 
14170
 
    result = (bool)LassoNameRegistration_get_isSessionDirty(arg1);
14171
 
    
14172
 
    jresult = result; 
14173
 
    return jresult;
14174
 
}
14175
 
 
14176
 
 
14177
 
DllExport char * SWIGSTDCALL CSharp_get_NameRegistration_msgBody(void * jarg1) {
14178
 
    char * jresult = 0 ;
14179
 
    LassoNameRegistration *arg1 = (LassoNameRegistration *) 0 ;
14180
 
    char *result;
14181
 
    
14182
 
    arg1 = (LassoNameRegistration *)jarg1; 
14183
 
    result = (char *)LassoNameRegistration_get_msgBody(arg1);
14184
 
    
14185
 
    jresult = SWIG_csharp_string_callback(result); 
14186
 
    return jresult;
14187
 
}
14188
 
 
14189
 
 
14190
 
DllExport char * SWIGSTDCALL CSharp_get_NameRegistration_msgRelayState(void * jarg1) {
14191
 
    char * jresult = 0 ;
14192
 
    LassoNameRegistration *arg1 = (LassoNameRegistration *) 0 ;
14193
 
    char *result;
14194
 
    
14195
 
    arg1 = (LassoNameRegistration *)jarg1; 
14196
 
    result = (char *)LassoNameRegistration_get_msgRelayState(arg1);
14197
 
    
14198
 
    jresult = SWIG_csharp_string_callback(result); 
14199
 
    return jresult;
14200
 
}
14201
 
 
14202
 
 
14203
 
DllExport char * SWIGSTDCALL CSharp_get_NameRegistration_msgUrl(void * jarg1) {
14204
 
    char * jresult = 0 ;
14205
 
    LassoNameRegistration *arg1 = (LassoNameRegistration *) 0 ;
14206
 
    char *result;
14207
 
    
14208
 
    arg1 = (LassoNameRegistration *)jarg1; 
14209
 
    result = (char *)LassoNameRegistration_get_msgUrl(arg1);
14210
 
    
14211
 
    jresult = SWIG_csharp_string_callback(result); 
14212
 
    return jresult;
14213
 
}
14214
 
 
14215
 
 
14216
 
DllExport void SWIGSTDCALL CSharp_set_NameRegistration_nameIdentifier(void * jarg1, void * jarg2) {
14217
 
    LassoNameRegistration *arg1 = (LassoNameRegistration *) 0 ;
14218
 
    LassoSamlNameIdentifier *arg2 = (LassoSamlNameIdentifier *) 0 ;
14219
 
    
14220
 
    arg1 = (LassoNameRegistration *)jarg1; 
14221
 
    arg2 = (LassoSamlNameIdentifier *)jarg2; 
14222
 
    LassoNameRegistration_set_nameIdentifier(arg1,arg2);
14223
 
    
14224
 
}
14225
 
 
14226
 
 
14227
 
DllExport void * SWIGSTDCALL CSharp_get_NameRegistration_nameIdentifier(void * jarg1) {
14228
 
    void * jresult = 0 ;
14229
 
    LassoNameRegistration *arg1 = (LassoNameRegistration *) 0 ;
14230
 
    LassoSamlNameIdentifier *result;
14231
 
    
14232
 
    arg1 = (LassoNameRegistration *)jarg1; 
14233
 
    result = (LassoSamlNameIdentifier *)LassoNameRegistration_get_nameIdentifier(arg1);
14234
 
    
14235
 
    jresult = (void *)result; 
14236
 
    return jresult;
14237
 
}
14238
 
 
14239
 
 
14240
 
DllExport void SWIGSTDCALL CSharp_set_NameRegistration_remoteProviderId(void * jarg1, char * jarg2) {
14241
 
    LassoNameRegistration *arg1 = (LassoNameRegistration *) 0 ;
14242
 
    char *arg2 = (char *) 0 ;
14243
 
    
14244
 
    arg1 = (LassoNameRegistration *)jarg1; 
14245
 
    arg2 = jarg2; 
14246
 
    LassoNameRegistration_set_remoteProviderId(arg1,arg2);
14247
 
    
14248
 
}
14249
 
 
14250
 
 
14251
 
DllExport char * SWIGSTDCALL CSharp_get_NameRegistration_remoteProviderId(void * jarg1) {
14252
 
    char * jresult = 0 ;
14253
 
    LassoNameRegistration *arg1 = (LassoNameRegistration *) 0 ;
14254
 
    char *result;
14255
 
    
14256
 
    arg1 = (LassoNameRegistration *)jarg1; 
14257
 
    result = (char *)LassoNameRegistration_get_remoteProviderId(arg1);
14258
 
    
14259
 
    jresult = SWIG_csharp_string_callback(result); 
14260
 
    return jresult;
14261
 
}
14262
 
 
14263
 
 
14264
 
DllExport void SWIGSTDCALL CSharp_set_NameRegistration_request(void * jarg1, void * jarg2) {
14265
 
    LassoNameRegistration *arg1 = (LassoNameRegistration *) 0 ;
14266
 
    LassoSamlpRequestAbstract *arg2 = (LassoSamlpRequestAbstract *) 0 ;
14267
 
    
14268
 
    arg1 = (LassoNameRegistration *)jarg1; 
14269
 
    arg2 = (LassoSamlpRequestAbstract *)jarg2; 
14270
 
    LassoNameRegistration_set_request(arg1,arg2);
14271
 
    
14272
 
}
14273
 
 
14274
 
 
14275
 
DllExport void * SWIGSTDCALL CSharp_get_NameRegistration_request(void * jarg1) {
14276
 
    void * jresult = 0 ;
14277
 
    LassoNameRegistration *arg1 = (LassoNameRegistration *) 0 ;
14278
 
    LassoSamlpRequestAbstract *result;
14279
 
    
14280
 
    arg1 = (LassoNameRegistration *)jarg1; 
14281
 
    result = (LassoSamlpRequestAbstract *)LassoNameRegistration_get_request(arg1);
14282
 
    
14283
 
    jresult = (void *)result; 
14284
 
    return jresult;
14285
 
}
14286
 
 
14287
 
 
14288
 
DllExport void SWIGSTDCALL CSharp_set_NameRegistration_response(void * jarg1, void * jarg2) {
14289
 
    LassoNameRegistration *arg1 = (LassoNameRegistration *) 0 ;
14290
 
    LassoSamlpResponseAbstract *arg2 = (LassoSamlpResponseAbstract *) 0 ;
14291
 
    
14292
 
    arg1 = (LassoNameRegistration *)jarg1; 
14293
 
    arg2 = (LassoSamlpResponseAbstract *)jarg2; 
14294
 
    LassoNameRegistration_set_response(arg1,arg2);
14295
 
    
14296
 
}
14297
 
 
14298
 
 
14299
 
DllExport void * SWIGSTDCALL CSharp_get_NameRegistration_response(void * jarg1) {
14300
 
    void * jresult = 0 ;
14301
 
    LassoNameRegistration *arg1 = (LassoNameRegistration *) 0 ;
14302
 
    LassoSamlpResponseAbstract *result;
14303
 
    
14304
 
    arg1 = (LassoNameRegistration *)jarg1; 
14305
 
    result = (LassoSamlpResponseAbstract *)LassoNameRegistration_get_response(arg1);
14306
 
    
14307
 
    jresult = (void *)result; 
14308
 
    return jresult;
14309
 
}
14310
 
 
14311
 
 
14312
 
DllExport void SWIGSTDCALL CSharp_set_NameRegistration_server(void * jarg1, void * jarg2) {
14313
 
    LassoNameRegistration *arg1 = (LassoNameRegistration *) 0 ;
14314
 
    LassoServer *arg2 = (LassoServer *) 0 ;
14315
 
    
14316
 
    arg1 = (LassoNameRegistration *)jarg1; 
14317
 
    arg2 = (LassoServer *)jarg2; 
14318
 
    LassoNameRegistration_set_server(arg1,arg2);
14319
 
    
14320
 
}
14321
 
 
14322
 
 
14323
 
DllExport void * SWIGSTDCALL CSharp_get_NameRegistration_server(void * jarg1) {
14324
 
    void * jresult = 0 ;
14325
 
    LassoNameRegistration *arg1 = (LassoNameRegistration *) 0 ;
14326
 
    LassoServer *result;
14327
 
    
14328
 
    arg1 = (LassoNameRegistration *)jarg1; 
14329
 
    result = (LassoServer *)LassoNameRegistration_get_server(arg1);
14330
 
    
14331
 
    jresult = (void *)result; 
14332
 
    return jresult;
14333
 
}
14334
 
 
14335
 
 
14336
 
DllExport void SWIGSTDCALL CSharp_set_NameRegistration_session(void * jarg1, void * jarg2) {
14337
 
    LassoNameRegistration *arg1 = (LassoNameRegistration *) 0 ;
14338
 
    LassoSession *arg2 = (LassoSession *) 0 ;
14339
 
    
14340
 
    arg1 = (LassoNameRegistration *)jarg1; 
14341
 
    arg2 = (LassoSession *)jarg2; 
14342
 
    LassoNameRegistration_set_session(arg1,arg2);
14343
 
    
14344
 
}
14345
 
 
14346
 
 
14347
 
DllExport void * SWIGSTDCALL CSharp_get_NameRegistration_session(void * jarg1) {
14348
 
    void * jresult = 0 ;
14349
 
    LassoNameRegistration *arg1 = (LassoNameRegistration *) 0 ;
14350
 
    LassoSession *result;
14351
 
    
14352
 
    arg1 = (LassoNameRegistration *)jarg1; 
14353
 
    result = (LassoSession *)LassoNameRegistration_get_session(arg1);
14354
 
    
14355
 
    jresult = (void *)result; 
14356
 
    return jresult;
14357
 
}
14358
 
 
14359
 
 
14360
 
DllExport void SWIGSTDCALL CSharp_set_NameRegistration_oldNameIdentifier(void * jarg1, void * jarg2) {
14361
 
    LassoNameRegistration *arg1 = (LassoNameRegistration *) 0 ;
14362
 
    LassoSamlNameIdentifier *arg2 = (LassoSamlNameIdentifier *) 0 ;
14363
 
    
14364
 
    arg1 = (LassoNameRegistration *)jarg1; 
14365
 
    arg2 = (LassoSamlNameIdentifier *)jarg2; 
14366
 
    LassoNameRegistration_set_oldNameIdentifier(arg1,arg2);
14367
 
    
14368
 
}
14369
 
 
14370
 
 
14371
 
DllExport void * SWIGSTDCALL CSharp_get_NameRegistration_oldNameIdentifier(void * jarg1) {
14372
 
    void * jresult = 0 ;
14373
 
    LassoNameRegistration *arg1 = (LassoNameRegistration *) 0 ;
14374
 
    LassoSamlNameIdentifier *result;
14375
 
    
14376
 
    arg1 = (LassoNameRegistration *)jarg1; 
14377
 
    result = (LassoSamlNameIdentifier *)LassoNameRegistration_get_oldNameIdentifier(arg1);
14378
 
    
14379
 
    jresult = (void *)result; 
14380
 
    return jresult;
14381
 
}
14382
 
 
14383
 
 
14384
 
DllExport void * SWIGSTDCALL CSharp_new_NameRegistration(void * jarg1) {
14385
 
    void * jresult = 0 ;
14386
 
    LassoServer *arg1 = (LassoServer *) 0 ;
14387
 
    LassoNameRegistration *result;
14388
 
    
14389
 
    arg1 = (LassoServer *)jarg1; 
14390
 
    result = (LassoNameRegistration *)new_LassoNameRegistration(arg1);
14391
 
    
14392
 
    jresult = (void *)result; 
14393
 
    return jresult;
14394
 
}
14395
 
 
14396
 
 
14397
 
DllExport void SWIGSTDCALL CSharp_delete_NameRegistration(void * jarg1) {
14398
 
    LassoNameRegistration *arg1 = (LassoNameRegistration *) 0 ;
14399
 
    
14400
 
    arg1 = (LassoNameRegistration *)jarg1; 
14401
 
    delete_LassoNameRegistration(arg1);
14402
 
    
14403
 
}
14404
 
 
14405
 
 
14406
 
DllExport void * SWIGSTDCALL CSharp_NameRegistration_newFromDump(void * jarg1, char * jarg2) {
14407
 
    void * jresult = 0 ;
14408
 
    LassoServer *arg1 = (LassoServer *) 0 ;
14409
 
    char *arg2 = (char *) 0 ;
14410
 
    LassoNameRegistration *result;
14411
 
    
14412
 
    arg1 = (LassoServer *)jarg1; 
14413
 
    arg2 = jarg2; 
14414
 
    result = (LassoNameRegistration *)NameRegistration_newFromDump(arg1,arg2);
14415
 
    
14416
 
    jresult = (void *)result; 
14417
 
    return jresult;
14418
 
}
14419
 
 
14420
 
 
14421
 
DllExport int SWIGSTDCALL CSharp_NameRegistration_setIdentityFromDump(void * jarg1, char * jarg2) {
14422
 
    int jresult = 0 ;
14423
 
    LassoNameRegistration *arg1 = (LassoNameRegistration *) 0 ;
14424
 
    char *arg2 = (char *) 0 ;
14425
 
    int result;
14426
 
    
14427
 
    arg1 = (LassoNameRegistration *)jarg1; 
14428
 
    arg2 = jarg2; 
14429
 
    {
14430
 
        int errorCode;
14431
 
        errorCode = result = (int)LassoNameRegistration_setIdentityFromDump(arg1,arg2);
14432
 
        
14433
 
        if (errorCode) {
14434
 
            char errorMsg[256];
14435
 
            build_exception_msg(errorCode, errorMsg);
14436
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
14437
 
        }
14438
 
    }
14439
 
    jresult = result; 
14440
 
    return jresult;
14441
 
}
14442
 
 
14443
 
 
14444
 
DllExport int SWIGSTDCALL CSharp_NameRegistration_setSessionFromDump(void * jarg1, char * jarg2) {
14445
 
    int jresult = 0 ;
14446
 
    LassoNameRegistration *arg1 = (LassoNameRegistration *) 0 ;
14447
 
    char *arg2 = (char *) 0 ;
14448
 
    int result;
14449
 
    
14450
 
    arg1 = (LassoNameRegistration *)jarg1; 
14451
 
    arg2 = jarg2; 
14452
 
    {
14453
 
        int errorCode;
14454
 
        errorCode = result = (int)LassoNameRegistration_setSessionFromDump(arg1,arg2);
14455
 
        
14456
 
        if (errorCode) {
14457
 
            char errorMsg[256];
14458
 
            build_exception_msg(errorCode, errorMsg);
14459
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
14460
 
        }
14461
 
    }
14462
 
    jresult = result; 
14463
 
    return jresult;
14464
 
}
14465
 
 
14466
 
 
14467
 
DllExport int SWIGSTDCALL CSharp_NameRegistration_buildRequestMsg(void * jarg1) {
14468
 
    int jresult = 0 ;
14469
 
    LassoNameRegistration *arg1 = (LassoNameRegistration *) 0 ;
14470
 
    int result;
14471
 
    
14472
 
    arg1 = (LassoNameRegistration *)jarg1; 
14473
 
    {
14474
 
        int errorCode;
14475
 
        errorCode = result = (int)LassoNameRegistration_buildRequestMsg(arg1);
14476
 
        
14477
 
        if (errorCode) {
14478
 
            char errorMsg[256];
14479
 
            build_exception_msg(errorCode, errorMsg);
14480
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
14481
 
        }
14482
 
    }
14483
 
    jresult = result; 
14484
 
    return jresult;
14485
 
}
14486
 
 
14487
 
 
14488
 
DllExport int SWIGSTDCALL CSharp_NameRegistration_buildResponseMsg(void * jarg1) {
14489
 
    int jresult = 0 ;
14490
 
    LassoNameRegistration *arg1 = (LassoNameRegistration *) 0 ;
14491
 
    int result;
14492
 
    
14493
 
    arg1 = (LassoNameRegistration *)jarg1; 
14494
 
    {
14495
 
        int errorCode;
14496
 
        errorCode = result = (int)LassoNameRegistration_buildResponseMsg(arg1);
14497
 
        
14498
 
        if (errorCode) {
14499
 
            char errorMsg[256];
14500
 
            build_exception_msg(errorCode, errorMsg);
14501
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
14502
 
        }
14503
 
    }
14504
 
    jresult = result; 
14505
 
    return jresult;
14506
 
}
14507
 
 
14508
 
 
14509
 
DllExport char * SWIGSTDCALL CSharp_NameRegistration_dump(void * jarg1) {
14510
 
    char * jresult = 0 ;
14511
 
    LassoNameRegistration *arg1 = (LassoNameRegistration *) 0 ;
14512
 
    char *result;
14513
 
    
14514
 
    arg1 = (LassoNameRegistration *)jarg1; 
14515
 
    result = (char *)LassoNameRegistration_dump(arg1);
14516
 
    
14517
 
    jresult = SWIG_csharp_string_callback(result); 
14518
 
    free(result);
14519
 
    return jresult;
14520
 
}
14521
 
 
14522
 
 
14523
 
DllExport int SWIGSTDCALL CSharp_NameRegistration_initRequest(void * jarg1, char * jarg2, int jarg3) {
14524
 
    int jresult = 0 ;
14525
 
    LassoNameRegistration *arg1 = (LassoNameRegistration *) 0 ;
14526
 
    char *arg2 = (char *) 0 ;
14527
 
    LassoHttpMethod arg3 = (LassoHttpMethod) LASSO_HTTP_METHOD_ANY ;
14528
 
    int result;
14529
 
    
14530
 
    arg1 = (LassoNameRegistration *)jarg1; 
14531
 
    arg2 = jarg2; 
14532
 
    arg3 = (LassoHttpMethod)jarg3; 
14533
 
    {
14534
 
        int errorCode;
14535
 
        errorCode = result = (int)LassoNameRegistration_initRequest(arg1,arg2,(LassoHttpMethod )arg3);
14536
 
        
14537
 
        if (errorCode) {
14538
 
            char errorMsg[256];
14539
 
            build_exception_msg(errorCode, errorMsg);
14540
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
14541
 
        }
14542
 
    }
14543
 
    jresult = result; 
14544
 
    return jresult;
14545
 
}
14546
 
 
14547
 
 
14548
 
DllExport int SWIGSTDCALL CSharp_NameRegistration_processRequestMsg(void * jarg1, char * jarg2) {
14549
 
    int jresult = 0 ;
14550
 
    LassoNameRegistration *arg1 = (LassoNameRegistration *) 0 ;
14551
 
    char *arg2 = (char *) 0 ;
14552
 
    int result;
14553
 
    
14554
 
    arg1 = (LassoNameRegistration *)jarg1; 
14555
 
    arg2 = jarg2; 
14556
 
    {
14557
 
        int errorCode;
14558
 
        errorCode = result = (int)LassoNameRegistration_processRequestMsg(arg1,arg2);
14559
 
        
14560
 
        if (errorCode) {
14561
 
            char errorMsg[256];
14562
 
            build_exception_msg(errorCode, errorMsg);
14563
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
14564
 
        }
14565
 
    }
14566
 
    jresult = result; 
14567
 
    return jresult;
14568
 
}
14569
 
 
14570
 
 
14571
 
DllExport int SWIGSTDCALL CSharp_NameRegistration_processResponseMsg(void * jarg1, char * jarg2) {
14572
 
    int jresult = 0 ;
14573
 
    LassoNameRegistration *arg1 = (LassoNameRegistration *) 0 ;
14574
 
    char *arg2 = (char *) 0 ;
14575
 
    int result;
14576
 
    
14577
 
    arg1 = (LassoNameRegistration *)jarg1; 
14578
 
    arg2 = jarg2; 
14579
 
    {
14580
 
        int errorCode;
14581
 
        errorCode = result = (int)LassoNameRegistration_processResponseMsg(arg1,arg2);
14582
 
        
14583
 
        if (errorCode) {
14584
 
            char errorMsg[256];
14585
 
            build_exception_msg(errorCode, errorMsg);
14586
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
14587
 
        }
14588
 
    }
14589
 
    jresult = result; 
14590
 
    return jresult;
14591
 
}
14592
 
 
14593
 
 
14594
 
DllExport int SWIGSTDCALL CSharp_NameRegistration_validateRequest(void * jarg1) {
14595
 
    int jresult = 0 ;
14596
 
    LassoNameRegistration *arg1 = (LassoNameRegistration *) 0 ;
14597
 
    int result;
14598
 
    
14599
 
    arg1 = (LassoNameRegistration *)jarg1; 
14600
 
    {
14601
 
        int errorCode;
14602
 
        errorCode = result = (int)LassoNameRegistration_validateRequest(arg1);
14603
 
        
14604
 
        if (errorCode) {
14605
 
            char errorMsg[256];
14606
 
            build_exception_msg(errorCode, errorMsg);
14607
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
14608
 
        }
14609
 
    }
14610
 
    jresult = result; 
14611
 
    return jresult;
14612
 
}
14613
 
 
14614
 
 
14615
 
#ifdef __cplusplus
14616
 
}
14617
 
#endif
14618