← Back to branch summary

~ubuntu-branches/ubuntu/jaunty/lasso/jaunty

« back to all changes in this revision

Viewing changes to java/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:
java/lasso_wrap.c
306
306
        xmlOutputBufferPtr buf;
307
307
        char *xmlString;
308
308
 
 
309
        if (xmlnode == NULL) {
 
310
                return NULL;
 
311
        }
 
312
 
309
313
        buf = xmlAllocOutputBuffer(NULL);
310
314
        if (buf == NULL)
311
315
                xmlString = NULL;
322
326
        return xmlString;
323
327
}
324
328
 
 
329
static xmlNode *get_string_xml(const char *string) {
 
330
        xmlDoc *doc;
 
331
        xmlNode *node;
 
332
 
 
333
        doc = xmlReadDoc(string, NULL, NULL, XML_PARSE_NONET);
 
334
        node = xmlDocGetRootElement(doc);
 
335
        if (node != NULL)
 
336
                node = xmlCopyNode(node, 1);
 
337
        xmlFreeDoc(doc);
 
338
 
 
339
        return node;
 
340
}
 
341
 
325
342
static void set_node(gpointer *nodePointer, gpointer value)
326
343
{
327
344
        if (*nodePointer != NULL)
412
429
        }
413
430
}
414
431
 
 
432
static void set_xml_string(xmlNode **xmlnode, const char* string)
 
433
{
 
434
        xmlDoc *doc;
 
435
        xmlNode *node;
 
436
 
 
437
        doc = xmlReadDoc(string, NULL, NULL, XML_PARSE_NONET);
 
438
        node = xmlDocGetRootElement(doc);
 
439
        if (node != NULL)
 
440
                node = xmlCopyNode(node, 1);
 
441
        xmlFreeDoc(doc);
 
442
 
 
443
        if (*xmlnode)
 
444
                xmlFreeNode(*xmlnode);
 
445
 
 
446
        *xmlnode = node;
 
447
}
 
448
 
 
449
 
 
450
 
415
451
 
416
452
 
417
453
 
1775
1811
#define LassoServer_set_public_key(self, value) set_string(&LASSO_PROVIDER(self)->public_key, (value))
1776
1812
#define LassoServer_public_key_set(self, value) set_string(&LASSO_PROVIDER(self)->public_key, (value))
1777
1813
 
 
1814
/* role */
 
1815
#define LassoServer_get_role(self) LASSO_PROVIDER(self)->role
 
1816
#define LassoServer_role_get(self) LASSO_PROVIDER(self)->role
 
1817
#define LassoServer_set_role(self, value) LASSO_PROVIDER(self)->role = value
 
1818
#define LassoServer_role_set(self, value) LASSO_PROVIDER(self)->role = value
 
1819
 
1778
1820
/* Attributes implementations */
1779
1821
 
1780
1822
/* providerIds */
1872
1914
#define LassoIdentity_dump lasso_identity_dump
1873
1915
#define LassoIdentity_getFederation lasso_identity_get_federation
1874
1916
 
 
1917
#ifdef LASSO_WSF_ENABLED
 
1918
#define LassoIdentity_addResourceOffering lasso_identity_add_resource_offering
 
1919
#define LassoIdentity_removeResourceOffering lasso_identity_remove_resource_offering
 
1920
 
 
1921
LassoNodeList *LassoIdentity_getOfferings(LassoIdentity *self, const char *service_type) {
 
1922
        GPtrArray *array = NULL;
 
1923
        GList *list;
 
1924
 
 
1925
        list = lasso_identity_get_offerings(self, service_type);
 
1926
        if (list) {
 
1927
                array = get_node_list(list);
 
1928
                g_list_foreach(list, (GFunc) free_node_list_item, NULL);
 
1929
                g_list_free(list);
 
1930
        }
 
1931
        return array;
 
1932
}
 
1933
#endif
 
1934
 
1875
1935
 
1876
1936
 
1877
1937
 
3748
3808
}
3749
3809
 
3750
3810
 
 
3811
JNIEXPORT jint JNICALL Java_com_entrouvert_lasso_lassoJNI_get_1ERROR_1UNIMPLEMENTED(JNIEnv *jenv, jclass jcls) {
 
3812
    jint jresult = 0 ;
 
3813
    int result;
 
3814
    
 
3815
    (void)jenv;
 
3816
    (void)jcls;
 
3817
    result = (int) -2;
 
3818
    
 
3819
    jresult = (jint)result; 
 
3820
    return jresult;
 
3821
}
 
3822
 
 
3823
 
3751
3824
JNIEXPORT jint JNICALL Java_com_entrouvert_lasso_lassoJNI_get_1XML_1ERROR_1NODE_1NOT_1FOUND(JNIEnv *jenv, jclass jcls) {
3752
3825
    jint jresult = 0 ;
3753
3826
    int result;
4359
4432
}
4360
4433
 
4361
4434
 
4362
 
JNIEXPORT jint JNICALL Java_com_entrouvert_lasso_lassoJNI_get_1LASSO_1LOGIN_1ERROR_1INVALID_1NAMEIDPOLICY(JNIEnv *jenv, jclass jcls) {
 
4435
JNIEXPORT jint JNICALL Java_com_entrouvert_lasso_lassoJNI_get_1LOGIN_1ERROR_1INVALID_1NAMEIDPOLICY(JNIEnv *jenv, jclass jcls) {
4363
4436
    jint jresult = 0 ;
4364
4437
    int result;
4365
4438
    
4372
4445
}
4373
4446
 
4374
4447
 
4375
 
JNIEXPORT jint JNICALL Java_com_entrouvert_lasso_lassoJNI_get_1LASSO_1LOGIN_1ERROR_1REQUEST_1DENIED(JNIEnv *jenv, jclass jcls) {
 
4448
JNIEXPORT jint JNICALL Java_com_entrouvert_lasso_lassoJNI_get_1LOGIN_1ERROR_1REQUEST_1DENIED(JNIEnv *jenv, jclass jcls) {
4376
4449
    jint jresult = 0 ;
4377
4450
    int result;
4378
4451
    
4424
4497
}
4425
4498
 
4426
4499
 
 
4500
JNIEXPORT jint JNICALL Java_com_entrouvert_lasso_lassoJNI_get_1LOGIN_1ERROR_1UNKNOWN_1PRINCIPAL(JNIEnv *jenv, jclass jcls) {
 
4501
    jint jresult = 0 ;
 
4502
    int result;
 
4503
    
 
4504
    (void)jenv;
 
4505
    (void)jcls;
 
4506
    result = (int) 608;
 
4507
    
 
4508
    jresult = (jint)result; 
 
4509
    return jresult;
 
4510
}
 
4511
 
 
4512
 
4427
4513
JNIEXPORT jint JNICALL Java_com_entrouvert_lasso_lassoJNI_get_1DEFEDERATION_1ERROR_1MISSING_1NAME_1IDENTIFIER(JNIEnv *jenv, jclass jcls) {
4428
4514
    jint jresult = 0 ;
4429
4515
    int result;
4523
4609
}
4524
4610
 
4525
4611
 
 
4612
JNIEXPORT void JNICALL Java_com_entrouvert_lasso_lassoJNI_registerDstService(JNIEnv *jenv, jclass jcls, jstring jarg1, jstring jarg2) {
 
4613
    char *arg1 = (char *) 0 ;
 
4614
    char *arg2 = (char *) 0 ;
 
4615
    
 
4616
    (void)jenv;
 
4617
    (void)jcls;
 
4618
    {
 
4619
        arg1 = 0;
 
4620
        if (jarg1) {
 
4621
            arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);
 
4622
            if (!arg1) return ;
 
4623
        }
 
4624
    }
 
4625
    {
 
4626
        arg2 = 0;
 
4627
        if (jarg2) {
 
4628
            arg2 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg2, 0);
 
4629
            if (!arg2) return ;
 
4630
        }
 
4631
    }
 
4632
    lasso_register_dst_service((char const *)arg1,(char const *)arg2);
 
4633
    
 
4634
    {
 
4635
        if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, arg1); 
 
4636
    }
 
