← Back to branch summary

~ubuntu-branches/ubuntu/intrepid/lasso/intrepid

« back to all changes in this revision

Viewing changes to perl/lasso_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:
perl/lasso_wrap.c
1319
1319
        xmlOutputBufferPtr buf;
1320
1320
        char *xmlString;
1321
1321
 
 
1322
        if (xmlnode == NULL) {
 
1323
                return NULL;
 
1324
        }
 
1325
 
1322
1326
        buf = xmlAllocOutputBuffer(NULL);
1323
1327
        if (buf == NULL)
1324
1328
                xmlString = NULL;
1335
1339
        return xmlString;
1336
1340
}
1337
1341
 
 
1342
static xmlNode *get_string_xml(const char *string) {
 
1343
        xmlDoc *doc;
 
1344
        xmlNode *node;
 
1345
 
 
1346
        doc = xmlReadDoc(string, NULL, NULL, XML_PARSE_NONET);
 
1347
        node = xmlDocGetRootElement(doc);
 
1348
        if (node != NULL)
 
1349
                node = xmlCopyNode(node, 1);
 
1350
        xmlFreeDoc(doc);
 
1351
 
 
1352
        return node;
 
1353
}
 
1354
 
1338
1355
static void set_node(gpointer *nodePointer, gpointer value)
1339
1356
{
1340
1357
        if (*nodePointer != NULL)
1425
1442
        }
1426
1443
}
1427
1444
 
 
1445
static void set_xml_string(xmlNode **xmlnode, const char* string)
 
1446
{
 
1447
        xmlDoc *doc;
 
1448
        xmlNode *node;
 
1449
 
 
1450
        doc = xmlReadDoc(string, NULL, NULL, XML_PARSE_NONET);
 
1451
        node = xmlDocGetRootElement(doc);
 
1452
        if (node != NULL)
 
1453
                node = xmlCopyNode(node, 1);
 
1454
        xmlFreeDoc(doc);
 
1455
 
 
1456
        if (*xmlnode)
 
1457
                xmlFreeNode(*xmlnode);
 
1458
 
 
1459
        *xmlnode = node;
 
1460
}
 
1461
 
 
1462
 
 
1463
 
1428
1464
 
1429
1465
 
1430
1466
 
2788
2824
#define LassoServer_set_public_key(self, value) set_string(&LASSO_PROVIDER(self)->public_key, (value))
2789
2825
#define LassoServer_public_key_set(self, value) set_string(&LASSO_PROVIDER(self)->public_key, (value))
2790
2826
 
 
2827
/* role */
 
2828
#define LassoServer_get_role(self) LASSO_PROVIDER(self)->role
 
2829
#define LassoServer_role_get(self) LASSO_PROVIDER(self)->role
 
2830
#define LassoServer_set_role(self, value) LASSO_PROVIDER(self)->role = value
 
2831
#define LassoServer_role_set(self, value) LASSO_PROVIDER(self)->role = value
 
2832
 
2791
2833
/* Attributes implementations */
2792
2834
 
2793
2835
/* providerIds */
2885
2927
#define LassoIdentity_dump lasso_identity_dump
2886
2928
#define LassoIdentity_getFederation lasso_identity_get_federation
2887
2929
 
 
2930
#ifdef LASSO_WSF_ENABLED
 
2931
#define LassoIdentity_addResourceOffering lasso_identity_add_resource_offering
 
2932
#define LassoIdentity_removeResourceOffering lasso_identity_remove_resource_offering
 
2933
 
 
2934
LassoNodeList *LassoIdentity_getOfferings(LassoIdentity *self, const char *service_type) {
 
2935
        GPtrArray *array = NULL;
 
2936
        GList *list;
 
2937
 
 
2938
        list = lasso_identity_get_offerings(self, service_type);
 
2939
        if (list) {
 
2940
                array = get_node_list(list);
 
2941
                g_list_foreach(list, (GFunc) free_node_list_item, NULL);
 
2942
                g_list_free(list);
 
2943
        }
 
2944
        return array;
 
2945
}
 
2946
#endif
 
2947
 
2888
2948
 
2889
2949
 
2890
2950
 
3635
3695
}
3636
3696
 
3637
3697
 
 
3698
XS(_wrap_registerDstService) {
 
3699
    {
 
3700
        char *arg1 = (char *) 0 ;
 
3701
        char *arg2 = (char *) 0 ;
 
3702
        int argvi = 0;
 
3703
        dXSARGS;
 
3704
        
 
3705
        if ((items < 2) || (items > 2)) {
 
3706
            SWIG_croak("Usage: registerDstService(prefix,href);");
 
3707
        }
 
3708
        if (!SvOK((SV*) ST(0))) arg1 = 0;
 
3709
        else arg1 = (char *) SvPV(ST(0), PL_na);
 
3710
        if (!SvOK((SV*) ST(1))) arg2 = 0;
 
3711
        else arg2 = (char *) SvPV(ST(1), PL_na);
 
3712
        lasso_register_dst_service((char const *)arg1,(char const *)arg2);
 
3713
        
 
3714
        
 
3715
        XSRETURN(argvi);
 
3716
        fail:
 
3717
        ;
 
3718
    }
 
3719
    croak(Nullch);
 
3720
}
 
3721
 
 
3722
 
3638
3723
XS(_wrap_new_Node) {
3639
3724
    {
3640
3725
        LassoNode *result;
3787
3872
        } else {
3788
3873
            sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
3789
3874
        }
3790
 
        free(result);
 
3875
        g_free(result);
3791
3876
        XSRETURN(argvi);
3792
3877
        fail:
3793
3878
        ;
4530
4615
        } else {
4531
4616
            sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
4532
4617
        }
4533
 
        free(result);
 
4618
        g_free(result);
4534
4619
        XSRETURN(argvi);
4535
4620
        fail:
4536
4621
        ;
5454
5539
        } else {
5455
5540
            sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
5456
5541
        }
5457
 
        free(result);
 
5542
        g_free(result);
5458
5543
        XSRETURN(argvi);
5459
5544
        fail:
5460
5545
        ;
5708
5793
        } else {
5709
5794
            sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
5710
5795
        }
5711
 
        free(result);
 
5796
        g_free(result);
5712
5797
        XSRETURN(argvi);
5713
5798
        fail:
5714
5799
        ;
5918
6003
        } else {
5919
6004
            sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
5920
6005
        }
5921
 
        free(result);
 
6006
        g_free(result);
5922
6007
        XSRETURN(argvi);
5923
6008
        fail:
5924
6009
        ;
6112
6197
        } else {
6113
6198
            sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
6114
6199
        }
6115
 
        free(result);
 
6200
        g_free(result);
6116
6201
        XSRETURN(argvi);
6117
6202
        fail:
6118
6203
        ;
6248
6333
        } else {
6249
6334
            sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
6250
6335
        }
6251
 
        free(result);
 
6336
        g_free(result);
6252
6337
        XSRETURN(argvi);
6253
6338
        fail:
6254
6339
        ;
6384
6469
        } else {
6385
6470
            sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
6386
6471
        }
6387
 
        free(result);
 
6472
        g_free(result);
6388
6473
        XSRETURN(argvi);
6389
6474
        fail:
6390
6475
        ;
6710
6795
        } else {
6711
6796
            sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
6712
6797
        }
6713
 
        free(result);
 
6798
        g_free(result);
6714
6799
        XSRETURN(argvi);
6715
6800
        fail:
6716
6801
        ;
6986
7071
        } else {
6987
7072
            sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
6988
7073
        }
6989
 
        free(result);
 
7074
        g_free(result);
6990
7075
        XSRETURN(argvi);
6991
7076
        fail:
6992
7077
        ;
7018
7103
        } else {
7019
7104
            sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
7020
7105
        }
7021
 
        free(result);
 
7106
        g_free(result);
7022
7107
        XSRETURN(argvi);
7023
7108
        fail:
7024
7109
        ;
7344
7429
        } else {
7345
7430
            sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
7346
7431
        }
7347
 
        free(result);
 
7432
        g_free(result);
7348
7433
        XSRETURN(argvi);
7349
7434
        fail:
7350
7435
        ;
7620
7705
        } else {
7621
7706
            sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
7622
7707
        }
