10.0.0.21 Git - tlspool/blob - lib/go/tlspool.c

   1 /* ----------------------------------------------------------------------------
   2  * This file was automatically generated by SWIG (http://www.swig.org).
   3  * Version 3.0.10
   4  *
   5  * This file is not intended to be easily readable and contains a number of
   6  * coding conventions designed to improve portability and efficiency. Do not make
   7  * changes to this file unless you know what you are doing--modify the SWIG
   8  * interface file instead.
   9  * ----------------------------------------------------------------------------- */
  10
  11 /* source: go-tlspool.i */
  12
  13 #define SWIGMODULE tlspool
  14 /* -----------------------------------------------------------------------------
  15  *  This section contains generic SWIG labels for method/variable
  16  *  declarations/attributes, and other compiler dependent labels.
  17  * ----------------------------------------------------------------------------- */
  18
  19 /* template workaround for compilers that cannot correctly implement the C++ standard */
  20 #ifndef SWIGTEMPLATEDISAMBIGUATOR
  21 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
  22 #  define SWIGTEMPLATEDISAMBIGUATOR template
  23 # elif defined(__HP_aCC)
  24 /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
  25 /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
  26 #  define SWIGTEMPLATEDISAMBIGUATOR template
  27 # else
  28 #  define SWIGTEMPLATEDISAMBIGUATOR
  29 # endif
  30 #endif
  31
  32 /* inline attribute */
  33 #ifndef SWIGINLINE
  34 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
  35 #   define SWIGINLINE inline
  36 # else
  37 #   define SWIGINLINE
  38 # endif
  39 #endif
  40
  41 /* attribute recognised by some compilers to avoid 'unused' warnings */
  42 #ifndef SWIGUNUSED
  43 # if defined(__GNUC__)
  44 #   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
  45 #     define SWIGUNUSED __attribute__ ((__unused__))
  46 #   else
  47 #     define SWIGUNUSED
  48 #   endif
  49 # elif defined(__ICC)
  50 #   define SWIGUNUSED __attribute__ ((__unused__))
  51 # else
  52 #   define SWIGUNUSED
  53 # endif
  54 #endif
  55
  56 #ifndef SWIG_MSC_UNSUPPRESS_4505
  57 # if defined(_MSC_VER)
  58 #   pragma warning(disable : 4505) /* unreferenced local function has been removed */
  59 # endif
  60 #endif
  61
  62 #ifndef SWIGUNUSEDPARM
  63 # ifdef __cplusplus
  64 #   define SWIGUNUSEDPARM(p)
  65 # else
  66 #   define SWIGUNUSEDPARM(p) p SWIGUNUSED
  67 # endif
  68 #endif
  69
  70 /* internal SWIG method */
  71 #ifndef SWIGINTERN
  72 # define SWIGINTERN static SWIGUNUSED
  73 #endif
  74
  75 /* internal inline SWIG method */
  76 #ifndef SWIGINTERNINLINE
  77 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
  78 #endif
  79
  80 /* exporting methods */
  81 #if defined(__GNUC__)
  82 #  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
  83 #    ifndef GCC_HASCLASSVISIBILITY
  84 #      define GCC_HASCLASSVISIBILITY
  85 #    endif
  86 #  endif
  87 #endif
  88
  89 #ifndef SWIGEXPORT
  90 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
  91 #   if defined(STATIC_LINKED)
  92 #     define SWIGEXPORT
  93 #   else
  94 #     define SWIGEXPORT __declspec(dllexport)
  95 #   endif
  96 # else
  97 #   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
  98 #     define SWIGEXPORT __attribute__ ((visibility("default")))
  99 #   else
 100 #     define SWIGEXPORT
 101 #   endif
 102 # endif
 103 #endif
 104
 105 /* calling conventions for Windows */
 106 #ifndef SWIGSTDCALL
 107 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 108 #   define SWIGSTDCALL __stdcall
 109 # else
 110 #   define SWIGSTDCALL
 111 # endif
 112 #endif
 113
 114 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
 115 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
 116 # define _CRT_SECURE_NO_DEPRECATE
 117 #endif
 118
 119 /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
 120 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
 121 # define _SCL_SECURE_NO_DEPRECATE
 122 #endif
 123
 124 /* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
 125 #if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
 126 # define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
 127 #endif
 128
 129 /* Intel's compiler complains if a variable which was never initialised is
 130  * cast to void, which is a common idiom which we use to indicate that we
 131  * are aware a variable isn't used.  So we just silence that warning.
 132  * See: https://github.com/swig/swig/issues/192 for more discussion.
 133  */
 134 #ifdef __INTEL_COMPILER
 135 # pragma warning disable 592
 136 #endif
 137
 138
 139 #include <stddef.h>
 140 #include <stdio.h>
 141 #include <stdlib.h>
 142 #include <string.h>
 143 #include <sys/types.h>
 144
 145
 146
 147 typedef long long intgo;
 148 typedef unsigned long long uintgo;
 149
 150
 151 # if !defined(__clang__) && (defined(__i386__) || defined(__x86_64__))
 152 #   define SWIGSTRUCTPACKED __attribute__((__packed__, __gcc_struct__))
 153 # else
 154 #   define SWIGSTRUCTPACKED __attribute__((__packed__))
 155 # endif
 156
 157
 158
 159 typedef struct { char *p; intgo n; } _gostring_;
 160 typedef struct { void* array; intgo len; intgo cap; } _goslice_;
 161
 162
 163
 164
 165 #define swiggo_size_assert_eq(x, y, name) typedef char name[(x-y)*(x-y)*-2+1];
 166 #define swiggo_size_assert(t, n) swiggo_size_assert_eq(sizeof(t), n, swiggo_sizeof_##t##_is_not_##n)
 167
 168 swiggo_size_assert(char, 1)
 169 swiggo_size_assert(short, 2)
 170 swiggo_size_assert(int, 4)
 171 typedef long long swiggo_long_long;
 172 swiggo_size_assert(swiggo_long_long, 8)
 173 swiggo_size_assert(float, 4)
 174 swiggo_size_assert(double, 8)
 175
 176 #ifdef __cplusplus
 177 extern "C" {
 178 #endif
 179 extern void crosscall2(void (*fn)(void *, int), void *, int);
 180 extern char* _cgo_topofstack(void) __attribute__ ((weak));
 181 extern void _cgo_allocate(void *, int);
 182 extern void _cgo_panic(void *, int);
 183 #ifdef __cplusplus
 184 }
 185 #endif
 186
 187 static char *_swig_topofstack() {
 188   if (_cgo_topofstack) {
 189     return _cgo_topofstack();
 190   } else {
 191     return 0;
 192   }
 193 }
 194
 195 static void _swig_gopanic(const char *p) {
 196   struct {
 197     const char *p;
 198   } SWIGSTRUCTPACKED a;
 199   a.p = p;
 200   crosscall2(_cgo_panic, &a, (int) sizeof a);
 201 }
 202
 203
 204
 205
 206 #define SWIG_contract_assert(expr, msg) \
 207   if (!(expr)) { _swig_gopanic(msg); } else
 208
 209
 210 static _gostring_ Swig_AllocateString(const char *p, size_t l) {
 211   _gostring_ ret;
 212   ret.p = (char*)malloc(l);
 213   memcpy(ret.p, p, l);
 214   ret.n = l;
 215   return ret;
 216 }
 217
 218
 219 static void Swig_free(void* p) {
 220   free(p);
 221 }
 222
 223 static void* Swig_malloc(int c) {
 224   return malloc(c);
 225 }
 226
 227
 228
 229 #include <tlspool/starttls.h>
 230 #include <tlspool/commands.h>
 231
 232
 233
 234
 235         typedef char identity_t [128];
 236
 237         typedef uint8_t ctlkey_t [16];
 238
 239         typedef char service_t [16];
 240
 241         typedef int pool_handle_t;
 242
 243         typedef struct {
 244                 int tlserrno;
 245                 char message [128];
 246         } error_data;
 247
 248         typedef struct {
 249                 char YYYYMMDD_producer [8+128]; // when & who?
 250                 uint32_t facilities;            // PIOF_FACILITY_xxx
 251         } ping_data;
 252
 253         typedef struct {
 254                 uint32_t flags;
 255                 uint32_t local;
 256                 uint8_t ipproto;
 257                 uint16_t streamid;
 258                 identity_t localid;
 259                 identity_t remoteid;
 260                 ctlkey_t ctlkey;
 261                 service_t service;
 262                 uint32_t timeout;
 263         } starttls_data;
 264
 265         typedef struct {
 266                 uint32_t flags;
 267                 ctlkey_t ctlkey;
 268                 identity_t name;
 269         } control_data;
 270
 271         typedef struct {
 272                 int16_t in1_len, in2_len, prng_len;
 273                 uint8_t buffer [350];
 274         } prng_data;
 275
 276         typedef union {
 277                 int unix_socket;
 278         } socket_data;
 279
 280
 281 #ifdef __cplusplus
 282 extern "C" {
 283 #endif
 284
 285 void _wrap_Swig_free_tlspool_03ad2d7a43d805c7(void *_swig_go_0) {
 286   void *arg1 = (void *) 0 ;
 287
 288   arg1 = *(void **)&_swig_go_0;
 289
 290   Swig_free(arg1);
 291
 292 }
 293
 294
 295 void *_wrap_Swig_malloc_tlspool_03ad2d7a43d805c7(intgo _swig_go_0) {
 296   int arg1 ;
 297   void *result = 0 ;
 298   void *_swig_go_result;
 299
 300   arg1 = (int)_swig_go_0;
 301
 302   result = (void *)Swig_malloc(arg1);
 303   *(void **)&_swig_go_result = (void *)result;
 304   return _swig_go_result;
 305 }
 306
 307
 308 void _wrap_error_data_tlserrno_set_tlspool_03ad2d7a43d805c7(error_data *_swig_go_0, intgo _swig_go_1) {
 309   error_data *arg1 = (error_data *) 0 ;
 310   int arg2 ;
 311
 312   arg1 = *(error_data **)&_swig_go_0;
 313   arg2 = (int)_swig_go_1;
 314
 315   if (arg1) (arg1)->tlserrno = arg2;
 316
 317 }
 318
 319
 320 intgo _wrap_error_data_tlserrno_get_tlspool_03ad2d7a43d805c7(error_data *_swig_go_0) {
 321   error_data *arg1 = (error_data *) 0 ;
 322   int result;
 323   intgo _swig_go_result;
 324
 325   arg1 = *(error_data **)&_swig_go_0;
 326
 327   result = (int) ((arg1)->tlserrno);
 328   _swig_go_result = result;
 329   return _swig_go_result;
 330 }
 331
 332
 333 void _wrap_error_data_message_set_tlspool_03ad2d7a43d805c7(error_data *_swig_go_0, _gostring_ _swig_go_1) {
 334   error_data *arg1 = (error_data *) 0 ;
 335   char *arg2 ;
 336
 337   arg1 = *(error_data **)&_swig_go_0;
 338
 339   arg2 = (char *)malloc(_swig_go_1.n + 1);
 340   memcpy(arg2, _swig_go_1.p, _swig_go_1.n);
 341   arg2[_swig_go_1.n] = '\0';
 342
 343
 344   {
 345     if(arg2) {
 346       strncpy((char*)arg1->message, (const char *)arg2, 128-1);
 347       arg1->message[128-1] = 0;
 348     } else {
 349       arg1->message[0] = 0;
 350     }
 351   }
 352
 353   free(arg2);
 354 }
 355
 356
 357 _gostring_ _wrap_error_data_message_get_tlspool_03ad2d7a43d805c7(error_data *_swig_go_0) {
 358   error_data *arg1 = (error_data *) 0 ;
 359   char *result = 0 ;
 360   _gostring_ _swig_go_result;
 361
 362   arg1 = *(error_data **)&_swig_go_0;
 363
 364   result = (char *)(char *) ((arg1)->message);
 365   _swig_go_result = Swig_AllocateString((char*)result, result ? strlen((char*)result) : 0);
 366   return _swig_go_result;
 367 }
 368
 369
 370 error_data *_wrap_new_error_data_tlspool_03ad2d7a43d805c7() {
 371   error_data *result = 0 ;
 372   error_data *_swig_go_result;
 373
 374
 375   result = (error_data *)calloc(1, sizeof(error_data));
 376   *(error_data **)&_swig_go_result = (error_data *)result;
 377   return _swig_go_result;
 378 }
 379
 380
 381 void _wrap_delete_error_data_tlspool_03ad2d7a43d805c7(error_data *_swig_go_0) {
 382   error_data *arg1 = (error_data *) 0 ;
 383
 384   arg1 = *(error_data **)&_swig_go_0;
 385
 386   free((char *) arg1);
 387
 388 }
 389
 390
 391 void _wrap_ping_data_YYYYMMDD_producer_set_tlspool_03ad2d7a43d805c7(ping_data *_swig_go_0, _gostring_ _swig_go_1) {
 392   ping_data *arg1 = (ping_data *) 0 ;
 393   char *arg2 ;
 394
 395   arg1 = *(ping_data **)&_swig_go_0;
 396
 397   arg2 = (char *)malloc(_swig_go_1.n + 1);
 398   memcpy(arg2, _swig_go_1.p, _swig_go_1.n);
 399   arg2[_swig_go_1.n] = '\0';
 400
 401
 402   {
 403     if(arg2) {
 404       strncpy((char*)arg1->YYYYMMDD_producer, (const char *)arg2, 8+128-1);
 405       arg1->YYYYMMDD_producer[8+128-1] = 0;
 406     } else {
 407       arg1->YYYYMMDD_producer[0] = 0;
 408     }
 409   }
 410
 411   free(arg2);
 412 }
 413
 414
 415 _gostring_ _wrap_ping_data_YYYYMMDD_producer_get_tlspool_03ad2d7a43d805c7(ping_data *_swig_go_0) {
 416   ping_data *arg1 = (ping_data *) 0 ;
 417   char *result = 0 ;
 418   _gostring_ _swig_go_result;
 419
 420   arg1 = *(ping_data **)&_swig_go_0;
 421
 422   result = (char *)(char *) ((arg1)->YYYYMMDD_producer);
 423   _swig_go_result = Swig_AllocateString((char*)result, result ? strlen((char*)result) : 0);
 424   return _swig_go_result;
 425 }
 426
 427
 428 void _wrap_ping_data_facilities_set_tlspool_03ad2d7a43d805c7(ping_data *_swig_go_0, intgo _swig_go_1) {
 429   ping_data *arg1 = (ping_data *) 0 ;
 430   uint32_t arg2 ;
 431
 432   arg1 = *(ping_data **)&_swig_go_0;
 433   arg2 = (uint32_t)_swig_go_1;
 434
 435   if (arg1) (arg1)->facilities = arg2;
 436
 437 }
 438
 439
 440 intgo _wrap_ping_data_facilities_get_tlspool_03ad2d7a43d805c7(ping_data *_swig_go_0) {
 441   ping_data *arg1 = (ping_data *) 0 ;
 442   uint32_t result;
 443   intgo _swig_go_result;
 444
 445   arg1 = *(ping_data **)&_swig_go_0;
 446
 447   result =  ((arg1)->facilities);
 448   _swig_go_result = result;
 449   return _swig_go_result;
 450 }
 451
 452
 453 ping_data *_wrap_new_ping_data_tlspool_03ad2d7a43d805c7() {
 454   ping_data *result = 0 ;
 455   ping_data *_swig_go_result;
 456
 457
 458   result = (ping_data *)calloc(1, sizeof(ping_data));
 459   *(ping_data **)&_swig_go_result = (ping_data *)result;
 460   return _swig_go_result;
 461 }
 462
 463
 464 void _wrap_delete_ping_data_tlspool_03ad2d7a43d805c7(ping_data *_swig_go_0) {
 465   ping_data *arg1 = (ping_data *) 0 ;
 466
 467   arg1 = *(ping_data **)&_swig_go_0;
 468
 469   free((char *) arg1);
 470
 471 }
 472
 473
 474 void _wrap_starttls_data_flags_set_tlspool_03ad2d7a43d805c7(starttls_data *_swig_go_0, intgo _swig_go_1) {
 475   starttls_data *arg1 = (starttls_data *) 0 ;
 476   uint32_t arg2 ;
 477
 478   arg1 = *(starttls_data **)&_swig_go_0;
 479   arg2 = (uint32_t)_swig_go_1;
 480
 481   if (arg1) (arg1)->flags = arg2;
 482
 483 }
 484
 485
 486 intgo _wrap_starttls_data_flags_get_tlspool_03ad2d7a43d805c7(starttls_data *_swig_go_0) {
 487   starttls_data *arg1 = (starttls_data *) 0 ;
 488   uint32_t result;
 489   intgo _swig_go_result;
 490
 491   arg1 = *(starttls_data **)&_swig_go_0;
 492
 493   result =  ((arg1)->flags);
 494   _swig_go_result = result;
 495   return _swig_go_result;
 496 }
 497
 498
 499 void _wrap_starttls_data_local_set_tlspool_03ad2d7a43d805c7(starttls_data *_swig_go_0, intgo _swig_go_1) {
 500   starttls_data *arg1 = (starttls_data *) 0 ;
 501   uint32_t arg2 ;
 502
 503   arg1 = *(starttls_data **)&_swig_go_0;
 504   arg2 = (uint32_t)_swig_go_1;
 505
 506   if (arg1) (arg1)->local = arg2;
 507
 508 }
 509
 510
 511 intgo _wrap_starttls_data_local_get_tlspool_03ad2d7a43d805c7(starttls_data *_swig_go_0) {
 512   starttls_data *arg1 = (starttls_data *) 0 ;
 513   uint32_t result;
 514   intgo _swig_go_result;
 515
 516   arg1 = *(starttls_data **)&_swig_go_0;
 517
 518   result =  ((arg1)->local);
 519   _swig_go_result = result;
 520   return _swig_go_result;
 521 }
 522
 523
 524 void _wrap_starttls_data_ipproto_set_tlspool_03ad2d7a43d805c7(starttls_data *_swig_go_0, char _swig_go_1) {
 525   starttls_data *arg1 = (starttls_data *) 0 ;
 526   uint8_t arg2 ;
 527
 528   arg1 = *(starttls_data **)&_swig_go_0;
 529   arg2 = (uint8_t)_swig_go_1;
 530
 531   if (arg1) (arg1)->ipproto = arg2;
 532
 533 }
 534
 535
 536 char _wrap_starttls_data_ipproto_get_tlspool_03ad2d7a43d805c7(starttls_data *_swig_go_0) {
 537   starttls_data *arg1 = (starttls_data *) 0 ;
 538   uint8_t result;
 539   char _swig_go_result;
 540
 541   arg1 = *(starttls_data **)&_swig_go_0;
 542
 543   result =  ((arg1)->ipproto);
 544   _swig_go_result = result;
 545   return _swig_go_result;
 546 }
 547
 548
 549 void _wrap_starttls_data_streamid_set_tlspool_03ad2d7a43d805c7(starttls_data *_swig_go_0, short _swig_go_1) {
 550   starttls_data *arg1 = (starttls_data *) 0 ;
 551   uint16_t arg2 ;
 552
 553   arg1 = *(starttls_data **)&_swig_go_0;
 554   arg2 = (uint16_t)_swig_go_1;
 555
 556   if (arg1) (arg1)->streamid = arg2;
 557
 558 }
 559
 560
 561 short _wrap_starttls_data_streamid_get_tlspool_03ad2d7a43d805c7(starttls_data *_swig_go_0) {
 562   starttls_data *arg1 = (starttls_data *) 0 ;
 563   uint16_t result;
 564   short _swig_go_result;
 565
 566   arg1 = *(starttls_data **)&_swig_go_0;
 567
 568   result =  ((arg1)->streamid);
 569   _swig_go_result = result;
 570   return _swig_go_result;
 571 }
 572
 573
 574 void _wrap_starttls_data_localid_set_tlspool_03ad2d7a43d805c7(starttls_data *_swig_go_0, _gostring_ _swig_go_1) {
 575   starttls_data *arg1 = (starttls_data *) 0 ;
 576   char *arg2 ;
 577
 578   arg1 = *(starttls_data **)&_swig_go_0;
 579
 580   arg2 = (char *)malloc(_swig_go_1.n + 1);
 581   memcpy(arg2, _swig_go_1.p, _swig_go_1.n);
 582   arg2[_swig_go_1.n] = '\0';
 583
 584
 585   {
 586     if(arg2) {
 587       strncpy((char*)arg1->localid, (const char *)arg2, 128-1);
 588       arg1->localid[128-1] = 0;
 589     } else {
 590       arg1->localid[0] = 0;
 591     }
 592   }
 593
 594   free(arg2);
 595 }
 596
 597
 598 _gostring_ _wrap_starttls_data_localid_get_tlspool_03ad2d7a43d805c7(starttls_data *_swig_go_0) {
 599   starttls_data *arg1 = (starttls_data *) 0 ;
 600   char *result = 0 ;
 601   _gostring_ _swig_go_result;
 602
 603   arg1 = *(starttls_data **)&_swig_go_0;
 604
 605   result = (char *) ((arg1)->localid);
 606   _swig_go_result = Swig_AllocateString((char*)result, result ? strlen((char*)result) : 0);
 607   return _swig_go_result;
 608 }
 609
 610
 611 void _wrap_starttls_data_remoteid_set_tlspool_03ad2d7a43d805c7(starttls_data *_swig_go_0, _gostring_ _swig_go_1) {
 612   starttls_data *arg1 = (starttls_data *) 0 ;
 613   char *arg2 ;
 614
 615   arg1 = *(starttls_data **)&_swig_go_0;
 616
 617   arg2 = (char *)malloc(_swig_go_1.n + 1);
 618   memcpy(arg2, _swig_go_1.p, _swig_go_1.n);
 619   arg2[_swig_go_1.n] = '\0';
 620
 621
 622   {
 623     if(arg2) {
 624       strncpy((char*)arg1->remoteid, (const char *)arg2, 128-1);
 625       arg1->remoteid[128-1] = 0;
 626     } else {
 627       arg1->remoteid[0] = 0;
 628     }
 629   }
 630
 631   free(arg2);
 632 }
 633
 634
 635 _gostring_ _wrap_starttls_data_remoteid_get_tlspool_03ad2d7a43d805c7(starttls_data *_swig_go_0) {
 636   starttls_data *arg1 = (starttls_data *) 0 ;
 637   char *result = 0 ;
 638   _gostring_ _swig_go_result;
 639
 640   arg1 = *(starttls_data **)&_swig_go_0;
 641
 642   result = (char *) ((arg1)->remoteid);
 643   _swig_go_result = Swig_AllocateString((char*)result, result ? strlen((char*)result) : 0);
 644   return _swig_go_result;
 645 }
 646
 647
 648 void _wrap_starttls_data_ctlkey_set_tlspool_03ad2d7a43d805c7(starttls_data *_swig_go_0, char *_swig_go_1) {
 649   starttls_data *arg1 = (starttls_data *) 0 ;
 650   uint8_t *arg2 ;
 651
 652   arg1 = *(starttls_data **)&_swig_go_0;
 653   arg2 = *(uint8_t **)&_swig_go_1;
 654
 655   {
 656     size_t ii;
 657     uint8_t *b = (uint8_t *) arg1->ctlkey;
 658     for (ii = 0; ii < (size_t)16; ii++) b[ii] = *((uint8_t *) arg2 + ii);
 659   }
 660
 661 }
 662
 663
 664 char *_wrap_starttls_data_ctlkey_get_tlspool_03ad2d7a43d805c7(starttls_data *_swig_go_0) {
 665   starttls_data *arg1 = (starttls_data *) 0 ;
 666   uint8_t *result = 0 ;
 667   char *_swig_go_result;
 668
 669   arg1 = *(starttls_data **)&_swig_go_0;
 670
 671   result = (uint8_t *) ((arg1)->ctlkey);
 672   *(uint8_t **)&_swig_go_result = result;
 673   return _swig_go_result;
 674 }
 675
 676
 677 void _wrap_starttls_data_service_set_tlspool_03ad2d7a43d805c7(starttls_data *_swig_go_0, _gostring_ _swig_go_1) {
 678   starttls_data *arg1 = (starttls_data *) 0 ;
 679   char *arg2 ;
 680
 681   arg1 = *(starttls_data **)&_swig_go_0;
 682
 683   arg2 = (char *)malloc(_swig_go_1.n + 1);
 684   memcpy(arg2, _swig_go_1.p, _swig_go_1.n);
 685   arg2[_swig_go_1.n] = '\0';
 686
 687
 688   {
 689     if(arg2) {
 690       strncpy((char*)arg1->service, (const char *)arg2, 16-1);
 691       arg1->service[16-1] = 0;
 692     } else {
 693       arg1->service[0] = 0;
 694     }
 695   }
 696
 697   free(arg2);
 698 }
 699
 700
 701 _gostring_ _wrap_starttls_data_service_get_tlspool_03ad2d7a43d805c7(starttls_data *_swig_go_0) {
 702   starttls_data *arg1 = (starttls_data *) 0 ;
 703   char *result = 0 ;
 704   _gostring_ _swig_go_result;
 705
 706   arg1 = *(starttls_data **)&_swig_go_0;
 707
 708   result = (char *) ((arg1)->service);
 709   _swig_go_result = Swig_AllocateString((char*)result, result ? strlen((char*)result) : 0);
 710   return _swig_go_result;
 711 }
 712
 713
 714 void _wrap_starttls_data_timeout_set_tlspool_03ad2d7a43d805c7(starttls_data *_swig_go_0, intgo _swig_go_1) {
 715   starttls_data *arg1 = (starttls_data *) 0 ;
 716   uint32_t arg2 ;
 717
 718   arg1 = *(starttls_data **)&_swig_go_0;
 719   arg2 = (uint32_t)_swig_go_1;
 720
 721   if (arg1) (arg1)->timeout = arg2;
 722
 723 }
 724
 725
 726 intgo _wrap_starttls_data_timeout_get_tlspool_03ad2d7a43d805c7(starttls_data *_swig_go_0) {
 727   starttls_data *arg1 = (starttls_data *) 0 ;
 728   uint32_t result;
 729   intgo _swig_go_result;
 730
 731   arg1 = *(starttls_data **)&_swig_go_0;
 732
 733   result =  ((arg1)->timeout);
 734   _swig_go_result = result;
 735   return _swig_go_result;
 736 }
 737
 738
 739 starttls_data *_wrap_new_starttls_data_tlspool_03ad2d7a43d805c7() {
 740   starttls_data *result = 0 ;
 741   starttls_data *_swig_go_result;
 742
 743
 744   result = (starttls_data *)calloc(1, sizeof(starttls_data));
 745   *(starttls_data **)&_swig_go_result = (starttls_data *)result;
 746   return _swig_go_result;
 747 }
 748
 749
 750 void _wrap_delete_starttls_data_tlspool_03ad2d7a43d805c7(starttls_data *_swig_go_0) {
 751   starttls_data *arg1 = (starttls_data *) 0 ;
 752
 753   arg1 = *(starttls_data **)&_swig_go_0;
 754
 755   free((char *) arg1);
 756
 757 }
 758
 759
 760 void _wrap_control_data_flags_set_tlspool_03ad2d7a43d805c7(control_data *_swig_go_0, intgo _swig_go_1) {
 761   control_data *arg1 = (control_data *) 0 ;
 762   uint32_t arg2 ;
 763
 764   arg1 = *(control_data **)&_swig_go_0;
 765   arg2 = (uint32_t)_swig_go_1;
 766
 767   if (arg1) (arg1)->flags = arg2;
 768
 769 }
 770
 771
 772 intgo _wrap_control_data_flags_get_tlspool_03ad2d7a43d805c7(control_data *_swig_go_0) {
 773   control_data *arg1 = (control_data *) 0 ;
 774   uint32_t result;
 775   intgo _swig_go_result;
 776
 777   arg1 = *(control_data **)&_swig_go_0;
 778
 779   result =  ((arg1)->flags);
 780   _swig_go_result = result;
 781   return _swig_go_result;
 782 }
 783
 784
 785 void _wrap_control_data_ctlkey_set_tlspool_03ad2d7a43d805c7(control_data *_swig_go_0, char *_swig_go_1) {
 786   control_data *arg1 = (control_data *) 0 ;
 787   uint8_t *arg2 ;
 788
 789   arg1 = *(control_data **)&_swig_go_0;
 790   arg2 = *(uint8_t **)&_swig_go_1;
 791
 792   {
 793     size_t ii;
 794     uint8_t *b = (uint8_t *) arg1->ctlkey;
 795     for (ii = 0; ii < (size_t)16; ii++) b[ii] = *((uint8_t *) arg2 + ii);
 796   }
 797
 798 }
 799
 800
 801 char *_wrap_control_data_ctlkey_get_tlspool_03ad2d7a43d805c7(control_data *_swig_go_0) {
 802   control_data *arg1 = (control_data *) 0 ;
 803   uint8_t *result = 0 ;
 804   char *_swig_go_result;
 805
 806   arg1 = *(control_data **)&_swig_go_0;
 807
 808   result = (uint8_t *) ((arg1)->ctlkey);
 809   *(uint8_t **)&_swig_go_result = result;
 810   return _swig_go_result;
 811 }
 812
 813
 814 void _wrap_control_data_name_set_tlspool_03ad2d7a43d805c7(control_data *_swig_go_0, _gostring_ _swig_go_1) {
 815   control_data *arg1 = (control_data *) 0 ;
 816   char *arg2 ;
 817
 818   arg1 = *(control_data **)&_swig_go_0;
 819
 820   arg2 = (char *)malloc(_swig_go_1.n + 1);
 821   memcpy(arg2, _swig_go_1.p, _swig_go_1.n);
 822   arg2[_swig_go_1.n] = '\0';
 823
 824
 825   {
 826     if(arg2) {
 827       strncpy((char*)arg1->name, (const char *)arg2, 128-1);
 828       arg1->name[128-1] = 0;
 829     } else {
 830       arg1->name[0] = 0;
 831     }
 832   }
 833
 834   free(arg2);
 835 }
 836
 837
 838 _gostring_ _wrap_control_data_name_get_tlspool_03ad2d7a43d805c7(control_data *_swig_go_0) {
 839   control_data *arg1 = (control_data *) 0 ;
 840   char *result = 0 ;
 841   _gostring_ _swig_go_result;
 842
 843   arg1 = *(control_data **)&_swig_go_0;
 844
 845   result = (char *) ((arg1)->name);
 846   _swig_go_result = Swig_AllocateString((char*)result, result ? strlen((char*)result) : 0);
 847   return _swig_go_result;
 848 }
 849
 850
 851 control_data *_wrap_new_control_data_tlspool_03ad2d7a43d805c7() {
 852   control_data *result = 0 ;
 853   control_data *_swig_go_result;
 854
 855
 856   result = (control_data *)calloc(1, sizeof(control_data));
 857   *(control_data **)&_swig_go_result = (control_data *)result;
 858   return _swig_go_result;
 859 }
 860
 861
 862 void _wrap_delete_control_data_tlspool_03ad2d7a43d805c7(control_data *_swig_go_0) {
 863   control_data *arg1 = (control_data *) 0 ;
 864
 865   arg1 = *(control_data **)&_swig_go_0;
 866
 867   free((char *) arg1);
 868
 869 }
 870
 871
 872 void _wrap_prng_data_in1_len_set_tlspool_03ad2d7a43d805c7(prng_data *_swig_go_0, short _swig_go_1) {
 873   prng_data *arg1 = (prng_data *) 0 ;
 874   int16_t arg2 ;
 875
 876   arg1 = *(prng_data **)&_swig_go_0;
 877   arg2 = (int16_t)_swig_go_1;
 878
 879   if (arg1) (arg1)->in1_len = arg2;
 880
 881 }
 882
 883
 884 short _wrap_prng_data_in1_len_get_tlspool_03ad2d7a43d805c7(prng_data *_swig_go_0) {
 885   prng_data *arg1 = (prng_data *) 0 ;
 886   int16_t result;
 887   short _swig_go_result;
 888
 889   arg1 = *(prng_data **)&_swig_go_0;
 890
 891   result =  ((arg1)->in1_len);
 892   _swig_go_result = result;
 893   return _swig_go_result;
 894 }
 895
 896
 897 void _wrap_prng_data_in2_len_set_tlspool_03ad2d7a43d805c7(prng_data *_swig_go_0, short _swig_go_1) {
 898   prng_data *arg1 = (prng_data *) 0 ;
 899   int16_t arg2 ;
 900
 901   arg1 = *(prng_data **)&_swig_go_0;
 902   arg2 = (int16_t)_swig_go_1;
 903
 904   if (arg1) (arg1)->in2_len = arg2;
 905
 906 }
 907
 908
 909 short _wrap_prng_data_in2_len_get_tlspool_03ad2d7a43d805c7(prng_data *_swig_go_0) {
 910   prng_data *arg1 = (prng_data *) 0 ;
 911   int16_t result;
 912   short _swig_go_result;
 913
 914   arg1 = *(prng_data **)&_swig_go_0;
 915
 916   result =  ((arg1)->in2_len);
 917   _swig_go_result = result;
 918   return _swig_go_result;
 919 }
 920
 921
 922 void _wrap_prng_data_prng_len_set_tlspool_03ad2d7a43d805c7(prng_data *_swig_go_0, short _swig_go_1) {
 923   prng_data *arg1 = (prng_data *) 0 ;
 924   int16_t arg2 ;
 925
 926   arg1 = *(prng_data **)&_swig_go_0;
 927   arg2 = (int16_t)_swig_go_1;
 928
 929   if (arg1) (arg1)->prng_len = arg2;
 930
 931 }
 932
 933
 934 short _wrap_prng_data_prng_len_get_tlspool_03ad2d7a43d805c7(prng_data *_swig_go_0) {
 935   prng_data *arg1 = (prng_data *) 0 ;
 936   int16_t result;
 937   short _swig_go_result;
 938
 939   arg1 = *(prng_data **)&_swig_go_0;
 940
 941   result =  ((arg1)->prng_len);
 942   _swig_go_result = result;
 943   return _swig_go_result;
 944 }
 945
 946
 947 void _wrap_prng_data_buffer_set_tlspool_03ad2d7a43d805c7(prng_data *_swig_go_0, char *_swig_go_1) {
 948   prng_data *arg1 = (prng_data *) 0 ;
 949   uint8_t *arg2 ;
 950
 951   arg1 = *(prng_data **)&_swig_go_0;
 952   arg2 = *(uint8_t **)&_swig_go_1;
 953
 954   {
 955     size_t ii;
 956     uint8_t *b = (uint8_t *) arg1->buffer;
 957     for (ii = 0; ii < (size_t)350; ii++) b[ii] = *((uint8_t *) arg2 + ii);
 958   }
 959
 960 }
 961
 962
 963 char *_wrap_prng_data_buffer_get_tlspool_03ad2d7a43d805c7(prng_data *_swig_go_0) {
 964   prng_data *arg1 = (prng_data *) 0 ;
 965   uint8_t *result = 0 ;
 966   char *_swig_go_result;
 967
 968   arg1 = *(prng_data **)&_swig_go_0;
 969
 970   result = (uint8_t *)(uint8_t *) ((arg1)->buffer);
 971   *(uint8_t **)&_swig_go_result = result;
 972   return _swig_go_result;
 973 }
 974
 975
 976 prng_data *_wrap_new_prng_data_tlspool_03ad2d7a43d805c7() {
 977   prng_data *result = 0 ;
 978   prng_data *_swig_go_result;
 979
 980
 981   result = (prng_data *)calloc(1, sizeof(prng_data));
 982   *(prng_data **)&_swig_go_result = (prng_data *)result;
 983   return _swig_go_result;
 984 }
 985
 986
 987 void _wrap_delete_prng_data_tlspool_03ad2d7a43d805c7(prng_data *_swig_go_0) {
 988   prng_data *arg1 = (prng_data *) 0 ;
 989
 990   arg1 = *(prng_data **)&_swig_go_0;
 991
 992   free((char *) arg1);
 993
 994 }
 995
 996
 997 void _wrap_socket_data_unix_socket_set_tlspool_03ad2d7a43d805c7(socket_data *_swig_go_0, intgo _swig_go_1) {
 998   socket_data *arg1 = (socket_data *) 0 ;
 999   int arg2 ;
1000
1001   arg1 = *(socket_data **)&_swig_go_0;
1002   arg2 = (int)_swig_go_1;
1003
1004   if (arg1) (arg1)->unix_socket = arg2;
1005
1006 }
1007
1008
1009 intgo _wrap_socket_data_unix_socket_get_tlspool_03ad2d7a43d805c7(socket_data *_swig_go_0) {
1010   socket_data *arg1 = (socket_data *) 0 ;
1011   int result;
1012   intgo _swig_go_result;
1013
1014   arg1 = *(socket_data **)&_swig_go_0;
1015
1016   result = (int) ((arg1)->unix_socket);
1017   _swig_go_result = result;
1018   return _swig_go_result;
1019 }
1020
1021
1022 socket_data *_wrap_new_socket_data_tlspool_03ad2d7a43d805c7() {
1023   socket_data *result = 0 ;
1024   socket_data *_swig_go_result;
1025
1026
1027   result = (socket_data *)calloc(1, sizeof(socket_data));
1028   *(socket_data **)&_swig_go_result = (socket_data *)result;
1029   return _swig_go_result;
1030 }
1031
1032
1033 void _wrap_delete_socket_data_tlspool_03ad2d7a43d805c7(socket_data *_swig_go_0) {
1034   socket_data *arg1 = (socket_data *) 0 ;
1035
1036   arg1 = *(socket_data **)&_swig_go_0;
1037
1038   free((char *) arg1);
1039
1040 }
1041
1042
1043 intgo _wrap_Internal_pid_tlspool_03ad2d7a43d805c7(_gostring_ _swig_go_0) {
1044   char *arg1 = (char *) 0 ;
1045   int result;
1046   intgo _swig_go_result;
1047
1048
1049   arg1 = (char *)malloc(_swig_go_0.n + 1);
1050   memcpy(arg1, _swig_go_0.p, _swig_go_0.n);
1051   arg1[_swig_go_0.n] = '\0';
1052
1053
1054   result = (int)tlspool_pid(arg1);
1055   _swig_go_result = result;
1056   free(arg1);
1057   return _swig_go_result;
1058 }
1059
1060
1061 intgo _wrap_Internal_open_poolhandle_tlspool_03ad2d7a43d805c7(_gostring_ _swig_go_0) {
1062   char *arg1 = (char *) 0 ;
1063   pool_handle_t result;
1064   intgo _swig_go_result;
1065
1066
1067   arg1 = (char *)malloc(_swig_go_0.n + 1);
1068   memcpy(arg1, _swig_go_0.p, _swig_go_0.n);
1069   arg1[_swig_go_0.n] = '\0';
1070
1071
1072   result = (pool_handle_t)tlspool_open_poolhandle(arg1);
1073   _swig_go_result = result;
1074   free(arg1);
1075   return _swig_go_result;
1076 }
1077
1078
1079 intgo _wrap_Internal_ping_tlspool_03ad2d7a43d805c7(ping_data *_swig_go_0) {
1080   ping_data *arg1 = (ping_data *) 0 ;
1081   int result;
1082   intgo _swig_go_result;
1083
1084   arg1 = *(ping_data **)&_swig_go_0;
1085
1086   result = (int)tlspool_ping(arg1);
1087   _swig_go_result = result;
1088   return _swig_go_result;
1089 }
1090
1091
1092 intgo _wrap_Internal_starttls_tlspool_03ad2d7a43d805c7(intgo _swig_go_0, starttls_data *_swig_go_1, void *_swig_go_2, void *_swig_go_3) {
1093   int arg1 ;
1094   starttls_data *arg2 = (starttls_data *) 0 ;
1095   void *arg3 = (void *) 0 ;
1096   void *arg4 = (void *) 0 ;
1097   int result;
1098   intgo _swig_go_result;
1099
1100   arg1 = (int)_swig_go_0;
1101   arg2 = *(starttls_data **)&_swig_go_1;
1102   arg3 = *(void **)&_swig_go_2;
1103   arg4 = *(void **)&_swig_go_3;
1104
1105   result = (int)tlspool_starttls(arg1,arg2,arg3,arg4);
1106   _swig_go_result = result;
1107   return _swig_go_result;
1108 }
1109
1110
1111 intgo _wrap_Internal_control_detach_tlspool_03ad2d7a43d805c7(char *_swig_go_0) {
1112   uint8_t *arg1 ;
1113   int result;
1114   intgo _swig_go_result;
1115
1116   arg1 = *(uint8_t **)&_swig_go_0;
1117
1118   result = (int)tlspool_control_detach(arg1);
1119   _swig_go_result = result;
1120   return _swig_go_result;
1121 }
1122
1123
1124 intgo _wrap_Internal_control_reattach_tlspool_03ad2d7a43d805c7(char *_swig_go_0) {
1125   uint8_t *arg1 ;
1126   int result;
1127   intgo _swig_go_result;
1128
1129   arg1 = *(uint8_t **)&_swig_go_0;
1130
1131   result = (int)tlspool_control_reattach(arg1);
1132   _swig_go_result = result;
1133   return _swig_go_result;
1134 }
1135
1136
1137 intgo _wrap_Internal_prng_tlspool_03ad2d7a43d805c7(_gostring_ _swig_go_0, _gostring_ _swig_go_1, short _swig_go_2, char *_swig_go_3, char *_swig_go_4) {
1138   char *arg1 = (char *) 0 ;
1139   char *arg2 = (char *) 0 ;
1140   uint16_t arg3 ;
1141   uint8_t *arg4 = (uint8_t *) 0 ;
1142   uint8_t *arg5 ;
1143   int result;
1144   intgo _swig_go_result;
1145
1146
1147   arg1 = (char *)malloc(_swig_go_0.n + 1);
1148   memcpy(arg1, _swig_go_0.p, _swig_go_0.n);
1149   arg1[_swig_go_0.n] = '\0';
1150
1151
1152   arg2 = (char *)malloc(_swig_go_1.n + 1);
1153   memcpy(arg2, _swig_go_1.p, _swig_go_1.n);
1154   arg2[_swig_go_1.n] = '\0';
1155
1156   arg3 = (uint16_t)_swig_go_2;
1157   arg4 = *(uint8_t **)&_swig_go_3;
1158   arg5 = *(uint8_t **)&_swig_go_4;
1159
1160   result = (int)tlspool_prng(arg1,arg2,arg3,arg4,arg5);
1161   _swig_go_result = result;
1162   free(arg1);
1163   free(arg2);
1164   return _swig_go_result;
1165 }
1166
1167
1168 _gostring_ _wrap_tlspool_configvar_tlspool_03ad2d7a43d805c7(_gostring_ _swig_go_0, _gostring_ _swig_go_1) {
1169   char *arg1 = (char *) 0 ;
1170   char *arg2 = (char *) 0 ;
1171   char *result = 0 ;
1172   _gostring_ _swig_go_result;
1173
1174
1175   arg1 = (char *)malloc(_swig_go_0.n + 1);
1176   memcpy(arg1, _swig_go_0.p, _swig_go_0.n);
1177   arg1[_swig_go_0.n] = '\0';
1178
1179
1180   arg2 = (char *)malloc(_swig_go_1.n + 1);
1181   memcpy(arg2, _swig_go_1.p, _swig_go_1.n);
1182   arg2[_swig_go_1.n] = '\0';
1183
1184
1185   result = (char *)tlspool_configvar(arg1,arg2);
1186   _swig_go_result = Swig_AllocateString((char*)result, result ? strlen((char*)result) : 0);
1187   free(arg1);
1188   free(arg2);
1189   return _swig_go_result;
1190 }
1191
1192
1193 intgo _wrap_PIOC_LOCAL_tlspool_03ad2d7a43d805c7() {
1194   int result;
1195   intgo _swig_go_result;
1196
1197
1198   result = -0x80000000;
1199
1200   _swig_go_result = result;
1201   return _swig_go_result;
1202 }
1203
1204
1205 #ifdef __cplusplus
1206 }
1207 #endif
1208