4637
    {
 
4638
        if (arg2) (*jenv)->ReleaseStringUTFChars(jenv, jarg2, arg2); 
 
4639
    }
 
4640
}
 
4641
 
 
4642
 
4526
4643
JNIEXPORT jlong JNICALL Java_com_entrouvert_lasso_lassoJNI_new_1Node(JNIEnv *jenv, jclass jcls) {
4527
4644
    jlong jresult = 0 ;
4528
4645
    LassoNode *result;
4560
4677
    {
4561
4678
        if(result) jresult = (*jenv)->NewStringUTF(jenv, result); 
4562
4679
    }
4563
 
    free(result);
 
4680
    g_free(result);
4564
4681
    return jresult;
4565
4682
}
4566
4683
 
4934
5051
    {
4935
5052
        if(result) jresult = (*jenv)->NewStringUTF(jenv, result); 
4936
5053
    }
4937
 
    free(result);
 
5054
    g_free(result);
4938
5055
    return jresult;
4939
5056
}
4940
5057
 
5468
5585
    {
5469
5586
        if(result) jresult = (*jenv)->NewStringUTF(jenv, result); 
5470
5587
    }
5471
 
    free(result);
 
5588
    g_free(result);
5472
5589
    return jresult;
5473
5590
}
5474
5591
 
5616
5733
    {
5617
5734
        if(result) jresult = (*jenv)->NewStringUTF(jenv, result); 
5618
5735
    }
5619
 
    free(result);
 
5736
    g_free(result);
5620
5737
    return jresult;
5621
5738
}
5622
5739
 
5750
5867
    {
5751
5868
        if(result) jresult = (*jenv)->NewStringUTF(jenv, result); 
5752
5869
    }
5753
 
    free(result);
 
5870
    g_free(result);
5754
5871
    return jresult;
5755
5872
}
5756
5873
 
5848
5965
    {
5849
5966
        if(result) jresult = (*jenv)->NewStringUTF(jenv, result); 
5850
5967
    }
5851
 
    free(result);
 
5968
    g_free(result);
5852
5969
    return jresult;
5853
5970
}
5854
5971
 
5918
6035
    {
5919
6036
        if(result) jresult = (*jenv)->NewStringUTF(jenv, result); 
5920
6037
    }
5921
 
    free(result);
 
6038
    g_free(result);
5922
6039
    return jresult;
5923
6040
}
5924
6041
 
5988
6105
    {
5989
6106
        if(result) jresult = (*jenv)->NewStringUTF(jenv, result); 
5990
6107
    }
5991
 
    free(result);
 
6108
    g_free(result);
5992
6109
    return jresult;
5993
6110
}
5994
6111
 
6178
6295
    {
6179
6296
        if(result) jresult = (*jenv)->NewStringUTF(jenv, result); 
6180
6297
    }
6181
 
    free(result);
 
6298
    g_free(result);
6182
6299
    return jresult;
6183
6300
}
6184
6301
 
6358
6475
    {
6359
6476
        if(result) jresult = (*jenv)->NewStringUTF(jenv, result); 
6360
6477
    }
6361
 
    free(result);
 
6478
    g_free(result);
6362
6479
    return jresult;
6363
6480
}
6364
6481
 
6376
6493
    {
6377
6494
        if(result) jresult = (*jenv)->NewStringUTF(jenv, result); 
6378
6495
    }
6379
 
    free(result);
 
6496
    g_free(result);
6380
6497
    return jresult;
6381
6498
}
6382
6499
 
6566
6683
    {
6567
6684
        if(result) jresult = (*jenv)->NewStringUTF(jenv, result); 
6568
6685
    }
6569
 
    free(result);
 
6686
    g_free(result);
6570
6687
    return jresult;
6571
6688
}
6572
6689
 
6746
6863
    {
6747
6864
        if(result) jresult = (*jenv)->NewStringUTF(jenv, result); 
6748
6865
    }
6749
 
    free(result);
 
6866
    g_free(result);
6750
6867
    return jresult;
6751
6868
}
6752
6869
 
6764
6881
    {
6765
6882
        if(result) jresult = (*jenv)->NewStringUTF(jenv, result); 
6766
6883
    }
6767
 
    free(result);
 
6884
    g_free(result);
6768
6885
    return jresult;
6769
6886
}
6770
6887
 
6862
6979
    {
6863
6980
        if(result) jresult = (*jenv)->NewStringUTF(jenv, result); 
6864
6981
    }
6865
 
    free(result);
 
6982
    g_free(result);
6866
6983
    return jresult;
6867
6984
}
6868
6985
 
6978
7095
    {
6979
7096
        if(result) jresult = (*jenv)->NewStringUTF(jenv, result); 
6980
7097
    }
6981
 
    free(result);
 
7098
    g_free(result);
6982
7099
    return jresult;
6983
7100
}
6984
7101
 
7112
7229
    {
7113
7230
        if(result) jresult = (*jenv)->NewStringUTF(jenv, result); 
7114
7231
    }
7115
 
    free(result);
 
7232
    g_free(result);
7116
7233
    return jresult;
7117
7234
}
7118
7235
 
7182
7299
    {
7183
7300
        if(result) jresult = (*jenv)->NewStringUTF(jenv, result); 
7184
7301
    }
7185
 
    free(result);
 
7302
    g_free(result);
7186
7303
    return jresult;
7187
7304
}
7188
7305
 
7228
7345
    {
7229
7346
        if(result) jresult = (*jenv)->NewStringUTF(jenv, result); 
7230
7347
    }
7231
 
    free(result);
 
7348
    g_free(result);
7232
7349
    return jresult;
7233
7350
}
7234
7351
 
7622
7739
    {
7623
7740
        if(result) jresult = (*jenv)->NewStringUTF(jenv, result); 
7624
7741
    }
7625
 
    free(result);
 
7742
    g_free(result);
7626
7743
    return jresult;
7627
7744
}
7628
7745
 
7974
8091
    {
7975
8092
        if(result) jresult = (*jenv)->NewStringUTF(jenv, result); 
7976
8093
    }
7977
 
    free(result);
 
8094
    g_free(result);
7978
8095
    return jresult;
7979
8096
}
7980
8097
 
8428
8545
    {
8429
8546
        if(result) jresult = (*jenv)->NewStringUTF(jenv, result); 
8430
8547
    }
8431
 
    free(result);
 
8548
    g_free(result);
8432
8549
    return jresult;
8433
8550
}
8434
8551
 
8844
8961
    {
8845
8962
        if(result) jresult = (*jenv)->NewStringUTF(jenv, result); 
8846
8963
    }
8847
 
    free(result);
 
8964
    g_free(result);
8848
8965
    return jresult;
8849
8966
}
8850
8967
 
8960
9077
    {
8961
9078
        if(result) jresult = (*jenv)->NewStringUTF(jenv, result); 
8962
9079
    }
8963
 
    free(result);
 
9080
    g_free(result);
8964
9081
    return jresult;