7623
 
        free(result);
 
7708
        g_free(result);
7624
7709
        XSRETURN(argvi);
7625
7710
        fail:
7626
7711
        ;
7652
7737
        } else {
7653
7738
            sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
7654
7739
        }
7655
 
        free(result);
 
7740
        g_free(result);
7656
7741
        XSRETURN(argvi);
7657
7742
        fail:
7658
7743
        ;
7846
7931
        } else {
7847
7932
            sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
7848
7933
        }
7849
 
        free(result);
 
7934
        g_free(result);
7850
7935
        XSRETURN(argvi);
7851
7936
        fail:
7852
7937
        ;
8048
8133
        } else {
8049
8134
            sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
8050
8135
        }
8051
 
        free(result);
 
8136
        g_free(result);
8052
8137
        XSRETURN(argvi);
8053
8138
        fail:
8054
8139
        ;
8258
8343
        } else {
8259
8344
            sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
8260
8345
        }
8261
 
        free(result);
 
8346
        g_free(result);
8262
8347
        XSRETURN(argvi);
8263
8348
        fail:
8264
8349
        ;
8394
8479
        } else {
8395
8480
            sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
8396
8481
        }
8397
 
        free(result);
 
8482
        g_free(result);
8398
8483
        XSRETURN(argvi);
8399
8484
        fail:
8400
8485
        ;
8484
8569
        } else {
8485
8570
            sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
8486
8571
        }
8487
 
        free(result);
 
8572
        g_free(result);
8488
8573
        XSRETURN(argvi);
8489
8574
        fail:
8490
8575
        ;
9148
9233
        } else {
9149
9234
            sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
9150
9235
        }
9151
 
        free(result);
 
9236
        g_free(result);
9152
9237
        XSRETURN(argvi);
9153
9238
        fail:
9154
9239
        ;
10488
10573
        } else {
10489
10574
            sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
10490
10575
        }
10491
 
        free(result);
 
10576
        g_free(result);
10492
10577
        XSRETURN(argvi);
10493
10578
        fail:
10494
10579
        ;
11262
11347
        } else {
11263
11348
            sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
11264
11349
        }
11265
 
        free(result);
 
11350
        g_free(result);
11266
11351
        XSRETURN(argvi);
11267
11352
        fail:
11268
11353
        ;
12756
12841
        } else {
12757
12842
            sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
12758
12843
        }
12759
 
        free(result);
 
12844
        g_free(result);
12760
12845
        XSRETURN(argvi);
12761
12846
        fail:
12762
12847
        ;
12958
13043
        } else {
12959
13044
            sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
12960
13045
        }
12961
 
        free(result);
 
13046
        g_free(result);
12962
13047
        XSRETURN(argvi);
12963
13048
        fail:
12964
13049
        ;
13160
13245
        } else {
13161
13246
            sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
13162
13247
        }
13163
 
        free(result);
 
13248
        g_free(result);
13164
13249
        XSRETURN(argvi);
13165
13250
        fail:
13166
13251
        ;
14085
14170
        } else {
14086
14171
            sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
14087
14172
        }
14088
 
        free(result);
 
14173
        g_free(result);
14089
14174
        XSRETURN(argvi);
14090
14175
        fail:
14091
14176
        ;
15369
15454
        } else {
15370
15455
            sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
15371
15456
        }
15372
 
        free(result);
 
15457
        g_free(result);
15373
15458
        XSRETURN(argvi);
15374
15459
        fail:
15375
15460
        ;
15770
15855
        } else {
15771
15856
            sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
15772
15857
        }
15773
 
        free(result);
 
15858
        g_free(result);
15774
15859
        XSRETURN(argvi);
15775
15860
        fail:
15776
15861
        ;
16722
16807
        } else {
16723
16808
            sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
16724
16809
        }
16725
 
        free(result);
 
16810
        g_free(result);
16726
16811
        XSRETURN(argvi);
16727
16812
        fail:
16728
16813
        ;
17806
17891
        } else {
17807
17892
            sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
17808
17893
        }
17809
 
        free(result);
 
17894
        g_free(result);
17810
17895
        XSRETURN(argvi);
17811
17896
        fail:
17812
17897
        ;
18161
18246
        } else {
18162
18247
            sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
18163
18248
        }
18164
 
        free(result);
 
18249
        g_free(result);
18165
18250
        XSRETURN(argvi);
18166
18251
        fail:
18167
18252
        ;
19175
19260
        } else {
19176
19261
            sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
19177
19262
        }
19178
 
        free(result);
 
19263
        g_free(result);
19179
19264
        XSRETURN(argvi);
19180
19265
        fail:
19181
19266
        ;
19530
19615
        } else {
19531
19616
            sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
19532
19617
        }
19533
 
        free(result);
 
19618
        g_free(result);
19534
19619
        XSRETURN(argvi);
19535
19620
        fail:
19536
19621
        ;
19790
19875
        } else {
19791
19876
            sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
19792
19877
        }
19793
 
        free(result);
 
19878
        g_free(result);
19794
19879
        XSRETURN(argvi);
19795
19880
        fail:
19796
19881
        ;
20116
20201
        } else {
20117
20202
            sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
20118
20203
        }
20119
 
        free(result);
 
20204
        g_free(result);
20120
20205
        XSRETURN(argvi);
20121
20206
        fail:
20122
20207
        ;
20547
20632
        } else {
20548
20633
            sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
20549
20634
        }
20550
 
        free(result);
 
20635
        g_free(result);
20551
20636
        XSRETURN(argvi);
20552
20637
        fail:
20553
20638
        ;
20627
20712
        } else {
20628
20713
            sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
20629
20714
        }
20630
 
        free(result);
 
20715
        g_free(result);
20631
20716
        XSRETURN(argvi);
20632
20717
        fail:
20633
20718
        ;
20659
20744
        } else {
20660
20745
            sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
20661
20746
        }
20662
 
        free(result);
 
20747
        g_free(result);
20663
20748
        XSRETURN(argvi);
20664
20749
        fail:
20665
20750
        ;
20691
20776
        } else {
20692
20777
            sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
20693
20778
        }
20694
 
        free(result);
 
20779
        g_free(result);
20695
20780
        XSRETURN(argvi);
20696
20781
        fail:
20697
20782
        ;
20767
20852
        } else {
20768
20853
            sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
20769
20854
        }
20770
 
        free(result);
 
20855
        g_free(result);
20771
20856
        XSRETURN(argvi);
20772
20857
        fail:
20773
20858
        ;
21302
21387
}
21303
21388
 
21304
21389
 
 
21390
XS(_wrap_Server_role_set) {
 
21391
    {
 
21392
        LassoServer *arg1 = (LassoServer *) 0 ;
 
21393
        LassoProviderRole arg2 ;
 
21394
        int argvi = 0;
 
21395
        dXSARGS;
 
21396
        
 
21397
        if ((items < 2) || (items > 2)) {
 
21398
            SWIG_croak("Usage: Server_role_set(self,role);");
 
21399
        }
 
21400
        {
 
21401
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_LassoServer,0) < 0) {
 
21402
                SWIG_croak("Type error in argument 1 of Server_role_set. Expected _p_LassoServer");
 
21403
            }
 
21404
        }
 
21405
        arg2 = (LassoProviderRole) SvIV(ST(1));
 
21406
        LassoServer_role_set(arg1,(LassoProviderRole )arg2);
 
21407
        
 
21408
        
 
21409
        XSRETURN(argvi);
 
21410
        fail:
 
21411
        ;
 
21412
    }
 
21413
    croak(Nullch);
 
21414
}
 
21415
 
 
21416
 
 
21417
XS(_wrap_Server_role_get) {
 
21418
    {
 
21419
        LassoServer *arg1 = (LassoServer *) 0 ;
 
21420
        LassoProviderRole result;
 
21421
        int argvi = 0;
 
21422
        dXSARGS;
 
21423
        
 
21424
        if ((items < 1) || (items > 1)) {
 
21425
            SWIG_croak("Usage: Server_role_get(self);");
 
21426
        }
 
21427
        {
 
21428
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_LassoServer,0) < 0) {
 
21429
                SWIG_croak("Type error in argument 1 of Server_role_get. Expected _p_LassoServer");
 
21430
            }
 
21431
        }
 