8965
9082
}
8966
9083
 
9076
9193
    {
9077
9194
        if(result) jresult = (*jenv)->NewStringUTF(jenv, result); 
9078
9195
    }
9079
 
    free(result);
 
9196
    g_free(result);
9080
9197
    return jresult;
9081
9198
}
9082
9199
 
9643
9760
    {
9644
9761
        if(result) jresult = (*jenv)->NewStringUTF(jenv, result); 
9645
9762
    }
9646
 
    free(result);
 
9763
    g_free(result);
9647
9764
    return jresult;
9648
9765
}
9649
9766
 
10425
10542
    {
10426
10543
        if(result) jresult = (*jenv)->NewStringUTF(jenv, result); 
10427
10544
    }
10428
 
    free(result);
 
10545
    g_free(result);
10429
10546
    return jresult;
10430
10547
}
10431
10548
 
10674
10791
    {
10675
10792
        if(result) jresult = (*jenv)->NewStringUTF(jenv, result); 
10676
10793
    }
10677
 
    free(result);
 
10794
    g_free(result);
10678
10795
    return jresult;
10679
10796
}
10680
10797
 
11252
11369
    {
11253
11370
        if(result) jresult = (*jenv)->NewStringUTF(jenv, result); 
11254
11371
    }
11255
 
    free(result);
 
11372
    g_free(result);
11256
11373
    return jresult;
11257
11374
}
11258
11375
 
11922
12039
    {
11923
12040
        if(result) jresult = (*jenv)->NewStringUTF(jenv, result); 
11924
12041
    }
11925
 
    free(result);
 
12042
    g_free(result);
11926
12043
    return jresult;
11927
12044
}
11928
12045
 
12145
12262
    {
12146
12263
        if(result) jresult = (*jenv)->NewStringUTF(jenv, result); 
12147
12264
    }
12148
 
    free(result);
 
12265
    g_free(result);
12149
12266
    return jresult;
12150
12267
}
12151
12268
 
12737
12854
    {
12738
12855
        if(result) jresult = (*jenv)->NewStringUTF(jenv, result); 
12739
12856
    }
12740
 
    free(result);
 
12857
    g_free(result);
12741
12858
    return jresult;
12742
12859
}
12743
12860
 
12960
13077
    {
12961
13078
        if(result) jresult = (*jenv)->NewStringUTF(jenv, result); 
12962
13079
    }
12963
 
    free(result);
 
13080
    g_free(result);
12964
13081
    return jresult;
12965
13082
}
12966
13083
 
13104
13221
    {
13105
13222
        if(result) jresult = (*jenv)->NewStringUTF(jenv, result); 
13106
13223
    }
13107
 
    free(result);
 
13224
    g_free(result);
13108
13225
    return jresult;
13109
13226
}
13110
13227
 
13294
13411
    {
13295
13412
        if(result) jresult = (*jenv)->NewStringUTF(jenv, result); 
13296
13413
    }
13297
 
    free(result);
 
13414
    g_free(result);
13298
13415
    return jresult;
13299
13416
}
13300
13417
 
13607
13724
    {
13608
13725
        if(result) jresult = (*jenv)->NewStringUTF(jenv, result); 
13609
13726
    }
13610
 
    free(result);
 
13727
    g_free(result);
13611
13728
    return jresult;
13612
13729
}
13613
13730
 
13665
13782
    {
13666
13783
        if (arg2) (*jenv)->ReleaseStringUTFChars(jenv, jarg2, arg2); 
13667
13784
    }
13668
 
    free(result);
 
13785
    g_free(result);
13669
13786
    return jresult;
13670
13787
}
13671
13788
 
13683
13800
    {
13684
13801
        if(result) jresult = (*jenv)->NewStringUTF(jenv, result); 
13685
13802
    }
13686
 
    free(result);
 
13803
    g_free(result);
13687
13804
    return jresult;
13688
13805
}
13689
13806
 
13701
13818
    {
13702
13819
        if(result) jresult = (*jenv)->NewStringUTF(jenv, result); 
13703
13820
    }
13704
 
    free(result);
 
13821
    g_free(result);
13705
13822
    return jresult;
13706
13823
}
13707
13824
 
13755
13872
    {
13756
13873
        if (arg2) (*jenv)->ReleaseStringUTFChars(jenv, jarg2, arg2); 
13757
13874
    }
13758
 
    free(result);
 
13875
    g_free(result);
13759
13876
    return jresult;
13760
13877
}
13761
13878
 
14116
14233
}
14117
14234
 
14118
14235
 
 
14236
JNIEXPORT void JNICALL Java_com_entrouvert_lasso_lassoJNI_set_1Server_1role(JNIEnv *jenv, jclass jcls, jlong jarg1, jint jarg2) {
 
14237
    LassoServer *arg1 = (LassoServer *) 0 ;
 
14238
    LassoProviderRole arg2 ;
 
14239
    
 
14240
    (void)jenv;
 
14241
    (void)jcls;
 
14242
    arg1 = *(LassoServer **)&jarg1; 
 
14243
    arg2 = (LassoProviderRole)jarg2; 
 
14244
    LassoServer_set_role(arg1,(LassoProviderRole )arg2);
 
14245
    
 
14246
}
 
14247
 
 
14248
 
 
14249
JNIEXPORT jint JNICALL Java_com_entrouvert_lasso_lassoJNI_get_1Server_1role(JNIEnv *jenv, jclass jcls, jlong jarg1) {
 
14250
    jint jresult = 0 ;
 
14251
    LassoServer *arg1 = (LassoServer *) 0 ;
 
14252
    LassoProviderRole result;
 
14253
    
 
14254
    (void)jenv;
 
14255
    (void)jcls;
 
14256
    arg1 = *(LassoServer **)&jarg1; 
 
14257
    result = (LassoProviderRole)LassoServer_get_role(arg1);
 
14258
    
 
14259
    jresult = (jint)result; 
 
14260
    return jresult;
 
14261
}
 
14262
 
 
14263
 
14119
14264
JNIEXPORT jlong JNICALL Java_com_entrouvert_lasso_lassoJNI_get_1Server_1providerIds(JNIEnv *jenv, jclass jcls, jlong jarg1) {
14120
14265
    jlong jresult = 0 ;
14121
14266
    LassoServer *arg1 = (LassoServer *) 0 ;
14276
14421
    {
14277
14422
        if (arg2) (*jenv)->ReleaseStringUTFChars(jenv, jarg2, arg2); 
14278
14423
    }
14279
 
    free(result);
 
14424
    g_free(result);
14280
14425
    return jresult;
14281
14426
}
14282
14427
 
14294
14439
    {
14295
14440
        if(result) jresult = (*jenv)->NewStringUTF(jenv, result); 
14296
14441
    }
14297
 
    free(result);
 
14442
    g_free(result);
14298
14443
    return jresult;
14299
14444
}
14300
14445
 
14312
14457
    {
14313
14458
        if(result) jresult = (*jenv)->NewStringUTF(jenv, result); 
14314
14459
    }
14315
 
    free(result);
 
14460
    g_free(result);
14316
14461
    return jresult;
14317
14462
}
14318
14463
 
14366
14511
    {
14367
14512
        if (arg2) (*jenv)->ReleaseStringUTFChars(jenv, jarg2, arg2); 
14368
14513
    }
14369
 
    free(result);
 
14514
    g_free(result);
14370
14515
    return jresult;
14371
14516
}
14372
14517
 
14445
14590
        
14446
14591
        if (errorCode) {
14447
14592
            char errorMsg[256];
 
14593
            int swig_error = SWIG_RuntimeError;
 
14594
            if (errorCode == -501 || 
 
14595
            errorCode == -501) {
 
14596
                swig_error = SWIG_ValueError;
 
14597
            }
14448
14598
            build_exception_msg(errorCode, errorMsg);
14449
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
 
14599
            SWIG_exception(swig_error, errorMsg);
14450
14600
        }
14451
14601
    }
14452
14602
    jresult = (jint)result; 
14476
14626
    {
14477
14627
        if(result) jresult = (*jenv)->NewStringUTF(jenv, result); 
14478
14628
    }
14479
 
    free(result);
 
14629
    g_free(result);
14480
14630
    return jresult;
14481
14631
}
14482
14632
 
14657
14807
    {
14658
14808
        if(result) jresult = (*jenv)->NewStringUTF(jenv, result); 
14659
14809
    }
14660
 
    free(result);
 
14810
    g_free(result);
14661
14811
    return jresult;
14662
14812
}
14663
14813
 
14814
14964
    {
14815
14965
        if(result) jresult = (*jenv)->NewStringUTF(jenv, result); 
14816
14966
    }
14817
 
    free(result);
 
14967
    g_free(result);
14818
14968
    return jresult;
14819
14969
}
14820
14970
 
14936
15086
    {
14937
15087
        if(result) jresult = (*jenv)->NewStringUTF(jenv, result); 
14938
15088
    }
14939
 
    free(result);
 
15089
    g_free(result);
14940
15090
    return jresult;
14941
15091
}
14942
15092
 
15351
15501
        
15352
15502
        if (errorCode) {
15353
15503
            char errorMsg[256];
 
15504
            int swig_error = SWIG_RuntimeError;
 
15505
            if (errorCode == -501 || 
 
15506
            errorCode == -501) {
 
15507
                swig_error = SWIG_ValueError;
 
15508
            }
15354
15509
            build_exception_msg(errorCode, errorMsg);
15355
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
 
15510
            SWIG_exception(swig_error, errorMsg);
15356
15511
        }
15357
15512
    }
15358
15513
    jresult = (jint)result; 
15385
15540
        
15386
15541
        if (errorCode) {
15387
15542
            char errorMsg[256];
 
15543
            int swig_error = SWIG_RuntimeError;
 
15544
            if (errorCode == -501 || 
 
15545
            errorCode == -501) {
 
15546
                swig_error = SWIG_ValueError;
 
15547
            }
15388
15548
            build_exception_msg(errorCode, errorMsg);
15389
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
 
15549
            SWIG_exception(swig_error, errorMsg);
15390
15550
        }
15391
15551
    }
15392
15552
    jresult = (jint)result; 
15411
15571
        
15412
15572
        if (errorCode) {
15413
15573
            char errorMsg[256];
 
15574
            int swig_error = SWIG_RuntimeError;
 
15575
            if (errorCode == -501 || 
 
15576
            errorCode == -501) {
 
15577
                swig_error = SWIG_ValueError;
 
15578
            }
15414
15579
            build_exception_msg(errorCode, errorMsg);
15415
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
 
15580
            SWIG_exception(swig_error, errorMsg);
15416
15581
        }
15417
15582
    }
15418
15583
    jresult = (jint)result; 
15444
15609
        
15445
15610
        if (errorCode) {
15446
15611
            char errorMsg[256];
 
15612
            int swig_error = SWIG_RuntimeError;
 
15613
            if (errorCode == -501 || 
 
15614
            errorCode == -501) {
 
15615
                swig_error = SWIG_ValueError;
 
15616
            }
15447
15617
            build_exception_msg(errorCode, errorMsg);
15448
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
 
15618
            SWIG_exception(swig_error, errorMsg);
15449
15619
        }
15450
15620
    }
15451
15621
    jresult = (jint)result; 
15478
15648
        
15479
15649
        if (errorCode) {
15480
15650
            char errorMsg[256];
 
15651
            int swig_error = SWIG_RuntimeError;
 
15652
            if (errorCode == -501 || 
 
15653
            errorCode == -501) {
 
15654
                swig_error = SWIG_ValueError;
 
15655
            }
15481
15656
            build_exception_msg(errorCode, errorMsg);
15482
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
 
15657
            SWIG_exception(swig_error, errorMsg);
15483
15658
        }
15484
15659
    }
15485
15660
    jresult = (jint)result; 
15504
15679
        
15505
15680
        if (errorCode) {
15506
15681
            char errorMsg[256];
 
15682
            int swig_error = SWIG_RuntimeError;
 
15683
            if (errorCode == -501 || 
 
15684
            errorCode == -501) {
 
15685
                swig_error = SWIG_ValueError;
 
15686
            }
15507
15687
            build_exception_msg(errorCode, errorMsg);
15508
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
 
15688
            SWIG_exception(swig_error, errorMsg);
15509
15689
        }
15510
15690
    }
15511
15691
    jresult = (jint)result; 
15907
16087
        
15908
16088
        if (errorCode) {
15909
16089
            char errorMsg[256];
 
16090
            int swig_error = SWIG_RuntimeError;
 
16091
            if (errorCode == -501 || 
 
16092
            errorCode == -501) {
 
16093
                swig_error = SWIG_ValueError;
 
16094
            }
15910
16095
            build_exception_msg(errorCode, errorMsg);
15911
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
 
16096
            SWIG_exception(swig_error, errorMsg);
15912
16097
        }
15913
16098
    }
15914
16099
    jresult = (jint)result; 
15941
16126
        
15942
16127
        if (errorCode) {
15943
16128
            char errorMsg[256];
 
16129
            int swig_error = SWIG_RuntimeError;
 
16130
            if (errorCode == -501 || 
 
16131
            errorCode == -501) {
 
16132
                swig_error = SWIG_ValueError;
 
16133
            }
15944
16134
            build_exception_msg(errorCode, errorMsg);
15945
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
 
16135
            SWIG_exception(swig_error, errorMsg);
15946
16136
        }
15947
16137
    }
15948
16138
    jresult = (jint)result; 
15967
16157
        
15968
16158
        if (errorCode) {
15969
16159
            char errorMsg[256];
 
16160
            int swig_error = SWIG_RuntimeError;
 
16161
            if (errorCode == -501 || 
 
16162
            errorCode == -501) {
 
16163
                swig_error = SWIG_ValueError;
 
16164
            }
15970
16165
            build_exception_msg(errorCode, errorMsg);
15971
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
 
16166
            SWIG_exception(swig_error, errorMsg);
15972
16167
        }
15973
16168
    }
15974
16169
    jresult = (jint)result; 
15992
16187
        
15993
16188
        if (errorCode) {
15994
16189
            char errorMsg[256];
 
16190
            int swig_error = SWIG_RuntimeError;
 
16191
            if (errorCode == -501 || 
 
16192
            errorCode == -501) {
 
16193
                swig_error = SWIG_ValueError;
 
16194
            }
15995
16195
            build_exception_msg(errorCode, errorMsg);
15996
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
 
16196
            SWIG_exception(swig_error, errorMsg);
15997
16197
        }
15998
16198
    }
15999
16199
    jresult = (jint)result; 
16055
16255
        
16056
16256
        if (errorCode) {
16057
16257
            char errorMsg[256];
 
16258
            int swig_error = SWIG_RuntimeError;
 
16259
            if (errorCode == -501 || 
 
16260
            errorCode == -501) {
 
16261
                swig_error = SWIG_ValueError;
 
16262
            }
16058
16263
            build_exception_msg(errorCode, errorMsg);
16059
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
 
16264
            SWIG_exception(swig_error, errorMsg);
16060
16265
        }