21432
        result = (LassoProviderRole)LassoServer_role_get(arg1);
 
21433
        
 
21434
        ST(argvi) = sv_newmortal();
 
21435
        sv_setiv(ST(argvi++), (IV) result);
 
21436
        XSRETURN(argvi);
 
21437
        fail:
 
21438
        ;
 
21439
    }
 
21440
    croak(Nullch);
 
21441
}
 
21442
 
 
21443
 
21305
21444
XS(_wrap_Server_providerIds_get) {
21306
21445
    {
21307
21446
        LassoServer *arg1 = (LassoServer *) 0 ;
21490
21629
        } else {
21491
21630
            sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
21492
21631
        }
21493
 
        free(result);
 
21632
        g_free(result);
21494
21633
        XSRETURN(argvi);
21495
21634
        fail:
21496
21635
        ;
21522
21661
        } else {
21523
21662
            sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
21524
21663
        }
21525
 
        free(result);
 
21664
        g_free(result);
21526
21665
        XSRETURN(argvi);
21527
21666
        fail:
21528
21667
        ;
21554
21693
        } else {
21555
21694
            sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
21556
21695
        }
21557
 
        free(result);
 
21696
        g_free(result);
21558
21697
        XSRETURN(argvi);
21559
21698
        fail:
21560
21699
        ;
21630
21769
        } else {
21631
21770
            sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
21632
21771
        }
21633
 
        free(result);
 
21772
        g_free(result);
21634
21773
        XSRETURN(argvi);
21635
21774
        fail:
21636
21775
        ;
21713
21852
            
21714
21853
            if (errorCode) {
21715
21854
                char errorMsg[256];
 
21855
                int swig_error = SWIG_RuntimeError;
 
21856
                if (errorCode == -501 || 
 
21857
                errorCode == -501) {
 
21858
                    swig_error = SWIG_ValueError;
 
21859
                }
21716
21860
                build_exception_msg(errorCode, errorMsg);
21717
 
                SWIG_exception(SWIG_UnknownError, errorMsg);
 
21861
                SWIG_exception(swig_error, errorMsg);
21718
21862
            }
21719
21863
        }
21720
21864
        ST(argvi) = sv_newmortal();
21750
21894
        } else {
21751
21895
            sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
21752
21896
        }
21753
 
        free(result);
 
21897
        g_free(result);
21754
21898
        XSRETURN(argvi);
21755
21899
        fail:
21756
21900
        ;
22043
22187
        } else {
22044
22188
            sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
22045
22189
        }
22046
 
        free(result);
 
22190
        g_free(result);
22047
22191
        XSRETURN(argvi);
22048
22192
        fail:
22049
22193
        ;
22266
22410
        } else {
22267
22411
            sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
22268
22412
        }
22269
 
        free(result);
 
22413
        g_free(result);
22270
22414
        XSRETURN(argvi);
22271
22415
        fail:
22272
22416
        ;
22452
22596
        } else {
22453
22597
            sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
22454
22598
        }
22455
 
        free(result);
 
22599
        g_free(result);
22456
22600
        XSRETURN(argvi);
22457
22601
        fail:
22458
22602
        ;
23255
23399
            
23256
23400
            if (errorCode) {
23257
23401
                char errorMsg[256];
 
23402
                int swig_error = SWIG_RuntimeError;
 
23403
                if (errorCode == -501 || 
 
23404
                errorCode == -501) {
 
23405
                    swig_error = SWIG_ValueError;
 
23406
                }
23258
23407
                build_exception_msg(errorCode, errorMsg);
23259
 
                SWIG_exception(SWIG_UnknownError, errorMsg);
 
23408
                SWIG_exception(swig_error, errorMsg);
23260
23409
            }
23261
23410
        }
23262
23411
        ST(argvi) = sv_newmortal();
23293
23442
            
23294
23443
            if (errorCode) {
23295
23444
                char errorMsg[256];
 
23445
                int swig_error = SWIG_RuntimeError;
 
23446
                if (errorCode == -501 || 
 
23447
                errorCode == -501) {
 
23448
                    swig_error = SWIG_ValueError;
 
23449
                }
23296
23450
                build_exception_msg(errorCode, errorMsg);
23297
 
                SWIG_exception(SWIG_UnknownError, errorMsg);
 
23451
                SWIG_exception(swig_error, errorMsg);
23298
23452
            }
23299
23453
        }
23300
23454
        ST(argvi) = sv_newmortal();
23328
23482
            
23329
23483
            if (errorCode) {
23330
23484
                char errorMsg[256];
 
23485
                int swig_error = SWIG_RuntimeError;
 
23486
                if (errorCode == -501 || 
 
23487
                errorCode == -501) {
 
23488
                    swig_error = SWIG_ValueError;
 
23489
                }
23331
23490
                build_exception_msg(errorCode, errorMsg);
23332
 
                SWIG_exception(SWIG_UnknownError, errorMsg);
 
23491
                SWIG_exception(swig_error, errorMsg);
23333
23492
            }
23334
23493
        }
23335
23494
        ST(argvi) = sv_newmortal();
23372
23531
            
23373
23532
            if (errorCode) {
23374
23533
                char errorMsg[256];
 
23534
                int swig_error = SWIG_RuntimeError;
 
23535
                if (errorCode == -501 || 
 
23536
                errorCode == -501) {
 
23537
                    swig_error = SWIG_ValueError;
 
23538
                }
23375
23539
                build_exception_msg(errorCode, errorMsg);
23376
 
                SWIG_exception(SWIG_UnknownError, errorMsg);
 
23540
                SWIG_exception(swig_error, errorMsg);
23377
23541
            }
23378
23542
        }
23379
23543
        ST(argvi) = sv_newmortal();
23410
23574
            
23411
23575
            if (errorCode) {
23412
23576
                char errorMsg[256];
 
23577
                int swig_error = SWIG_RuntimeError;
 
23578
                if (errorCode == -501 || 
 
23579
                errorCode == -501) {
 
23580
                    swig_error = SWIG_ValueError;
 
23581
                }
23413
23582
                build_exception_msg(errorCode, errorMsg);
23414
 
                SWIG_exception(SWIG_UnknownError, errorMsg);
 
23583
                SWIG_exception(swig_error, errorMsg);
23415
23584
            }
23416
23585
        }
23417
23586
        ST(argvi) = sv_newmortal();
23445
23614
            
23446
23615
            if (errorCode) {
23447
23616
                char errorMsg[256];
 
23617
                int swig_error = SWIG_RuntimeError;
 
23618
                if (errorCode == -501 || 
 
23619
                errorCode == -501) {
 
23620
                    swig_error = SWIG_ValueError;
 
23621
                }
23448
23622
                build_exception_msg(errorCode, errorMsg);
23449
 
                SWIG_exception(SWIG_UnknownError, errorMsg);
 
23623
                SWIG_exception(swig_error, errorMsg);
23450
23624
            }
23451
23625
        }
23452
23626
        ST(argvi) = sv_newmortal();
24263
24437
            
24264
24438
            if (errorCode) {
24265
24439
                char errorMsg[256];
 
24440
                int swig_error = SWIG_RuntimeError;
 
24441
                if (errorCode == -501 || 
 
24442
                errorCode == -501) {
 
24443
                    swig_error = SWIG_ValueError;
 
24444
                }
24266
24445
                build_exception_msg(errorCode, errorMsg);
24267
 
                SWIG_exception(SWIG_UnknownError, errorMsg);
 
24446
                SWIG_exception(swig_error, errorMsg);
24268
24447
            }
24269
24448
        }
24270
24449
        ST(argvi) = sv_newmortal();
24301
24480
            
24302
24481
            if (errorCode) {
24303
24482
                char errorMsg[256];
 
24483
                int swig_error = SWIG_RuntimeError;
 
24484
                if (errorCode == -501 || 
 
24485
                errorCode == -501) {
 
24486
                    swig_error = SWIG_ValueError;
 
24487
                }
24304
24488
                build_exception_msg(errorCode, errorMsg);
24305
 
                SWIG_exception(SWIG_UnknownError, errorMsg);
 
24489
                SWIG_exception(swig_error, errorMsg);
24306
24490
            }