16061
16266
    }
16062
16267
    jresult = (jint)result; 
16093
16298
        
16094
16299
        if (errorCode) {
16095
16300
            char errorMsg[256];
 
16301
            int swig_error = SWIG_RuntimeError;
 
16302
            if (errorCode == -501 || 
 
16303
            errorCode == -501) {
 
16304
                swig_error = SWIG_ValueError;
 
16305
            }
16096
16306
            build_exception_msg(errorCode, errorMsg);
16097
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
 
16307
            SWIG_exception(swig_error, errorMsg);
16098
16308
        }
16099
16309
    }
16100
16310
    jresult = (jint)result; 
16116
16326
        
16117
16327
        if (errorCode) {
16118
16328
            char errorMsg[256];
 
16329
            int swig_error = SWIG_RuntimeError;
 
16330
            if (errorCode == -501 || 
 
16331
            errorCode == -501) {
 
16332
                swig_error = SWIG_ValueError;
 
16333
            }
16119
16334
            build_exception_msg(errorCode, errorMsg);
16120
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
 
16335
            SWIG_exception(swig_error, errorMsg);
16121
16336
        }
16122
16337
    }
16123
16338
    jresult = (jint)result; 
16139
16354
        
16140
16355
        if (errorCode) {
16141
16356
            char errorMsg[256];
 
16357
            int swig_error = SWIG_RuntimeError;
 
16358
            if (errorCode == -501 || 
 
16359
            errorCode == -501) {
 
16360
                swig_error = SWIG_ValueError;
 
16361
            }
16142
16362
            build_exception_msg(errorCode, errorMsg);
16143
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
 
16363
            SWIG_exception(swig_error, errorMsg);
16144
16364
        }
16145
16365
    }
16146
16366
    jresult = (jint)result; 
16170
16390
        
16171
16391
        if (errorCode) {
16172
16392
            char errorMsg[256];
 
16393
            int swig_error = SWIG_RuntimeError;
 
16394
            if (errorCode == -501 || 
 
16395
            errorCode == -501) {
 
16396
                swig_error = SWIG_ValueError;
 
16397
            }
16173
16398
            build_exception_msg(errorCode, errorMsg);
16174
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
 
16399
            SWIG_exception(swig_error, errorMsg);
16175
16400
        }
16176
16401
    }
16177
16402
    jresult = (jint)result; 
16195
16420
    {
16196
16421
        if(result) jresult = (*jenv)->NewStringUTF(jenv, result); 
16197
16422
    }
16198
 
    free(result);
 
16423
    g_free(result);
16199
16424
    return jresult;
16200
16425
}
16201
16426
 
16224
16449
        
16225
16450
        if (errorCode) {
16226
16451
            char errorMsg[256];
 
16452
            int swig_error = SWIG_RuntimeError;
 
16453
            if (errorCode == -501 || 
 
16454
            errorCode == -501) {
 
16455
                swig_error = SWIG_ValueError;
 
16456
            }
16227
16457
            build_exception_msg(errorCode, errorMsg);
16228
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
 
16458
            SWIG_exception(swig_error, errorMsg);
16229
16459
        }
16230
16460
    }
16231
16461
    jresult = (jint)result; 
16260
16490
        
16261
16491
        if (errorCode) {
16262
16492
            char errorMsg[256];
 
16493
            int swig_error = SWIG_RuntimeError;
 
16494
            if (errorCode == -501 || 
 
16495
            errorCode == -501) {
 
16496
                swig_error = SWIG_ValueError;
 
16497
            }
16263
16498
            build_exception_msg(errorCode, errorMsg);
16264
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
 
16499
            SWIG_exception(swig_error, errorMsg);
16265
16500
        }
16266
16501
    }
16267
16502
    jresult = (jint)result; 
16294
16529
        
16295
16530
        if (errorCode) {
16296
16531
            char errorMsg[256];
 
16532
            int swig_error = SWIG_RuntimeError;
 
16533
            if (errorCode == -501 || 
 
16534
            errorCode == -501) {
 
16535
                swig_error = SWIG_ValueError;
 
16536
            }
16297
16537
            build_exception_msg(errorCode, errorMsg);
16298
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
 
16538
            SWIG_exception(swig_error, errorMsg);
16299
16539
        }
16300
16540
    }
16301
16541
    jresult = (jint)result; 
16358
16598
        
16359
16599
        if (errorCode) {
16360
16600
            char errorMsg[256];
 
16601
            int swig_error = SWIG_RuntimeError;
 
16602
            if (errorCode == -501 || 
 
16603
            errorCode == -501) {
 
16604
                swig_error = SWIG_ValueError;
 
16605
            }
16361
16606
            build_exception_msg(errorCode, errorMsg);
16362
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
 
16607
            SWIG_exception(swig_error, errorMsg);
16363
16608
        }
16364
16609
    }
16365
16610
    jresult = (jint)result; 
16392
16637
        
16393
16638
        if (errorCode) {
16394
16639
            char errorMsg[256];
 
16640
            int swig_error = SWIG_RuntimeError;
 
16641
            if (errorCode == -501 || 
 
16642
            errorCode == -501) {
 
16643
                swig_error = SWIG_ValueError;
 
16644
            }
16395
16645
            build_exception_msg(errorCode, errorMsg);
16396
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
 
16646
            SWIG_exception(swig_error, errorMsg);
16397
16647
        }
16398
16648
    }
16399
16649
    jresult = (jint)result; 
16426
16676
        
16427
16677
        if (errorCode) {
16428
16678
            char errorMsg[256];
 
16679
            int swig_error = SWIG_RuntimeError;
 
16680
            if (errorCode == -501 || 
 
16681
            errorCode == -501) {
 
16682
                swig_error = SWIG_ValueError;
 
16683
            }
16429
16684
            build_exception_msg(errorCode, errorMsg);
16430
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
 
16685
            SWIG_exception(swig_error, errorMsg);
16431
16686
        }
16432
16687
    }
16433
16688
    jresult = (jint)result; 
16460
16715
        
16461
16716
        if (errorCode) {
16462
16717
            char errorMsg[256];
 
16718
            int swig_error = SWIG_RuntimeError;
 
16719
            if (errorCode == -501 || 
 
16720
            errorCode == -501) {
 
16721
                swig_error = SWIG_ValueError;
 
16722
            }
16463
16723
            build_exception_msg(errorCode, errorMsg);
16464
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
 
16724
            SWIG_exception(swig_error, errorMsg);
16465
16725
        }
16466
16726
    }
16467
16727
    jresult = (jint)result; 
16494
16754
        
16495
16755
        if (errorCode) {
16496
16756
            char errorMsg[256];
 
16757
            int swig_error = SWIG_RuntimeError;
 
16758
            if (errorCode == -501 || 
 
16759
            errorCode == -501) {
 
16760
                swig_error = SWIG_ValueError;
 
16761
            }
16497
16762
            build_exception_msg(errorCode, errorMsg);
16498
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
 
16763
            SWIG_exception(swig_error, errorMsg);
16499
16764
        }
16500
16765
    }
16501
16766
    jresult = (jint)result; 
16524
16789
        
16525
16790
        if (errorCode) {
16526
16791
            char errorMsg[256];
 
16792
            int swig_error = SWIG_RuntimeError;
 
16793
            if (errorCode == -501 || 
 
16794
            errorCode == -501) {
 
16795
                swig_error = SWIG_ValueError;
 
16796
            }
16527
16797
            build_exception_msg(errorCode, errorMsg);
16528
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
 
16798
            SWIG_exception(swig_error, errorMsg);
16529
16799
        }
16530
16800
    }
16531
16801
    jresult = (jint)result; 
16895
17165
        
16896
17166
        if (errorCode) {
16897
17167
            char errorMsg[256];
 
17168
            int swig_error = SWIG_RuntimeError;
 
17169
            if (errorCode == -501 || 
 
17170
            errorCode == -501) {
 
17171
                swig_error = SWIG_ValueError;
 
17172
            }
16898
17173
            build_exception_msg(errorCode, errorMsg);
16899
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
 
17174
            SWIG_exception(swig_error, errorMsg);
16900
17175
        }
16901
17176
    }
16902
17177
    jresult = (jint)result; 
16929
17204
        
16930
17205
        if (errorCode) {
16931
17206
            char errorMsg[256];
 
17207
            int swig_error = SWIG_RuntimeError;
 
17208
            if (errorCode == -501 || 
 
17209
            errorCode == -501) {
 
17210
                swig_error = SWIG_ValueError;
 
17211
            }
16932
17212
            build_exception_msg(errorCode, errorMsg);
16933
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
 
17213
            SWIG_exception(swig_error, errorMsg);
16934
17214
        }
16935
17215
    }
16936
17216
    jresult = (jint)result; 
16955
17235
        
16956
17236
        if (errorCode) {
16957
17237
            char errorMsg[256];
 
17238
            int swig_error = SWIG_RuntimeError;
 
17239
            if (errorCode == -501 || 
 
17240
            errorCode == -501) {
 
17241
                swig_error = SWIG_ValueError;
 
17242
            }
16958
17243
            build_exception_msg(errorCode, errorMsg);
16959
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
 
17244
            SWIG_exception(swig_error, errorMsg);
16960
17245
        }
16961
17246
    }
16962
17247
    jresult = (jint)result; 
16978
17263
        
16979
17264
        if (errorCode) {
16980
17265
            char errorMsg[256];
 
17266
            int swig_error = SWIG_RuntimeError;
 
17267
            if (errorCode == -501 || 
 
17268
            errorCode == -501) {
 
17269
                swig_error = SWIG_ValueError;
 
17270
            }
16981
17271
            build_exception_msg(errorCode, errorMsg);
16982
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
 
17272
            SWIG_exception(swig_error, errorMsg);
16983
17273
        }
16984
17274
    }
16985
17275
    jresult = (jint)result; 
17000
17290
    {
17001
17291
        if(result) jresult = (*jenv)->NewStringUTF(jenv, result); 
17002
17292
    }
17003
 
    free(result);
 
17293
    g_free(result);
17004
17294
    return jresult;
17005
17295
}
17006
17296
 
17018
17308
    {
17019
17309
        if(result) jresult = (*jenv)->NewStringUTF(jenv, result); 
17020
17310
    }
17021
 
    free(result);
 
17311
    g_free(result);
17022
17312
    return jresult;
17023
17313
}
17024
17314
 
17047
17337
        
17048
17338
        if (errorCode) {
17049
17339
            char errorMsg[256];
 
17340
            int swig_error = SWIG_RuntimeError;
 
17341
            if (errorCode == -501 || 
 
17342
            errorCode == -501) {
 
17343
                swig_error = SWIG_ValueError;
 
17344
            }
17050
17345
            build_exception_msg(errorCode, errorMsg);
17051
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
 
17346
            SWIG_exception(swig_error, errorMsg);
17052
17347
        }
17053
17348
    }
17054
17349
    jresult = (jint)result; 
17081
17376
        
17082
17377
        if (errorCode) {
17083
17378
            char errorMsg[256];
 
17379
            int swig_error = SWIG_RuntimeError;
 
17380
            if (errorCode == -501 || 
 
17381
            errorCode == -501) {
 
17382
                swig_error = SWIG_ValueError;
 
17383
            }
17084
17384
            build_exception_msg(errorCode, errorMsg);
17085
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
 
17385
            SWIG_exception(swig_error, errorMsg);
17086
17386
        }
17087
17387
    }
17088
17388
    jresult = (jint)result; 
17115
17415
        
17116
17416
        if (errorCode) {
17117
17417
            char errorMsg[256];
 
17418
            int swig_error = SWIG_RuntimeError;
 
17419
            if (errorCode == -501 || 
 
17420
            errorCode == -501) {
 
17421
                swig_error = SWIG_ValueError;
 
17422
            }
17118
17423
            build_exception_msg(errorCode, errorMsg);
17119
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
 
17424
            SWIG_exception(swig_error, errorMsg);
17120
17425
        }
17121
17426
    }
17122
17427
    jresult = (jint)result; 
17141
17446
        
17142
17447
        if (errorCode) {
17143
17448
            char errorMsg[256];
 
17449
            int swig_error = SWIG_RuntimeError;
 
17450
            if (errorCode == -501 || 
 
17451
            errorCode == -501) {
 
17452
                swig_error = SWIG_ValueError;
 
17453
            }
17144
17454
            build_exception_msg(errorCode, errorMsg);
17145
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
 
17455
            SWIG_exception(swig_error, errorMsg);
17146
17456
        }
17147
17457
    }
17148
17458
    jresult = (jint)result; 
17164
17474
        
17165
17475
        if (errorCode) {
17166
17476
            char errorMsg[256];
 
17477
            int swig_error = SWIG_RuntimeError;
 
17478
            if (errorCode == -501 || 
 
17479
            errorCode == -501) {
 
17480
                swig_error = SWIG_ValueError;
 
17481
            }
17167
17482
            build_exception_msg(errorCode, errorMsg);
17168
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
 
17483
            SWIG_exception(swig_error, errorMsg);
17169
17484
        }
17170
17485
    }
17171
17486
    jresult = (jint)result; 
17509
17824
        
17510
17825
        if (errorCode) {
17511
17826
            char errorMsg[256];
 
17827
            int swig_error = SWIG_RuntimeError;
 
17828
            if (errorCode == -501 || 
 
17829
            errorCode == -501) {
 
17830
                swig_error = SWIG_ValueError;
 
17831
            }
17512
17832
            build_exception_msg(errorCode, errorMsg);
17513
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
 
17833
            SWIG_exception(swig_error, errorMsg);
17514
17834
        }
17515
17835
    }
17516
17836
    jresult = (jint)result; 
17543
17863
        
17544
17864
        if (errorCode) {
17545
17865
            char errorMsg[256];
 
17866
            int swig_error = SWIG_RuntimeError;
 
17867
            if (errorCode == -501 || 
 
17868
            errorCode == -501) {
 
17869
                swig_error = SWIG_ValueError;
 
17870
            }
17546
17871
            build_exception_msg(errorCode, errorMsg);
17547
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
 
17872
            SWIG_exception(swig_error, errorMsg);
17548
17873
        }
17549
17874
    }
17550
17875
    jresult = (jint)result; 
17609
17934
        
17610
17935
        if (errorCode) {
17611
17936
            char errorMsg[256];
 
17937
            int swig_error = SWIG_RuntimeError;
 
17938
            if (errorCode == -501 || 
 
17939
            errorCode == -501) {
 
17940
                swig_error = SWIG_ValueError;
 
17941
            }
17612
17942
            build_exception_msg(errorCode, errorMsg);
17613
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
 
17943
            SWIG_exception(swig_error, errorMsg);
17614
17944
        }