24307
24491
        }
24308
24492
        ST(argvi) = sv_newmortal();
24336
24520
            
24337
24521
            if (errorCode) {
24338
24522
                char errorMsg[256];
 
24523
                int swig_error = SWIG_RuntimeError;
 
24524
                if (errorCode == -501 || 
 
24525
                errorCode == -501) {
 
24526
                    swig_error = SWIG_ValueError;
 
24527
                }
24339
24528
                build_exception_msg(errorCode, errorMsg);
24340
 
                SWIG_exception(SWIG_UnknownError, errorMsg);
 
24529
                SWIG_exception(swig_error, errorMsg);
24341
24530
            }
24342
24531
        }
24343
24532
        ST(argvi) = sv_newmortal();
24373
24562
            
24374
24563
            if (errorCode) {
24375
24564
                char errorMsg[256];
 
24565
                int swig_error = SWIG_RuntimeError;
 
24566
                if (errorCode == -501 || 
 
24567
                errorCode == -501) {
 
24568
                    swig_error = SWIG_ValueError;
 
24569
                }
24376
24570
                build_exception_msg(errorCode, errorMsg);
24377
 
                SWIG_exception(SWIG_UnknownError, errorMsg);
 
24571
                SWIG_exception(swig_error, errorMsg);
24378
24572
            }
24379
24573
        }
24380
24574
        ST(argvi) = sv_newmortal();
24423
24617
            
24424
24618
            if (errorCode) {
24425
24619
                char errorMsg[256];
 
24620
                int swig_error = SWIG_RuntimeError;
 
24621
                if (errorCode == -501 || 
 
24622
                errorCode == -501) {
 
24623
                    swig_error = SWIG_ValueError;
 
24624
                }
24426
24625
                build_exception_msg(errorCode, errorMsg);
24427
 
                SWIG_exception(SWIG_UnknownError, errorMsg);
 
24626
                SWIG_exception(swig_error, errorMsg);
24428
24627
            }
24429
24628
        }
24430
24629
        ST(argvi) = sv_newmortal();
24458
24657
            
24459
24658
            if (errorCode) {
24460
24659
                char errorMsg[256];
 
24660
                int swig_error = SWIG_RuntimeError;
 
24661
                if (errorCode == -501 || 
 
24662
                errorCode == -501) {
 
24663
                    swig_error = SWIG_ValueError;
 
24664
                }
24461
24665
                build_exception_msg(errorCode, errorMsg);
24462
 
                SWIG_exception(SWIG_UnknownError, errorMsg);
 
24666
                SWIG_exception(swig_error, errorMsg);
24463
24667
            }
24464
24668
        }
24465
24669
        ST(argvi) = sv_newmortal();
24493
24697
            
24494
24698
            if (errorCode) {
24495
24699
                char errorMsg[256];
 
24700
                int swig_error = SWIG_RuntimeError;
 
24701
                if (errorCode == -501 || 
 
24702
                errorCode == -501) {
 
24703
                    swig_error = SWIG_ValueError;
 
24704
                }
24496
24705
                build_exception_msg(errorCode, errorMsg);
24497
 
                SWIG_exception(SWIG_UnknownError, errorMsg);
 
24706
                SWIG_exception(swig_error, errorMsg);
24498
24707
            }
24499
24708
        }
24500
24709
        ST(argvi) = sv_newmortal();
24528
24737
            
24529
24738
            if (errorCode) {
24530
24739
                char errorMsg[256];
 
24740
                int swig_error = SWIG_RuntimeError;
 
24741
                if (errorCode == -501 || 
 
24742
                errorCode == -501) {
 
24743
                    swig_error = SWIG_ValueError;
 
24744
                }
24531
24745
                build_exception_msg(errorCode, errorMsg);
24532
 
                SWIG_exception(SWIG_UnknownError, errorMsg);
 
24746
                SWIG_exception(swig_error, errorMsg);
24533
24747
            }
24534
24748
        }
24535
24749
        ST(argvi) = sv_newmortal();
24566
24780
            
24567
24781
            if (errorCode) {
24568
24782
                char errorMsg[256];
 
24783
                int swig_error = SWIG_RuntimeError;
 
24784
                if (errorCode == -501 || 
 
24785
                errorCode == -501) {
 
24786
                    swig_error = SWIG_ValueError;
 
24787
                }
24569
24788
                build_exception_msg(errorCode, errorMsg);
24570
 
                SWIG_exception(SWIG_UnknownError, errorMsg);
 
24789
                SWIG_exception(swig_error, errorMsg);
24571
24790
            }
24572
24791
        }
24573
24792
        ST(argvi) = sv_newmortal();
24603
24822
        } else {
24604
24823
            sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
24605
24824
        }
24606
 
        free(result);
 
24825
        g_free(result);
24607
24826
        XSRETURN(argvi);
24608
24827
        fail:
24609
24828
        ;
24642
24861
            
24643
24862
            if (errorCode) {
24644
24863
                char errorMsg[256];
 
24864
                int swig_error = SWIG_RuntimeError;
 
24865
                if (errorCode == -501 || 
 
24866
                errorCode == -501) {
 
24867
                    swig_error = SWIG_ValueError;
 
24868
                }
24645
24869
                build_exception_msg(errorCode, errorMsg);
24646
 
                SWIG_exception(SWIG_UnknownError, errorMsg);
 
24870
                SWIG_exception(swig_error, errorMsg);
24647
24871
            }
24648
24872
        }
24649
24873
        ST(argvi) = sv_newmortal();
24684
24908
            
24685
24909
            if (errorCode) {
24686
24910
                char errorMsg[256];
 
24911
                int swig_error = SWIG_RuntimeError;
 
24912
                if (errorCode == -501 || 
 
24913
                errorCode == -501) {
 
24914
                    swig_error = SWIG_ValueError;
 
24915
                }
24687
24916
                build_exception_msg(errorCode, errorMsg);
24688
 
                SWIG_exception(SWIG_UnknownError, errorMsg);
 
24917
                SWIG_exception(swig_error, errorMsg);
24689
24918
            }
24690
24919
        }
24691
24920
        ST(argvi) = sv_newmortal();
24724
24953
            
24725
24954
            if (errorCode) {
24726
24955
                char errorMsg[256];
 
24956
                int swig_error = SWIG_RuntimeError;
 
24957
                if (errorCode == -501 || 
 
24958
                errorCode == -501) {
 
24959
                    swig_error = SWIG_ValueError;
 
24960
                }
24727
24961
                build_exception_msg(errorCode, errorMsg);
24728
 
                SWIG_exception(SWIG_UnknownError, errorMsg);
 
24962
                SWIG_exception(swig_error, errorMsg);
24729
24963
            }
24730
24964
        }
24731
24965
        ST(argvi) = sv_newmortal();
24816
25050
            
24817
25051
            if (errorCode) {
24818
25052
                char errorMsg[256];
 
25053
                int swig_error = SWIG_RuntimeError;
 
25054
                if (errorCode == -501 || 
 
25055
                errorCode == -501) {
 
25056
                    swig_error = SWIG_ValueError;
 
25057
                }
24819
25058
                build_exception_msg(errorCode, errorMsg);
24820
 
                SWIG_exception(SWIG_UnknownError, errorMsg);
 
25059
                SWIG_exception(swig_error, errorMsg);
24821
25060
            }
24822
25061
        }
24823
25062
        ST(argvi) = sv_newmortal();
24854
25093
            
24855
25094
            if (errorCode) {
24856
25095
                char errorMsg[256];
 
25096
                int swig_error = SWIG_RuntimeError;
 
25097
                if (errorCode == -501 || 
 
25098
                errorCode == -501) {
 
25099
                    swig_error = SWIG_ValueError;
 
25100
                }
24857
25101
                build_exception_msg(errorCode, errorMsg);
24858
 
                SWIG_exception(SWIG_UnknownError, errorMsg);
 
25102
                SWIG_exception(swig_error, errorMsg);
24859
25103
            }
24860
25104
        }
24861
25105
        ST(argvi) = sv_newmortal();
24892
25136
            