17615
17945
    }
17616
17946
    jresult = (jint)result; 
17655
17985
        
17656
17986
        if (errorCode) {
17657
17987
            char errorMsg[256];
 
17988
            int swig_error = SWIG_RuntimeError;
 
17989
            if (errorCode == -501 || 
 
17990
            errorCode == -501) {
 
17991
                swig_error = SWIG_ValueError;
 
17992
            }
17658
17993
            build_exception_msg(errorCode, errorMsg);
17659
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
 
17994
            SWIG_exception(swig_error, errorMsg);
17660
17995
        }
17661
17996
    }
17662
17997
    jresult = (jint)result; 
17685
18020
        
17686
18021
        if (errorCode) {
17687
18022
            char errorMsg[256];
 
18023
            int swig_error = SWIG_RuntimeError;
 
18024
            if (errorCode == -501 || 
 
18025
            errorCode == -501) {
 
18026
                swig_error = SWIG_ValueError;
 
18027
            }
17688
18028
            build_exception_msg(errorCode, errorMsg);
17689
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
 
18029
            SWIG_exception(swig_error, errorMsg);
17690
18030
        }
17691
18031
    }
17692
18032
    jresult = (jint)result; 
17708
18048
        
17709
18049
        if (errorCode) {
17710
18050
            char errorMsg[256];
 
18051
            int swig_error = SWIG_RuntimeError;
 
18052
            if (errorCode == -501 || 
 
18053
            errorCode == -501) {
 
18054
                swig_error = SWIG_ValueError;
 
18055
            }
17711
18056
            build_exception_msg(errorCode, errorMsg);
17712
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
 
18057
            SWIG_exception(swig_error, errorMsg);
17713
18058
        }
17714
18059
    }
17715
18060
    jresult = (jint)result; 
17731
18076
        
17732
18077
        if (errorCode) {
17733
18078
            char errorMsg[256];
 
18079
            int swig_error = SWIG_RuntimeError;
 
18080
            if (errorCode == -501 || 
 
18081
            errorCode == -501) {
 
18082
                swig_error = SWIG_ValueError;
 
18083
            }
17734
18084
            build_exception_msg(errorCode, errorMsg);
17735
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
 
18085
            SWIG_exception(swig_error, errorMsg);
17736
18086
        }
17737
18087
    }
17738
18088
    jresult = (jint)result; 
17754
18104
        
17755
18105
        if (errorCode) {
17756
18106
            char errorMsg[256];
 
18107
            int swig_error = SWIG_RuntimeError;
 
18108
            if (errorCode == -501 || 
 
18109
            errorCode == -501) {
 
18110
                swig_error = SWIG_ValueError;
 
18111
            }
17757
18112
            build_exception_msg(errorCode, errorMsg);
17758
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
 
18113
            SWIG_exception(swig_error, errorMsg);
17759
18114
        }
17760
18115
    }
17761
18116
    jresult = (jint)result; 
17777
18132
        
17778
18133
        if (errorCode) {
17779
18134
            char errorMsg[256];
 
18135
            int swig_error = SWIG_RuntimeError;
 
18136
            if (errorCode == -501 || 
 
18137
            errorCode == -501) {
 
18138
                swig_error = SWIG_ValueError;
 
18139
            }
17780
18140
            build_exception_msg(errorCode, errorMsg);
17781
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
 
18141
            SWIG_exception(swig_error, errorMsg);
17782
18142
        }
17783
18143
    }
17784
18144
    jresult = (jint)result; 
17808
18168
        
17809
18169
        if (errorCode) {
17810
18170
            char errorMsg[256];
 
18171
            int swig_error = SWIG_RuntimeError;
 
18172
            if (errorCode == -501 || 
 
18173
            errorCode == -501) {
 
18174
                swig_error = SWIG_ValueError;
 
18175
            }
17811
18176
            build_exception_msg(errorCode, errorMsg);
17812
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
 
18177
            SWIG_exception(swig_error, errorMsg);
17813
18178
        }
17814
18179
    }
17815
18180
    jresult = (jint)result; 
17842
18207
        
17843
18208
        if (errorCode) {
17844
18209
            char errorMsg[256];
 
18210
            int swig_error = SWIG_RuntimeError;
 
18211
            if (errorCode == -501 || 
 
18212
            errorCode == -501) {
 
18213
                swig_error = SWIG_ValueError;
 
18214
            }
17845
18215
            build_exception_msg(errorCode, errorMsg);
17846
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
 
18216
            SWIG_exception(swig_error, errorMsg);
17847
18217
        }
17848
18218
    }
17849
18219
    jresult = (jint)result; 
17876
18246
        
17877
18247
        if (errorCode) {
17878
18248
            char errorMsg[256];
 
18249
            int swig_error = SWIG_RuntimeError;
 
18250
            if (errorCode == -501 || 
 
18251
            errorCode == -501) {
 
18252
                swig_error = SWIG_ValueError;
 
18253
            }
17879
18254
            build_exception_msg(errorCode, errorMsg);
17880
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
 
18255
            SWIG_exception(swig_error, errorMsg);
17881
18256
        }
17882
18257
    }
17883
18258
    jresult = (jint)result; 
17910
18285
        
17911
18286
        if (errorCode) {
17912
18287
            char errorMsg[256];
 
18288
            int swig_error = SWIG_RuntimeError;
 
18289
            if (errorCode == -501 || 
 
18290
            errorCode == -501) {
 
18291
                swig_error = SWIG_ValueError;
 
18292
            }
17913
18293
            build_exception_msg(errorCode, errorMsg);
17914
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
 
18294
            SWIG_exception(swig_error, errorMsg);
17915
18295
        }
17916
18296
    }
17917
18297
    jresult = (jint)result; 
18258
18638
        
18259
18639
        if (errorCode) {
18260
18640
            char errorMsg[256];
 
18641
            int swig_error = SWIG_RuntimeError;
 
18642
            if (errorCode == -501 || 
 
18643
            errorCode == -501) {
 
18644
                swig_error = SWIG_ValueError;
 
18645
            }
18261
18646
            build_exception_msg(errorCode, errorMsg);
18262
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
 
18647
            SWIG_exception(swig_error, errorMsg);
18263
18648
        }
18264
18649
    }
18265
18650
    jresult = (jint)result; 
18292
18677
        
18293
18678
        if (errorCode) {
18294
18679
            char errorMsg[256];
 
18680
            int swig_error = SWIG_RuntimeError;
 
18681
            if (errorCode == -501 || 
 
18682
            errorCode == -501) {
 
18683
                swig_error = SWIG_ValueError;
 
18684
            }
18295
18685
            build_exception_msg(errorCode, errorMsg);
18296
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
 
18686
            SWIG_exception(swig_error, errorMsg);
18297
18687
        }
18298
18688
    }
18299
18689
    jresult = (jint)result; 
18318
18708
        
18319
18709
        if (errorCode) {
18320
18710
            char errorMsg[256];
 
18711
            int swig_error = SWIG_RuntimeError;
 
18712
            if (errorCode == -501 || 
 
18713
            errorCode == -501) {
 
18714
                swig_error = SWIG_ValueError;
 
18715
            }
18321
18716
            build_exception_msg(errorCode, errorMsg);
18322
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
 
18717
            SWIG_exception(swig_error, errorMsg);
18323
18718
        }
18324
18719
    }
18325
18720
    jresult = (jint)result; 
18341
18736
        