24893
25137
            if (errorCode) {
24894
25138
                char errorMsg[256];
 
25139
                int swig_error = SWIG_RuntimeError;
 
25140
                if (errorCode == -501 || 
 
25141
                errorCode == -501) {
 
25142
                    swig_error = SWIG_ValueError;
 
25143
                }
24895
25144
                build_exception_msg(errorCode, errorMsg);
24896
 
                SWIG_exception(SWIG_UnknownError, errorMsg);
 
25145
                SWIG_exception(swig_error, errorMsg);
24897
25146
            }
24898
25147
        }
24899
25148
        ST(argvi) = sv_newmortal();
24930
25179
            
24931
25180
            if (errorCode) {
24932
25181
                char errorMsg[256];
 
25182
                int swig_error = SWIG_RuntimeError;
 
25183
                if (errorCode == -501 || 
 
25184
                errorCode == -501) {
 
25185
                    swig_error = SWIG_ValueError;
 
25186
                }
24933
25187
                build_exception_msg(errorCode, errorMsg);
24934
 
                SWIG_exception(SWIG_UnknownError, errorMsg);
 
25188
                SWIG_exception(swig_error, errorMsg);
24935
25189
            }
24936
25190
        }
24937
25191
        ST(argvi) = sv_newmortal();
24968
25222
            
24969
25223
            if (errorCode) {
24970
25224
                char errorMsg[256];
 
25225
                int swig_error = SWIG_RuntimeError;
 
25226
                if (errorCode == -501 || 
 
25227
                errorCode == -501) {
 
25228
                    swig_error = SWIG_ValueError;
 
25229
                }
24971
25230
                build_exception_msg(errorCode, errorMsg);
24972
 
                SWIG_exception(SWIG_UnknownError, errorMsg);
 
25231
                SWIG_exception(swig_error, errorMsg);
24973
25232
            }
24974
25233
        }
24975
25234
        ST(argvi) = sv_newmortal();
25007
25266
            
25008
25267
            if (errorCode) {
25009
25268
                char errorMsg[256];
 
25269
                int swig_error = SWIG_RuntimeError;
 
25270
                if (errorCode == -501 || 
 
25271
                errorCode == -501) {
 
25272
                    swig_error = SWIG_ValueError;
 
25273
                }
25010
25274
                build_exception_msg(errorCode, errorMsg);
25011
 
                SWIG_exception(SWIG_UnknownError, errorMsg);
 
25275
                SWIG_exception(swig_error, errorMsg);
25012
25276
            }
25013
25277
        }
25014
25278
        ST(argvi) = sv_newmortal();
25767
26031
            
25768
26032
            if (errorCode) {
25769
26033
                char errorMsg[256];
 
26034
                int swig_error = SWIG_RuntimeError;
 
26035
                if (errorCode == -501 || 
 
26036
                errorCode == -501) {
 
26037
                    swig_error = SWIG_ValueError;
 
26038
                }
25770
26039
                build_exception_msg(errorCode, errorMsg);
25771
 
                SWIG_exception(SWIG_UnknownError, errorMsg);
 
26040
                SWIG_exception(swig_error, errorMsg);
25772
26041
            }
25773
26042
        }
25774
26043
        ST(argvi) = sv_newmortal();
25805
26074
            
25806
26075
            if (errorCode) {
25807
26076
                char errorMsg[256];
 
26077
                int swig_error = SWIG_RuntimeError;
 
26078
                if (errorCode == -501 || 
 
26079
                errorCode == -501) {
 
26080
                    swig_error = SWIG_ValueError;
 
26081
                }
25808
26082
                build_exception_msg(errorCode, errorMsg);
25809
 
                SWIG_exception(SWIG_UnknownError, errorMsg);
 
26083
                SWIG_exception(swig_error, errorMsg);
25810
26084
            }
25811
26085
        }
25812
26086
        ST(argvi) = sv_newmortal();
25840
26114
            
25841
26115
            if (errorCode) {
25842
26116
                char errorMsg[256];
 
26117
                int swig_error = SWIG_RuntimeError;
 
26118
                if (errorCode == -501 || 
 
26119
                errorCode == -501) {
 
26120
                    swig_error = SWIG_ValueError;
 
26121
                }
25843
26122
                build_exception_msg(errorCode, errorMsg);
25844
 
                SWIG_exception(SWIG_UnknownError, errorMsg);
 
26123
                SWIG_exception(swig_error, errorMsg);
25845
26124
            }
25846
26125
        }
25847
26126
        ST(argvi) = sv_newmortal();
25875
26154
            
25876
26155
            if (errorCode) {
25877
26156
                char errorMsg[256];
 
26157
                int swig_error = SWIG_RuntimeError;
 
26158
                if (errorCode == -501 || 
 
26159
                errorCode == -501) {
 
26160
                    swig_error = SWIG_ValueError;
 
26161
                }
25878
26162
                build_exception_msg(errorCode, errorMsg);
25879
 
                SWIG_exception(SWIG_UnknownError, errorMsg);
 
26163
                SWIG_exception(swig_error, errorMsg);
25880
26164
            }
25881
26165
        }
25882
26166
        ST(argvi) = sv_newmortal();
25912
26196
        } else {
25913
26197
            sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
25914
26198
        }
25915
 
        free(result);
 
26199
        g_free(result);
25916
26200
        XSRETURN(argvi);
25917
26201
        fail:
25918
26202
        ;
25944
26228
        } else {
25945
26229
            sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
25946
26230
        }
25947
 
        free(result);
 
26231
        g_free(result);
25948
26232
        XSRETURN(argvi);
25949
26233
        fail:
25950
26234
        ;
25983
26267
            
25984
26268
            if (errorCode) {
25985
26269
                char errorMsg[256];
 
26270
                int swig_error = SWIG_RuntimeError;
 
26271
                if (errorCode == -501 || 
 
26272
                errorCode == -501) {
 
26273
                    swig_error = SWIG_ValueError;
 
26274
                }
25986
26275
                build_exception_msg(errorCode, errorMsg);
25987
 
                SWIG_exception(SWIG_UnknownError, errorMsg);
 
26276
                SWIG_exception(swig_error, errorMsg);
25988
26277
            }
25989
26278
        }
25990
26279
        ST(argvi) = sv_newmortal();
26021
26310
            
26022
26311
            if (errorCode) {
26023
26312
                char errorMsg[256];
 
26313
                int swig_error = SWIG_RuntimeError;
 
26314
                if (errorCode == -501 || 
 
26315
                errorCode == -501) {
 
26316
                    swig_error = SWIG_ValueError;
 
26317
                }
26024
26318
                build_exception_msg(errorCode, errorMsg);
26025
 
                SWIG_exception(SWIG_UnknownError, errorMsg);
 
26319
                SWIG_exception(swig_error, errorMsg);
26026
26320
            }
26027
26321
        }
26028
26322
        ST(argvi) = sv_newmortal();
26059
26353
            
26060
26354
            if (errorCode) {
26061
26355
                char errorMsg[256];
 
26356
                int swig_error = SWIG_RuntimeError;
 
26357
                if (errorCode == -501 || 
 
26358
                errorCode == -501) {
 
26359
                    swig_error = SWIG_ValueError;
 
26360
                }
26062
26361
                build_exception_msg(errorCode, errorMsg);
26063
 
                SWIG_exception(SWIG_UnknownError, errorMsg);
 
26362
                SWIG_exception(swig_error, errorMsg);
26064
26363
            }
26065
26364
        }
26066
26365
        ST(argvi) = sv_newmortal();
26094
26393
            
26095
26394
            if (errorCode) {
26096
26395
                char errorMsg[256];
 
26396
                int swig_error = SWIG_RuntimeError;
 
26397
                if (errorCode == -501 || 
 
26398
                errorCode == -501) {
 
26399
                    swig_error = SWIG_ValueError;
 
26400
                }
26097
26401
                build_exception_msg(errorCode, errorMsg);
26098
 
                SWIG_exception(SWIG_UnknownError, errorMsg);
 
26402
                SWIG_exception(swig_error, errorMsg);
26099
26403
            }
26100
26404
        }
26101
26405
        ST(argvi) = sv_newmortal();
26129
26433
            
26130
26434
            if (errorCode) {
26131
26435
                char errorMsg[256];
 
26436
                int swig_error = SWIG_RuntimeError;
 
26437
                if (errorCode == -501 || 
 
26438
                errorCode == -501) {
 
26439
                    swig_error = SWIG_ValueError;
 
26440
                }
26132
26441
                build_exception_msg(errorCode, errorMsg);
26133
 
                SWIG_exception(SWIG_UnknownError, errorMsg);
 
26442
                SWIG_exception(swig_error, errorMsg);
26134
26443
            }
26135
26444
        }
26136
26445
        ST(argvi) = sv_newmortal();
26859
27168
            
26860
27169
            if (errorCode) {
26861
27170
                char errorMsg[256];
 
27171
                int swig_error = SWIG_RuntimeError;
 
27172
                if (errorCode == -501 || 
 
27173
                errorCode == -501) {
 
27174
                    swig_error = SWIG_ValueError;
 
27175
                }
26862
27176
                build_exception_msg(errorCode, errorMsg);
26863
 
                SWIG_exception(SWIG_UnknownError, errorMsg);
 
27177
                SWIG_exception(swig_error, errorMsg);
26864
27178
            }
26865
27179
        }
26866
27180
        ST(argvi) = sv_newmortal();
26897
27211
            
26898
27212
            if (errorCode) {
26899
27213
                char errorMsg[256];
 
27214
                int swig_error = SWIG_RuntimeError;
 
27215
                if (errorCode == -501 || 
 
27216
                errorCode == -501) {
 
27217
                    swig_error = SWIG_ValueError;
 
27218
                }
26900
27219
                build_exception_msg(errorCode, errorMsg);
26901
 
                SWIG_exception(SWIG_UnknownError, errorMsg);
 
27220
                SWIG_exception(swig_error, errorMsg);
26902
27221
            }
26903
27222
        }
26904
27223
        ST(argvi) = sv_newmortal();
26947
27266
            
26948
27267
            if (errorCode) {
26949
27268
                char errorMsg[256];
 
27269
                int swig_error = SWIG_RuntimeError;
 
27270
                if (errorCode == -501 || 
 
27271
                errorCode == -501) {
 
27272
                    swig_error = SWIG_ValueError;
 
27273
                }
26950
27274
                build_exception_msg(errorCode, errorMsg);
26951
 
                SWIG_exception(SWIG_UnknownError, errorMsg);
 
27275
                SWIG_exception(swig_error, errorMsg);
26952
27276
            }
26953
27277
        }
26954
27278
        ST(argvi) = sv_newmortal();
26985
27309
            
26986
27310
            if (errorCode) {
26987
27311
                char errorMsg[256];
 
27312
                int swig_error = SWIG_RuntimeError;
 
27313
                if (errorCode == -501 || 
 
27314
                errorCode == -501) {
 
27315
                    swig_error = SWIG_ValueError;
 
27316
                }
26988
27317
                build_exception_msg(errorCode, errorMsg);
26989
 
                SWIG_exception(SWIG_UnknownError, errorMsg);
 
27318
                SWIG_exception(swig_error, errorMsg);
26990
27319
            }
26991
27320
        }
26992
27321
        ST(argvi) = sv_newmortal();
27024
27353
            
27025
27354
            if (errorCode) {
27026
27355
                char errorMsg[256];
 
27356
                int swig_error = SWIG_RuntimeError;
 
27357
                if (errorCode == -501 || 
 
27358
                errorCode == -501) {
 
27359
                    swig_error = SWIG_ValueError;
 
27360
                }
27027
27361
                build_exception_msg(errorCode, errorMsg);
27028
 
                SWIG_exception(SWIG_UnknownError, errorMsg);
 
27362
                SWIG_exception(swig_error, errorMsg);
27029
27363
            }
27030
27364
        }
27031
27365
        ST(argvi) = sv_newmortal();
27059
27393
            
27060
27394
            if (errorCode) {
27061
27395
                char errorMsg[256];
 
27396
                int swig_error = SWIG_RuntimeError;
 
27397
                if (errorCode == -501 || 
 
27398
                errorCode == -501) {
 
27399
                    swig_error = SWIG_ValueError;
 
27400
                }
27062
27401
                build_exception_msg(errorCode, errorMsg);
27063
 
                SWIG_exception(SWIG_UnknownError, errorMsg);
 
27402
                SWIG_exception(swig_error, errorMsg);
27064
27403
            }
27065
27404
        }
27066
27405
        ST(argvi) = sv_newmortal();
27094
27433
            
27095
27434
            if (errorCode) {
27096
27435
                char errorMsg[256];
 
27436
                int swig_error = SWIG_RuntimeError;
 
27437
                if (errorCode == -501 || 
 
27438
                errorCode == -501) {
 
27439
                    swig_error = SWIG_ValueError;
 
27440
                }
27097
27441
                build_exception_msg(errorCode, errorMsg);
27098
 
                SWIG_exception(SWIG_UnknownError, errorMsg);
 
27442
                SWIG_exception(swig_error, errorMsg);
27099
27443
            }
27100
27444
        }
27101
27445
        ST(argvi) = sv_newmortal();
27129
27473
            
27130
27474
            if (errorCode) {
27131
27475
                char errorMsg[256];
 
27476
                int swig_error = SWIG_RuntimeError;
 
27477
                if (errorCode == -501 || 
 
27478
                errorCode == -501) {
 
27479
                    swig_error = SWIG_ValueError;
 
27480
                }
27132
27481
                build_exception_msg(errorCode, errorMsg);
27133
 
                SWIG_exception(SWIG_UnknownError, errorMsg);
 
27482
                SWIG_exception(swig_error, errorMsg);
27134
27483
            }
27135
27484
        }
27136
27485
        ST(argvi) = sv_newmortal();
27164
27513
            
27165
27514
            if (errorCode) {
27166
27515
                char errorMsg[256];
 
27516
                int swig_error = SWIG_RuntimeError;
 
27517
                if (errorCode == -501 || 
 
27518
                errorCode == -501) {
 
27519
                    swig_error = SWIG_ValueError;
 
27520
                }
27167
27521
                build_exception_msg(errorCode, errorMsg);
27168
 
                SWIG_exception(SWIG_UnknownError, errorMsg);
 
27522
                SWIG_exception(swig_error, errorMsg);
27169
27523
            }
27170
27524
        }
27171
27525
        ST(argvi) = sv_newmortal();
27204
27558
            
27205
27559
            if (errorCode) {
27206
27560
                char errorMsg[256];
 
27561
                int swig_error = SWIG_RuntimeError;
 
27562
                if (errorCode == -501 || 
 
27563
                errorCode == -501) {
 
27564
                    swig_error = SWIG_ValueError;
 
27565
                }
27207
27566
                build_exception_msg(errorCode, errorMsg);
27208
 
                SWIG_exception(SWIG_UnknownError, errorMsg);
 
27567
                SWIG_exception(swig_error, errorMsg);
27209
27568
            }
27210
27569
        }
27211
27570
        ST(argvi) = sv_newmortal();
27242
27601
            
27243
27602
            if (errorCode) {
27244
27603
                char errorMsg[256];
 
27604
                int swig_error = SWIG_RuntimeError;
 
27605
                if (errorCode == -501 || 
 
27606
                errorCode == -501) {
 
27607
                    swig_error = SWIG_ValueError;
 
27608
                }
27245
27609
                build_exception_msg(errorCode, errorMsg);
27246
 
                SWIG_exception(SWIG_UnknownError, errorMsg);
 
27610
                SWIG_exception(swig_error, errorMsg);
27247
27611
            }
27248
27612
        }
27249
27613
        ST(argvi) = sv_newmortal();
27280
27644
            
27281
27645
            if (errorCode) {
27282
27646
                char errorMsg[256];
 
27647
                int swig_error = SWIG_RuntimeError;
 
27648
                if (errorCode == -501 || 
 
27649
                errorCode == -501) {
 
27650
                    swig_error = SWIG_ValueError;
 
27651
                }
27283
27652
                build_exception_msg(errorCode, errorMsg);
27284
 
                SWIG_exception(SWIG_UnknownError, errorMsg);
 
27653
                SWIG_exception(swig_error, errorMsg);
27285
27654
            }