18342
18737
        if (errorCode) {
18343
18738
            char errorMsg[256];
 
18739
            int swig_error = SWIG_RuntimeError;
 
18740
            if (errorCode == -501 || 
 
18741
            errorCode == -501) {
 
18742
                swig_error = SWIG_ValueError;
 
18743
            }
18344
18744
            build_exception_msg(errorCode, errorMsg);
18345
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
 
18745
            SWIG_exception(swig_error, errorMsg);
18346
18746
        }
18347
18747
    }
18348
18748
    jresult = (jint)result; 
18380
18780
        
18381
18781
        if (errorCode) {
18382
18782
            char errorMsg[256];
 
18783
            int swig_error = SWIG_RuntimeError;
 
18784
            if (errorCode == -501 || 
 
18785
            errorCode == -501) {
 
18786
                swig_error = SWIG_ValueError;
 
18787
            }
18383
18788
            build_exception_msg(errorCode, errorMsg);
18384
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
 
18789
            SWIG_exception(swig_error, errorMsg);
18385
18790
        }
18386
18791
    }
18387
18792
    jresult = (jint)result; 
18417
18822
        
18418
18823
        if (errorCode) {
18419
18824
            char errorMsg[256];
 
18825
            int swig_error = SWIG_RuntimeError;
 
18826
            if (errorCode == -501 || 
 
18827
            errorCode == -501) {
 
18828
                swig_error = SWIG_ValueError;
 
18829
            }
18420
18830
            build_exception_msg(errorCode, errorMsg);
18421
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
 
18831
            SWIG_exception(swig_error, errorMsg);
18422
18832
        }
18423
18833
    }
18424
18834
    jresult = (jint)result; 
18451
18861
        
18452
18862
        if (errorCode) {
18453
18863
            char errorMsg[256];
 
18864
            int swig_error = SWIG_RuntimeError;
 
18865
            if (errorCode == -501 || 
 
18866
            errorCode == -501) {
 
18867
                swig_error = SWIG_ValueError;
 
18868
            }
18454
18869
            build_exception_msg(errorCode, errorMsg);
18455
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
 
18870
            SWIG_exception(swig_error, errorMsg);
18456
18871
        }
18457
18872
    }
18458
18873
    jresult = (jint)result; 
18477
18892
        
18478
18893
        if (errorCode) {
18479
18894
            char errorMsg[256];
 
18895
            int swig_error = SWIG_RuntimeError;
 
18896
            if (errorCode == -501 || 
 
18897
            errorCode == -501) {
 
18898
                swig_error = SWIG_ValueError;
 
18899
            }
18480
18900
            build_exception_msg(errorCode, errorMsg);
18481
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
 
18901
            SWIG_exception(swig_error, errorMsg);
18482
18902
        }
18483
18903
    }
18484
18904
    jresult = (jint)result; 
18876
19296
        
18877
19297
        if (errorCode) {
18878
19298
            char errorMsg[256];
 
19299
            int swig_error = SWIG_RuntimeError;
 
19300
            if (errorCode == -501 || 
 
19301
            errorCode == -501) {
 
19302
                swig_error = SWIG_ValueError;
 
19303
            }
18879
19304
            build_exception_msg(errorCode, errorMsg);
18880
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
 
19305
            SWIG_exception(swig_error, errorMsg);
18881
19306
        }
18882
19307
    }
18883
19308
    jresult = (jint)result; 
18910
19335
        
18911
19336
        if (errorCode) {
18912
19337
            char errorMsg[256];
 
19338
            int swig_error = SWIG_RuntimeError;
 
19339
            if (errorCode == -501 || 
 
19340
            errorCode == -501) {
 
19341
                swig_error = SWIG_ValueError;
 
19342
            }
18913
19343
            build_exception_msg(errorCode, errorMsg);
18914
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
 
19344
            SWIG_exception(swig_error, errorMsg);
18915
19345
        }
18916
19346
    }
18917
19347
    jresult = (jint)result; 
18936
19366
        
18937
19367
        if (errorCode) {
18938
19368
            char errorMsg[256];
 
19369
            int swig_error = SWIG_RuntimeError;
 
19370
            if (errorCode == -501 || 
 
19371
            errorCode == -501) {
 
19372
                swig_error = SWIG_ValueError;
 
19373
            }
18939
19374
            build_exception_msg(errorCode, errorMsg);
18940
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
 
19375
            SWIG_exception(swig_error, errorMsg);
18941
19376
        }
18942
19377
    }
18943
19378
    jresult = (jint)result; 
18959
19394
        
18960
19395
        if (errorCode) {
18961
19396
            char errorMsg[256];
 
19397
            int swig_error = SWIG_RuntimeError;
 
19398
            if (errorCode == -501 || 
 
19399
            errorCode == -501) {
 
19400
                swig_error = SWIG_ValueError;
 
19401
            }
18962
19402
            build_exception_msg(errorCode, errorMsg);
18963
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
 
19403
            SWIG_exception(swig_error, errorMsg);
18964
19404
        }
18965
19405
    }
18966
19406
    jresult = (jint)result; 
18981
19421
    {
18982
19422
        if(result) jresult = (*jenv)->NewStringUTF(jenv, result); 
18983
19423
    }
18984
 
    free(result);
 
19424
    g_free(result);
18985
19425
    return jresult;
18986
19426
}
18987
19427
 
19010
19450
        
19011
19451
        if (errorCode) {
19012
19452
            char errorMsg[256];
 
19453
            int swig_error = SWIG_RuntimeError;
 
19454
            if (errorCode == -501 || 
 
19455
            errorCode == -501) {
 
19456
                swig_error = SWIG_ValueError;
 
19457
            }
19013
19458
            build_exception_msg(errorCode, errorMsg);
19014
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
 
19459
            SWIG_exception(swig_error, errorMsg);
19015
19460
        }
19016
19461
    }
19017
19462
    jresult = (jint)result; 
19044
19489
        
19045
19490
        if (errorCode) {
19046
19491
            char errorMsg[256];
 
19492
            int swig_error = SWIG_RuntimeError;
 
19493
            if (errorCode == -501 || 
 
19494
            errorCode == -501) {
 
19495
                swig_error = SWIG_ValueError;
 
19496
            }
19047
19497
            build_exception_msg(errorCode, errorMsg);
19048
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
 
19498
            SWIG_exception(swig_error, errorMsg);
19049
19499
        }
19050
19500
    }
19051
19501
    jresult = (jint)result; 
19078
19528
        
19079
19529
        if (errorCode) {
19080
19530
            char errorMsg[256];
 
19531
            int swig_error = SWIG_RuntimeError;
 
19532
            if (errorCode == -501 || 
 
19533
            errorCode == -501) {
 
19534
                swig_error = SWIG_ValueError;
 
19535
            }
19081
19536
            build_exception_msg(errorCode, errorMsg);
19082
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
 
19537
            SWIG_exception(swig_error, errorMsg);
19083
19538
        }
19084
19539
    }
19085
19540
    jresult = (jint)result; 
19104
19559
        
19105
19560
        if (errorCode) {
19106
19561
            char errorMsg[256];
 
19562
            int swig_error = SWIG_RuntimeError;
 
19563
            if (errorCode == -501 || 
 
19564
            errorCode == -501) {
 
19565
                swig_error = SWIG_ValueError;
 
19566
            }
19107
19567
            build_exception_msg(errorCode, errorMsg);
19108
 
            SWIG_exception(SWIG_UnknownError, errorMsg);
 
19568
            SWIG_exception(swig_error, errorMsg);
19109
19569
        }
19110
19570
    }
19111
19571
    jresult = (jint)result;