27286
27655
        }
27287
27656
        ST(argvi) = sv_newmortal();
27318
27687
            
27319
27688
            if (errorCode) {
27320
27689
                char errorMsg[256];
 
27690
                int swig_error = SWIG_RuntimeError;
 
27691
                if (errorCode == -501 || 
 
27692
                errorCode == -501) {
 
27693
                    swig_error = SWIG_ValueError;
 
27694
                }
27321
27695
                build_exception_msg(errorCode, errorMsg);
27322
 
                SWIG_exception(SWIG_UnknownError, errorMsg);
 
27696
                SWIG_exception(swig_error, errorMsg);
27323
27697
            }
27324
27698
        }
27325
27699
        ST(argvi) = sv_newmortal();
28048
28422
            
28049
28423
            if (errorCode) {
28050
28424
                char errorMsg[256];
 
28425
                int swig_error = SWIG_RuntimeError;
 
28426
                if (errorCode == -501 || 
 
28427
                errorCode == -501) {
 
28428
                    swig_error = SWIG_ValueError;
 
28429
                }
28051
28430
                build_exception_msg(errorCode, errorMsg);
28052
 
                SWIG_exception(SWIG_UnknownError, errorMsg);
 
28431
                SWIG_exception(swig_error, errorMsg);
28053
28432
            }
28054
28433
        }
28055
28434
        ST(argvi) = sv_newmortal();
28086
28465
            
28087
28466
            if (errorCode) {
28088
28467
                char errorMsg[256];
 
28468
                int swig_error = SWIG_RuntimeError;
 
28469
                if (errorCode == -501 || 
 
28470
                errorCode == -501) {
 
28471
                    swig_error = SWIG_ValueError;
 
28472
                }
28089
28473
                build_exception_msg(errorCode, errorMsg);
28090
 
                SWIG_exception(SWIG_UnknownError, errorMsg);
 
28474
                SWIG_exception(swig_error, errorMsg);
28091
28475
            }
28092
28476
        }
28093
28477
        ST(argvi) = sv_newmortal();
28121
28505
            
28122
28506
            if (errorCode) {
28123
28507
                char errorMsg[256];
 
28508
                int swig_error = SWIG_RuntimeError;
 
28509
                if (errorCode == -501 || 
 
28510
                errorCode == -501) {
 
28511
                    swig_error = SWIG_ValueError;
 
28512
                }
28124
28513
                build_exception_msg(errorCode, errorMsg);
28125
 
                SWIG_exception(SWIG_UnknownError, errorMsg);
 
28514
                SWIG_exception(swig_error, errorMsg);
28126
28515
            }
28127
28516
        }
28128
28517
        ST(argvi) = sv_newmortal();
28156
28545
            
28157
28546
            if (errorCode) {
28158
28547
                char errorMsg[256];
 
28548
                int swig_error = SWIG_RuntimeError;
 
28549
                if (errorCode == -501 || 
 
28550
                errorCode == -501) {
 
28551
                    swig_error = SWIG_ValueError;
 
28552
                }
28159
28553
                build_exception_msg(errorCode, errorMsg);
28160
 
                SWIG_exception(SWIG_UnknownError, errorMsg);
 
28554
                SWIG_exception(swig_error, errorMsg);
28161
28555
            }
28162
28556
        }
28163
28557
        ST(argvi) = sv_newmortal();
28199
28593
            
28200
28594
            if (errorCode) {
28201
28595
                char errorMsg[256];
 
28596
                int swig_error = SWIG_RuntimeError;
 
28597
                if (errorCode == -501 || 
 
28598
                errorCode == -501) {
 
28599
                    swig_error = SWIG_ValueError;
 
28600
                }
28202
28601
                build_exception_msg(errorCode, errorMsg);
28203
 
                SWIG_exception(SWIG_UnknownError, errorMsg);
 
28602
                SWIG_exception(swig_error, errorMsg);
28204
28603
            }
28205
28604
        }
28206
28605
        ST(argvi) = sv_newmortal();
28237
28636
            
28238
28637
            if (errorCode) {
28239
28638
                char errorMsg[256];
 
28639
                int swig_error = SWIG_RuntimeError;
 
28640
                if (errorCode == -501 || 
 
28641
                errorCode == -501) {
 
28642
                    swig_error = SWIG_ValueError;
 
28643
                }
28240
28644
                build_exception_msg(errorCode, errorMsg);
28241
 
                SWIG_exception(SWIG_UnknownError, errorMsg);
 
28645
                SWIG_exception(swig_error, errorMsg);
28242
28646
            }
28243
28647
        }
28244
28648
        ST(argvi) = sv_newmortal();
28275
28679
            
28276
28680
            if (errorCode) {
28277
28681
                char errorMsg[256];
 
28682
                int swig_error = SWIG_RuntimeError;
 
28683
                if (errorCode == -501 || 
 
28684
                errorCode == -501) {
 
28685
                    swig_error = SWIG_ValueError;
 
28686
                }
28278
28687
                build_exception_msg(errorCode, errorMsg);
28279
 
                SWIG_exception(SWIG_UnknownError, errorMsg);
 
28688
                SWIG_exception(swig_error, errorMsg);
28280
28689
            }
28281
28690
        }
28282
28691
        ST(argvi) = sv_newmortal();
28310
28719
            
28311
28720
            if (errorCode) {
28312
28721
                char errorMsg[256];
 
28722
                int swig_error = SWIG_RuntimeError;
 
28723
                if (errorCode == -501 || 
 
28724
                errorCode == -501) {
 
28725
                    swig_error = SWIG_ValueError;
 
28726
                }
28313
28727
                build_exception_msg(errorCode, errorMsg);
28314
 
                SWIG_exception(SWIG_UnknownError, errorMsg);
 
28728
                SWIG_exception(swig_error, errorMsg);
28315
28729
            }
28316
28730
        }
28317
28731
        ST(argvi) = sv_newmortal();
29128
29542
            
29129
29543
            if (errorCode) {
29130
29544
                char errorMsg[256];
 
29545
                int swig_error = SWIG_RuntimeError;
 
29546
                if (errorCode == -501 || 
 
29547
                errorCode == -501) {
 
29548
                    swig_error = SWIG_ValueError;
 
29549
                }
29131
29550
                build_exception_msg(errorCode, errorMsg);
29132
 
                SWIG_exception(SWIG_UnknownError, errorMsg);
 
29551
                SWIG_exception(swig_error, errorMsg);
29133
29552
            }
29134
29553
        }
29135
29554
        ST(argvi) = sv_newmortal();
29166
29585
            
29167
29586
            if (errorCode) {
29168
29587
                char errorMsg[256];
 
29588
                int swig_error = SWIG_RuntimeError;
 
29589
                if (errorCode == -501 || 
 
29590
                errorCode == -501) {
 
29591
                    swig_error = SWIG_ValueError;
 
29592
                }
29169
29593
                build_exception_msg(errorCode, errorMsg);
29170
 
                SWIG_exception(SWIG_UnknownError, errorMsg);
 
29594
                SWIG_exception(swig_error, errorMsg);
29171
29595
            }
29172
29596
        }
29173
29597
        ST(argvi) = sv_newmortal();
29201
29625
            
29202
29626
            if (errorCode) {
29203
29627
                char errorMsg[256];
 
29628
                int swig_error = SWIG_RuntimeError;
 
29629
                if (errorCode == -501 || 
 
29630
                errorCode == -501) {
 
29631
                    swig_error = SWIG_ValueError;
 
29632
                }
29204
29633
                build_exception_msg(errorCode, errorMsg);
29205
 
                SWIG_exception(SWIG_UnknownError, errorMsg);
 
29634
                SWIG_exception(swig_error, errorMsg);
29206
29635
            }
29207
29636
        }
29208
29637
        ST(argvi) = sv_newmortal();
29236
29665
            
29237
29666
            if (errorCode) {
29238
29667
                char errorMsg[256];
 
29668
                int swig_error = SWIG_RuntimeError;
 
29669
                if (errorCode == -501 || 
 
29670
                errorCode == -501) {
 
29671
                    swig_error = SWIG_ValueError;
 
29672
                }
29239
29673
                build_exception_msg(errorCode, errorMsg);
29240
 
                SWIG_exception(SWIG_UnknownError, errorMsg);
 
29674
                SWIG_exception(swig_error, errorMsg);
29241
29675
            }
29242
29676
        }
29243
29677
        ST(argvi) = sv_newmortal();
29273
29707
        } else {
29274
29708
            sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
29275
29709
        }
29276
 
        free(result);
 
29710
        g_free(result);
29277
29711
        XSRETURN(argvi);
29278
29712
        fail:
29279
29713
        ;
29310
29744
            
29311
29745
            if (errorCode) {
29312
29746
                char errorMsg[256];
 
29747
                int swig_error = SWIG_RuntimeError;
 
29748
                if (errorCode == -501 || 
 
29749
                errorCode == -501) {
 
29750
                    swig_error = SWIG_ValueError;
 
29751
                }
29313
29752
                build_exception_msg(errorCode, errorMsg);
29314
 
                SWIG_exception(SWIG_UnknownError, errorMsg);
 
29753
                SWIG_exception(swig_error, errorMsg);
29315
29754
            }
29316
29755
        }
29317
29756
        ST(argvi) = sv_newmortal();
29348
29787
            
29349
29788
            if (errorCode) {
29350
29789
                char errorMsg[256];
 
29790
                int swig_error = SWIG_RuntimeError;
 
29791
                if (errorCode == -501 || 
 
29792
                errorCode == -501) {
 
29793
                    swig_error = SWIG_ValueError;
 
29794
                }
29351
29795
                build_exception_msg(errorCode, errorMsg);
29352
 
                SWIG_exception(SWIG_UnknownError, errorMsg);
 
29796
                SWIG_exception(swig_error, errorMsg);
29353
29797
            }
29354
29798
        }
29355
29799
        ST(argvi) = sv_newmortal();
29386
29830
            
29387
29831
            if (errorCode) {
29388
29832
                char errorMsg[256];
 
29833
                int swig_error = SWIG_RuntimeError;
 
29834
                if (errorCode == -501 || 
 
29835
                errorCode == -501) {
 
29836
                    swig_error = SWIG_ValueError;
 
29837
                }
29389
29838
                build_exception_msg(errorCode, errorMsg);
29390
 
                SWIG_exception(SWIG_UnknownError, errorMsg);
 
29839
                SWIG_exception(swig_error, errorMsg);
29391
29840
            }
29392
29841
        }
29393
29842
        ST(argvi) = sv_newmortal();
29421
29870
            
29422
29871
            if (errorCode) {
29423
29872
                char errorMsg[256];
 
29873
                int swig_error = SWIG_RuntimeError;
 
29874
                if (errorCode == -501 || 
 
29875
                errorCode == -501) {
 
29876
                    swig_error = SWIG_ValueError;
 
29877
                }
29424
29878
                build_exception_msg(errorCode, errorMsg);
29425
 
                SWIG_exception(SWIG_UnknownError, errorMsg);
 
29879
                SWIG_exception(swig_error, errorMsg);
29426
29880
            }
29427
29881
        }
29428
29882
        ST(argvi) = sv_newmortal();
29644
30098
{ SWIG_INT,     (char *) SWIG_prefix "SIGNATURE_METHOD_RSA_SHA1", (long) LASSO_SIGNATURE_METHOD_RSA_SHA1, 0, 0, 0},
29645
30099
{ SWIG_INT,     (char *) SWIG_prefix "SIGNATURE_METHOD_DSA_SHA1", (long) LASSO_SIGNATURE_METHOD_DSA_SHA1, 0, 0, 0},
29646
30100
{ SWIG_INT,     (char *) SWIG_prefix "ERROR_UNDEFINED", (long) -1, 0, 0, 0},
 
30101
{ SWIG_INT,     (char *) SWIG_prefix "ERROR_UNIMPLEMENTED", (long) -2, 0, 0, 0},
29647
30102
{ SWIG_INT,     (char *) SWIG_prefix "XML_ERROR_NODE_NOT_FOUND", (long) -10, 0, 0, 0},
29648
30103
{ SWIG_INT,     (char *) SWIG_prefix "XML_ERROR_NODE_CONTENT_NOT_FOUND", (long) -11, 0, 0, 0},
29649
30104
{ SWIG_INT,     (char *) SWIG_prefix "XML_ERROR_ATTR_NOT_FOUND", (long) -12, 0, 0, 0},
29691
30146
{ SWIG_INT,     (char *) SWIG_prefix "LASSO_PARAM_ERROR_CHECK_FAILED", (long) -503, 0, 0, 0},
29692
30147
{ SWIG_INT,     (char *) SWIG_prefix "LOGIN_ERROR_FEDERATION_NOT_FOUND", (long) 601, 0, 0, 0},
29693
30148
{ SWIG_INT,     (char *) SWIG_prefix "LOGIN_ERROR_CONSENT_NOT_OBTAINED", (long) 602, 0, 0, 0},
29694
 
{ SWIG_INT,     (char *) SWIG_prefix "LASSO_LOGIN_ERROR_INVALID_NAMEIDPOLICY", (long) -603, 0, 0, 0},
29695
 
{ SWIG_INT,     (char *) SWIG_prefix "LASSO_LOGIN_ERROR_REQUEST_DENIED", (long) 604, 0, 0, 0},
 
30149
{ SWIG_INT,     (char *) SWIG_prefix "LOGIN_ERROR_INVALID_NAMEIDPOLICY", (long) -603, 0, 0, 0},
 
30150
{ SWIG_INT,     (char *) SWIG_prefix "LOGIN_ERROR_REQUEST_DENIED", (long) 604, 0, 0, 0},
29696
30151
{ SWIG_INT,     (char *) SWIG_prefix "LOGIN_ERROR_INVALID_SIGNATURE", (long) 605, 0, 0, 0},
29697
30152
{ SWIG_INT,     (char *) SWIG_prefix "LOGIN_ERROR_UNSIGNED_AUTHN_REQUEST", (long) 606, 0, 0, 0},
29698
30153
{ SWIG_INT,     (char *) SWIG_prefix "LOGIN_ERROR_STATUS_NOT_SUCCESS", (long) 607, 0, 0, 0},
 
30154
{ SWIG_INT,     (char *) SWIG_prefix "LOGIN_ERROR_UNKNOWN_PRINCIPAL", (long) 608, 0, 0, 0},
29699
30155
{ SWIG_INT,     (char *) SWIG_prefix "DEFEDERATION_ERROR_MISSING_NAME_IDENTIFIER", (long) -700, 0, 0, 0},
29700
30156
{ SWIG_INT,     (char *) SWIG_prefix "CHECK_VERSION_EXACT", (long) LASSO_CHECK_VERSION_EXACT, 0, 0, 0},
29701
30157
{ SWIG_INT,     (char *) SWIG_prefix "CHECK_VERSIONABI_COMPATIBLE", (long) LASSO_CHECK_VERSIONABI_COMPATIBLE, 0, 0, 0},
29712
30168
{"lassoc::init", _wrap_init},
29713
30169
{"lassoc::shutdown", _wrap_shutdown},
29714
30170
{"lassoc::checkVersion", _wrap_checkVersion},
 
30171
{"lassoc::registerDstService", _wrap_registerDstService},
29715
30172
{"lassoc::new_Node", _wrap_new_Node},
29716
30173
{"lassoc::delete_Node", _wrap_delete_Node},
29717
30174
{"lassoc::Node_dump", _wrap_Node_dump},
30248
30705
{"lassoc::Server_providerId_get", _wrap_Server_providerId_get},
30249
30706
{"lassoc::Server_publicKey_set", _wrap_Server_publicKey_set},
30250
30707
{"lassoc::Server_publicKey_get", _wrap_Server_publicKey_get},
 
30708
{"lassoc::Server_role_set", _wrap_Server_role_set},
 
30709
{"lassoc::Server_role_get", _wrap_Server_role_get},
30251
30710
{"lassoc::Server_providerIds_get", _wrap_Server_providerIds_get},
30252
30711
{"lassoc::new_Server", _wrap_new_Server},
30253
30712
{"lassoc::delete_Server", _wrap_delete_Server},