1 /* ---------------------------------------------------------------------------- 2 * This file was automatically generated by SWIG (http://www.swig.org). 3 * Version 2.0.11 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 #define SWIGPYTHON 12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE 13 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 (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) 82 # ifndef GCC_HASCLASSVISIBILITY 83 # define GCC_HASCLASSVISIBILITY 84 # endif 85 #endif 86 87 #ifndef SWIGEXPORT 88 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) 89 # if defined(STATIC_LINKED) 90 # define SWIGEXPORT 91 # else 92 # define SWIGEXPORT __declspec(dllexport) 93 # endif 94 # else 95 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY) 96 # define SWIGEXPORT __attribute__ ((visibility("default"))) 97 # else 98 # define SWIGEXPORT 99 # endif 100 # endif 101 #endif 102 103 /* calling conventions for Windows */ 104 #ifndef SWIGSTDCALL 105 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) 106 # define SWIGSTDCALL __stdcall 107 # else 108 # define SWIGSTDCALL 109 # endif 110 #endif 111 112 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */ 113 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE) 114 # define _CRT_SECURE_NO_DEPRECATE 115 #endif 116 117 /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */ 118 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE) 119 # define _SCL_SECURE_NO_DEPRECATE 120 #endif 121 122 123 124 #if defined(_DEBUG) && defined(SWIG_PYTHON_INTERPRETER_NO_DEBUG) 125 /* Use debug wrappers with the Python release dll */ 126 # undef _DEBUG 127 # include <Python.h> 128 # define _DEBUG 129 #else 130 # include <Python.h> 131 #endif 132 133 /* ----------------------------------------------------------------------------- 134 * swigrun.swg 135 * 136 * This file contains generic C API SWIG runtime support for pointer 137 * type checking. 138 * ----------------------------------------------------------------------------- */ 139 140 /* This should only be incremented when either the layout of swig_type_info changes, 141 or for whatever reason, the runtime changes incompatibly */ 142 #define SWIG_RUNTIME_VERSION "4" 143 144 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */ 145 #ifdef SWIG_TYPE_TABLE 146 # define SWIG_QUOTE_STRING(x) #x 147 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x) 148 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE) 149 #else 150 # define SWIG_TYPE_TABLE_NAME 151 #endif 152 153 /* 154 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for 155 creating a static or dynamic library from the SWIG runtime code. 156 In 99.9% of the cases, SWIG just needs to declare them as 'static'. 157 158 But only do this if strictly necessary, ie, if you have problems 159 with your compiler or suchlike. 160 */ 161 162 #ifndef SWIGRUNTIME 163 # define SWIGRUNTIME SWIGINTERN 164 #endif 165 166 #ifndef SWIGRUNTIMEINLINE 167 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE 168 #endif 169 170 /* Generic buffer size */ 171 #ifndef SWIG_BUFFER_SIZE 172 # define SWIG_BUFFER_SIZE 1024 173 #endif 174 175 /* Flags for pointer conversions */ 176 #define SWIG_POINTER_DISOWN 0x1 177 #define SWIG_CAST_NEW_MEMORY 0x2 178 179 /* Flags for new pointer objects */ 180 #define SWIG_POINTER_OWN 0x1 181 182 183 /* 184 Flags/methods for returning states. 185 186 The SWIG conversion methods, as ConvertPtr, return an integer 187 that tells if the conversion was successful or not. And if not, 188 an error code can be returned (see swigerrors.swg for the codes). 189 190 Use the following macros/flags to set or process the returning 191 states. 192 193 In old versions of SWIG, code such as the following was usually written: 194 195 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) { 196 // success code 197 } else { 198 //fail code 199 } 200 201 Now you can be more explicit: 202 203 int res = SWIG_ConvertPtr(obj,vptr,ty.flags); 204 if (SWIG_IsOK(res)) { 205 // success code 206 } else { 207 // fail code 208 } 209 210 which is the same really, but now you can also do 211 212 Type *ptr; 213 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags); 214 if (SWIG_IsOK(res)) { 215 // success code 216 if (SWIG_IsNewObj(res) { 217 ... 218 delete *ptr; 219 } else { 220 ... 221 } 222 } else { 223 // fail code 224 } 225 226 I.e., now SWIG_ConvertPtr can return new objects and you can 227 identify the case and take care of the deallocation. Of course that 228 also requires SWIG_ConvertPtr to return new result values, such as 229 230 int SWIG_ConvertPtr(obj, ptr,...) { 231 if (<obj is ok>) { 232 if (<need new object>) { 233 *ptr = <ptr to new allocated object>; 234 return SWIG_NEWOBJ; 235 } else { 236 *ptr = <ptr to old object>; 237 return SWIG_OLDOBJ; 238 } 239 } else { 240 return SWIG_BADOBJ; 241 } 242 } 243 244 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be 245 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the 246 SWIG errors code. 247 248 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code 249 allows to return the 'cast rank', for example, if you have this 250 251 int food(double) 252 int fooi(int); 253 254 and you call 255 256 food(1) // cast rank '1' (1 -> 1.0) 257 fooi(1) // cast rank '0' 258 259 just use the SWIG_AddCast()/SWIG_CheckState() 260 */ 261 262 #define SWIG_OK (0) 263 #define SWIG_ERROR (-1) 264 #define SWIG_IsOK(r) (r >= 0) 265 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError) 266 267 /* The CastRankLimit says how many bits are used for the cast rank */ 268 #define SWIG_CASTRANKLIMIT (1 << 8) 269 /* The NewMask denotes the object was created (using new/malloc) */ 270 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1) 271 /* The TmpMask is for in/out typemaps that use temporal objects */ 272 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1) 273 /* Simple returning values */ 274 #define SWIG_BADOBJ (SWIG_ERROR) 275 #define SWIG_OLDOBJ (SWIG_OK) 276 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK) 277 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK) 278 /* Check, add and del mask methods */ 279 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r) 280 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r) 281 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK)) 282 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r) 283 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r) 284 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK)) 285 286 /* Cast-Rank Mode */ 287 #if defined(SWIG_CASTRANK_MODE) 288 # ifndef SWIG_TypeRank 289 # define SWIG_TypeRank unsigned long 290 # endif 291 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */ 292 # define SWIG_MAXCASTRANK (2) 293 # endif 294 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1) 295 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK) 296 SWIGINTERNINLINE int SWIG_AddCast(int r) { 297 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r; 298 } 299 SWIGINTERNINLINE int SWIG_CheckState(int r) { 300 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0; 301 } 302 #else /* no cast-rank mode */ 303 # define SWIG_AddCast(r) (r) 304 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0) 305 #endif 306 307 308 #include <string.h> 309 310 #ifdef __cplusplus 311 extern "C" { 312 #endif 313 314 typedef void *(*swig_converter_func)(void *, int *); 315 typedef struct swig_type_info *(*swig_dycast_func)(void **); 316 317 /* Structure to store information on one type */ 318 typedef struct swig_type_info { 319 const char *name; /* mangled name of this type */ 320 const char *str; /* human readable name of this type */ 321 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */ 322 struct swig_cast_info *cast; /* linked list of types that can cast into this type */ 323 void *clientdata; /* language specific type data */ 324 int owndata; /* flag if the structure owns the clientdata */ 325 } swig_type_info; 326 327 /* Structure to store a type and conversion function used for casting */ 328 typedef struct swig_cast_info { 329 swig_type_info *type; /* pointer to type that is equivalent to this type */ 330 swig_converter_func converter; /* function to cast the void pointers */ 331 struct swig_cast_info *next; /* pointer to next cast in linked list */ 332 struct swig_cast_info *prev; /* pointer to the previous cast */ 333 } swig_cast_info; 334 335 /* Structure used to store module information 336 * Each module generates one structure like this, and the runtime collects 337 * all of these structures and stores them in a circularly linked list.*/ 338 typedef struct swig_module_info { 339 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */ 340 size_t size; /* Number of types in this module */ 341 struct swig_module_info *next; /* Pointer to next element in circularly linked list */ 342 swig_type_info **type_initial; /* Array of initially generated type structures */ 343 swig_cast_info **cast_initial; /* Array of initially generated casting structures */ 344 void *clientdata; /* Language specific module data */ 345 } swig_module_info; 346 347 /* 348 Compare two type names skipping the space characters, therefore 349 "char*" == "char *" and "Class<int>" == "Class<int >", etc. 350 351 Return 0 when the two name types are equivalent, as in 352 strncmp, but skipping ' '. 353 */ 354 SWIGRUNTIME int 355 SWIG_TypeNameComp(const char *f1, const char *l1, 356 const char *f2, const char *l2) { 357 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) { 358 while ((*f1 == ' ') && (f1 != l1)) ++f1; 359 while ((*f2 == ' ') && (f2 != l2)) ++f2; 360 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1; 361 } 362 return (int)((l1 - f1) - (l2 - f2)); 363 } 364 365 /* 366 Check type equivalence in a name list like <name1>|<name2>|... 367 Return 0 if equal, -1 if nb < tb, 1 if nb > tb 368 */ 369 SWIGRUNTIME int 370 SWIG_TypeCmp(const char *nb, const char *tb) { 371 int equiv = 1; 372 const char* te = tb + strlen(tb); 373 const char* ne = nb; 374 while (equiv != 0 && *ne) { 375 for (nb = ne; *ne; ++ne) { 376 if (*ne == '|') break; 377 } 378 equiv = SWIG_TypeNameComp(nb, ne, tb, te); 379 if (*ne) ++ne; 380 } 381 return equiv; 382 } 383 384 /* 385 Check type equivalence in a name list like <name1>|<name2>|... 386 Return 0 if not equal, 1 if equal 387 */ 388 SWIGRUNTIME int 389 SWIG_TypeEquiv(const char *nb, const char *tb) { 390 return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0; 391 } 392 393 /* 394 Check the typename 395 */ 396 SWIGRUNTIME swig_cast_info * 397 SWIG_TypeCheck(const char *c, swig_type_info *ty) { 398 if (ty) { 399 swig_cast_info *iter = ty->cast; 400 while (iter) { 401 if (strcmp(iter->type->name, c) == 0) { 402 if (iter == ty->cast) 403 return iter; 404 /* Move iter to the top of the linked list */ 405 iter->prev->next = iter->next; 406 if (iter->next) 407 iter->next->prev = iter->prev; 408 iter->next = ty->cast; 409 iter->prev = 0; 410 if (ty->cast) ty->cast->prev = iter; 411 ty->cast = iter; 412 return iter; 413 } 414 iter = iter->next; 415 } 416 } 417 return 0; 418 } 419 420 /* 421 Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison 422 */ 423 SWIGRUNTIME swig_cast_info * 424 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) { 425 if (ty) { 426 swig_cast_info *iter = ty->cast; 427 while (iter) { 428 if (iter->type == from) { 429 if (iter == ty->cast) 430 return iter; 431 /* Move iter to the top of the linked list */ 432 iter->prev->next = iter->next; 433 if (iter->next) 434 iter->next->prev = iter->prev; 435 iter->next = ty->cast; 436 iter->prev = 0; 437 if (ty->cast) ty->cast->prev = iter; 438 ty->cast = iter; 439 return iter; 440 } 441 iter = iter->next; 442 } 443 } 444 return 0; 445 } 446 447 /* 448 Cast a pointer up an inheritance hierarchy 449 */ 450 SWIGRUNTIMEINLINE void * 451 SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) { 452 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory); 453 } 454 455 /* 456 Dynamic pointer casting. Down an inheritance hierarchy 457 */ 458 SWIGRUNTIME swig_type_info * 459 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) { 460 swig_type_info *lastty = ty; 461 if (!ty || !ty->dcast) return ty; 462 while (ty && (ty->dcast)) { 463 ty = (*ty->dcast)(ptr); 464 if (ty) lastty = ty; 465 } 466 return lastty; 467 } 468 469 /* 470 Return the name associated with this type 471 */ 472 SWIGRUNTIMEINLINE const char * 473 SWIG_TypeName(const swig_type_info *ty) { 474 return ty->name; 475 } 476 477 /* 478 Return the pretty name associated with this type, 479 that is an unmangled type name in a form presentable to the user. 480 */ 481 SWIGRUNTIME const char * 482 SWIG_TypePrettyName(const swig_type_info *type) { 483 /* The "str" field contains the equivalent pretty names of the 484 type, separated by vertical-bar characters. We choose 485 to print the last name, as it is often (?) the most 486 specific. */ 487 if (!type) return NULL; 488 if (type->str != NULL) { 489 const char *last_name = type->str; 490 const char *s; 491 for (s = type->str; *s; s++) 492 if (*s == '|') last_name = s+1; 493 return last_name; 494 } 495 else 496 return type->name; 497 } 498 499 /* 500 Set the clientdata field for a type 501 */ 502 SWIGRUNTIME void 503 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) { 504 swig_cast_info *cast = ti->cast; 505 /* if (ti->clientdata == clientdata) return; */ 506 ti->clientdata = clientdata; 507 508 while (cast) { 509 if (!cast->converter) { 510 swig_type_info *tc = cast->type; 511 if (!tc->clientdata) { 512 SWIG_TypeClientData(tc, clientdata); 513 } 514 } 515 cast = cast->next; 516 } 517 } 518 SWIGRUNTIME void 519 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) { 520 SWIG_TypeClientData(ti, clientdata); 521 ti->owndata = 1; 522 } 523 524 /* 525 Search for a swig_type_info structure only by mangled name 526 Search is a O(log #types) 527 528 We start searching at module start, and finish searching when start == end. 529 Note: if start == end at the beginning of the function, we go all the way around 530 the circular list. 531 */ 532 SWIGRUNTIME swig_type_info * 533 SWIG_MangledTypeQueryModule(swig_module_info *start, 534 swig_module_info *end, 535 const char *name) { 536 swig_module_info *iter = start; 537 do { 538 if (iter->size) { 539 register size_t l = 0; 540 register size_t r = iter->size - 1; 541 do { 542 /* since l+r >= 0, we can (>> 1) instead (/ 2) */ 543 register size_t i = (l + r) >> 1; 544 const char *iname = iter->types[i]->name; 545 if (iname) { 546 register int compare = strcmp(name, iname); 547 if (compare == 0) { 548 return iter->types[i]; 549 } else if (compare < 0) { 550 if (i) { 551 r = i - 1; 552 } else { 553 break; 554 } 555 } else if (compare > 0) { 556 l = i + 1; 557 } 558 } else { 559 break; /* should never happen */ 560 } 561 } while (l <= r); 562 } 563 iter = iter->next; 564 } while (iter != end); 565 return 0; 566 } 567 568 /* 569 Search for a swig_type_info structure for either a mangled name or a human readable name. 570 It first searches the mangled names of the types, which is a O(log #types) 571 If a type is not found it then searches the human readable names, which is O(#types). 572 573 We start searching at module start, and finish searching when start == end. 574 Note: if start == end at the beginning of the function, we go all the way around 575 the circular list. 576 */ 577 SWIGRUNTIME swig_type_info * 578 SWIG_TypeQueryModule(swig_module_info *start, 579 swig_module_info *end, 580 const char *name) { 581 /* STEP 1: Search the name field using binary search */ 582 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name); 583 if (ret) { 584 return ret; 585 } else { 586 /* STEP 2: If the type hasn't been found, do a complete search 587 of the str field (the human readable name) */ 588 swig_module_info *iter = start; 589 do { 590 register size_t i = 0; 591 for (; i < iter->size; ++i) { 592 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name))) 593 return iter->types[i]; 594 } 595 iter = iter->next; 596 } while (iter != end); 597 } 598 599 /* neither found a match */ 600 return 0; 601 } 602 603 /* 604 Pack binary data into a string 605 */ 606 SWIGRUNTIME char * 607 SWIG_PackData(char *c, void *ptr, size_t sz) { 608 static const char hex[17] = "0123456789abcdef"; 609 register const unsigned char *u = (unsigned char *) ptr; 610 register const unsigned char *eu = u + sz; 611 for (; u != eu; ++u) { 612 register unsigned char uu = *u; 613 *(c++) = hex[(uu & 0xf0) >> 4]; 614 *(c++) = hex[uu & 0xf]; 615 } 616 return c; 617 } 618 619 /* 620 Unpack binary data from a string 621 */ 622 SWIGRUNTIME const char * 623 SWIG_UnpackData(const char *c, void *ptr, size_t sz) { 624 register unsigned char *u = (unsigned char *) ptr; 625 register const unsigned char *eu = u + sz; 626 for (; u != eu; ++u) { 627 register char d = *(c++); 628 register unsigned char uu; 629 if ((d >= '0') && (d <= '9')) 630 uu = ((d - '0') << 4); 631 else if ((d >= 'a') && (d <= 'f')) 632 uu = ((d - ('a'-10)) << 4); 633 else 634 return (char *) 0; 635 d = *(c++); 636 if ((d >= '0') && (d <= '9')) 637 uu |= (d - '0'); 638 else if ((d >= 'a') && (d <= 'f')) 639 uu |= (d - ('a'-10)); 640 else 641 return (char *) 0; 642 *u = uu; 643 } 644 return c; 645 } 646 647 /* 648 Pack 'void *' into a string buffer. 649 */ 650 SWIGRUNTIME char * 651 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) { 652 char *r = buff; 653 if ((2*sizeof(void *) + 2) > bsz) return 0; 654 *(r++) = '_'; 655 r = SWIG_PackData(r,&ptr,sizeof(void *)); 656 if (strlen(name) + 1 > (bsz - (r - buff))) return 0; 657 strcpy(r,name); 658 return buff; 659 } 660 661 SWIGRUNTIME const char * 662 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) { 663 if (*c != '_') { 664 if (strcmp(c,"NULL") == 0) { 665 *ptr = (void *) 0; 666 return name; 667 } else { 668 return 0; 669 } 670 } 671 return SWIG_UnpackData(++c,ptr,sizeof(void *)); 672 } 673 674 SWIGRUNTIME char * 675 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) { 676 char *r = buff; 677 size_t lname = (name ? strlen(name) : 0); 678 if ((2*sz + 2 + lname) > bsz) return 0; 679 *(r++) = '_'; 680 r = SWIG_PackData(r,ptr,sz); 681 if (lname) { 682 strncpy(r,name,lname+1); 683 } else { 684 *r = 0; 685 } 686 return buff; 687 } 688 689 SWIGRUNTIME const char * 690 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) { 691 if (*c != '_') { 692 if (strcmp(c,"NULL") == 0) { 693 memset(ptr,0,sz); 694 return name; 695 } else { 696 return 0; 697 } 698 } 699 return SWIG_UnpackData(++c,ptr,sz); 700 } 701 702 #ifdef __cplusplus 703 } 704 #endif 705 706 /* Errors in SWIG */ 707 #define SWIG_UnknownError -1 708 #define SWIG_IOError -2 709 #define SWIG_RuntimeError -3 710 #define SWIG_IndexError -4 711 #define SWIG_TypeError -5 712 #define SWIG_DivisionByZero -6 713 #define SWIG_OverflowError -7 714 #define SWIG_SyntaxError -8 715 #define SWIG_ValueError -9 716 #define SWIG_SystemError -10 717 #define SWIG_AttributeError -11 718 #define SWIG_MemoryError -12 719 #define SWIG_NullReferenceError -13 720 721 722 723 /* Compatibility macros for Python 3 */ 724 #if PY_VERSION_HEX >= 0x03000000 725 726 #define PyClass_Check(obj) PyObject_IsInstance(obj, (PyObject *)&PyType_Type) 727 #define PyInt_Check(x) PyLong_Check(x) 728 #define PyInt_AsLong(x) PyLong_AsLong(x) 729 #define PyInt_FromLong(x) PyLong_FromLong(x) 730 #define PyInt_FromSize_t(x) PyLong_FromSize_t(x) 731 #define PyString_Check(name) PyBytes_Check(name) 732 #define PyString_FromString(x) PyUnicode_FromString(x) 733 #define PyString_Format(fmt, args) PyUnicode_Format(fmt, args) 734 #define PyString_AsString(str) PyBytes_AsString(str) 735 #define PyString_Size(str) PyBytes_Size(str) 736 #define PyString_InternFromString(key) PyUnicode_InternFromString(key) 737 #define Py_TPFLAGS_HAVE_CLASS Py_TPFLAGS_BASETYPE 738 #define PyString_AS_STRING(x) PyUnicode_AS_STRING(x) 739 #define _PyLong_FromSsize_t(x) PyLong_FromSsize_t(x) 740 741 #endif 742 743 #ifndef Py_TYPE 744 # define Py_TYPE(op) ((op)->ob_type) 745 #endif 746 747 /* SWIG APIs for compatibility of both Python 2 & 3 */ 748 749 #if PY_VERSION_HEX >= 0x03000000 750 # define SWIG_Python_str_FromFormat PyUnicode_FromFormat 751 #else 752 # define SWIG_Python_str_FromFormat PyString_FromFormat 753 #endif 754 755 756 /* Warning: This function will allocate a new string in Python 3, 757 * so please call SWIG_Python_str_DelForPy3(x) to free the space. 758 */ 759 SWIGINTERN char* 760 SWIG_Python_str_AsChar(PyObject *str) 761 { 762 #if PY_VERSION_HEX >= 0x03000000 763 char *cstr; 764 char *newstr; 765 Py_ssize_t len; 766 str = PyUnicode_AsUTF8String(str); 767 PyBytes_AsStringAndSize(str, &cstr, &len); 768 newstr = (char *) malloc(len+1); 769 memcpy(newstr, cstr, len+1); 770 Py_XDECREF(str); 771 return newstr; 772 #else 773 return PyString_AsString(str); 774 #endif 775 } 776 777 #if PY_VERSION_HEX >= 0x03000000 778 # define SWIG_Python_str_DelForPy3(x) free( (void*) (x) ) 779 #else 780 # define SWIG_Python_str_DelForPy3(x) 781 #endif 782 783 784 SWIGINTERN PyObject* 785 SWIG_Python_str_FromChar(const char *c) 786 { 787 #if PY_VERSION_HEX >= 0x03000000 788 return PyUnicode_FromString(c); 789 #else 790 return PyString_FromString(c); 791 #endif 792 } 793 794 /* Add PyOS_snprintf for old Pythons */ 795 #if PY_VERSION_HEX < 0x02020000 796 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM) 797 # define PyOS_snprintf _snprintf 798 # else 799 # define PyOS_snprintf snprintf 800 # endif 801 #endif 802 803 /* A crude PyString_FromFormat implementation for old Pythons */ 804 #if PY_VERSION_HEX < 0x02020000 805 806 #ifndef SWIG_PYBUFFER_SIZE 807 # define SWIG_PYBUFFER_SIZE 1024 808 #endif 809 810 static PyObject * 811 PyString_FromFormat(const char *fmt, ...) { 812 va_list ap; 813 char buf[SWIG_PYBUFFER_SIZE * 2]; 814 int res; 815 va_start(ap, fmt); 816 res = vsnprintf(buf, sizeof(buf), fmt, ap); 817 va_end(ap); 818 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf); 819 } 820 #endif 821 822 /* Add PyObject_Del for old Pythons */ 823 #if PY_VERSION_HEX < 0x01060000 824 # define PyObject_Del(op) PyMem_DEL((op)) 825 #endif 826 #ifndef PyObject_DEL 827 # define PyObject_DEL PyObject_Del 828 #endif 829 830 /* A crude PyExc_StopIteration exception for old Pythons */ 831 #if PY_VERSION_HEX < 0x02020000 832 # ifndef PyExc_StopIteration 833 # define PyExc_StopIteration PyExc_RuntimeError 834 # endif 835 # ifndef PyObject_GenericGetAttr 836 # define PyObject_GenericGetAttr 0 837 # endif 838 #endif 839 840 /* Py_NotImplemented is defined in 2.1 and up. */ 841 #if PY_VERSION_HEX < 0x02010000 842 # ifndef Py_NotImplemented 843 # define Py_NotImplemented PyExc_RuntimeError 844 # endif 845 #endif 846 847 /* A crude PyString_AsStringAndSize implementation for old Pythons */ 848 #if PY_VERSION_HEX < 0x02010000 849 # ifndef PyString_AsStringAndSize 850 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;} 851 # endif 852 #endif 853 854 /* PySequence_Size for old Pythons */ 855 #if PY_VERSION_HEX < 0x02000000 856 # ifndef PySequence_Size 857 # define PySequence_Size PySequence_Length 858 # endif 859 #endif 860 861 /* PyBool_FromLong for old Pythons */ 862 #if PY_VERSION_HEX < 0x02030000 863 static 864 PyObject *PyBool_FromLong(long ok) 865 { 866 PyObject *result = ok ? Py_True : Py_False; 867 Py_INCREF(result); 868 return result; 869 } 870 #endif 871 872 /* Py_ssize_t for old Pythons */ 873 /* This code is as recommended by: */ 874 /* http://www.python.org/dev/peps/pep-0353/#conversion-guidelines */ 875 #if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN) 876 typedef int Py_ssize_t; 877 # define PY_SSIZE_T_MAX INT_MAX 878 # define PY_SSIZE_T_MIN INT_MIN 879 typedef inquiry lenfunc; 880 typedef intargfunc ssizeargfunc; 881 typedef intintargfunc ssizessizeargfunc; 882 typedef intobjargproc ssizeobjargproc; 883 typedef intintobjargproc ssizessizeobjargproc; 884 typedef getreadbufferproc readbufferproc; 885 typedef getwritebufferproc writebufferproc; 886 typedef getsegcountproc segcountproc; 887 typedef getcharbufferproc charbufferproc; 888 static long PyNumber_AsSsize_t (PyObject *x, void *SWIGUNUSEDPARM(exc)) 889 { 890 long result = 0; 891 PyObject *i = PyNumber_Int(x); 892 if (i) { 893 result = PyInt_AsLong(i); 894 Py_DECREF(i); 895 } 896 return result; 897 } 898 #endif 899 900 #if PY_VERSION_HEX < 0x02050000 901 #define PyInt_FromSize_t(x) PyInt_FromLong((long)x) 902 #endif 903 904 #if PY_VERSION_HEX < 0x02040000 905 #define Py_VISIT(op) \ 906 do { \ 907 if (op) { \ 908 int vret = visit((op), arg); \ 909 if (vret) \ 910 return vret; \ 911 } \ 912 } while (0) 913 #endif 914 915 #if PY_VERSION_HEX < 0x02030000 916 typedef struct { 917 PyTypeObject type; 918 PyNumberMethods as_number; 919 PyMappingMethods as_mapping; 920 PySequenceMethods as_sequence; 921 PyBufferProcs as_buffer; 922 PyObject *name, *slots; 923 } PyHeapTypeObject; 924 #endif 925 926 #if PY_VERSION_HEX < 0x02030000 927 typedef destructor freefunc; 928 #endif 929 930 #if ((PY_MAJOR_VERSION == 2 && PY_MINOR_VERSION > 6) || \ 931 (PY_MAJOR_VERSION == 3 && PY_MINOR_VERSION > 0) || \ 932 (PY_MAJOR_VERSION > 3)) 933 # define SWIGPY_USE_CAPSULE 934 # define SWIGPY_CAPSULE_NAME ((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION ".type_pointer_capsule" SWIG_TYPE_TABLE_NAME) 935 #endif 936 937 #if PY_VERSION_HEX < 0x03020000 938 #define PyDescr_TYPE(x) (((PyDescrObject *)(x))->d_type) 939 #define PyDescr_NAME(x) (((PyDescrObject *)(x))->d_name) 940 #endif 941 942 /* ----------------------------------------------------------------------------- 943 * error manipulation 944 * ----------------------------------------------------------------------------- */ 945 946 SWIGRUNTIME PyObject* 947 SWIG_Python_ErrorType(int code) { 948 PyObject* type = 0; 949 switch(code) { 950 case SWIG_MemoryError: 951 type = PyExc_MemoryError; 952 break; 953 case SWIG_IOError: 954 type = PyExc_IOError; 955 break; 956 case SWIG_RuntimeError: 957 type = PyExc_RuntimeError; 958 break; 959 case SWIG_IndexError: 960 type = PyExc_IndexError; 961 break; 962 case SWIG_TypeError: 963 type = PyExc_TypeError; 964 break; 965 case SWIG_DivisionByZero: 966 type = PyExc_ZeroDivisionError; 967 break; 968 case SWIG_OverflowError: 969 type = PyExc_OverflowError; 970 break; 971 case SWIG_SyntaxError: 972 type = PyExc_SyntaxError; 973 break; 974 case SWIG_ValueError: 975 type = PyExc_ValueError; 976 break; 977 case SWIG_SystemError: 978 type = PyExc_SystemError; 979 break; 980 case SWIG_AttributeError: 981 type = PyExc_AttributeError; 982 break; 983 default: 984 type = PyExc_RuntimeError; 985 } 986 return type; 987 } 988 989 990 SWIGRUNTIME void 991 SWIG_Python_AddErrorMsg(const char* mesg) 992 { 993 PyObject *type = 0; 994 PyObject *value = 0; 995 PyObject *traceback = 0; 996 997 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback); 998 if (value) { 999 char *tmp; 1000 PyObject *old_str = PyObject_Str(value); 1001 PyErr_Clear(); 1002 Py_XINCREF(type); 1003 1004 PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg); 1005 SWIG_Python_str_DelForPy3(tmp); 1006 Py_DECREF(old_str); 1007 Py_DECREF(value); 1008 } else { 1009 PyErr_SetString(PyExc_RuntimeError, mesg); 1010 } 1011 } 1012 1013 #if defined(SWIG_PYTHON_NO_THREADS) 1014 # if defined(SWIG_PYTHON_THREADS) 1015 # undef SWIG_PYTHON_THREADS 1016 # endif 1017 #endif 1018 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */ 1019 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL) 1020 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */ 1021 # define SWIG_PYTHON_USE_GIL 1022 # endif 1023 # endif 1024 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */ 1025 # ifndef SWIG_PYTHON_INITIALIZE_THREADS 1026 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads() 1027 # endif 1028 # ifdef __cplusplus /* C++ code */ 1029 class SWIG_Python_Thread_Block { 1030 bool status; 1031 PyGILState_STATE state; 1032 public: 1033 void end() { if (status) { PyGILState_Release(state); status = false;} } 1034 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {} 1035 ~SWIG_Python_Thread_Block() { end(); } 1036 }; 1037 class SWIG_Python_Thread_Allow { 1038 bool status; 1039 PyThreadState *save; 1040 public: 1041 void end() { if (status) { PyEval_RestoreThread(save); status = false; }} 1042 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {} 1043 ~SWIG_Python_Thread_Allow() { end(); } 1044 }; 1045 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block 1046 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end() 1047 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow 1048 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end() 1049 # else /* C code */ 1050 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure() 1051 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block) 1052 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread() 1053 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow) 1054 # endif 1055 # else /* Old thread way, not implemented, user must provide it */ 1056 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS) 1057 # define SWIG_PYTHON_INITIALIZE_THREADS 1058 # endif 1059 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK) 1060 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK 1061 # endif 1062 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK) 1063 # define SWIG_PYTHON_THREAD_END_BLOCK 1064 # endif 1065 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW) 1066 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW 1067 # endif 1068 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW) 1069 # define SWIG_PYTHON_THREAD_END_ALLOW 1070 # endif 1071 # endif 1072 #else /* No thread support */ 1073 # define SWIG_PYTHON_INITIALIZE_THREADS 1074 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK 1075 # define SWIG_PYTHON_THREAD_END_BLOCK 1076 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW 1077 # define SWIG_PYTHON_THREAD_END_ALLOW 1078 #endif 1079 1080 /* ----------------------------------------------------------------------------- 1081 * Python API portion that goes into the runtime 1082 * ----------------------------------------------------------------------------- */ 1083 1084 #ifdef __cplusplus 1085 extern "C" { 1086 #endif 1087 1088 /* ----------------------------------------------------------------------------- 1089 * Constant declarations 1090 * ----------------------------------------------------------------------------- */ 1091 1092 /* Constant Types */ 1093 #define SWIG_PY_POINTER 4 1094 #define SWIG_PY_BINARY 5 1095 1096 /* Constant information structure */ 1097 typedef struct swig_const_info { 1098 int type; 1099 char *name; 1100 long lvalue; 1101 double dvalue; 1102 void *pvalue; 1103 swig_type_info **ptype; 1104 } swig_const_info; 1105 1106 1107 /* ----------------------------------------------------------------------------- 1108 * Wrapper of PyInstanceMethod_New() used in Python 3 1109 * It is exported to the generated module, used for -fastproxy 1110 * ----------------------------------------------------------------------------- */ 1111 #if PY_VERSION_HEX >= 0x03000000 1112 SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func) 1113 { 1114 return PyInstanceMethod_New(func); 1115 } 1116 #else 1117 SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *SWIGUNUSEDPARM(func)) 1118 { 1119 return NULL; 1120 } 1121 #endif 1122 1123 #ifdef __cplusplus 1124 } 1125 #endif 1126 1127 1128 /* ----------------------------------------------------------------------------- 1129 * pyrun.swg 1130 * 1131 * This file contains the runtime support for Python modules 1132 * and includes code for managing global variables and pointer 1133 * type checking. 1134 * 1135 * ----------------------------------------------------------------------------- */ 1136 1137 /* Common SWIG API */ 1138 1139 /* for raw pointers */ 1140 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0) 1141 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags) 1142 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own) 1143 1144 #ifdef SWIGPYTHON_BUILTIN 1145 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(self, ptr, type, flags) 1146 #else 1147 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags) 1148 #endif 1149 1150 #define SWIG_InternalNewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags) 1151 1152 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty) 1153 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src) 1154 #define swig_owntype int 1155 1156 /* for raw packed data */ 1157 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty) 1158 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type) 1159 1160 /* for class or struct pointers */ 1161 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags) 1162 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags) 1163 1164 /* for C or C++ function pointers */ 1165 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type) 1166 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(NULL, ptr, type, 0) 1167 1168 /* for C++ member pointers, ie, member methods */ 1169 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty) 1170 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type) 1171 1172 1173 /* Runtime API */ 1174 1175 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule(clientdata) 1176 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer) 1177 #define SWIG_NewClientData(obj) SwigPyClientData_New(obj) 1178 1179 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj 1180 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg 1181 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code) 1182 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg) 1183 #define SWIG_fail goto fail 1184 1185 1186 /* Runtime API implementation */ 1187 1188 /* Error manipulation */ 1189 1190 SWIGINTERN void 1191 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) { 1192 SWIG_PYTHON_THREAD_BEGIN_BLOCK; 1193 PyErr_SetObject(errtype, obj); 1194 Py_DECREF(obj); 1195 SWIG_PYTHON_THREAD_END_BLOCK; 1196 } 1197 1198 SWIGINTERN void 1199 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) { 1200 SWIG_PYTHON_THREAD_BEGIN_BLOCK; 1201 PyErr_SetString(errtype, msg); 1202 SWIG_PYTHON_THREAD_END_BLOCK; 1203 } 1204 1205 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj) 1206 1207 /* Set a constant value */ 1208 1209 #if defined(SWIGPYTHON_BUILTIN) 1210 1211 SWIGINTERN void 1212 SwigPyBuiltin_AddPublicSymbol(PyObject *seq, const char *key) { 1213 PyObject *s = PyString_InternFromString(key); 1214 PyList_Append(seq, s); 1215 Py_DECREF(s); 1216 } 1217 1218 SWIGINTERN void 1219 SWIG_Python_SetConstant(PyObject *d, PyObject *public_interface, const char *name, PyObject *obj) { 1220 #if PY_VERSION_HEX < 0x02030000 1221 PyDict_SetItemString(d, (char *)name, obj); 1222 #else 1223 PyDict_SetItemString(d, name, obj); 1224 #endif 1225 Py_DECREF(obj); 1226 if (public_interface) 1227 SwigPyBuiltin_AddPublicSymbol(public_interface, name); 1228 } 1229 1230 #else 1231 1232 SWIGINTERN void 1233 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) { 1234 #if PY_VERSION_HEX < 0x02030000 1235 PyDict_SetItemString(d, (char *)name, obj); 1236 #else 1237 PyDict_SetItemString(d, name, obj); 1238 #endif 1239 Py_DECREF(obj); 1240 } 1241 1242 #endif 1243 1244 /* Append a value to the result obj */ 1245 1246 SWIGINTERN PyObject* 1247 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) { 1248 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE) 1249 if (!result) { 1250 result = obj; 1251 } else if (result == Py_None) { 1252 Py_DECREF(result); 1253 result = obj; 1254 } else { 1255 if (!PyList_Check(result)) { 1256 PyObject *o2 = result; 1257 result = PyList_New(1); 1258 PyList_SetItem(result, 0, o2); 1259 } 1260 PyList_Append(result,obj); 1261 Py_DECREF(obj); 1262 } 1263 return result; 1264 #else 1265 PyObject* o2; 1266 PyObject* o3; 1267 if (!result) { 1268 result = obj; 1269 } else if (result == Py_None) { 1270 Py_DECREF(result); 1271 result = obj; 1272 } else { 1273 if (!PyTuple_Check(result)) { 1274 o2 = result; 1275 result = PyTuple_New(1); 1276 PyTuple_SET_ITEM(result, 0, o2); 1277 } 1278 o3 = PyTuple_New(1); 1279 PyTuple_SET_ITEM(o3, 0, obj); 1280 o2 = result; 1281 result = PySequence_Concat(o2, o3); 1282 Py_DECREF(o2); 1283 Py_DECREF(o3); 1284 } 1285 return result; 1286 #endif 1287 } 1288 1289 /* Unpack the argument tuple */ 1290 1291 SWIGINTERN int 1292 SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs) 1293 { 1294 if (!args) { 1295 if (!min && !max) { 1296 return 1; 1297 } else { 1298 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none", 1299 name, (min == max ? "" : "at least "), (int)min); 1300 return 0; 1301 } 1302 } 1303 if (!PyTuple_Check(args)) { 1304 if (min <= 1 && max >= 1) { 1305 register int i; 1306 objs[0] = args; 1307 for (i = 1; i < max; ++i) { 1308 objs[i] = 0; 1309 } 1310 return 2; 1311 } 1312 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple"); 1313 return 0; 1314 } else { 1315 register Py_ssize_t l = PyTuple_GET_SIZE(args); 1316 if (l < min) { 1317 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d", 1318 name, (min == max ? "" : "at least "), (int)min, (int)l); 1319 return 0; 1320 } else if (l > max) { 1321 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d", 1322 name, (min == max ? "" : "at most "), (int)max, (int)l); 1323 return 0; 1324 } else { 1325 register int i; 1326 for (i = 0; i < l; ++i) { 1327 objs[i] = PyTuple_GET_ITEM(args, i); 1328 } 1329 for (; l < max; ++l) { 1330 objs[l] = 0; 1331 } 1332 return i + 1; 1333 } 1334 } 1335 } 1336 1337 /* A functor is a function object with one single object argument */ 1338 #if PY_VERSION_HEX >= 0x02020000 1339 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL); 1340 #else 1341 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj); 1342 #endif 1343 1344 /* 1345 Helper for static pointer initialization for both C and C++ code, for example 1346 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...); 1347 */ 1348 #ifdef __cplusplus 1349 #define SWIG_STATIC_POINTER(var) var 1350 #else 1351 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var 1352 #endif 1353 1354 /* ----------------------------------------------------------------------------- 1355 * Pointer declarations 1356 * ----------------------------------------------------------------------------- */ 1357 1358 /* Flags for new pointer objects */ 1359 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1) 1360 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN) 1361 1362 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1) 1363 1364 #define SWIG_BUILTIN_TP_INIT (SWIG_POINTER_OWN << 2) 1365 #define SWIG_BUILTIN_INIT (SWIG_BUILTIN_TP_INIT | SWIG_POINTER_OWN) 1366 1367 #ifdef __cplusplus 1368 extern "C" { 1369 #endif 1370 1371 /* How to access Py_None */ 1372 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) 1373 # ifndef SWIG_PYTHON_NO_BUILD_NONE 1374 # ifndef SWIG_PYTHON_BUILD_NONE 1375 # define SWIG_PYTHON_BUILD_NONE 1376 # endif 1377 # endif 1378 #endif 1379 1380 #ifdef SWIG_PYTHON_BUILD_NONE 1381 # ifdef Py_None 1382 # undef Py_None 1383 # define Py_None SWIG_Py_None() 1384 # endif 1385 SWIGRUNTIMEINLINE PyObject * 1386 _SWIG_Py_None(void) 1387 { 1388 PyObject *none = Py_BuildValue((char*)""); 1389 Py_DECREF(none); 1390 return none; 1391 } 1392 SWIGRUNTIME PyObject * 1393 SWIG_Py_None(void) 1394 { 1395 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None(); 1396 return none; 1397 } 1398 #endif 1399 1400 /* The python void return value */ 1401 1402 SWIGRUNTIMEINLINE PyObject * 1403 SWIG_Py_Void(void) 1404 { 1405 PyObject *none = Py_None; 1406 Py_INCREF(none); 1407 return none; 1408 } 1409 1410 /* SwigPyClientData */ 1411 1412 typedef struct { 1413 PyObject *klass; 1414 PyObject *newraw; 1415 PyObject *newargs; 1416 PyObject *destroy; 1417 int delargs; 1418 int implicitconv; 1419 PyTypeObject *pytype; 1420 } SwigPyClientData; 1421 1422 SWIGRUNTIMEINLINE int 1423 SWIG_Python_CheckImplicit(swig_type_info *ty) 1424 { 1425 SwigPyClientData *data = (SwigPyClientData *)ty->clientdata; 1426 return data ? data->implicitconv : 0; 1427 } 1428 1429 SWIGRUNTIMEINLINE PyObject * 1430 SWIG_Python_ExceptionType(swig_type_info *desc) { 1431 SwigPyClientData *data = desc ? (SwigPyClientData *) desc->clientdata : 0; 1432 PyObject *klass = data ? data->klass : 0; 1433 return (klass ? klass : PyExc_RuntimeError); 1434 } 1435 1436 1437 SWIGRUNTIME SwigPyClientData * 1438 SwigPyClientData_New(PyObject* obj) 1439 { 1440 if (!obj) { 1441 return 0; 1442 } else { 1443 SwigPyClientData *data = (SwigPyClientData *)malloc(sizeof(SwigPyClientData)); 1444 /* the klass element */ 1445 data->klass = obj; 1446 Py_INCREF(data->klass); 1447 /* the newraw method and newargs arguments used to create a new raw instance */ 1448 if (PyClass_Check(obj)) { 1449 data->newraw = 0; 1450 data->newargs = obj; 1451 Py_INCREF(obj); 1452 } else { 1453 #if (PY_VERSION_HEX < 0x02020000) 1454 data->newraw = 0; 1455 #else 1456 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__"); 1457 #endif 1458 if (data->newraw) { 1459 Py_INCREF(data->newraw); 1460 data->newargs = PyTuple_New(1); 1461 PyTuple_SetItem(data->newargs, 0, obj); 1462 } else { 1463 data->newargs = obj; 1464 } 1465 Py_INCREF(data->newargs); 1466 } 1467 /* the destroy method, aka as the C++ delete method */ 1468 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__"); 1469 if (PyErr_Occurred()) { 1470 PyErr_Clear(); 1471 data->destroy = 0; 1472 } 1473 if (data->destroy) { 1474 int flags; 1475 Py_INCREF(data->destroy); 1476 flags = PyCFunction_GET_FLAGS(data->destroy); 1477 #ifdef METH_O 1478 data->delargs = !(flags & (METH_O)); 1479 #else 1480 data->delargs = 0; 1481 #endif 1482 } else { 1483 data->delargs = 0; 1484 } 1485 data->implicitconv = 0; 1486 data->pytype = 0; 1487 return data; 1488 } 1489 } 1490 1491 SWIGRUNTIME void 1492 SwigPyClientData_Del(SwigPyClientData *data) { 1493 Py_XDECREF(data->newraw); 1494 Py_XDECREF(data->newargs); 1495 Py_XDECREF(data->destroy); 1496 } 1497 1498 /* =============== SwigPyObject =====================*/ 1499 1500 typedef struct { 1501 PyObject_HEAD 1502 void *ptr; 1503 swig_type_info *ty; 1504 int own; 1505 PyObject *next; 1506 #ifdef SWIGPYTHON_BUILTIN 1507 PyObject *dict; 1508 #endif 1509 } SwigPyObject; 1510 1511 SWIGRUNTIME PyObject * 1512 SwigPyObject_long(SwigPyObject *v) 1513 { 1514 return PyLong_FromVoidPtr(v->ptr); 1515 } 1516 1517 SWIGRUNTIME PyObject * 1518 SwigPyObject_format(const char* fmt, SwigPyObject *v) 1519 { 1520 PyObject *res = NULL; 1521 PyObject *args = PyTuple_New(1); 1522 if (args) { 1523 if (PyTuple_SetItem(args, 0, SwigPyObject_long(v)) == 0) { 1524 PyObject *ofmt = SWIG_Python_str_FromChar(fmt); 1525 if (ofmt) { 1526 #if PY_VERSION_HEX >= 0x03000000 1527 res = PyUnicode_Format(ofmt,args); 1528 #else 1529 res = PyString_Format(ofmt,args); 1530 #endif 1531 Py_DECREF(ofmt); 1532 } 1533 Py_DECREF(args); 1534 } 1535 } 1536 return res; 1537 } 1538 1539 SWIGRUNTIME PyObject * 1540 SwigPyObject_oct(SwigPyObject *v) 1541 { 1542 return SwigPyObject_format("%o",v); 1543 } 1544 1545 SWIGRUNTIME PyObject * 1546 SwigPyObject_hex(SwigPyObject *v) 1547 { 1548 return SwigPyObject_format("%x",v); 1549 } 1550 1551 SWIGRUNTIME PyObject * 1552 #ifdef METH_NOARGS 1553 SwigPyObject_repr(SwigPyObject *v) 1554 #else 1555 SwigPyObject_repr(SwigPyObject *v, PyObject *args) 1556 #endif 1557 { 1558 const char *name = SWIG_TypePrettyName(v->ty); 1559 PyObject *repr = SWIG_Python_str_FromFormat("<Swig Object of type '%s' at %p>", (name ? name : "unknown"), (void *)v); 1560 if (v->next) { 1561 # ifdef METH_NOARGS 1562 PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next); 1563 # else 1564 PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next, args); 1565 # endif 1566 # if PY_VERSION_HEX >= 0x03000000 1567 PyObject *joined = PyUnicode_Concat(repr, nrep); 1568 Py_DecRef(repr); 1569 Py_DecRef(nrep); 1570 repr = joined; 1571 # else 1572 PyString_ConcatAndDel(&repr,nrep); 1573 # endif 1574 } 1575 return repr; 1576 } 1577 1578 SWIGRUNTIME int 1579 SwigPyObject_compare(SwigPyObject *v, SwigPyObject *w) 1580 { 1581 void *i = v->ptr; 1582 void *j = w->ptr; 1583 return (i < j) ? -1 : ((i > j) ? 1 : 0); 1584 } 1585 1586 /* Added for Python 3.x, would it also be useful for Python 2.x? */ 1587 SWIGRUNTIME PyObject* 1588 SwigPyObject_richcompare(SwigPyObject *v, SwigPyObject *w, int op) 1589 { 1590 PyObject* res; 1591 if( op != Py_EQ && op != Py_NE ) { 1592 Py_INCREF(Py_NotImplemented); 1593 return Py_NotImplemented; 1594 } 1595 res = PyBool_FromLong( (SwigPyObject_compare(v, w)==0) == (op == Py_EQ) ? 1 : 0); 1596 return res; 1597 } 1598 1599 1600 SWIGRUNTIME PyTypeObject* SwigPyObject_TypeOnce(void); 1601 1602 #ifdef SWIGPYTHON_BUILTIN 1603 static swig_type_info *SwigPyObject_stype = 0; 1604 SWIGRUNTIME PyTypeObject* 1605 SwigPyObject_type(void) { 1606 SwigPyClientData *cd; 1607 assert(SwigPyObject_stype); 1608 cd = (SwigPyClientData*) SwigPyObject_stype->clientdata; 1609 assert(cd); 1610 assert(cd->pytype); 1611 return cd->pytype; 1612 } 1613 #else 1614 SWIGRUNTIME PyTypeObject* 1615 SwigPyObject_type(void) { 1616 static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyObject_TypeOnce(); 1617 return type; 1618 } 1619 #endif 1620 1621 SWIGRUNTIMEINLINE int 1622 SwigPyObject_Check(PyObject *op) { 1623 #ifdef SWIGPYTHON_BUILTIN 1624 PyTypeObject *target_tp = SwigPyObject_type(); 1625 if (PyType_IsSubtype(op->ob_type, target_tp)) 1626 return 1; 1627 return (strcmp(op->ob_type->tp_name, "SwigPyObject") == 0); 1628 #else 1629 return (Py_TYPE(op) == SwigPyObject_type()) 1630 || (strcmp(Py_TYPE(op)->tp_name,"SwigPyObject") == 0); 1631 #endif 1632 } 1633 1634 SWIGRUNTIME PyObject * 1635 SwigPyObject_New(void *ptr, swig_type_info *ty, int own); 1636 1637 SWIGRUNTIME void 1638 SwigPyObject_dealloc(PyObject *v) 1639 { 1640 SwigPyObject *sobj = (SwigPyObject *) v; 1641 PyObject *next = sobj->next; 1642 if (sobj->own == SWIG_POINTER_OWN) { 1643 swig_type_info *ty = sobj->ty; 1644 SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0; 1645 PyObject *destroy = data ? data->destroy : 0; 1646 if (destroy) { 1647 /* destroy is always a VARARGS method */ 1648 PyObject *res; 1649 if (data->delargs) { 1650 /* we need to create a temporary object to carry the destroy operation */ 1651 PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0); 1652 res = SWIG_Python_CallFunctor(destroy, tmp); 1653 Py_DECREF(tmp); 1654 } else { 1655 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy); 1656 PyObject *mself = PyCFunction_GET_SELF(destroy); 1657 res = ((*meth)(mself, v)); 1658 } 1659 Py_XDECREF(res); 1660 } 1661 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK) 1662 else { 1663 const char *name = SWIG_TypePrettyName(ty); 1664 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name : "unknown")); 1665 } 1666 #endif 1667 } 1668 Py_XDECREF(next); 1669 PyObject_DEL(v); 1670 } 1671 1672 SWIGRUNTIME PyObject* 1673 SwigPyObject_append(PyObject* v, PyObject* next) 1674 { 1675 SwigPyObject *sobj = (SwigPyObject *) v; 1676 #ifndef METH_O 1677 PyObject *tmp = 0; 1678 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL; 1679 next = tmp; 1680 #endif 1681 if (!SwigPyObject_Check(next)) { 1682 return NULL; 1683 } 1684 sobj->next = next; 1685 Py_INCREF(next); 1686 return SWIG_Py_Void(); 1687 } 1688 1689 SWIGRUNTIME PyObject* 1690 #ifdef METH_NOARGS 1691 SwigPyObject_next(PyObject* v) 1692 #else 1693 SwigPyObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args)) 1694 #endif 1695 { 1696 SwigPyObject *sobj = (SwigPyObject *) v; 1697 if (sobj->next) { 1698 Py_INCREF(sobj->next); 1699 return sobj->next; 1700 } else { 1701 return SWIG_Py_Void(); 1702 } 1703 } 1704 1705 SWIGINTERN PyObject* 1706 #ifdef METH_NOARGS 1707 SwigPyObject_disown(PyObject *v) 1708 #else 1709 SwigPyObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args)) 1710 #endif 1711 { 1712 SwigPyObject *sobj = (SwigPyObject *)v; 1713 sobj->own = 0; 1714 return SWIG_Py_Void(); 1715 } 1716 1717 SWIGINTERN PyObject* 1718 #ifdef METH_NOARGS 1719 SwigPyObject_acquire(PyObject *v) 1720 #else 1721 SwigPyObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args)) 1722 #endif 1723 { 1724 SwigPyObject *sobj = (SwigPyObject *)v; 1725 sobj->own = SWIG_POINTER_OWN; 1726 return SWIG_Py_Void(); 1727 } 1728 1729 SWIGINTERN PyObject* 1730 SwigPyObject_own(PyObject *v, PyObject *args) 1731 { 1732 PyObject *val = 0; 1733 #if (PY_VERSION_HEX < 0x02020000) 1734 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val)) 1735 #elif (PY_VERSION_HEX < 0x02050000) 1736 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val)) 1737 #else 1738 if (!PyArg_UnpackTuple(args, "own", 0, 1, &val)) 1739 #endif 1740 { 1741 return NULL; 1742 } 1743 else 1744 { 1745 SwigPyObject *sobj = (SwigPyObject *)v; 1746 PyObject *obj = PyBool_FromLong(sobj->own); 1747 if (val) { 1748 #ifdef METH_NOARGS 1749 if (PyObject_IsTrue(val)) { 1750 SwigPyObject_acquire(v); 1751 } else { 1752 SwigPyObject_disown(v); 1753 } 1754 #else 1755 if (PyObject_IsTrue(val)) { 1756 SwigPyObject_acquire(v,args); 1757 } else { 1758 SwigPyObject_disown(v,args); 1759 } 1760 #endif 1761 } 1762 return obj; 1763 } 1764 } 1765 1766 #ifdef METH_O 1767 static PyMethodDef 1768 swigobject_methods[] = { 1769 {(char *)"disown", (PyCFunction)SwigPyObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"}, 1770 {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_NOARGS, (char *)"acquires ownership of the pointer"}, 1771 {(char *)"own", (PyCFunction)SwigPyObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"}, 1772 {(char *)"append", (PyCFunction)SwigPyObject_append, METH_O, (char *)"appends another 'this' object"}, 1773 {(char *)"next", (PyCFunction)SwigPyObject_next, METH_NOARGS, (char *)"returns the next 'this' object"}, 1774 {(char *)"__repr__",(PyCFunction)SwigPyObject_repr, METH_NOARGS, (char *)"returns object representation"}, 1775 {0, 0, 0, 0} 1776 }; 1777 #else 1778 static PyMethodDef 1779 swigobject_methods[] = { 1780 {(char *)"disown", (PyCFunction)SwigPyObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"}, 1781 {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"}, 1782 {(char *)"own", (PyCFunction)SwigPyObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"}, 1783 {(char *)"append", (PyCFunction)SwigPyObject_append, METH_VARARGS, (char *)"appends another 'this' object"}, 1784 {(char *)"next", (PyCFunction)SwigPyObject_next, METH_VARARGS, (char *)"returns the next 'this' object"}, 1785 {(char *)"__repr__",(PyCFunction)SwigPyObject_repr, METH_VARARGS, (char *)"returns object representation"}, 1786 {0, 0, 0, 0} 1787 }; 1788 #endif 1789 1790 #if PY_VERSION_HEX < 0x02020000 1791 SWIGINTERN PyObject * 1792 SwigPyObject_getattr(SwigPyObject *sobj,char *name) 1793 { 1794 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name); 1795 } 1796 #endif 1797 1798 SWIGRUNTIME PyTypeObject* 1799 SwigPyObject_TypeOnce(void) { 1800 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer"; 1801 1802 static PyNumberMethods SwigPyObject_as_number = { 1803 (binaryfunc)0, /*nb_add*/ 1804 (binaryfunc)0, /*nb_subtract*/ 1805 (binaryfunc)0, /*nb_multiply*/ 1806 /* nb_divide removed in Python 3 */ 1807 #if PY_VERSION_HEX < 0x03000000 1808 (binaryfunc)0, /*nb_divide*/ 1809 #endif 1810 (binaryfunc)0, /*nb_remainder*/ 1811 (binaryfunc)0, /*nb_divmod*/ 1812 (ternaryfunc)0,/*nb_power*/ 1813 (unaryfunc)0, /*nb_negative*/ 1814 (unaryfunc)0, /*nb_positive*/ 1815 (unaryfunc)0, /*nb_absolute*/ 1816 (inquiry)0, /*nb_nonzero*/ 1817 0, /*nb_invert*/ 1818 0, /*nb_lshift*/ 1819 0, /*nb_rshift*/ 1820 0, /*nb_and*/ 1821 0, /*nb_xor*/ 1822 0, /*nb_or*/ 1823 #if PY_VERSION_HEX < 0x03000000 1824 0, /*nb_coerce*/ 1825 #endif 1826 (unaryfunc)SwigPyObject_long, /*nb_int*/ 1827 #if PY_VERSION_HEX < 0x03000000 1828 (unaryfunc)SwigPyObject_long, /*nb_long*/ 1829 #else 1830 0, /*nb_reserved*/ 1831 #endif 1832 (unaryfunc)0, /*nb_float*/ 1833 #if PY_VERSION_HEX < 0x03000000 1834 (unaryfunc)SwigPyObject_oct, /*nb_oct*/ 1835 (unaryfunc)SwigPyObject_hex, /*nb_hex*/ 1836 #endif 1837 #if PY_VERSION_HEX >= 0x03000000 /* 3.0 */ 1838 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index, nb_inplace_divide removed */ 1839 #elif PY_VERSION_HEX >= 0x02050000 /* 2.5.0 */ 1840 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */ 1841 #elif PY_VERSION_HEX >= 0x02020000 /* 2.2.0 */ 1842 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */ 1843 #elif PY_VERSION_HEX >= 0x02000000 /* 2.0.0 */ 1844 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */ 1845 #endif 1846 }; 1847 1848 static PyTypeObject swigpyobject_type; 1849 static int type_init = 0; 1850 if (!type_init) { 1851 const PyTypeObject tmp = { 1852 /* PyObject header changed in Python 3 */ 1853 #if PY_VERSION_HEX >= 0x03000000 1854 PyVarObject_HEAD_INIT(NULL, 0) 1855 #else 1856 PyObject_HEAD_INIT(NULL) 1857 0, /* ob_size */ 1858 #endif 1859 (char *)"SwigPyObject", /* tp_name */ 1860 sizeof(SwigPyObject), /* tp_basicsize */ 1861 0, /* tp_itemsize */ 1862 (destructor)SwigPyObject_dealloc, /* tp_dealloc */ 1863 0, /* tp_print */ 1864 #if PY_VERSION_HEX < 0x02020000 1865 (getattrfunc)SwigPyObject_getattr, /* tp_getattr */ 1866 #else 1867 (getattrfunc)0, /* tp_getattr */ 1868 #endif 1869 (setattrfunc)0, /* tp_setattr */ 1870 #if PY_VERSION_HEX >= 0x03000000 1871 0, /* tp_reserved in 3.0.1, tp_compare in 3.0.0 but not used */ 1872 #else 1873 (cmpfunc)SwigPyObject_compare, /* tp_compare */ 1874 #endif 1875 (reprfunc)SwigPyObject_repr, /* tp_repr */ 1876 &SwigPyObject_as_number, /* tp_as_number */ 1877 0, /* tp_as_sequence */ 1878 0, /* tp_as_mapping */ 1879 (hashfunc)0, /* tp_hash */ 1880 (ternaryfunc)0, /* tp_call */ 1881 0, /* tp_str */ 1882 PyObject_GenericGetAttr, /* tp_getattro */ 1883 0, /* tp_setattro */ 1884 0, /* tp_as_buffer */ 1885 Py_TPFLAGS_DEFAULT, /* tp_flags */ 1886 swigobject_doc, /* tp_doc */ 1887 0, /* tp_traverse */ 1888 0, /* tp_clear */ 1889 (richcmpfunc)SwigPyObject_richcompare,/* tp_richcompare */ 1890 0, /* tp_weaklistoffset */ 1891 #if PY_VERSION_HEX >= 0x02020000 1892 0, /* tp_iter */ 1893 0, /* tp_iternext */ 1894 swigobject_methods, /* tp_methods */ 1895 0, /* tp_members */ 1896 0, /* tp_getset */ 1897 0, /* tp_base */ 1898 0, /* tp_dict */ 1899 0, /* tp_descr_get */ 1900 0, /* tp_descr_set */ 1901 0, /* tp_dictoffset */ 1902 0, /* tp_init */ 1903 0, /* tp_alloc */ 1904 0, /* tp_new */ 1905 0, /* tp_free */ 1906 0, /* tp_is_gc */ 1907 0, /* tp_bases */ 1908 0, /* tp_mro */ 1909 0, /* tp_cache */ 1910 0, /* tp_subclasses */ 1911 0, /* tp_weaklist */ 1912 #endif 1913 #if PY_VERSION_HEX >= 0x02030000 1914 0, /* tp_del */ 1915 #endif 1916 #if PY_VERSION_HEX >= 0x02060000 1917 0, /* tp_version */ 1918 #endif 1919 #ifdef COUNT_ALLOCS 1920 0,0,0,0 /* tp_alloc -> tp_next */ 1921 #endif 1922 }; 1923 swigpyobject_type = tmp; 1924 type_init = 1; 1925 #if PY_VERSION_HEX < 0x02020000 1926 swigpyobject_type.ob_type = &PyType_Type; 1927 #else 1928 if (PyType_Ready(&swigpyobject_type) < 0) 1929 return NULL; 1930 #endif 1931 } 1932 return &swigpyobject_type; 1933 } 1934 1935 SWIGRUNTIME PyObject * 1936 SwigPyObject_New(void *ptr, swig_type_info *ty, int own) 1937 { 1938 SwigPyObject *sobj = PyObject_NEW(SwigPyObject, SwigPyObject_type()); 1939 if (sobj) { 1940 sobj->ptr = ptr; 1941 sobj->ty = ty; 1942 sobj->own = own; 1943 sobj->next = 0; 1944 } 1945 return (PyObject *)sobj; 1946 } 1947 1948 /* ----------------------------------------------------------------------------- 1949 * Implements a simple Swig Packed type, and use it instead of string 1950 * ----------------------------------------------------------------------------- */ 1951 1952 typedef struct { 1953 PyObject_HEAD 1954 void *pack; 1955 swig_type_info *ty; 1956 size_t size; 1957 } SwigPyPacked; 1958 1959 SWIGRUNTIME int 1960 SwigPyPacked_print(SwigPyPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags)) 1961 { 1962 char result[SWIG_BUFFER_SIZE]; 1963 fputs("<Swig Packed ", fp); 1964 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) { 1965 fputs("at ", fp); 1966 fputs(result, fp); 1967 } 1968 fputs(v->ty->name,fp); 1969 fputs(">", fp); 1970 return 0; 1971 } 1972 1973 SWIGRUNTIME PyObject * 1974 SwigPyPacked_repr(SwigPyPacked *v) 1975 { 1976 char result[SWIG_BUFFER_SIZE]; 1977 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) { 1978 return SWIG_Python_str_FromFormat("<Swig Packed at %s%s>", result, v->ty->name); 1979 } else { 1980 return SWIG_Python_str_FromFormat("<Swig Packed %s>", v->ty->name); 1981 } 1982 } 1983 1984 SWIGRUNTIME PyObject * 1985 SwigPyPacked_str(SwigPyPacked *v) 1986 { 1987 char result[SWIG_BUFFER_SIZE]; 1988 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){ 1989 return SWIG_Python_str_FromFormat("%s%s", result, v->ty->name); 1990 } else { 1991 return SWIG_Python_str_FromChar(v->ty->name); 1992 } 1993 } 1994 1995 SWIGRUNTIME int 1996 SwigPyPacked_compare(SwigPyPacked *v, SwigPyPacked *w) 1997 { 1998 size_t i = v->size; 1999 size_t j = w->size; 2000 int s = (i < j) ? -1 : ((i > j) ? 1 : 0); 2001 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size); 2002 } 2003 2004 SWIGRUNTIME PyTypeObject* SwigPyPacked_TypeOnce(void); 2005 2006 SWIGRUNTIME PyTypeObject* 2007 SwigPyPacked_type(void) { 2008 static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyPacked_TypeOnce(); 2009 return type; 2010 } 2011 2012 SWIGRUNTIMEINLINE int 2013 SwigPyPacked_Check(PyObject *op) { 2014 return ((op)->ob_type == SwigPyPacked_TypeOnce()) 2015 || (strcmp((op)->ob_type->tp_name,"SwigPyPacked") == 0); 2016 } 2017 2018 SWIGRUNTIME void 2019 SwigPyPacked_dealloc(PyObject *v) 2020 { 2021 if (SwigPyPacked_Check(v)) { 2022 SwigPyPacked *sobj = (SwigPyPacked *) v; 2023 free(sobj->pack); 2024 } 2025 PyObject_DEL(v); 2026 } 2027 2028 SWIGRUNTIME PyTypeObject* 2029 SwigPyPacked_TypeOnce(void) { 2030 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer"; 2031 static PyTypeObject swigpypacked_type; 2032 static int type_init = 0; 2033 if (!type_init) { 2034 const PyTypeObject tmp = { 2035 /* PyObject header changed in Python 3 */ 2036 #if PY_VERSION_HEX>=0x03000000 2037 PyVarObject_HEAD_INIT(NULL, 0) 2038 #else 2039 PyObject_HEAD_INIT(NULL) 2040 0, /* ob_size */ 2041 #endif 2042 (char *)"SwigPyPacked", /* tp_name */ 2043 sizeof(SwigPyPacked), /* tp_basicsize */ 2044 0, /* tp_itemsize */ 2045 (destructor)SwigPyPacked_dealloc, /* tp_dealloc */ 2046 (printfunc)SwigPyPacked_print, /* tp_print */ 2047 (getattrfunc)0, /* tp_getattr */ 2048 (setattrfunc)0, /* tp_setattr */ 2049 #if PY_VERSION_HEX>=0x03000000 2050 0, /* tp_reserved in 3.0.1 */ 2051 #else 2052 (cmpfunc)SwigPyPacked_compare, /* tp_compare */ 2053 #endif 2054 (reprfunc)SwigPyPacked_repr, /* tp_repr */ 2055 0, /* tp_as_number */ 2056 0, /* tp_as_sequence */ 2057 0, /* tp_as_mapping */ 2058 (hashfunc)0, /* tp_hash */ 2059 (ternaryfunc)0, /* tp_call */ 2060 (reprfunc)SwigPyPacked_str, /* tp_str */ 2061 PyObject_GenericGetAttr, /* tp_getattro */ 2062 0, /* tp_setattro */ 2063 0, /* tp_as_buffer */ 2064 Py_TPFLAGS_DEFAULT, /* tp_flags */ 2065 swigpacked_doc, /* tp_doc */ 2066 0, /* tp_traverse */ 2067 0, /* tp_clear */ 2068 0, /* tp_richcompare */ 2069 0, /* tp_weaklistoffset */ 2070 #if PY_VERSION_HEX >= 0x02020000 2071 0, /* tp_iter */ 2072 0, /* tp_iternext */ 2073 0, /* tp_methods */ 2074 0, /* tp_members */ 2075 0, /* tp_getset */ 2076 0, /* tp_base */ 2077 0, /* tp_dict */ 2078 0, /* tp_descr_get */ 2079 0, /* tp_descr_set */ 2080 0, /* tp_dictoffset */ 2081 0, /* tp_init */ 2082 0, /* tp_alloc */ 2083 0, /* tp_new */ 2084 0, /* tp_free */ 2085 0, /* tp_is_gc */ 2086 0, /* tp_bases */ 2087 0, /* tp_mro */ 2088 0, /* tp_cache */ 2089 0, /* tp_subclasses */ 2090 0, /* tp_weaklist */ 2091 #endif 2092 #if PY_VERSION_HEX >= 0x02030000 2093 0, /* tp_del */ 2094 #endif 2095 #if PY_VERSION_HEX >= 0x02060000 2096 0, /* tp_version */ 2097 #endif 2098 #ifdef COUNT_ALLOCS 2099 0,0,0,0 /* tp_alloc -> tp_next */ 2100 #endif 2101 }; 2102 swigpypacked_type = tmp; 2103 type_init = 1; 2104 #if PY_VERSION_HEX < 0x02020000 2105 swigpypacked_type.ob_type = &PyType_Type; 2106 #else 2107 if (PyType_Ready(&swigpypacked_type) < 0) 2108 return NULL; 2109 #endif 2110 } 2111 return &swigpypacked_type; 2112 } 2113 2114 SWIGRUNTIME PyObject * 2115 SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty) 2116 { 2117 SwigPyPacked *sobj = PyObject_NEW(SwigPyPacked, SwigPyPacked_type()); 2118 if (sobj) { 2119 void *pack = malloc(size); 2120 if (pack) { 2121 memcpy(pack, ptr, size); 2122 sobj->pack = pack; 2123 sobj->ty = ty; 2124 sobj->size = size; 2125 } else { 2126 PyObject_DEL((PyObject *) sobj); 2127 sobj = 0; 2128 } 2129 } 2130 return (PyObject *) sobj; 2131 } 2132 2133 SWIGRUNTIME swig_type_info * 2134 SwigPyPacked_UnpackData(PyObject *obj, void *ptr, size_t size) 2135 { 2136 if (SwigPyPacked_Check(obj)) { 2137 SwigPyPacked *sobj = (SwigPyPacked *)obj; 2138 if (sobj->size != size) return 0; 2139 memcpy(ptr, sobj->pack, size); 2140 return sobj->ty; 2141 } else { 2142 return 0; 2143 } 2144 } 2145 2146 /* ----------------------------------------------------------------------------- 2147 * pointers/data manipulation 2148 * ----------------------------------------------------------------------------- */ 2149 2150 SWIGRUNTIMEINLINE PyObject * 2151 _SWIG_This(void) 2152 { 2153 return SWIG_Python_str_FromChar("this"); 2154 } 2155 2156 static PyObject *swig_this = NULL; 2157 2158 SWIGRUNTIME PyObject * 2159 SWIG_This(void) 2160 { 2161 if (swig_this == NULL) 2162 swig_this = _SWIG_This(); 2163 return swig_this; 2164 } 2165 2166 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */ 2167 2168 /* TODO: I don't know how to implement the fast getset in Python 3 right now */ 2169 #if PY_VERSION_HEX>=0x03000000 2170 #define SWIG_PYTHON_SLOW_GETSET_THIS 2171 #endif 2172 2173 SWIGRUNTIME SwigPyObject * 2174 SWIG_Python_GetSwigThis(PyObject *pyobj) 2175 { 2176 PyObject *obj; 2177 2178 if (SwigPyObject_Check(pyobj)) 2179 return (SwigPyObject *) pyobj; 2180 2181 #ifdef SWIGPYTHON_BUILTIN 2182 (void)obj; 2183 # ifdef PyWeakref_CheckProxy 2184 if (PyWeakref_CheckProxy(pyobj)) { 2185 pyobj = PyWeakref_GET_OBJECT(pyobj); 2186 if (pyobj && SwigPyObject_Check(pyobj)) 2187 return (SwigPyObject*) pyobj; 2188 } 2189 # endif 2190 return NULL; 2191 #else 2192 2193 obj = 0; 2194 2195 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000)) 2196 if (PyInstance_Check(pyobj)) { 2197 obj = _PyInstance_Lookup(pyobj, SWIG_This()); 2198 } else { 2199 PyObject **dictptr = _PyObject_GetDictPtr(pyobj); 2200 if (dictptr != NULL) { 2201 PyObject *dict = *dictptr; 2202 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0; 2203 } else { 2204 #ifdef PyWeakref_CheckProxy 2205 if (PyWeakref_CheckProxy(pyobj)) { 2206 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj); 2207 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0; 2208 } 2209 #endif 2210 obj = PyObject_GetAttr(pyobj,SWIG_This()); 2211 if (obj) { 2212 Py_DECREF(obj); 2213 } else { 2214 if (PyErr_Occurred()) PyErr_Clear(); 2215 return 0; 2216 } 2217 } 2218 } 2219 #else 2220 obj = PyObject_GetAttr(pyobj,SWIG_This()); 2221 if (obj) { 2222 Py_DECREF(obj); 2223 } else { 2224 if (PyErr_Occurred()) PyErr_Clear(); 2225 return 0; 2226 } 2227 #endif 2228 if (obj && !SwigPyObject_Check(obj)) { 2229 /* a PyObject is called 'this', try to get the 'real this' 2230 SwigPyObject from it */ 2231 return SWIG_Python_GetSwigThis(obj); 2232 } 2233 return (SwigPyObject *)obj; 2234 #endif 2235 } 2236 2237 /* Acquire a pointer value */ 2238 2239 SWIGRUNTIME int 2240 SWIG_Python_AcquirePtr(PyObject *obj, int own) { 2241 if (own == SWIG_POINTER_OWN) { 2242 SwigPyObject *sobj = SWIG_Python_GetSwigThis(obj); 2243 if (sobj) { 2244 int oldown = sobj->own; 2245 sobj->own = own; 2246 return oldown; 2247 } 2248 } 2249 return 0; 2250 } 2251 2252 /* Convert a pointer value */ 2253 2254 SWIGRUNTIME int 2255 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) { 2256 int res; 2257 SwigPyObject *sobj; 2258 int implicit_conv = (flags & SWIG_POINTER_IMPLICIT_CONV) != 0; 2259 2260 if (!obj) 2261 return SWIG_ERROR; 2262 if (obj == Py_None && !implicit_conv) { 2263 if (ptr) 2264 *ptr = 0; 2265 return SWIG_OK; 2266 } 2267 2268 res = SWIG_ERROR; 2269 2270 sobj = SWIG_Python_GetSwigThis(obj); 2271 if (own) 2272 *own = 0; 2273 while (sobj) { 2274 void *vptr = sobj->ptr; 2275 if (ty) { 2276 swig_type_info *to = sobj->ty; 2277 if (to == ty) { 2278 /* no type cast needed */ 2279 if (ptr) *ptr = vptr; 2280 break; 2281 } else { 2282 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty); 2283 if (!tc) { 2284 sobj = (SwigPyObject *)sobj->next; 2285 } else { 2286 if (ptr) { 2287 int newmemory = 0; 2288 *ptr = SWIG_TypeCast(tc,vptr,&newmemory); 2289 if (newmemory == SWIG_CAST_NEW_MEMORY) { 2290 assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */ 2291 if (own) 2292 *own = *own | SWIG_CAST_NEW_MEMORY; 2293 } 2294 } 2295 break; 2296 } 2297 } 2298 } else { 2299 if (ptr) *ptr = vptr; 2300 break; 2301 } 2302 } 2303 if (sobj) { 2304 if (own) 2305 *own = *own | sobj->own; 2306 if (flags & SWIG_POINTER_DISOWN) { 2307 sobj->own = 0; 2308 } 2309 res = SWIG_OK; 2310 } else { 2311 if (implicit_conv) { 2312 SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0; 2313 if (data && !data->implicitconv) { 2314 PyObject *klass = data->klass; 2315 if (klass) { 2316 PyObject *impconv; 2317 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/ 2318 impconv = SWIG_Python_CallFunctor(klass, obj); 2319 data->implicitconv = 0; 2320 if (PyErr_Occurred()) { 2321 PyErr_Clear(); 2322 impconv = 0; 2323 } 2324 if (impconv) { 2325 SwigPyObject *iobj = SWIG_Python_GetSwigThis(impconv); 2326 if (iobj) { 2327 void *vptr; 2328 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0); 2329 if (SWIG_IsOK(res)) { 2330 if (ptr) { 2331 *ptr = vptr; 2332 /* transfer the ownership to 'ptr' */ 2333 iobj->own = 0; 2334 res = SWIG_AddCast(res); 2335 res = SWIG_AddNewMask(res); 2336 } else { 2337 res = SWIG_AddCast(res); 2338 } 2339 } 2340 } 2341 Py_DECREF(impconv); 2342 } 2343 } 2344 } 2345 } 2346 if (!SWIG_IsOK(res) && obj == Py_None) { 2347 if (ptr) 2348 *ptr = 0; 2349 if (PyErr_Occurred()) 2350 PyErr_Clear(); 2351 res = SWIG_OK; 2352 } 2353 } 2354 return res; 2355 } 2356 2357 /* Convert a function ptr value */ 2358 2359 SWIGRUNTIME int 2360 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) { 2361 if (!PyCFunction_Check(obj)) { 2362 return SWIG_ConvertPtr(obj, ptr, ty, 0); 2363 } else { 2364 void *vptr = 0; 2365 2366 /* here we get the method pointer for callbacks */ 2367 const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc); 2368 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0; 2369 if (desc) 2370 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0; 2371 if (!desc) 2372 return SWIG_ERROR; 2373 if (ty) { 2374 swig_cast_info *tc = SWIG_TypeCheck(desc,ty); 2375 if (tc) { 2376 int newmemory = 0; 2377 *ptr = SWIG_TypeCast(tc,vptr,&newmemory); 2378 assert(!newmemory); /* newmemory handling not yet implemented */ 2379 } else { 2380 return SWIG_ERROR; 2381 } 2382 } else { 2383 *ptr = vptr; 2384 } 2385 return SWIG_OK; 2386 } 2387 } 2388 2389 /* Convert a packed value value */ 2390 2391 SWIGRUNTIME int 2392 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) { 2393 swig_type_info *to = SwigPyPacked_UnpackData(obj, ptr, sz); 2394 if (!to) return SWIG_ERROR; 2395 if (ty) { 2396 if (to != ty) { 2397 /* check type cast? */ 2398 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty); 2399 if (!tc) return SWIG_ERROR; 2400 } 2401 } 2402 return SWIG_OK; 2403 } 2404 2405 /* ----------------------------------------------------------------------------- 2406 * Create a new pointer object 2407 * ----------------------------------------------------------------------------- */ 2408 2409 /* 2410 Create a new instance object, without calling __init__, and set the 2411 'this' attribute. 2412 */ 2413 2414 SWIGRUNTIME PyObject* 2415 SWIG_Python_NewShadowInstance(SwigPyClientData *data, PyObject *swig_this) 2416 { 2417 #if (PY_VERSION_HEX >= 0x02020000) 2418 PyObject *inst = 0; 2419 PyObject *newraw = data->newraw; 2420 if (newraw) { 2421 inst = PyObject_Call(newraw, data->newargs, NULL); 2422 if (inst) { 2423 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS) 2424 PyObject **dictptr = _PyObject_GetDictPtr(inst); 2425 if (dictptr != NULL) { 2426 PyObject *dict = *dictptr; 2427 if (dict == NULL) { 2428 dict = PyDict_New(); 2429 *dictptr = dict; 2430 PyDict_SetItem(dict, SWIG_This(), swig_this); 2431 } 2432 } 2433 #else 2434 PyObject *key = SWIG_This(); 2435 PyObject_SetAttr(inst, key, swig_this); 2436 #endif 2437 } 2438 } else { 2439 #if PY_VERSION_HEX >= 0x03000000 2440 inst = PyBaseObject_Type.tp_new((PyTypeObject*) data->newargs, Py_None, Py_None); 2441 if (inst) { 2442 PyObject_SetAttr(inst, SWIG_This(), swig_this); 2443 Py_TYPE(inst)->tp_flags &= ~Py_TPFLAGS_VALID_VERSION_TAG; 2444 } 2445 #else 2446 PyObject *dict = PyDict_New(); 2447 if (dict) { 2448 PyDict_SetItem(dict, SWIG_This(), swig_this); 2449 inst = PyInstance_NewRaw(data->newargs, dict); 2450 Py_DECREF(dict); 2451 } 2452 #endif 2453 } 2454 return inst; 2455 #else 2456 #if (PY_VERSION_HEX >= 0x02010000) 2457 PyObject *inst = 0; 2458 PyObject *dict = PyDict_New(); 2459 if (dict) { 2460 PyDict_SetItem(dict, SWIG_This(), swig_this); 2461 inst = PyInstance_NewRaw(data->newargs, dict); 2462 Py_DECREF(dict); 2463 } 2464 return (PyObject *) inst; 2465 #else 2466 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type); 2467 if (inst == NULL) { 2468 return NULL; 2469 } 2470 inst->in_class = (PyClassObject *)data->newargs; 2471 Py_INCREF(inst->in_class); 2472 inst->in_dict = PyDict_New(); 2473 if (inst->in_dict == NULL) { 2474 Py_DECREF(inst); 2475 return NULL; 2476 } 2477 #ifdef Py_TPFLAGS_HAVE_WEAKREFS 2478 inst->in_weakreflist = NULL; 2479 #endif 2480 #ifdef Py_TPFLAGS_GC 2481 PyObject_GC_Init(inst); 2482 #endif 2483 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this); 2484 return (PyObject *) inst; 2485 #endif 2486 #endif 2487 } 2488 2489 SWIGRUNTIME void 2490 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this) 2491 { 2492 PyObject *dict; 2493 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS) 2494 PyObject **dictptr = _PyObject_GetDictPtr(inst); 2495 if (dictptr != NULL) { 2496 dict = *dictptr; 2497 if (dict == NULL) { 2498 dict = PyDict_New(); 2499 *dictptr = dict; 2500 } 2501 PyDict_SetItem(dict, SWIG_This(), swig_this); 2502 return; 2503 } 2504 #endif 2505 dict = PyObject_GetAttrString(inst, (char*)"__dict__"); 2506 PyDict_SetItem(dict, SWIG_This(), swig_this); 2507 Py_DECREF(dict); 2508 } 2509 2510 2511 SWIGINTERN PyObject * 2512 SWIG_Python_InitShadowInstance(PyObject *args) { 2513 PyObject *obj[2]; 2514 if (!SWIG_Python_UnpackTuple(args, "swiginit", 2, 2, obj)) { 2515 return NULL; 2516 } else { 2517 SwigPyObject *sthis = SWIG_Python_GetSwigThis(obj[0]); 2518 if (sthis) { 2519 SwigPyObject_append((PyObject*) sthis, obj[1]); 2520 } else { 2521 SWIG_Python_SetSwigThis(obj[0], obj[1]); 2522 } 2523 return SWIG_Py_Void(); 2524 } 2525 } 2526 2527 /* Create a new pointer object */ 2528 2529 SWIGRUNTIME PyObject * 2530 SWIG_Python_NewPointerObj(PyObject *self, void *ptr, swig_type_info *type, int flags) { 2531 SwigPyClientData *clientdata; 2532 PyObject * robj; 2533 int own; 2534 2535 if (!ptr) 2536 return SWIG_Py_Void(); 2537 2538 clientdata = type ? (SwigPyClientData *)(type->clientdata) : 0; 2539 own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0; 2540 if (clientdata && clientdata->pytype) { 2541 SwigPyObject *newobj; 2542 if (flags & SWIG_BUILTIN_TP_INIT) { 2543 newobj = (SwigPyObject*) self; 2544 if (newobj->ptr) { 2545 PyObject *next_self = clientdata->pytype->tp_alloc(clientdata->pytype, 0); 2546 while (newobj->next) 2547 newobj = (SwigPyObject *) newobj->next; 2548 newobj->next = next_self; 2549 newobj = (SwigPyObject *)next_self; 2550 } 2551 } else { 2552 newobj = PyObject_New(SwigPyObject, clientdata->pytype); 2553 } 2554 if (newobj) { 2555 newobj->ptr = ptr; 2556 newobj->ty = type; 2557 newobj->own = own; 2558 newobj->next = 0; 2559 #ifdef SWIGPYTHON_BUILTIN 2560 newobj->dict = 0; 2561 #endif 2562 return (PyObject*) newobj; 2563 } 2564 return SWIG_Py_Void(); 2565 } 2566 2567 assert(!(flags & SWIG_BUILTIN_TP_INIT)); 2568 2569 robj = SwigPyObject_New(ptr, type, own); 2570 if (robj && clientdata && !(flags & SWIG_POINTER_NOSHADOW)) { 2571 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj); 2572 Py_DECREF(robj); 2573 robj = inst; 2574 } 2575 return robj; 2576 } 2577 2578 /* Create a new packed object */ 2579 2580 SWIGRUNTIMEINLINE PyObject * 2581 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) { 2582 return ptr ? SwigPyPacked_New((void *) ptr, sz, type) : SWIG_Py_Void(); 2583 } 2584 2585 /* -----------------------------------------------------------------------------* 2586 * Get type list 2587 * -----------------------------------------------------------------------------*/ 2588 2589 #ifdef SWIG_LINK_RUNTIME 2590 void *SWIG_ReturnGlobalTypeList(void *); 2591 #endif 2592 2593 SWIGRUNTIME swig_module_info * 2594 SWIG_Python_GetModule(void *SWIGUNUSEDPARM(clientdata)) { 2595 static void *type_pointer = (void *)0; 2596 /* first check if module already created */ 2597 if (!type_pointer) { 2598 #ifdef SWIG_LINK_RUNTIME 2599 type_pointer = SWIG_ReturnGlobalTypeList((void *)0); 2600 #else 2601 # ifdef SWIGPY_USE_CAPSULE 2602 type_pointer = PyCapsule_Import(SWIGPY_CAPSULE_NAME, 0); 2603 # else 2604 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION, 2605 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME); 2606 # endif 2607 if (PyErr_Occurred()) { 2608 PyErr_Clear(); 2609 type_pointer = (void *)0; 2610 } 2611 #endif 2612 } 2613 return (swig_module_info *) type_pointer; 2614 } 2615 2616 #if PY_MAJOR_VERSION < 2 2617 /* PyModule_AddObject function was introduced in Python 2.0. The following function 2618 is copied out of Python/modsupport.c in python version 2.3.4 */ 2619 SWIGINTERN int 2620 PyModule_AddObject(PyObject *m, char *name, PyObject *o) 2621 { 2622 PyObject *dict; 2623 if (!PyModule_Check(m)) { 2624 PyErr_SetString(PyExc_TypeError, 2625 "PyModule_AddObject() needs module as first arg"); 2626 return SWIG_ERROR; 2627 } 2628 if (!o) { 2629 PyErr_SetString(PyExc_TypeError, 2630 "PyModule_AddObject() needs non-NULL value"); 2631 return SWIG_ERROR; 2632 } 2633 2634 dict = PyModule_GetDict(m); 2635 if (dict == NULL) { 2636 /* Internal error -- modules must have a dict! */ 2637 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__", 2638 PyModule_GetName(m)); 2639 return SWIG_ERROR; 2640 } 2641 if (PyDict_SetItemString(dict, name, o)) 2642 return SWIG_ERROR; 2643 Py_DECREF(o); 2644 return SWIG_OK; 2645 } 2646 #endif 2647 2648 SWIGRUNTIME void 2649 #ifdef SWIGPY_USE_CAPSULE 2650 SWIG_Python_DestroyModule(PyObject *obj) 2651 #else 2652 SWIG_Python_DestroyModule(void *vptr) 2653 #endif 2654 { 2655 #ifdef SWIGPY_USE_CAPSULE 2656 swig_module_info *swig_module = (swig_module_info *) PyCapsule_GetPointer(obj, SWIGPY_CAPSULE_NAME); 2657 #else 2658 swig_module_info *swig_module = (swig_module_info *) vptr; 2659 #endif 2660 swig_type_info **types = swig_module->types; 2661 size_t i; 2662 for (i =0; i < swig_module->size; ++i) { 2663 swig_type_info *ty = types[i]; 2664 if (ty->owndata) { 2665 SwigPyClientData *data = (SwigPyClientData *) ty->clientdata; 2666 if (data) SwigPyClientData_Del(data); 2667 } 2668 } 2669 Py_DECREF(SWIG_This()); 2670 swig_this = NULL; 2671 } 2672 2673 SWIGRUNTIME void 2674 SWIG_Python_SetModule(swig_module_info *swig_module) { 2675 #if PY_VERSION_HEX >= 0x03000000 2676 /* Add a dummy module object into sys.modules */ 2677 PyObject *module = PyImport_AddModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION); 2678 #else 2679 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} }; /* Sentinel */ 2680 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION, swig_empty_runtime_method_table); 2681 #endif 2682 #ifdef SWIGPY_USE_CAPSULE 2683 PyObject *pointer = PyCapsule_New((void *) swig_module, SWIGPY_CAPSULE_NAME, SWIG_Python_DestroyModule); 2684 if (pointer && module) { 2685 PyModule_AddObject(module, (char*)"type_pointer_capsule" SWIG_TYPE_TABLE_NAME, pointer); 2686 } else { 2687 Py_XDECREF(pointer); 2688 } 2689 #else 2690 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule); 2691 if (pointer && module) { 2692 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer); 2693 } else { 2694 Py_XDECREF(pointer); 2695 } 2696 #endif 2697 } 2698 2699 /* The python cached type query */ 2700 SWIGRUNTIME PyObject * 2701 SWIG_Python_TypeCache(void) { 2702 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New(); 2703 return cache; 2704 } 2705 2706 SWIGRUNTIME swig_type_info * 2707 SWIG_Python_TypeQuery(const char *type) 2708 { 2709 PyObject *cache = SWIG_Python_TypeCache(); 2710 PyObject *key = SWIG_Python_str_FromChar(type); 2711 PyObject *obj = PyDict_GetItem(cache, key); 2712 swig_type_info *descriptor; 2713 if (obj) { 2714 #ifdef SWIGPY_USE_CAPSULE 2715 descriptor = (swig_type_info *) PyCapsule_GetPointer(obj, NULL); 2716 #else 2717 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj); 2718 #endif 2719 } else { 2720 swig_module_info *swig_module = SWIG_GetModule(0); 2721 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type); 2722 if (descriptor) { 2723 #ifdef SWIGPY_USE_CAPSULE 2724 obj = PyCapsule_New((void*) descriptor, NULL, NULL); 2725 #else 2726 obj = PyCObject_FromVoidPtr(descriptor, NULL); 2727 #endif 2728 PyDict_SetItem(cache, key, obj); 2729 Py_DECREF(obj); 2730 } 2731 } 2732 Py_DECREF(key); 2733 return descriptor; 2734 } 2735 2736 /* 2737 For backward compatibility only 2738 */ 2739 #define SWIG_POINTER_EXCEPTION 0 2740 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg) 2741 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags) 2742 2743 SWIGRUNTIME int 2744 SWIG_Python_AddErrMesg(const char* mesg, int infront) 2745 { 2746 if (PyErr_Occurred()) { 2747 PyObject *type = 0; 2748 PyObject *value = 0; 2749 PyObject *traceback = 0; 2750 PyErr_Fetch(&type, &value, &traceback); 2751 if (value) { 2752 char *tmp; 2753 PyObject *old_str = PyObject_Str(value); 2754 Py_XINCREF(type); 2755 PyErr_Clear(); 2756 if (infront) { 2757 PyErr_Format(type, "%s %s", mesg, tmp = SWIG_Python_str_AsChar(old_str)); 2758 } else { 2759 PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg); 2760 } 2761 SWIG_Python_str_DelForPy3(tmp); 2762 Py_DECREF(old_str); 2763 } 2764 return 1; 2765 } else { 2766 return 0; 2767 } 2768 } 2769 2770 SWIGRUNTIME int 2771 SWIG_Python_ArgFail(int argnum) 2772 { 2773 if (PyErr_Occurred()) { 2774 /* add information about failing argument */ 2775 char mesg[256]; 2776 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum); 2777 return SWIG_Python_AddErrMesg(mesg, 1); 2778 } else { 2779 return 0; 2780 } 2781 } 2782 2783 SWIGRUNTIMEINLINE const char * 2784 SwigPyObject_GetDesc(PyObject *self) 2785 { 2786 SwigPyObject *v = (SwigPyObject *)self; 2787 swig_type_info *ty = v ? v->ty : 0; 2788 return ty ? ty->str : ""; 2789 } 2790 2791 SWIGRUNTIME void 2792 SWIG_Python_TypeError(const char *type, PyObject *obj) 2793 { 2794 if (type) { 2795 #if defined(SWIG_COBJECT_TYPES) 2796 if (obj && SwigPyObject_Check(obj)) { 2797 const char *otype = (const char *) SwigPyObject_GetDesc(obj); 2798 if (otype) { 2799 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'SwigPyObject(%s)' is received", 2800 type, otype); 2801 return; 2802 } 2803 } else 2804 #endif 2805 { 2806 const char *otype = (obj ? obj->ob_type->tp_name : 0); 2807 if (otype) { 2808 PyObject *str = PyObject_Str(obj); 2809 const char *cstr = str ? SWIG_Python_str_AsChar(str) : 0; 2810 if (cstr) { 2811 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received", 2812 type, otype, cstr); 2813 SWIG_Python_str_DelForPy3(cstr); 2814 } else { 2815 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received", 2816 type, otype); 2817 } 2818 Py_XDECREF(str); 2819 return; 2820 } 2821 } 2822 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type); 2823 } else { 2824 PyErr_Format(PyExc_TypeError, "unexpected type is received"); 2825 } 2826 } 2827 2828 2829 /* Convert a pointer value, signal an exception on a type mismatch */ 2830 SWIGRUNTIME void * 2831 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int SWIGUNUSEDPARM(argnum), int flags) { 2832 void *result; 2833 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) { 2834 PyErr_Clear(); 2835 #if SWIG_POINTER_EXCEPTION 2836 if (flags) { 2837 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj); 2838 SWIG_Python_ArgFail(argnum); 2839 } 2840 #endif 2841 } 2842 return result; 2843 } 2844 2845 #ifdef SWIGPYTHON_BUILTIN 2846 SWIGRUNTIME int 2847 SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *value) { 2848 PyTypeObject *tp = obj->ob_type; 2849 PyObject *descr; 2850 PyObject *encoded_name; 2851 descrsetfunc f; 2852 int res = -1; 2853 2854 # ifdef Py_USING_UNICODE 2855 if (PyString_Check(name)) { 2856 name = PyUnicode_Decode(PyString_AsString(name), PyString_Size(name), NULL, NULL); 2857 if (!name) 2858 return -1; 2859 } else if (!PyUnicode_Check(name)) 2860 # else 2861 if (!PyString_Check(name)) 2862 # endif 2863 { 2864 PyErr_Format(PyExc_TypeError, "attribute name must be string, not '%.200s'", name->ob_type->tp_name); 2865 return -1; 2866 } else { 2867 Py_INCREF(name); 2868 } 2869 2870 if (!tp->tp_dict) { 2871 if (PyType_Ready(tp) < 0) 2872 goto done; 2873 } 2874 2875 descr = _PyType_Lookup(tp, name); 2876 f = NULL; 2877 if (descr != NULL) 2878 f = descr->ob_type->tp_descr_set; 2879 if (!f) { 2880 if (PyString_Check(name)) { 2881 encoded_name = name; 2882 Py_INCREF(name); 2883 } else { 2884 encoded_name = PyUnicode_AsUTF8String(name); 2885 } 2886 PyErr_Format(PyExc_AttributeError, "'%.100s' object has no attribute '%.200s'", tp->tp_name, PyString_AsString(encoded_name)); 2887 Py_DECREF(encoded_name); 2888 } else { 2889 res = f(descr, obj, value); 2890 } 2891 2892 done: 2893 Py_DECREF(name); 2894 return res; 2895 } 2896 #endif 2897 2898 2899 #ifdef __cplusplus 2900 } 2901 #endif 2902 2903 2904 2905 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0) 2906 2907 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else 2908 2909 2910 2911 #define SWIG_exception(code, msg) do { SWIG_Error(code, msg); SWIG_fail;; } while(0) 2912 2913 2914 /* -------- TYPES TABLE (BEGIN) -------- */ 2915 2916 #define SWIGTYPE_p_char swig_types[0] 2917 #define SWIGTYPE_p_int swig_types[1] 2918 #define SWIGTYPE_p_long_long swig_types[2] 2919 #define SWIGTYPE_p_qpol_avrule swig_types[3] 2920 #define SWIGTYPE_p_qpol_bool swig_types[4] 2921 #define SWIGTYPE_p_qpol_capability swig_types[5] 2922 #define SWIGTYPE_p_qpol_cat swig_types[6] 2923 #define SWIGTYPE_p_qpol_class swig_types[7] 2924 #define SWIGTYPE_p_qpol_common swig_types[8] 2925 #define SWIGTYPE_p_qpol_cond swig_types[9] 2926 #define SWIGTYPE_p_qpol_cond_expr_node swig_types[10] 2927 #define SWIGTYPE_p_qpol_constraint swig_types[11] 2928 #define SWIGTYPE_p_qpol_constraint_expr_node swig_types[12] 2929 #define SWIGTYPE_p_qpol_context swig_types[13] 2930 #define SWIGTYPE_p_qpol_default_object swig_types[14] 2931 #define SWIGTYPE_p_qpol_devicetreecon swig_types[15] 2932 #define SWIGTYPE_p_qpol_filename_trans swig_types[16] 2933 #define SWIGTYPE_p_qpol_fs_use swig_types[17] 2934 #define SWIGTYPE_p_qpol_genfscon swig_types[18] 2935 #define SWIGTYPE_p_qpol_iomemcon swig_types[19] 2936 #define SWIGTYPE_p_qpol_ioportcon swig_types[20] 2937 #define SWIGTYPE_p_qpol_isid swig_types[21] 2938 #define SWIGTYPE_p_qpol_iterator swig_types[22] 2939 #define SWIGTYPE_p_qpol_level swig_types[23] 2940 #define SWIGTYPE_p_qpol_mls_level swig_types[24] 2941 #define SWIGTYPE_p_qpol_mls_range swig_types[25] 2942 #define SWIGTYPE_p_qpol_netifcon swig_types[26] 2943 #define SWIGTYPE_p_qpol_nodecon swig_types[27] 2944 #define SWIGTYPE_p_qpol_pcidevicecon swig_types[28] 2945 #define SWIGTYPE_p_qpol_pirqcon swig_types[29] 2946 #define SWIGTYPE_p_qpol_polcap swig_types[30] 2947 #define SWIGTYPE_p_qpol_policy swig_types[31] 2948 #define SWIGTYPE_p_qpol_portcon swig_types[32] 2949 #define SWIGTYPE_p_qpol_range_trans swig_types[33] 2950 #define SWIGTYPE_p_qpol_role swig_types[34] 2951 #define SWIGTYPE_p_qpol_role_allow swig_types[35] 2952 #define SWIGTYPE_p_qpol_role_trans swig_types[36] 2953 #define SWIGTYPE_p_qpol_rolebounds swig_types[37] 2954 #define SWIGTYPE_p_qpol_semantic_level swig_types[38] 2955 #define SWIGTYPE_p_qpol_terule swig_types[39] 2956 #define SWIGTYPE_p_qpol_type swig_types[40] 2957 #define SWIGTYPE_p_qpol_typebounds swig_types[41] 2958 #define SWIGTYPE_p_qpol_user swig_types[42] 2959 #define SWIGTYPE_p_qpol_userbounds swig_types[43] 2960 #define SWIGTYPE_p_qpol_validatetrans swig_types[44] 2961 #define SWIGTYPE_p_short swig_types[45] 2962 #define SWIGTYPE_p_signed_char swig_types[46] 2963 #define SWIGTYPE_p_unsigned_char swig_types[47] 2964 #define SWIGTYPE_p_unsigned_int swig_types[48] 2965 #define SWIGTYPE_p_unsigned_long_long swig_types[49] 2966 #define SWIGTYPE_p_unsigned_short swig_types[50] 2967 #define SWIGTYPE_p_void swig_types[51] 2968 static swig_type_info *swig_types[53]; 2969 static swig_module_info swig_module = {swig_types, 52, 0, 0, 0, 0}; 2970 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name) 2971 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name) 2972 2973 /* -------- TYPES TABLE (END) -------- */ 2974 2975 #if (PY_VERSION_HEX <= 0x02000000) 2976 # if !defined(SWIG_PYTHON_CLASSIC) 2977 # error "This python version requires swig to be run with the '-classic' option" 2978 # endif 2979 #endif 2980 2981 /*----------------------------------------------- 2982 @(target):= _qpol.so 2983 ------------------------------------------------*/ 2984 #if PY_VERSION_HEX >= 0x03000000 2985 # define SWIG_init PyInit__qpol 2986 2987 #else 2988 # define SWIG_init init_qpol 2989 2990 #endif 2991 #define SWIG_name "_qpol" 2992 2993 #define SWIGVERSION 0x020011 2994 #define SWIG_VERSION SWIGVERSION 2995 2996 2997 #define SWIG_as_voidptr(a) (void *)((const void *)(a)) 2998 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a)) 2999 3000 3001 #include <sys/stat.h> 3002 #include <arpa/inet.h> 3003 #include <sepol/policydb.h> 3004 #include <sepol/policydb/policydb.h> 3005 #include "include/qpol/avrule_query.h" 3006 #include "include/qpol/bool_query.h" 3007 #include "include/qpol/class_perm_query.h" 3008 #include "include/qpol/cond_query.h" 3009 #include "include/qpol/constraint_query.h" 3010 #include "include/qpol/context_query.h" 3011 #include "include/qpol/fs_use_query.h" 3012 #include "include/qpol/genfscon_query.h" 3013 #include "include/qpol/isid_query.h" 3014 #include "include/qpol/iterator.h" 3015 #include "include/qpol/mls_query.h" 3016 #include "include/qpol/mlsrule_query.h" 3017 #include "include/qpol/module.h" 3018 #include "include/qpol/netifcon_query.h" 3019 #include "include/qpol/nodecon_query.h" 3020 #include "include/qpol/policy.h" 3021 #include "include/qpol/policy_extend.h" 3022 #include "include/qpol/portcon_query.h" 3023 #include "include/qpol/rbacrule_query.h" 3024 #include "include/qpol/role_query.h" 3025 #include "include/qpol/syn_rule_query.h" 3026 #include "include/qpol/terule_query.h" 3027 #include "include/qpol/type_query.h" 3028 #include "include/qpol/user_query.h" 3029 #include "include/qpol/util.h" 3030 #include "include/qpol/xen_query.h" 3031 3032 /* Provide hooks so that language-specific modules can define the 3033 * callback function, used by the handler in 3034 * qpol_policy_open_from_file(). 3035 */ 3036 SWIGEXPORT qpol_callback_fn_t qpol_swig_message_callback = NULL; 3037 SWIGEXPORT void * qpol_swig_message_callback_arg = NULL; 3038 3039 3040 3041 #include <stdint.h> // Use the C99 official header 3042 3043 3044 /* cast void * to char * as it can't have a constructor */ 3045 const char * to_str(void *x) { 3046 return (const char *)x; 3047 } 3048 3049 /* cast a void * to int, while freeing the pointer */ 3050 int to_int_with_free(void *x) { 3051 int i = *(int *)x; 3052 free(x); 3053 return i; 3054 } 3055 3056 3057 SWIGINTERN swig_type_info* 3058 SWIG_pchar_descriptor(void) 3059 { 3060 static int init = 0; 3061 static swig_type_info* info = 0; 3062 if (!init) { 3063 info = SWIG_TypeQuery("_p_char"); 3064 init = 1; 3065 } 3066 return info; 3067 } 3068 3069 3070 SWIGINTERNINLINE PyObject * 3071 SWIG_FromCharPtrAndSize(const char* carray, size_t size) 3072 { 3073 if (carray) { 3074 if (size > INT_MAX) { 3075 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor(); 3076 return pchar_descriptor ? 3077 SWIG_InternalNewPointerObj((char *)(carray), pchar_descriptor, 0) : SWIG_Py_Void(); 3078 } else { 3079 #if PY_VERSION_HEX >= 0x03000000 3080 return PyUnicode_FromStringAndSize(carray, (int)(size)); 3081 #else 3082 return PyString_FromStringAndSize(carray, (int)(size)); 3083 #endif 3084 } 3085 } else { 3086 return SWIG_Py_Void(); 3087 } 3088 } 3089 3090 3091 SWIGINTERNINLINE PyObject * 3092 SWIG_FromCharPtr(const char *cptr) 3093 { 3094 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0)); 3095 } 3096 3097 3098 SWIGINTERNINLINE PyObject* 3099 SWIG_From_int (int value) 3100 { 3101 return PyInt_FromLong((long) value); 3102 } 3103 3104 3105 /* C Bridge to Python logging callback */ 3106 __attribute__ ((format(printf, 4, 0))) 3107 static void qpol_log_callback(void *varg, 3108 const qpol_policy_t * p __attribute__ ((unused)), 3109 int level, 3110 const char *fmt, 3111 va_list va_args) 3112 { 3113 /* Expand to a full string to avoid any C format string 3114 * or variable args handling when passing to Python 3115 */ 3116 3117 PyObject *py_callback, *rc; 3118 char *str = NULL; 3119 3120 if(vasprintf(&str, fmt, va_args) < 0) 3121 return; 3122 3123 py_callback = (PyObject *) varg; 3124 3125 /* this char* casting doesn't make sense, but this runs afoul of -Werror 3126 * otherwise as the Python library doesn't do const char* */ 3127 rc = PyObject_CallFunction(py_callback, (char*)"(is)", level, str); 3128 Py_XDECREF(rc); 3129 free(str); 3130 } 3131 3132 3133 SWIGINTERN int 3134 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc) 3135 { 3136 #if PY_VERSION_HEX>=0x03000000 3137 if (PyUnicode_Check(obj)) 3138 #else 3139 if (PyString_Check(obj)) 3140 #endif 3141 { 3142 char *cstr; Py_ssize_t len; 3143 #if PY_VERSION_HEX>=0x03000000 3144 if (!alloc && cptr) { 3145 /* We can't allow converting without allocation, since the internal 3146 representation of string in Python 3 is UCS-2/UCS-4 but we require 3147 a UTF-8 representation. 3148 TODO(bhy) More detailed explanation */ 3149 return SWIG_RuntimeError; 3150 } 3151 obj = PyUnicode_AsUTF8String(obj); 3152 PyBytes_AsStringAndSize(obj, &cstr, &len); 3153 if(alloc) *alloc = SWIG_NEWOBJ; 3154 #else 3155 PyString_AsStringAndSize(obj, &cstr, &len); 3156 #endif 3157 if (cptr) { 3158 if (alloc) { 3159 /* 3160 In python the user should not be able to modify the inner 3161 string representation. To warranty that, if you define 3162 SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string 3163 buffer is always returned. 3164 3165 The default behavior is just to return the pointer value, 3166 so, be careful. 3167 */ 3168 #if defined(SWIG_PYTHON_SAFE_CSTRINGS) 3169 if (*alloc != SWIG_OLDOBJ) 3170 #else 3171 if (*alloc == SWIG_NEWOBJ) 3172 #endif 3173 { 3174 *cptr = (char *)memcpy((char *)malloc((len + 1)*sizeof(char)), cstr, sizeof(char)*(len + 1)); 3175 *alloc = SWIG_NEWOBJ; 3176 } 3177 else { 3178 *cptr = cstr; 3179 *alloc = SWIG_OLDOBJ; 3180 } 3181 } else { 3182 #if PY_VERSION_HEX>=0x03000000 3183 assert(0); /* Should never reach here in Python 3 */ 3184 #endif 3185 *cptr = SWIG_Python_str_AsChar(obj); 3186 } 3187 } 3188 if (psize) *psize = len + 1; 3189 #if PY_VERSION_HEX>=0x03000000 3190 Py_XDECREF(obj); 3191 #endif 3192 return SWIG_OK; 3193 } else { 3194 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor(); 3195 if (pchar_descriptor) { 3196 void* vptr = 0; 3197 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) { 3198 if (cptr) *cptr = (char *) vptr; 3199 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0; 3200 if (alloc) *alloc = SWIG_OLDOBJ; 3201 return SWIG_OK; 3202 } 3203 } 3204 } 3205 return SWIG_TypeError; 3206 } 3207 3208 3209 3210 3211 3212 #include <limits.h> 3213 #if !defined(SWIG_NO_LLONG_MAX) 3214 # if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__) 3215 # define LLONG_MAX __LONG_LONG_MAX__ 3216 # define LLONG_MIN (-LLONG_MAX - 1LL) 3217 # define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL) 3218 # endif 3219 #endif 3220 3221 3222 SWIGINTERN int 3223 SWIG_AsVal_double (PyObject *obj, double *val) 3224 { 3225 int res = SWIG_TypeError; 3226 if (PyFloat_Check(obj)) { 3227 if (val) *val = PyFloat_AsDouble(obj); 3228 return SWIG_OK; 3229 } else if (PyInt_Check(obj)) { 3230 if (val) *val = PyInt_AsLong(obj); 3231 return SWIG_OK; 3232 } else if (PyLong_Check(obj)) { 3233 double v = PyLong_AsDouble(obj); 3234 if (!PyErr_Occurred()) { 3235 if (val) *val = v; 3236 return SWIG_OK; 3237 } else { 3238 PyErr_Clear(); 3239 } 3240 } 3241 #ifdef SWIG_PYTHON_CAST_MODE 3242 { 3243 int dispatch = 0; 3244 double d = PyFloat_AsDouble(obj); 3245 if (!PyErr_Occurred()) { 3246 if (val) *val = d; 3247 return SWIG_AddCast(SWIG_OK); 3248 } else { 3249 PyErr_Clear(); 3250 } 3251 if (!dispatch) { 3252 long v = PyLong_AsLong(obj); 3253 if (!PyErr_Occurred()) { 3254 if (val) *val = v; 3255 return SWIG_AddCast(SWIG_AddCast(SWIG_OK)); 3256 } else { 3257 PyErr_Clear(); 3258 } 3259 } 3260 } 3261 #endif 3262 return res; 3263 } 3264 3265 3266 #include <float.h> 3267 3268 3269 #include <math.h> 3270 3271 3272 SWIGINTERNINLINE int 3273 SWIG_CanCastAsInteger(double *d, double min, double max) { 3274 double x = *d; 3275 if ((min <= x && x <= max)) { 3276 double fx = floor(x); 3277 double cx = ceil(x); 3278 double rd = ((x - fx) < 0.5) ? fx : cx; /* simple rint */ 3279 if ((errno == EDOM) || (errno == ERANGE)) { 3280 errno = 0; 3281 } else { 3282 double summ, reps, diff; 3283 if (rd < x) { 3284 diff = x - rd; 3285 } else if (rd > x) { 3286 diff = rd - x; 3287 } else { 3288 return 1; 3289 } 3290 summ = rd + x; 3291 reps = diff/summ; 3292 if (reps < 8*DBL_EPSILON) { 3293 *d = rd; 3294 return 1; 3295 } 3296 } 3297 } 3298 return 0; 3299 } 3300 3301 3302 SWIGINTERN int 3303 SWIG_AsVal_long (PyObject *obj, long* val) 3304 { 3305 if (PyInt_Check(obj)) { 3306 if (val) *val = PyInt_AsLong(obj); 3307 return SWIG_OK; 3308 } else if (PyLong_Check(obj)) { 3309 long v = PyLong_AsLong(obj); 3310 if (!PyErr_Occurred()) { 3311 if (val) *val = v; 3312 return SWIG_OK; 3313 } else { 3314 PyErr_Clear(); 3315 } 3316 } 3317 #ifdef SWIG_PYTHON_CAST_MODE 3318 { 3319 int dispatch = 0; 3320 long v = PyInt_AsLong(obj); 3321 if (!PyErr_Occurred()) { 3322 if (val) *val = v; 3323 return SWIG_AddCast(SWIG_OK); 3324 } else { 3325 PyErr_Clear(); 3326 } 3327 if (!dispatch) { 3328 double d; 3329 int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d)); 3330 if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) { 3331 if (val) *val = (long)(d); 3332 return res; 3333 } 3334 } 3335 } 3336 #endif 3337 return SWIG_TypeError; 3338 } 3339 3340 3341 SWIGINTERN int 3342 SWIG_AsVal_int (PyObject * obj, int *val) 3343 { 3344 long v; 3345 int res = SWIG_AsVal_long (obj, &v); 3346 if (SWIG_IsOK(res)) { 3347 if ((v < INT_MIN || v > INT_MAX)) { 3348 return SWIG_OverflowError; 3349 } else { 3350 if (val) *val = (int)(v); 3351 } 3352 } 3353 return res; 3354 } 3355 3356 SWIGINTERN struct qpol_policy *new_qpol_policy(char const *path,int const options,PyObject *py_callback){ 3357 qpol_policy_t *p; 3358 3359 if (!PyCallable_Check(py_callback)) { 3360 PyErr_SetString(PyExc_TypeError, "Callback parameter must be callable"); 3361 return NULL; 3362 } 3363 3364 qpol_policy_open_from_file(path, &p, qpol_log_callback, (void*)py_callback, options); 3365 return p; 3366 } 3367 SWIGINTERN void delete_qpol_policy(struct qpol_policy *self){ 3368 qpol_policy_destroy(&self); 3369 } 3370 SWIGINTERN int qpol_policy_version(struct qpol_policy *self){ 3371 unsigned int v; 3372 (void)qpol_policy_get_policy_version(self, &v); /* only error is on null parameters neither can be here */ 3373 return (int) v; 3374 } 3375 SWIGINTERN char const *qpol_policy_handle_unknown(struct qpol_policy *self){ 3376 unsigned int h; 3377 qpol_policy_get_policy_handle_unknown(self, &h); 3378 3379 switch (h) { 3380 case SEPOL_DENY_UNKNOWN: return "deny"; 3381 case SEPOL_REJECT_UNKNOWN: return "reject"; 3382 case SEPOL_ALLOW_UNKNOWN: return "allow"; 3383 default: return "unknown"; 3384 } 3385 } 3386 SWIGINTERN char const *qpol_policy_target_platform(struct qpol_policy *self){ 3387 int t; 3388 (void)qpol_policy_get_target_platform(self, &t); 3389 switch (t) { 3390 case SEPOL_TARGET_SELINUX: return "selinux"; 3391 case SEPOL_TARGET_XEN: return "xen"; 3392 default: return "unknown"; 3393 } 3394 } 3395 SWIGINTERN int qpol_policy_capability(struct qpol_policy *self,qpol_capability_e cap){ 3396 return qpol_policy_has_capability(self, cap); 3397 } 3398 SWIGINTERN qpol_iterator_t *qpol_policy_type_iter(struct qpol_policy *self){ 3399 qpol_iterator_t *iter; 3400 if (qpol_policy_get_type_iter(self, &iter)) { 3401 SWIG_exception(SWIG_MemoryError, "Out of Memory"); 3402 } 3403 return iter; 3404 fail: 3405 return NULL; 3406 } 3407 SWIGINTERN size_t qpol_policy_type_count(struct qpol_policy *self){ 3408 qpol_iterator_t *iter; 3409 size_t count = 0; 3410 if (qpol_policy_get_type_iter(self, &iter)) { 3411 SWIG_exception(SWIG_MemoryError, "Out of Memory"); 3412 } 3413 qpol_iterator_get_size(iter, &count); 3414 return count; 3415 fail: 3416 return 0; 3417 } 3418 3419 #define SWIG_From_long PyLong_FromLong 3420 3421 3422 SWIGINTERNINLINE PyObject* 3423 SWIG_From_unsigned_SS_long (unsigned long value) 3424 { 3425 return (value > LONG_MAX) ? 3426 PyLong_FromUnsignedLong(value) : PyLong_FromLong((long)(value)); 3427 } 3428 3429 3430 SWIGINTERNINLINE PyObject * 3431 SWIG_From_size_t (size_t value) 3432 { 3433 return SWIG_From_unsigned_SS_long ((unsigned long)(value)); 3434 } 3435 3436 SWIGINTERN qpol_iterator_t *qpol_policy_role_iter(struct qpol_policy *self){ 3437 qpol_iterator_t *iter; 3438 if (qpol_policy_get_role_iter(self, &iter)) { 3439 SWIG_exception(SWIG_MemoryError, "Out of Memory"); 3440 } 3441 return iter; 3442 fail: 3443 return NULL; 3444 } 3445 SWIGINTERN size_t qpol_policy_role_count(struct qpol_policy *self){ 3446 qpol_iterator_t *iter; 3447 size_t count = 0; 3448 if (qpol_policy_get_role_iter(self, &iter)) { 3449 SWIG_exception(SWIG_MemoryError, "Out of Memory"); 3450 } 3451 qpol_iterator_get_size(iter, &count); 3452 return count; 3453 fail: 3454 return 0; 3455 } 3456 SWIGINTERN qpol_iterator_t *qpol_policy_level_iter(struct qpol_policy *self){ 3457 qpol_iterator_t *iter; 3458 if (qpol_policy_get_level_iter(self, &iter)) { 3459 SWIG_exception(SWIG_MemoryError, "Out of Memory"); 3460 } 3461 return iter; 3462 fail: 3463 return NULL; 3464 } 3465 SWIGINTERN size_t qpol_policy_level_count(struct qpol_policy *self){ 3466 qpol_iterator_t *iter; 3467 size_t count = 0; 3468 if (qpol_policy_get_level_iter(self, &iter)) { 3469 SWIG_exception(SWIG_MemoryError, "Out of Memory"); 3470 } 3471 qpol_iterator_get_size(iter, &count); 3472 return count; 3473 fail: 3474 return 0; 3475 } 3476 SWIGINTERN qpol_iterator_t *qpol_policy_cat_iter(struct qpol_policy *self){ 3477 qpol_iterator_t *iter; 3478 if (qpol_policy_get_cat_iter(self, &iter)) { 3479 SWIG_exception(SWIG_MemoryError, "Out of Memory"); 3480 } 3481 return iter; 3482 fail: 3483 return NULL; 3484 } 3485 SWIGINTERN size_t qpol_policy_cat_count(struct qpol_policy *self){ 3486 qpol_iterator_t *iter; 3487 size_t count = 0; 3488 if (qpol_policy_get_cat_iter(self, &iter)) { 3489 SWIG_exception(SWIG_MemoryError, "Out of Memory"); 3490 } 3491 qpol_iterator_get_size(iter, &count); 3492 return count; 3493 fail: 3494 return 0; 3495 } 3496 SWIGINTERN qpol_iterator_t *qpol_policy_user_iter(struct qpol_policy *self){ 3497 qpol_iterator_t *iter; 3498 if (qpol_policy_get_user_iter(self, &iter)) { 3499 SWIG_exception(SWIG_MemoryError, "Out of Memory"); 3500 } 3501 return iter; 3502 fail: 3503 return NULL; 3504 } 3505 SWIGINTERN size_t qpol_policy_user_count(struct qpol_policy *self){ 3506 qpol_iterator_t *iter; 3507 size_t count = 0; 3508 if (qpol_policy_get_user_iter(self, &iter)) { 3509 SWIG_exception(SWIG_MemoryError, "Out of Memory"); 3510 } 3511 qpol_iterator_get_size(iter, &count); 3512 return count; 3513 fail: 3514 return 0; 3515 } 3516 SWIGINTERN qpol_iterator_t *qpol_policy_bool_iter(struct qpol_policy *self){ 3517 qpol_iterator_t *iter; 3518 if (qpol_policy_get_bool_iter(self, &iter)) { 3519 SWIG_exception(SWIG_MemoryError, "Out of Memory"); 3520 } 3521 return iter; 3522 fail: 3523 return NULL; 3524 } 3525 SWIGINTERN size_t qpol_policy_bool_count(struct qpol_policy *self){ 3526 qpol_iterator_t *iter; 3527 size_t count = 0; 3528 if (qpol_policy_get_bool_iter(self, &iter)) { 3529 SWIG_exception(SWIG_MemoryError, "Out of Memory"); 3530 } 3531 qpol_iterator_get_size(iter, &count); 3532 return count; 3533 fail: 3534 return 0; 3535 } 3536 SWIGINTERN qpol_iterator_t *qpol_policy_class_iter(struct qpol_policy *self,char *perm){ 3537 qpol_iterator_t *iter; 3538 if (perm) { 3539 if (qpol_perm_get_class_iter(self, perm, &iter)) { 3540 SWIG_exception(SWIG_RuntimeError, "Could not get class iterator"); 3541 } 3542 } else { 3543 if (qpol_policy_get_class_iter(self, &iter)) { 3544 SWIG_exception(SWIG_MemoryError, "Out of Memory"); 3545 } 3546 } 3547 return iter; 3548 fail: 3549 return NULL; 3550 } 3551 SWIGINTERN size_t qpol_policy_class_count(struct qpol_policy *self){ 3552 qpol_iterator_t *iter; 3553 size_t count = 0; 3554 if (qpol_policy_get_class_iter(self, &iter)) { 3555 SWIG_exception(SWIG_MemoryError, "Out of Memory"); 3556 } 3557 qpol_iterator_get_size(iter, &count); 3558 return count; 3559 fail: 3560 return 0; 3561 } 3562 SWIGINTERN qpol_iterator_t *qpol_policy_common_iter(struct qpol_policy *self,char *perm){ 3563 qpol_iterator_t *iter; 3564 if (perm) { 3565 if (qpol_perm_get_common_iter(self, perm, &iter)) { 3566 SWIG_exception(SWIG_RuntimeError, "Could not get common iterator"); 3567 } 3568 } else { 3569 if (qpol_policy_get_common_iter(self, &iter)) { 3570 SWIG_exception(SWIG_MemoryError, "Out of Memory"); 3571 } 3572 } 3573 return iter; 3574 fail: 3575 return NULL; 3576 } 3577 SWIGINTERN size_t qpol_policy_common_count(struct qpol_policy *self){ 3578 qpol_iterator_t *iter; 3579 size_t count = 0; 3580 if (qpol_policy_get_common_iter(self, &iter)) { 3581 SWIG_exception(SWIG_MemoryError, "Out of Memory"); 3582 } 3583 qpol_iterator_get_size(iter, &count); 3584 return count; 3585 fail: 3586 return 0; 3587 } 3588 SWIGINTERN qpol_iterator_t *qpol_policy_fs_use_iter(struct qpol_policy *self){ 3589 qpol_iterator_t *iter; 3590 if (qpol_policy_get_fs_use_iter(self, &iter)) { 3591 SWIG_exception(SWIG_MemoryError, "Out of Memory"); 3592 } 3593 return iter; 3594 fail: 3595 return NULL; 3596 } 3597 SWIGINTERN size_t qpol_policy_fs_use_count(struct qpol_policy *self){ 3598 qpol_iterator_t *iter; 3599 size_t count = 0; 3600 if (qpol_policy_get_fs_use_iter(self, &iter)) { 3601 SWIG_exception(SWIG_MemoryError, "Out of Memory"); 3602 } 3603 qpol_iterator_get_size(iter, &count); 3604 return count; 3605 fail: 3606 return 0; 3607 } 3608 SWIGINTERN qpol_iterator_t *qpol_policy_genfscon_iter(struct qpol_policy *self){ 3609 qpol_iterator_t *iter; 3610 if (qpol_policy_get_genfscon_iter(self, &iter)) { 3611 SWIG_exception(SWIG_MemoryError, "Out of Memory"); 3612 } 3613 return iter; 3614 fail: 3615 return NULL; 3616 } 3617 SWIGINTERN size_t qpol_policy_genfscon_count(struct qpol_policy *self){ 3618 qpol_iterator_t *iter; 3619 size_t count = 0; 3620 if (qpol_policy_get_genfscon_iter(self, &iter)) { 3621 SWIG_exception(SWIG_MemoryError, "Out of Memory"); 3622 } 3623 qpol_iterator_get_size(iter, &count); 3624 return count; 3625 fail: 3626 return 0; 3627 } 3628 SWIGINTERN qpol_iterator_t *qpol_policy_isid_iter(struct qpol_policy *self){ 3629 qpol_iterator_t *iter; 3630 if (qpol_policy_get_isid_iter(self, &iter)) { 3631 SWIG_exception(SWIG_MemoryError, "Out of Memory"); 3632 } 3633 return iter; 3634 fail: 3635 return NULL; 3636 } 3637 SWIGINTERN size_t qpol_policy_isid_count(struct qpol_policy *self){ 3638 qpol_iterator_t *iter; 3639 size_t count = 0; 3640 if (qpol_policy_get_isid_iter(self, &iter)) { 3641 SWIG_exception(SWIG_MemoryError, "Out of Memory"); 3642 } 3643 qpol_iterator_get_size(iter, &count); 3644 return count; 3645 fail: 3646 return 0; 3647 } 3648 SWIGINTERN qpol_iterator_t *qpol_policy_netifcon_iter(struct qpol_policy *self){ 3649 qpol_iterator_t *iter; 3650 if (qpol_policy_get_netifcon_iter(self, &iter)) { 3651 SWIG_exception(SWIG_MemoryError, "Out of Memory"); 3652 } 3653 return iter; 3654 fail: 3655 return NULL; 3656 } 3657 SWIGINTERN size_t qpol_policy_netifcon_count(struct qpol_policy *self){ 3658 qpol_iterator_t *iter; 3659 size_t count = 0; 3660 if (qpol_policy_get_netifcon_iter(self, &iter)) { 3661 SWIG_exception(SWIG_MemoryError, "Out of Memory"); 3662 } 3663 qpol_iterator_get_size(iter, &count); 3664 return count; 3665 fail: 3666 return 0; 3667 } 3668 SWIGINTERN qpol_iterator_t *qpol_policy_nodecon_iter(struct qpol_policy *self){ 3669 qpol_iterator_t *iter; 3670 if (qpol_policy_get_nodecon_iter(self, &iter)) { 3671 SWIG_exception(SWIG_MemoryError, "Out of Memory"); 3672 } 3673 return iter; 3674 fail: 3675 return NULL; 3676 } 3677 SWIGINTERN size_t qpol_policy_nodecon_count(struct qpol_policy *self){ 3678 qpol_iterator_t *iter; 3679 size_t count = 0; 3680 if (qpol_policy_get_nodecon_iter(self, &iter)) { 3681 SWIG_exception(SWIG_MemoryError, "Out of Memory"); 3682 } 3683 qpol_iterator_get_size(iter, &count); 3684 return count; 3685 fail: 3686 return 0; 3687 } 3688 SWIGINTERN qpol_iterator_t *qpol_policy_portcon_iter(struct qpol_policy *self){ 3689 qpol_iterator_t *iter; 3690 if (qpol_policy_get_portcon_iter(self, &iter)) { 3691 SWIG_exception(SWIG_MemoryError, "Out of Memory"); 3692 } 3693 return iter; 3694 fail: 3695 return NULL; 3696 } 3697 SWIGINTERN size_t qpol_policy_portcon_count(struct qpol_policy *self){ 3698 qpol_iterator_t *iter; 3699 size_t count = 0; 3700 if (qpol_policy_get_portcon_iter(self, &iter)) { 3701 SWIG_exception(SWIG_MemoryError, "Out of Memory"); 3702 } 3703 qpol_iterator_get_size(iter, &count); 3704 return count; 3705 fail: 3706 return 0; 3707 } 3708 SWIGINTERN qpol_iterator_t *qpol_policy_constraint_iter(struct qpol_policy *self){ 3709 qpol_iterator_t *iter; 3710 if (qpol_policy_get_constraint_iter(self, &iter)) { 3711 SWIG_exception(SWIG_MemoryError, "Out of Memory"); 3712 } 3713 return iter; 3714 fail: 3715 return NULL; 3716 } 3717 SWIGINTERN size_t qpol_policy_constraint_count(struct qpol_policy *self){ 3718 qpol_iterator_t *iter; 3719 size_t count = 0; 3720 if (qpol_policy_get_constraint_iter(self, &iter)) { 3721 SWIG_exception(SWIG_MemoryError, "Out of Memory"); 3722 } 3723 qpol_iterator_get_size(iter, &count); 3724 return count; 3725 fail: 3726 return 0; 3727 } 3728 SWIGINTERN qpol_iterator_t *qpol_policy_validatetrans_iter(struct qpol_policy *self){ 3729 qpol_iterator_t *iter; 3730 if (qpol_policy_get_validatetrans_iter(self, &iter)) { 3731 SWIG_exception(SWIG_MemoryError, "Out of Memory"); 3732 } 3733 return iter; 3734 fail: 3735 return NULL; 3736 } 3737 SWIGINTERN size_t qpol_policy_validatetrans_count(struct qpol_policy *self){ 3738 qpol_iterator_t *iter; 3739 size_t count = 0; 3740 if (qpol_policy_get_validatetrans_iter(self, &iter)) { 3741 SWIG_exception(SWIG_MemoryError, "Out of Memory"); 3742 } 3743 qpol_iterator_get_size(iter, &count); 3744 return count; 3745 fail: 3746 return 0; 3747 } 3748 SWIGINTERN qpol_iterator_t *qpol_policy_role_allow_iter(struct qpol_policy *self){ 3749 qpol_iterator_t *iter; 3750 if (qpol_policy_get_role_allow_iter(self, &iter)) { 3751 SWIG_exception(SWIG_MemoryError, "Out of Memory"); 3752 } 3753 return iter; 3754 fail: 3755 return NULL; 3756 } 3757 SWIGINTERN size_t qpol_policy_role_allow_count(struct qpol_policy *self){ 3758 qpol_iterator_t *iter; 3759 size_t count = 0; 3760 if (qpol_policy_get_role_allow_iter(self, &iter)) { 3761 SWIG_exception(SWIG_MemoryError, "Out of Memory"); 3762 } 3763 qpol_iterator_get_size(iter, &count); 3764 return count; 3765 fail: 3766 return 0; 3767 } 3768 SWIGINTERN qpol_iterator_t *qpol_policy_role_trans_iter(struct qpol_policy *self){ 3769 qpol_iterator_t *iter; 3770 if (qpol_policy_get_role_trans_iter(self, &iter)) { 3771 SWIG_exception(SWIG_MemoryError, "Out of Memory"); 3772 } 3773 return iter; 3774 fail: 3775 return NULL; 3776 } 3777 SWIGINTERN size_t qpol_policy_role_trans_count(struct qpol_policy *self){ 3778 qpol_iterator_t *iter; 3779 size_t count = 0; 3780 if (qpol_policy_get_role_trans_iter(self, &iter)) { 3781 SWIG_exception(SWIG_MemoryError, "Out of Memory"); 3782 } 3783 qpol_iterator_get_size(iter, &count); 3784 return count; 3785 fail: 3786 return 0; 3787 } 3788 SWIGINTERN qpol_iterator_t *qpol_policy_range_trans_iter(struct qpol_policy *self){ 3789 qpol_iterator_t *iter; 3790 if (qpol_policy_get_range_trans_iter(self, &iter)) { 3791 SWIG_exception(SWIG_MemoryError, "Out of Memory"); 3792 } 3793 return iter; 3794 fail: 3795 return NULL; 3796 } 3797 SWIGINTERN size_t qpol_policy_range_trans_count(struct qpol_policy *self){ 3798 qpol_iterator_t *iter; 3799 size_t count = 0; 3800 if (qpol_policy_get_range_trans_iter(self, &iter)) { 3801 SWIG_exception(SWIG_MemoryError, "Out of Memory"); 3802 } 3803 qpol_iterator_get_size(iter, &count); 3804 return count; 3805 fail: 3806 return 0; 3807 } 3808 SWIGINTERN qpol_iterator_t *qpol_policy_avrule_iter(struct qpol_policy *self){ 3809 qpol_iterator_t *iter; 3810 uint32_t rule_types = QPOL_RULE_ALLOW | QPOL_RULE_AUDITALLOW | QPOL_RULE_DONTAUDIT; 3811 3812 if (qpol_policy_has_capability(self, QPOL_CAP_NEVERALLOW)) 3813 rule_types |= QPOL_RULE_NEVERALLOW; 3814 3815 if (qpol_policy_get_avrule_iter(self, rule_types, &iter)) { 3816 SWIG_exception(SWIG_MemoryError, "Out of Memory"); 3817 } 3818 return iter; 3819 fail: 3820 return NULL; 3821 } 3822 SWIGINTERN size_t qpol_policy_avrule_allow_count(struct qpol_policy *self){ 3823 qpol_iterator_t *iter; 3824 size_t count = 0; 3825 if (qpol_policy_get_avrule_iter(self, QPOL_RULE_ALLOW, &iter)) { 3826 SWIG_exception(SWIG_MemoryError, "Out of Memory"); 3827 } 3828 qpol_iterator_get_size(iter, &count); 3829 return count; 3830 fail: 3831 return 0; 3832 } 3833 SWIGINTERN size_t qpol_policy_avrule_auditallow_count(struct qpol_policy *self){ 3834 qpol_iterator_t *iter; 3835 size_t count = 0; 3836 if (qpol_policy_get_avrule_iter(self, QPOL_RULE_AUDITALLOW, &iter)) { 3837 SWIG_exception(SWIG_MemoryError, "Out of Memory"); 3838 } 3839 qpol_iterator_get_size(iter, &count); 3840 return count; 3841 fail: 3842 return 0; 3843 } 3844 SWIGINTERN size_t qpol_policy_avrule_neverallow_count(struct qpol_policy *self){ 3845 if (qpol_policy_has_capability(self, QPOL_CAP_NEVERALLOW)) { 3846 qpol_iterator_t *iter; 3847 size_t count = 0; 3848 if (qpol_policy_get_avrule_iter(self, QPOL_RULE_NEVERALLOW, &iter)) { 3849 SWIG_exception(SWIG_MemoryError, "Out of Memory"); 3850 } 3851 qpol_iterator_get_size(iter, &count); 3852 return count; 3853 } else { 3854 return 0; 3855 } 3856 fail: 3857 return 0; 3858 } 3859 SWIGINTERN size_t qpol_policy_avrule_dontaudit_count(struct qpol_policy *self){ 3860 qpol_iterator_t *iter; 3861 size_t count = 0; 3862 if (qpol_policy_get_avrule_iter(self, QPOL_RULE_DONTAUDIT, &iter)) { 3863 SWIG_exception(SWIG_MemoryError, "Out of Memory"); 3864 } 3865 qpol_iterator_get_size(iter, &count); 3866 return count; 3867 fail: 3868 return 0; 3869 } 3870 SWIGINTERN qpol_iterator_t *qpol_policy_avrulex_iter(struct qpol_policy *self){ 3871 qpol_iterator_t *iter; 3872 uint32_t rule_types = QPOL_RULE_XPERMS_ALLOW | QPOL_RULE_XPERMS_AUDITALLOW | QPOL_RULE_XPERMS_DONTAUDIT; 3873 3874 if (qpol_policy_has_capability(self, QPOL_CAP_NEVERALLOW)) 3875 rule_types |= QPOL_RULE_XPERMS_NEVERALLOW; 3876 3877 if (qpol_policy_get_avrule_iter(self, rule_types, &iter)) { 3878 SWIG_exception(SWIG_MemoryError, "Out of Memory"); 3879 } 3880 return iter; 3881 fail: 3882 return NULL; 3883 } 3884 SWIGINTERN size_t qpol_policy_avrule_allowx_count(struct qpol_policy *self){ 3885 qpol_iterator_t *iter; 3886 size_t count = 0; 3887 if (qpol_policy_get_avrule_iter(self, QPOL_RULE_XPERMS_ALLOW, &iter)) { 3888 SWIG_exception(SWIG_MemoryError, "Out of Memory"); 3889 } 3890 qpol_iterator_get_size(iter, &count); 3891 return count; 3892 fail: 3893 return 0; 3894 } 3895 SWIGINTERN size_t qpol_policy_avrule_auditallowx_count(struct qpol_policy *self){ 3896 qpol_iterator_t *iter; 3897 size_t count = 0; 3898 if (qpol_policy_get_avrule_iter(self, QPOL_RULE_XPERMS_AUDITALLOW, &iter)) { 3899 SWIG_exception(SWIG_MemoryError, "Out of Memory"); 3900 } 3901 qpol_iterator_get_size(iter, &count); 3902 return count; 3903 fail: 3904 return 0; 3905 } 3906 SWIGINTERN size_t qpol_policy_avrule_neverallowx_count(struct qpol_policy *self){ 3907 if (qpol_policy_has_capability(self, QPOL_CAP_NEVERALLOW)) { 3908 qpol_iterator_t *iter; 3909 size_t count = 0; 3910 if (qpol_policy_get_avrule_iter(self, QPOL_RULE_XPERMS_NEVERALLOW, &iter)) { 3911 SWIG_exception(SWIG_MemoryError, "Out of Memory"); 3912 } 3913 qpol_iterator_get_size(iter, &count); 3914 return count; 3915 } else { 3916 return 0; 3917 } 3918 fail: 3919 return 0; 3920 } 3921 SWIGINTERN size_t qpol_policy_avrule_dontauditx_count(struct qpol_policy *self){ 3922 qpol_iterator_t *iter; 3923 size_t count = 0; 3924 if (qpol_policy_get_avrule_iter(self, QPOL_RULE_XPERMS_DONTAUDIT, &iter)) { 3925 SWIG_exception(SWIG_MemoryError, "Out of Memory"); 3926 } 3927 qpol_iterator_get_size(iter, &count); 3928 return count; 3929 fail: 3930 return 0; 3931 } 3932 SWIGINTERN qpol_iterator_t *qpol_policy_terule_iter(struct qpol_policy *self){ 3933 qpol_iterator_t *iter; 3934 uint32_t rule_types = QPOL_RULE_TYPE_TRANS | QPOL_RULE_TYPE_CHANGE | QPOL_RULE_TYPE_MEMBER; 3935 3936 if (qpol_policy_get_terule_iter(self, rule_types, &iter)) { 3937 SWIG_exception(SWIG_MemoryError, "Out of Memory"); 3938 } 3939 return iter; 3940 fail: 3941 return NULL; 3942 } 3943 SWIGINTERN size_t qpol_policy_terule_trans_count(struct qpol_policy *self){ 3944 qpol_iterator_t *iter; 3945 size_t count = 0; 3946 if (qpol_policy_get_terule_iter(self, QPOL_RULE_TYPE_TRANS, &iter)) { 3947 SWIG_exception(SWIG_MemoryError, "Out of Memory"); 3948 } 3949 qpol_iterator_get_size(iter, &count); 3950 return count; 3951 fail: 3952 return 0; 3953 } 3954 SWIGINTERN size_t qpol_policy_terule_change_count(struct qpol_policy *self){ 3955 qpol_iterator_t *iter; 3956 size_t count = 0; 3957 if (qpol_policy_get_terule_iter(self, QPOL_RULE_TYPE_CHANGE, &iter)) { 3958 SWIG_exception(SWIG_MemoryError, "Out of Memory"); 3959 } 3960 qpol_iterator_get_size(iter, &count); 3961 return count; 3962 fail: 3963 return 0; 3964 } 3965 SWIGINTERN size_t qpol_policy_terule_member_count(struct qpol_policy *self){ 3966 qpol_iterator_t *iter; 3967 size_t count = 0; 3968 if (qpol_policy_get_terule_iter(self, QPOL_RULE_TYPE_MEMBER, &iter)) { 3969 SWIG_exception(SWIG_MemoryError, "Out of Memory"); 3970 } 3971 qpol_iterator_get_size(iter, &count); 3972 return count; 3973 fail: 3974 return 0; 3975 } 3976 SWIGINTERN qpol_iterator_t *qpol_policy_cond_iter(struct qpol_policy *self){ 3977 qpol_iterator_t *iter; 3978 if (qpol_policy_get_cond_iter(self, &iter)) { 3979 SWIG_exception(SWIG_MemoryError, "Out of Memory"); 3980 } 3981 return iter; 3982 fail: 3983 return NULL; 3984 } 3985 SWIGINTERN size_t qpol_policy_cond_count(struct qpol_policy *self){ 3986 qpol_iterator_t *iter; 3987 size_t count = 0; 3988 if (qpol_policy_get_cond_iter(self, &iter)) { 3989 SWIG_exception(SWIG_MemoryError, "Out of Memory"); 3990 } 3991 qpol_iterator_get_size(iter, &count); 3992 return count; 3993 fail: 3994 return 0; 3995 } 3996 SWIGINTERN qpol_iterator_t *qpol_policy_filename_trans_iter(struct qpol_policy *self){ 3997 qpol_iterator_t *iter; 3998 if (qpol_policy_get_filename_trans_iter(self, &iter)) { 3999 SWIG_exception(SWIG_MemoryError, "Out of Memory"); 4000 } 4001 return iter; 4002 fail: 4003 return NULL; 4004 } 4005 SWIGINTERN size_t qpol_policy_filename_trans_count(struct qpol_policy *self){ 4006 qpol_iterator_t *iter; 4007 size_t count = 0; 4008 if (qpol_policy_get_filename_trans_iter(self, &iter)) { 4009 SWIG_exception(SWIG_MemoryError, "Out of Memory"); 4010 } 4011 qpol_iterator_get_size(iter, &count); 4012 return count; 4013 fail: 4014 return 0; 4015 } 4016 SWIGINTERN qpol_iterator_t *qpol_policy_permissive_iter(struct qpol_policy *self){ 4017 qpol_iterator_t *iter; 4018 if (qpol_policy_get_permissive_iter(self, &iter)) { 4019 SWIG_exception(SWIG_MemoryError, "Out of Memory"); 4020 } 4021 return iter; 4022 fail: 4023 return NULL; 4024 } 4025 SWIGINTERN size_t qpol_policy_permissive_count(struct qpol_policy *self){ 4026 qpol_iterator_t *iter; 4027 size_t count = 0; 4028 if (qpol_policy_get_permissive_iter(self, &iter)) { 4029 SWIG_exception(SWIG_MemoryError, "Out of Memory"); 4030 } 4031 qpol_iterator_get_size(iter, &count); 4032 return count; 4033 fail: 4034 return 0; 4035 } 4036 SWIGINTERN qpol_iterator_t *qpol_policy_typebounds_iter(struct qpol_policy *self){ 4037 qpol_iterator_t *iter; 4038 if (qpol_policy_get_typebounds_iter(self, &iter)) { 4039 SWIG_exception(SWIG_MemoryError, "Out of Memory"); 4040 } 4041 return iter; 4042 fail: 4043 return NULL; 4044 } 4045 SWIGINTERN qpol_iterator_t *qpol_policy_polcap_iter(struct qpol_policy *self){ 4046 qpol_iterator_t *iter; 4047 if (qpol_policy_get_polcap_iter(self, &iter)) { 4048 SWIG_exception(SWIG_MemoryError, "Out of Memory"); 4049 } 4050 return iter; 4051 fail: 4052 return NULL; 4053 } 4054 SWIGINTERN size_t qpol_policy_polcap_count(struct qpol_policy *self){ 4055 qpol_iterator_t *iter; 4056 size_t count = 0; 4057 if (qpol_policy_get_polcap_iter(self, &iter)) { 4058 SWIG_exception(SWIG_MemoryError, "Out of Memory"); 4059 } 4060 qpol_iterator_get_size(iter, &count); 4061 return count; 4062 fail: 4063 return 0; 4064 } 4065 SWIGINTERN qpol_iterator_t *qpol_policy_default_iter(struct qpol_policy *self){ 4066 qpol_iterator_t *iter; 4067 if (qpol_policy_get_default_object_iter(self, &iter)) { 4068 SWIG_exception(SWIG_MemoryError, "Out of Memory"); 4069 } 4070 return iter; 4071 fail: 4072 return NULL; 4073 } 4074 SWIGINTERN qpol_iterator_t *qpol_policy_iomemcon_iter(struct qpol_policy *self){ 4075 qpol_iterator_t *iter; 4076 if (qpol_policy_get_iomemcon_iter(self, &iter)) { 4077 SWIG_exception(SWIG_MemoryError, "Out of Memory"); 4078 } 4079 return iter; 4080 fail: 4081 return NULL; 4082 } 4083 SWIGINTERN size_t qpol_policy_iomemcon_count(struct qpol_policy *self){ 4084 qpol_iterator_t *iter; 4085 size_t count = 0; 4086 if (qpol_policy_get_iomemcon_iter(self, &iter)) { 4087 SWIG_exception(SWIG_MemoryError, "Out of Memory"); 4088 } 4089 qpol_iterator_get_size(iter, &count); 4090 return count; 4091 fail: 4092 return 0; 4093 } 4094 SWIGINTERN qpol_iterator_t *qpol_policy_ioportcon_iter(struct qpol_policy *self){ 4095 qpol_iterator_t *iter; 4096 if (qpol_policy_get_ioportcon_iter(self, &iter)) { 4097 SWIG_exception(SWIG_MemoryError, "Out of Memory"); 4098 } 4099 return iter; 4100 fail: 4101 return NULL; 4102 } 4103 SWIGINTERN size_t qpol_policy_ioportcon_count(struct qpol_policy *self){ 4104 qpol_iterator_t *iter; 4105 size_t count = 0; 4106 if (qpol_policy_get_ioportcon_iter(self, &iter)) { 4107 SWIG_exception(SWIG_MemoryError, "Out of Memory"); 4108 } 4109 qpol_iterator_get_size(iter, &count); 4110 return count; 4111 fail: 4112 return 0; 4113 } 4114 SWIGINTERN qpol_iterator_t *qpol_policy_pcidevicecon_iter(struct qpol_policy *self){ 4115 qpol_iterator_t *iter; 4116 if (qpol_policy_get_pcidevicecon_iter(self, &iter)) { 4117 SWIG_exception(SWIG_MemoryError, "Out of Memory"); 4118 } 4119 return iter; 4120 fail: 4121 return NULL; 4122 } 4123 SWIGINTERN size_t qpol_policy_pcidevicecon_count(struct qpol_policy *self){ 4124 qpol_iterator_t *iter; 4125 size_t count = 0; 4126 if (qpol_policy_get_pcidevicecon_iter(self, &iter)) { 4127 SWIG_exception(SWIG_MemoryError, "Out of Memory"); 4128 } 4129 qpol_iterator_get_size(iter, &count); 4130 return count; 4131 fail: 4132 return 0; 4133 } 4134 SWIGINTERN qpol_iterator_t *qpol_policy_pirqcon_iter(struct qpol_policy *self){ 4135 qpol_iterator_t *iter; 4136 if (qpol_policy_get_pirqcon_iter(self, &iter)) { 4137 SWIG_exception(SWIG_MemoryError, "Out of Memory"); 4138 } 4139 return iter; 4140 fail: 4141 return NULL; 4142 } 4143 SWIGINTERN size_t qpol_policy_pirqcon_count(struct qpol_policy *self){ 4144 qpol_iterator_t *iter; 4145 size_t count = 0; 4146 if (qpol_policy_get_pirqcon_iter(self, &iter)) { 4147 SWIG_exception(SWIG_MemoryError, "Out of Memory"); 4148 } 4149 qpol_iterator_get_size(iter, &count); 4150 return count; 4151 fail: 4152 return 0; 4153 } 4154 SWIGINTERN qpol_iterator_t *qpol_policy_devicetreecon_iter(struct qpol_policy *self){ 4155 qpol_iterator_t *iter; 4156 if (qpol_policy_get_devicetreecon_iter(self, &iter)) { 4157 SWIG_exception(SWIG_MemoryError, "Out of Memory"); 4158 } 4159 return iter; 4160 fail: 4161 return NULL; 4162 } 4163 SWIGINTERN size_t qpol_policy_devicetreecon_count(struct qpol_policy *self){ 4164 qpol_iterator_t *iter; 4165 size_t count = 0; 4166 if (qpol_policy_get_devicetreecon_iter(self, &iter)) { 4167 SWIG_exception(SWIG_MemoryError, "Out of Memory"); 4168 } 4169 qpol_iterator_get_size(iter, &count); 4170 return count; 4171 fail: 4172 return 0; 4173 } 4174 SWIGINTERN struct qpol_iterator *new_qpol_iterator(void){ 4175 SWIG_exception(SWIG_TypeError, "User may not create iterators difectly"); 4176 fail: 4177 return NULL; 4178 } 4179 SWIGINTERN void delete_qpol_iterator(struct qpol_iterator *self){ 4180 qpol_iterator_destroy(&self); 4181 } 4182 SWIGINTERN void *qpol_iterator_item(struct qpol_iterator *self){ 4183 void *i; 4184 if (qpol_iterator_get_item(self, &i)) { 4185 SWIG_exception(SWIG_RuntimeError, "Could not get item"); 4186 } 4187 return i; 4188 fail: 4189 return NULL; 4190 } 4191 SWIGINTERN void qpol_iterator_next_(struct qpol_iterator *self){ 4192 if (qpol_iterator_next(self)) { 4193 SWIG_exception(SWIG_RuntimeError, "Error advancing iterator"); 4194 } 4195 fail: 4196 return; 4197 } 4198 SWIGINTERN int qpol_iterator_isend(struct qpol_iterator *self){ 4199 return qpol_iterator_end(self); 4200 } 4201 SWIGINTERN size_t qpol_iterator_size(struct qpol_iterator *self){ 4202 size_t s; 4203 if (qpol_iterator_get_size(self, &s)) { 4204 SWIG_exception(SWIG_ValueError, "Could not get iterator size"); 4205 } 4206 return s; 4207 fail: 4208 return 0; 4209 } 4210 SWIGINTERN struct qpol_type *new_qpol_type(qpol_policy_t *p,char const *name){ 4211 const qpol_type_t *t; 4212 qpol_policy_get_type_by_name(p, name, &t); 4213 return (qpol_type_t*)t; 4214 } 4215 SWIGINTERN void delete_qpol_type(struct qpol_type *self){ 4216 /* no op */ 4217 return; 4218 } 4219 SWIGINTERN char const *qpol_type_name(struct qpol_type *self,qpol_policy_t *p){ 4220 const char *name; 4221 if (qpol_type_get_name(p, self, &name)) { 4222 SWIG_exception(SWIG_ValueError, "Could not get type name"); 4223 } 4224 return name; 4225 fail: 4226 return NULL; 4227 } 4228 SWIGINTERN int qpol_type_value(struct qpol_type *self,qpol_policy_t *p){ 4229 uint32_t v; 4230 if (qpol_type_get_value(p, self, &v)) { 4231 SWIG_exception(SWIG_ValueError, "Could not get type value"); 4232 } 4233 fail: 4234 return (int) v; 4235 } 4236 SWIGINTERN int qpol_type_isalias(struct qpol_type *self,qpol_policy_t *p){ 4237 unsigned char i; 4238 if (qpol_type_get_isalias(p, self, &i)) { 4239 SWIG_exception(SWIG_ValueError, "Could not determine whether type is an alias"); 4240 } 4241 fail: 4242 return (int)i; 4243 } 4244 SWIGINTERN int qpol_type_isattr(struct qpol_type *self,qpol_policy_t *p){ 4245 unsigned char i; 4246 if (qpol_type_get_isattr(p, self, &i)) { 4247 SWIG_exception(SWIG_ValueError, "Could not determine whether type is an attribute"); 4248 } 4249 fail: 4250 return (int)i; 4251 } 4252 SWIGINTERN int qpol_type_ispermissive(struct qpol_type *self,qpol_policy_t *p){ 4253 unsigned char i; 4254 if (qpol_type_get_ispermissive(p, self, &i)) { 4255 SWIG_exception(SWIG_ValueError, "Could not determine whether type is permissive"); 4256 } 4257 fail: 4258 return (int)i; 4259 } 4260 SWIGINTERN qpol_iterator_t *qpol_type_type_iter(struct qpol_type *self,qpol_policy_t *p){ 4261 qpol_iterator_t *iter; 4262 int retv = qpol_type_get_type_iter(p, self, &iter); 4263 if (retv < 0) { 4264 SWIG_exception(SWIG_RuntimeError, "Could not get attribute types"); 4265 } else if (retv > 0) { 4266 SWIG_exception(SWIG_TypeError, "Type is not an attribute"); 4267 } 4268 fail: 4269 return iter; 4270 } 4271 SWIGINTERN qpol_iterator_t *qpol_type_attr_iter(struct qpol_type *self,qpol_policy_t *p){ 4272 qpol_iterator_t *iter; 4273 int retv = qpol_type_get_attr_iter(p, self, &iter); 4274 if (retv < 0) { 4275 SWIG_exception(SWIG_RuntimeError, "Could not get type attributes"); 4276 } else if (retv > 0) { 4277 SWIG_exception(SWIG_TypeError, "Type is an attribute"); 4278 } 4279 fail: 4280 return iter; 4281 } 4282 SWIGINTERN qpol_iterator_t *qpol_type_alias_iter(struct qpol_type *self,qpol_policy_t *p){ 4283 qpol_iterator_t *iter; 4284 if (qpol_type_get_alias_iter(p, self, &iter)) { 4285 SWIG_exception(SWIG_RuntimeError, "Could not get type aliases"); 4286 } 4287 fail: 4288 return iter; 4289 } 4290 4291 qpol_type_t *qpol_type_from_void(void *x) { 4292 return (qpol_type_t*)x; 4293 }; 4294 4295 SWIGINTERN struct qpol_role *new_qpol_role(qpol_policy_t *p,char const *name){ 4296 const qpol_role_t *r; 4297 qpol_policy_get_role_by_name(p, name, &r); 4298 return (qpol_role_t*)r; 4299 } 4300 SWIGINTERN void delete_qpol_role(struct qpol_role *self){ 4301 /* no op */ 4302 return; 4303 } 4304 SWIGINTERN int qpol_role_value(struct qpol_role *self,qpol_policy_t *p){ 4305 uint32_t v; 4306 if (qpol_role_get_value(p, self, &v)) { 4307 SWIG_exception(SWIG_ValueError, "Could not get role value"); 4308 } 4309 fail: 4310 return (int) v; 4311 } 4312 SWIGINTERN char const *qpol_role_name(struct qpol_role *self,qpol_policy_t *p){ 4313 const char *name; 4314 if (qpol_role_get_name(p, self, &name)) { 4315 SWIG_exception(SWIG_ValueError, "Could not get role name"); 4316 } 4317 return name; 4318 fail: 4319 return NULL; 4320 } 4321 SWIGINTERN qpol_iterator_t *qpol_role_type_iter(struct qpol_role *self,qpol_policy_t *p){ 4322 qpol_iterator_t *iter; 4323 if (qpol_role_get_type_iter(p, self, &iter)) { 4324 SWIG_exception(SWIG_RuntimeError, "Could not get role types"); 4325 } 4326 fail: 4327 return iter; 4328 } 4329 SWIGINTERN qpol_iterator_t *qpol_role_dominate_iter(struct qpol_role *self,qpol_policy_t *p){ 4330 qpol_iterator_t *iter; 4331 if (qpol_role_get_dominate_iter(p, self, &iter)) { 4332 SWIG_exception(SWIG_RuntimeError, "Could not get dominated roles"); 4333 } 4334 fail: 4335 return iter; 4336 } 4337 4338 qpol_role_t *qpol_role_from_void(void *x) { 4339 return (qpol_role_t*)x; 4340 }; 4341 4342 SWIGINTERN struct qpol_level *new_qpol_level(qpol_policy_t *p,char const *name){ 4343 const qpol_level_t *l; 4344 qpol_policy_get_level_by_name(p, name, &l); 4345 return (qpol_level_t*)l; 4346 } 4347 SWIGINTERN void delete_qpol_level(struct qpol_level *self){ 4348 /* no op */ 4349 return; 4350 } 4351 SWIGINTERN int qpol_level_isalias(struct qpol_level *self,qpol_policy_t *p){ 4352 unsigned char i; 4353 if (qpol_level_get_isalias(p, self, &i)) { 4354 SWIG_exception(SWIG_ValueError, "Could not determine whether level is an alias"); 4355 } 4356 fail: 4357 return (int)i; 4358 } 4359 SWIGINTERN int qpol_level_value(struct qpol_level *self,qpol_policy_t *p){ 4360 uint32_t v; 4361 if (qpol_level_get_value(p, self, &v)) { 4362 SWIG_exception(SWIG_ValueError, "Could not get level sensitivity value"); 4363 } 4364 fail: 4365 return (int) v; 4366 } 4367 SWIGINTERN char const *qpol_level_name(struct qpol_level *self,qpol_policy_t *p){ 4368 const char *name; 4369 if (qpol_level_get_name(p, self, &name)) { 4370 SWIG_exception(SWIG_ValueError, "Could not get level sensitivity name"); 4371 } 4372 return name; 4373 fail: 4374 return NULL; 4375 } 4376 SWIGINTERN qpol_iterator_t *qpol_level_cat_iter(struct qpol_level *self,qpol_policy_t *p){ 4377 qpol_iterator_t *iter; 4378 if (qpol_level_get_cat_iter(p, self, &iter)) { 4379 SWIG_exception(SWIG_RuntimeError, "Could not get level categories"); 4380 } 4381 fail: 4382 return iter; 4383 } 4384 SWIGINTERN qpol_iterator_t *qpol_level_alias_iter(struct qpol_level *self,qpol_policy_t *p){ 4385 qpol_iterator_t *iter; 4386 if (qpol_level_get_alias_iter(p, self, &iter)) { 4387 SWIG_exception(SWIG_RuntimeError, "Could not get level aliases"); 4388 } 4389 fail: 4390 return iter; 4391 } 4392 4393 qpol_level_t *qpol_level_from_void(void *x) { 4394 return (qpol_level_t*)x; 4395 }; 4396 4397 SWIGINTERN struct qpol_cat *new_qpol_cat(qpol_policy_t *p,char const *name){ 4398 const qpol_cat_t *c; 4399 qpol_policy_get_cat_by_name(p, name, &c); 4400 return (qpol_cat_t*)c; 4401 } 4402 SWIGINTERN void delete_qpol_cat(struct qpol_cat *self){ 4403 /* no op */ 4404 return; 4405 } 4406 SWIGINTERN int qpol_cat_isalias(struct qpol_cat *self,qpol_policy_t *p){ 4407 unsigned char i; 4408 if (qpol_cat_get_isalias(p, self, &i)) { 4409 SWIG_exception(SWIG_ValueError, "Could not determine whether category is an alias"); 4410 } 4411 fail: 4412 return (int)i; 4413 } 4414 SWIGINTERN int qpol_cat_value(struct qpol_cat *self,qpol_policy_t *p){ 4415 uint32_t v; 4416 if (qpol_cat_get_value(p, self, &v)) { 4417 SWIG_exception(SWIG_ValueError, "Could not get category value"); 4418 } 4419 fail: 4420 return (int) v; 4421 } 4422 SWIGINTERN char const *qpol_cat_name(struct qpol_cat *self,qpol_policy_t *p){ 4423 const char *name; 4424 if (qpol_cat_get_name(p, self, &name)) { 4425 SWIG_exception(SWIG_ValueError, "Could not get category name"); 4426 } 4427 return name; 4428 fail: 4429 return NULL; 4430 } 4431 SWIGINTERN qpol_iterator_t *qpol_cat_alias_iter(struct qpol_cat *self,qpol_policy_t *p){ 4432 qpol_iterator_t *iter; 4433 if (qpol_cat_get_alias_iter(p, self, &iter)) { 4434 SWIG_exception(SWIG_RuntimeError, "Could not get category aliases"); 4435 } 4436 fail: 4437 return iter; 4438 } 4439 4440 qpol_cat_t *qpol_cat_from_void(void *x) { 4441 return (qpol_cat_t*)x; 4442 }; 4443 4444 SWIGINTERN struct qpol_mls_range *new_qpol_mls_range(qpol_policy_t *p,qpol_mls_level_t *l,qpol_mls_level_t *h){ 4445 qpol_mls_range_t *range; 4446 qpol_policy_get_mls_range_from_mls_levels(p, l, h, &range); 4447 return range; 4448 } 4449 SWIGINTERN void delete_qpol_mls_range(struct qpol_mls_range *self){ 4450 /* no op */ 4451 return; 4452 } 4453 SWIGINTERN qpol_mls_level_t const *qpol_mls_range_high_level(struct qpol_mls_range *self,qpol_policy_t *p){ 4454 const qpol_mls_level_t *l; 4455 if (qpol_mls_range_get_high_level(p, self, &l)) { 4456 SWIG_exception(SWIG_ValueError, "Could not get range high levl"); 4457 } 4458 fail: 4459 return l; 4460 } 4461 SWIGINTERN qpol_mls_level_t const *qpol_mls_range_low_level(struct qpol_mls_range *self,qpol_policy_t *p){ 4462 const qpol_mls_level_t *l; 4463 if (qpol_mls_range_get_low_level(p, self, &l)) { 4464 SWIG_exception(SWIG_ValueError, "Could not get range low levl"); 4465 } 4466 fail: 4467 return l; 4468 } 4469 4470 qpol_mls_range_t *qpol_mls_range_from_void(void *x) { 4471 return (qpol_mls_range_t*)x; 4472 }; 4473 4474 SWIGINTERN struct qpol_semantic_level *new_qpol_semantic_level(qpol_policy_t *p,char const *name){ 4475 const qpol_semantic_level_t *l; 4476 qpol_policy_get_semantic_level_by_name(p, name, &l); 4477 return (qpol_semantic_level_t*)l; 4478 } 4479 SWIGINTERN void delete_qpol_semantic_level(struct qpol_semantic_level *self){ 4480 qpol_semantic_level_destroy(self); 4481 return; 4482 } 4483 SWIGINTERN int qpol_semantic_level_add_cats(struct qpol_semantic_level *self,qpol_policy_t *p,char const *low,char const *high){ 4484 return qpol_semantic_level_add_cats_by_name(p, self, low, high); 4485 } 4486 SWIGINTERN struct qpol_mls_level *new_qpol_mls_level(qpol_policy_t *p,qpol_semantic_level_t *l){ 4487 qpol_mls_level_t *level; 4488 qpol_mls_level_from_semantic_level(p, l, &level); 4489 return level; 4490 } 4491 SWIGINTERN void delete_qpol_mls_level(struct qpol_mls_level *self){ 4492 /* no op */ 4493 return; 4494 } 4495 SWIGINTERN char const *qpol_mls_level_sens_name(struct qpol_mls_level *self,qpol_policy_t *p){ 4496 const char *name; 4497 if (qpol_mls_level_get_sens_name(p, self, &name)) { 4498 SWIG_exception(SWIG_ValueError, "Could not get level sensitivity name"); 4499 } 4500 fail: 4501 return name; 4502 } 4503 SWIGINTERN qpol_iterator_t *qpol_mls_level_cat_iter(struct qpol_mls_level *self,qpol_policy_t *p){ 4504 qpol_iterator_t *iter; 4505 if (qpol_mls_level_get_cat_iter(p, self, &iter)) { 4506 SWIG_exception(SWIG_RuntimeError, "Could not get level categories"); 4507 } 4508 fail: 4509 return iter; 4510 } 4511 4512 qpol_mls_level_t *qpol_mls_level_from_void(void *x) { 4513 return (qpol_mls_level_t*)x; 4514 }; 4515 4516 SWIGINTERN struct qpol_user *new_qpol_user(qpol_policy_t *p,char const *name){ 4517 const qpol_user_t *u; 4518 qpol_policy_get_user_by_name(p, name, &u); 4519 return (qpol_user_t*)u; 4520 } 4521 SWIGINTERN void delete_qpol_user(struct qpol_user *self){ 4522 /* no op */ 4523 return; 4524 } 4525 SWIGINTERN int qpol_user_value(struct qpol_user *self,qpol_policy_t *p){ 4526 uint32_t v; 4527 if (qpol_user_get_value(p, self, &v)) { 4528 SWIG_exception(SWIG_ValueError, "Could not get user value"); 4529 } 4530 fail: 4531 return (int) v; 4532 } 4533 SWIGINTERN qpol_iterator_t *qpol_user_role_iter(struct qpol_user *self,qpol_policy_t *p){ 4534 qpol_iterator_t *iter; 4535 if (qpol_user_get_role_iter(p, self, &iter)) { 4536 SWIG_exception(SWIG_MemoryError, "Out of Memory"); 4537 } 4538 fail: 4539 return iter; 4540 } 4541 SWIGINTERN qpol_mls_range_t const *qpol_user_range(struct qpol_user *self,qpol_policy_t *p){ 4542 const qpol_mls_range_t *r; 4543 if (qpol_user_get_range(p, self, &r)) { 4544 SWIG_exception(SWIG_ValueError, "Could not get user range"); 4545 } 4546 fail: 4547 return r; 4548 } 4549 SWIGINTERN char const *qpol_user_name(struct qpol_user *self,qpol_policy_t *p){ 4550 const char *name; 4551 if (qpol_user_get_name(p, self, &name)) { 4552 SWIG_exception(SWIG_ValueError, "Could not get user name"); 4553 } 4554 fail: 4555 return name; 4556 } 4557 SWIGINTERN qpol_mls_level_t const *qpol_user_dfltlevel(struct qpol_user *self,qpol_policy_t *p){ 4558 const qpol_mls_level_t *l; 4559 if (qpol_user_get_dfltlevel(p, self, &l)) { 4560 SWIG_exception(SWIG_ValueError, "Could not get user default level"); 4561 } 4562 fail: 4563 return l; 4564 } 4565 4566 qpol_user_t *qpol_user_from_void(void *x) { 4567 return (qpol_user_t*)x; 4568 }; 4569 4570 SWIGINTERN struct qpol_bool *new_qpol_bool(qpol_policy_t *p,char const *name){ 4571 qpol_bool_t *b; 4572 if (qpol_policy_get_bool_by_name(p, name, &b)) { 4573 SWIG_exception(SWIG_RuntimeError, "Boolean does not exist"); 4574 } 4575 fail: 4576 return b; 4577 } 4578 SWIGINTERN void delete_qpol_bool(struct qpol_bool *self){ 4579 /* no op */ 4580 return; 4581 } 4582 SWIGINTERN int qpol_bool_value(struct qpol_bool *self,qpol_policy_t *p){ 4583 uint32_t v; 4584 if (qpol_bool_get_value(p, self, &v)) { 4585 SWIG_exception(SWIG_ValueError, "Could not get boolean value"); 4586 } 4587 fail: 4588 return (int) v; 4589 } 4590 SWIGINTERN int qpol_bool_state(struct qpol_bool *self,qpol_policy_t *p){ 4591 int s; 4592 if (qpol_bool_get_state(p, self, &s)) { 4593 SWIG_exception(SWIG_ValueError, "Could not get boolean state"); 4594 } 4595 fail: 4596 return s; 4597 } 4598 SWIGINTERN char const *qpol_bool_name(struct qpol_bool *self,qpol_policy_t *p){ 4599 const char *name; 4600 if (qpol_bool_get_name(p, self, &name)) { 4601 SWIG_exception(SWIG_ValueError, "Could not get boolean name"); 4602 } 4603 fail: 4604 return name; 4605 } 4606 4607 qpol_bool_t *qpol_bool_from_void(void *x) { 4608 return (qpol_bool_t*)x; 4609 }; 4610 4611 SWIGINTERN struct qpol_context *new_qpol_context(void){ 4612 SWIG_exception(SWIG_RuntimeError, "Cannot directly create qpol_context_t objects"); 4613 fail: 4614 return NULL; 4615 } 4616 SWIGINTERN void delete_qpol_context(struct qpol_context *self){ 4617 /* no op */ 4618 return; 4619 } 4620 SWIGINTERN qpol_user_t const *qpol_context_user(struct qpol_context *self,qpol_policy_t *p){ 4621 const qpol_user_t *u; 4622 if (qpol_context_get_user(p, self, &u)) { 4623 SWIG_exception(SWIG_ValueError, "Could not get user from context"); 4624 } 4625 fail: 4626 return u; 4627 } 4628 SWIGINTERN qpol_role_t const *qpol_context_role(struct qpol_context *self,qpol_policy_t *p){ 4629 const qpol_role_t *r; 4630 if (qpol_context_get_role(p, self, &r)) { 4631 SWIG_exception(SWIG_ValueError, "Could not get role from context"); 4632 } 4633 fail: 4634 return r; 4635 } 4636 SWIGINTERN qpol_type_t const *qpol_context_type_(struct qpol_context *self,qpol_policy_t *p){ 4637 const qpol_type_t *t; 4638 if (qpol_context_get_type(p, self, &t)) { 4639 SWIG_exception(SWIG_ValueError, "Could not get type from context"); 4640 } 4641 fail: 4642 return t; 4643 } 4644 SWIGINTERN qpol_mls_range_t const *qpol_context_range(struct qpol_context *self,qpol_policy_t *p){ 4645 const qpol_mls_range_t *r; 4646 if (qpol_context_get_range(p, self, &r)) { 4647 SWIG_exception(SWIG_ValueError, "Could not get range from context"); 4648 } 4649 fail: 4650 return r; 4651 } 4652 4653 qpol_context_t *qpol_context_from_void(void *x) { 4654 return (qpol_context_t*)x; 4655 }; 4656 4657 SWIGINTERN struct qpol_class *new_qpol_class(qpol_policy_t *p,char const *name){ 4658 const qpol_class_t *c; 4659 qpol_policy_get_class_by_name(p, name, &c); 4660 return (qpol_class_t*)c; 4661 } 4662 SWIGINTERN void delete_qpol_class(struct qpol_class *self){ 4663 /* no op */ 4664 return; 4665 } 4666 SWIGINTERN int qpol_class_value(struct qpol_class *self,qpol_policy_t *p){ 4667 uint32_t v; 4668 if (qpol_class_get_value(p, self, &v)) { 4669 SWIG_exception(SWIG_ValueError, "Could not get value for class"); 4670 } 4671 fail: 4672 return (int) v; 4673 } 4674 SWIGINTERN qpol_common_t const *qpol_class_common(struct qpol_class *self,qpol_policy_t *p){ 4675 const qpol_common_t *c; 4676 if(qpol_class_get_common(p, self, &c)) { 4677 SWIG_exception(SWIG_ValueError, "Could not get common for class"); 4678 } 4679 fail: 4680 return c; 4681 } 4682 SWIGINTERN qpol_iterator_t *qpol_class_perm_iter(struct qpol_class *self,qpol_policy_t *p){ 4683 qpol_iterator_t *iter; 4684 if(qpol_class_get_perm_iter(p, self, &iter)) { 4685 SWIG_exception(SWIG_RuntimeError, "Could not get class permissions"); 4686 } 4687 fail: 4688 return iter; 4689 } 4690 SWIGINTERN qpol_iterator_t *qpol_class_constraint_iter(struct qpol_class *self,qpol_policy_t *p){ 4691 qpol_iterator_t *iter; 4692 if(qpol_class_get_constraint_iter(p, self, &iter)) { 4693 SWIG_exception(SWIG_RuntimeError, "Could not get class constraints"); 4694 } 4695 fail: 4696 return iter; 4697 } 4698 SWIGINTERN qpol_iterator_t *qpol_class_validatetrans_iter(struct qpol_class *self,qpol_policy_t *p){ 4699 qpol_iterator_t *iter; 4700 if(qpol_class_get_validatetrans_iter(p, self, &iter)) { 4701 SWIG_exception(SWIG_RuntimeError, "Could not get class validatetrans statements"); 4702 } 4703 fail: 4704 return iter; 4705 } 4706 SWIGINTERN char const *qpol_class_name(struct qpol_class *self,qpol_policy_t *p){ 4707 const char *name; 4708 if (qpol_class_get_name(p, self, &name)) { 4709 SWIG_exception(SWIG_ValueError, "Could not get class name"); 4710 } 4711 fail: 4712 return name; 4713 } 4714 4715 qpol_class_t *qpol_class_from_void(void *x) { 4716 return (qpol_class_t*)x; 4717 }; 4718 4719 SWIGINTERN struct qpol_common *new_qpol_common(qpol_policy_t *p,char const *name){ 4720 const qpol_common_t *c; 4721 qpol_policy_get_common_by_name(p, name, &c); 4722 return (qpol_common_t*)c; 4723 } 4724 SWIGINTERN void delete_qpol_common(struct qpol_common *self){ 4725 /* no op */ 4726 return; 4727 } 4728 SWIGINTERN int qpol_common_value(struct qpol_common *self,qpol_policy_t *p){ 4729 uint32_t v; 4730 if (qpol_common_get_value(p, self, &v)) { 4731 SWIG_exception(SWIG_ValueError, "Could not get value for common"); 4732 } 4733 fail: 4734 return (int) v; 4735 } 4736 SWIGINTERN qpol_iterator_t *qpol_common_perm_iter(struct qpol_common *self,qpol_policy_t *p){ 4737 qpol_iterator_t *iter; 4738 if(qpol_common_get_perm_iter(p, self, &iter)) { 4739 SWIG_exception(SWIG_RuntimeError, "Could not get common permissions"); 4740 } 4741 fail: 4742 return iter; 4743 } 4744 SWIGINTERN char const *qpol_common_name(struct qpol_common *self,qpol_policy_t *p){ 4745 const char *name; 4746 if (qpol_common_get_name(p, self, &name)) { 4747 SWIG_exception(SWIG_ValueError, "Could not get common name"); 4748 } 4749 fail: 4750 return name; 4751 } 4752 4753 qpol_common_t *qpol_common_from_void(void *x) { 4754 return (qpol_common_t*)x; 4755 }; 4756 4757 4758 SWIGINTERNINLINE PyObject* 4759 SWIG_From_unsigned_SS_int (unsigned int value) 4760 { 4761 return PyInt_FromSize_t((size_t) value); 4762 } 4763 4764 SWIGINTERN struct qpol_fs_use *new_qpol_fs_use(qpol_policy_t *p,char const *name){ 4765 const qpol_fs_use_t *f; 4766 if (qpol_policy_get_fs_use_by_name(p, name, &f)) { 4767 SWIG_exception(SWIG_RuntimeError, "FS Use Statement does not exist"); 4768 } 4769 fail: 4770 return (qpol_fs_use_t*)f; 4771 } 4772 SWIGINTERN void delete_qpol_fs_use(struct qpol_fs_use *self){ 4773 /* no op */ 4774 return; 4775 } 4776 SWIGINTERN char const *qpol_fs_use_name(struct qpol_fs_use *self,qpol_policy_t *p){ 4777 const char *name; 4778 if (qpol_fs_use_get_name(p, self, &name)) { 4779 SWIG_exception(SWIG_ValueError, "Could not get file system name"); 4780 } 4781 fail: 4782 return name; 4783 } 4784 SWIGINTERN int qpol_fs_use_behavior(struct qpol_fs_use *self,qpol_policy_t *p){ 4785 uint32_t behav; 4786 if (qpol_fs_use_get_behavior(p, self, &behav)) { 4787 SWIG_exception(SWIG_ValueError, "Could not get file system labeling behavior"); 4788 } 4789 fail: 4790 return (int) behav; 4791 } 4792 SWIGINTERN qpol_context_t const *qpol_fs_use_context(struct qpol_fs_use *self,qpol_policy_t *p){ 4793 uint32_t behav; 4794 const qpol_context_t *ctx = NULL; 4795 qpol_fs_use_get_behavior(p, self, &behav); 4796 if (behav == 6U) { 4797 SWIG_exception(SWIG_TypeError, "Cannot get context for fs_use_psid statements"); 4798 } else if (qpol_fs_use_get_context(p, self, &ctx)) { 4799 SWIG_exception(SWIG_ValueError, "Could not get file system context"); 4800 } 4801 fail: 4802 return ctx; 4803 } 4804 4805 qpol_fs_use_t *qpol_fs_use_from_void(void *x) { 4806 return (qpol_fs_use_t*)x; 4807 }; 4808 4809 SWIGINTERN struct qpol_genfscon *new_qpol_genfscon(qpol_policy_t *p,char const *name,char const *path){ 4810 qpol_genfscon_t *g; 4811 if (qpol_policy_get_genfscon_by_name(p, name, path, &g)) { 4812 SWIG_exception(SWIG_RuntimeError, "Genfscon statement does not exist"); 4813 } 4814 fail: 4815 return g; 4816 } 4817 SWIGINTERN void delete_qpol_genfscon(struct qpol_genfscon *self){ 4818 free(self); 4819 } 4820 SWIGINTERN char const *qpol_genfscon_name(struct qpol_genfscon *self,qpol_policy_t *p){ 4821 const char *name; 4822 if (qpol_genfscon_get_name(p, self, &name)) { 4823 SWIG_exception(SWIG_ValueError, "Could not get file system name"); 4824 } 4825 fail: 4826 return name; 4827 } 4828 SWIGINTERN char const *qpol_genfscon_path(struct qpol_genfscon *self,qpol_policy_t *p){ 4829 const char *path; 4830 if (qpol_genfscon_get_path(p, self, &path)) { 4831 SWIG_exception(SWIG_ValueError, "Could not get file system path"); 4832 } 4833 fail: 4834 return path; 4835 } 4836 SWIGINTERN unsigned int qpol_genfscon_object_class(struct qpol_genfscon *self,qpol_policy_t *p){ 4837 uint32_t cls; 4838 if (qpol_genfscon_get_class(p, self, &cls)) { 4839 SWIG_exception(SWIG_ValueError, "Could not get genfscon statement class"); 4840 } 4841 switch (cls) { 4842 case 11U: return S_IFBLK; 4843 case 10U: return S_IFCHR; 4844 case 7U: return S_IFDIR; 4845 case 13U: return S_IFIFO; 4846 case 6U: return S_IFREG; 4847 case 9U: return S_IFLNK; 4848 case 12U: return S_IFSOCK; 4849 default: return 0; /* all file types */ 4850 } 4851 fail: 4852 return 0; 4853 } 4854 SWIGINTERN qpol_context_t const *qpol_genfscon_context(struct qpol_genfscon *self,qpol_policy_t *p){ 4855 const qpol_context_t *ctx; 4856 if (qpol_genfscon_get_context(p, self, &ctx)) { 4857 SWIG_exception(SWIG_ValueError, "Could not get context for genfscon statement"); 4858 } 4859 fail: 4860 return ctx; 4861 } 4862 4863 qpol_genfscon_t *qpol_genfscon_from_void(void *x) { 4864 return (qpol_genfscon_t*)x; 4865 }; 4866 4867 SWIGINTERN struct qpol_isid *new_qpol_isid(qpol_policy_t *p,char const *name){ 4868 const qpol_isid_t *i; 4869 qpol_policy_get_isid_by_name(p, name, &i); 4870 return (qpol_isid_t*)i; 4871 } 4872 SWIGINTERN void delete_qpol_isid(struct qpol_isid *self){ 4873 /* no op */ 4874 return; 4875 } 4876 SWIGINTERN char const *qpol_isid_name(struct qpol_isid *self,qpol_policy_t *p){ 4877 const char *name; 4878 if (qpol_isid_get_name(p, self, &name)) { 4879 SWIG_exception(SWIG_ValueError, "Could not get name for initial sid"); 4880 } 4881 fail: 4882 return name; 4883 } 4884 SWIGINTERN qpol_context_t const *qpol_isid_context(struct qpol_isid *self,qpol_policy_t *p){ 4885 const qpol_context_t *ctx; 4886 if (qpol_isid_get_context(p, self, &ctx)) { 4887 SWIG_exception(SWIG_ValueError, "Could not get context for initial sid"); 4888 } 4889 fail: 4890 return ctx; 4891 } 4892 4893 qpol_isid_t *qpol_isid_from_void(void *x) { 4894 return (qpol_isid_t*)x; 4895 }; 4896 4897 SWIGINTERN struct qpol_netifcon *new_qpol_netifcon(qpol_policy_t *p,char const *name){ 4898 const qpol_netifcon_t *n; 4899 if (qpol_policy_get_netifcon_by_name(p, name, &n)) { 4900 SWIG_exception(SWIG_RuntimeError, "Netifcon statement does not exist"); 4901 } 4902 fail: 4903 return (qpol_netifcon_t*)n; 4904 } 4905 SWIGINTERN void delete_qpol_netifcon(struct qpol_netifcon *self){ 4906 /* no op */ 4907 return; 4908 } 4909 SWIGINTERN char const *qpol_netifcon_name(struct qpol_netifcon *self,qpol_policy_t *p){ 4910 const char *name; 4911 if (qpol_netifcon_get_name(p, self, &name)) { 4912 SWIG_exception(SWIG_ValueError, "Could not get name for netifcon statement"); 4913 } 4914 fail: 4915 return name; 4916 } 4917 SWIGINTERN qpol_context_t const *qpol_netifcon_msg_con(struct qpol_netifcon *self,qpol_policy_t *p){ 4918 const qpol_context_t *ctx; 4919 if (qpol_netifcon_get_msg_con(p, self, &ctx)) { 4920 SWIG_exception(SWIG_ValueError, "Could not get message context for netifcon statement"); 4921 } 4922 fail: 4923 return ctx; 4924 } 4925 SWIGINTERN qpol_context_t const *qpol_netifcon_if_con(struct qpol_netifcon *self,qpol_policy_t *p){ 4926 const qpol_context_t *ctx; 4927 if (qpol_netifcon_get_if_con(p, self, &ctx)) { 4928 SWIG_exception(SWIG_ValueError, "Could not get interface context for netifcon statement"); 4929 } 4930 fail: 4931 return ctx; 4932 } 4933 4934 qpol_netifcon_t *qpol_netifcon_from_void(void *x) { 4935 return (qpol_netifcon_t*)x; 4936 }; 4937 4938 SWIGINTERN struct qpol_nodecon *new_qpol_nodecon(qpol_policy_t *p,int addr[4],int mask[4],int protocol){ 4939 uint32_t a[4], m[4]; 4940 qpol_nodecon_t *n; 4941 a[0] = (uint32_t) addr[0]; a[1] = (uint32_t) addr[1]; 4942 a[2] = (uint32_t) addr[2]; a[3] = (uint32_t) addr[3]; 4943 m[0] = (uint32_t) mask[0]; m[1] = (uint32_t) mask[1]; 4944 m[2] = (uint32_t) mask[2]; m[3] = (uint32_t) mask[3]; 4945 if (qpol_policy_get_nodecon_by_node(p, a, m, protocol, &n)) { 4946 SWIG_exception(SWIG_RuntimeError, "Nodecon statement does not exist"); 4947 } 4948 fail: 4949 return n; 4950 } 4951 SWIGINTERN void delete_qpol_nodecon(struct qpol_nodecon *self){ 4952 free(self); 4953 } 4954 SWIGINTERN char *qpol_nodecon_addr(struct qpol_nodecon *self,qpol_policy_t *p){ 4955 uint32_t *a; 4956 unsigned char proto; 4957 char *addr = NULL; 4958 4959 addr = malloc(INET6_ADDRSTRLEN * sizeof(char)); 4960 if(!addr) 4961 SWIG_exception(SWIG_MemoryError, "Out of memory"); 4962 4963 if (qpol_nodecon_get_addr(p, self, &a, &proto)) { 4964 SWIG_exception(SWIG_ValueError, "Could not get address of nodecon statement"); 4965 } 4966 4967 if(proto == 0) { 4968 inet_ntop(AF_INET, a, addr, INET6_ADDRSTRLEN); 4969 } else { 4970 inet_ntop(AF_INET6, a, addr, INET6_ADDRSTRLEN); 4971 } 4972 4973 fail: 4974 return addr; 4975 } 4976 SWIGINTERN char *qpol_nodecon_mask(struct qpol_nodecon *self,qpol_policy_t *p){ 4977 uint32_t *m; 4978 unsigned char proto; 4979 char *mask; 4980 mask = malloc(INET6_ADDRSTRLEN * sizeof(char)); 4981 if (!mask) 4982 SWIG_exception(SWIG_MemoryError, "Out of memory"); 4983 4984 if (qpol_nodecon_get_mask(p, self, &m, &proto)) { 4985 SWIG_exception(SWIG_ValueError, "Could not get mask of nodecon statement"); 4986 } 4987 4988 if(proto == 0) { 4989 inet_ntop(AF_INET, m, mask, INET6_ADDRSTRLEN); 4990 } else { 4991 inet_ntop(AF_INET6, m, mask, INET6_ADDRSTRLEN); 4992 } 4993 fail: 4994 return mask; 4995 } 4996 SWIGINTERN int qpol_nodecon_protocol(struct qpol_nodecon *self,qpol_policy_t *p){ 4997 unsigned char proto; 4998 if (qpol_nodecon_get_protocol(p, self, &proto)) { 4999 SWIG_exception(SWIG_ValueError, "Could not get protocol for nodecon statement"); 5000 } 5001 fail: 5002 if(proto == 0) { 5003 return AF_INET; 5004 } else { 5005 return AF_INET6; 5006 } 5007 } 5008 SWIGINTERN qpol_context_t const *qpol_nodecon_context(struct qpol_nodecon *self,qpol_policy_t *p){ 5009 const qpol_context_t *ctx; 5010 if (qpol_nodecon_get_context(p, self, &ctx)) { 5011 SWIG_exception(SWIG_ValueError, "Could not get context for nodecon statement"); 5012 } 5013 fail: 5014 return ctx; 5015 } 5016 5017 qpol_nodecon_t *qpol_nodecon_from_void(void *x) { 5018 return (qpol_nodecon_t*)x; 5019 }; 5020 5021 5022 SWIGINTERN int 5023 SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val) 5024 { 5025 #if PY_VERSION_HEX < 0x03000000 5026 if (PyInt_Check(obj)) { 5027 long v = PyInt_AsLong(obj); 5028 if (v >= 0) { 5029 if (val) *val = v; 5030 return SWIG_OK; 5031 } else { 5032 return SWIG_OverflowError; 5033 } 5034 } else 5035 #endif 5036 if (PyLong_Check(obj)) { 5037 unsigned long v = PyLong_AsUnsignedLong(obj); 5038 if (!PyErr_Occurred()) { 5039 if (val) *val = v; 5040 return SWIG_OK; 5041 } else { 5042 PyErr_Clear(); 5043 #if PY_VERSION_HEX >= 0x03000000 5044 { 5045 long v = PyLong_AsLong(obj); 5046 if (!PyErr_Occurred()) { 5047 if (v < 0) { 5048 return SWIG_OverflowError; 5049 } 5050 } else { 5051 PyErr_Clear(); 5052 } 5053 } 5054 #endif 5055 } 5056 } 5057 #ifdef SWIG_PYTHON_CAST_MODE 5058 { 5059 int dispatch = 0; 5060 unsigned long v = PyLong_AsUnsignedLong(obj); 5061 if (!PyErr_Occurred()) { 5062 if (val) *val = v; 5063 return SWIG_AddCast(SWIG_OK); 5064 } else { 5065 PyErr_Clear(); 5066 } 5067 if (!dispatch) { 5068 double d; 5069 int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d)); 5070 if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) { 5071 if (val) *val = (unsigned long)(d); 5072 return res; 5073 } 5074 } 5075 } 5076 #endif 5077 return SWIG_TypeError; 5078 } 5079 5080 5081 SWIGINTERN int 5082 SWIG_AsVal_unsigned_SS_short (PyObject * obj, unsigned short *val) 5083 { 5084 unsigned long v; 5085 int res = SWIG_AsVal_unsigned_SS_long (obj, &v); 5086 if (SWIG_IsOK(res)) { 5087 if ((v > USHRT_MAX)) { 5088 return SWIG_OverflowError; 5089 } else { 5090 if (val) *val = (unsigned short)(v); 5091 } 5092 } 5093 return res; 5094 } 5095 5096 5097 SWIGINTERN int 5098 SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val) 5099 { 5100 unsigned long v; 5101 int res = SWIG_AsVal_unsigned_SS_long (obj, &v); 5102 if (SWIG_IsOK(res)) { 5103 if ((v > UCHAR_MAX)) { 5104 return SWIG_OverflowError; 5105 } else { 5106 if (val) *val = (unsigned char)(v); 5107 } 5108 } 5109 return res; 5110 } 5111 5112 SWIGINTERN struct qpol_portcon *new_qpol_portcon(qpol_policy_t *p,uint16_t low,uint16_t high,uint8_t protocol){ 5113 const qpol_portcon_t *qp; 5114 if (qpol_policy_get_portcon_by_port(p, low, high, protocol, &qp)) { 5115 SWIG_exception(SWIG_RuntimeError, "Portcon statement does not exist"); 5116 } 5117 fail: 5118 return (qpol_portcon_t*)qp; 5119 } 5120 SWIGINTERN void delete_qpol_portcon(struct qpol_portcon *self){ 5121 /* no op */ 5122 return; 5123 } 5124 SWIGINTERN uint16_t qpol_portcon_low_port(struct qpol_portcon *self,qpol_policy_t *p){ 5125 uint16_t port = 0; 5126 if(qpol_portcon_get_low_port(p, self, &port)) { 5127 SWIG_exception(SWIG_RuntimeError, "Could not get low port for portcon statement"); 5128 } 5129 fail: 5130 return port; 5131 } 5132 5133 SWIGINTERNINLINE PyObject * 5134 SWIG_From_unsigned_SS_short (unsigned short value) 5135 { 5136 return SWIG_From_unsigned_SS_long (value); 5137 } 5138 5139 SWIGINTERN uint16_t qpol_portcon_high_port(struct qpol_portcon *self,qpol_policy_t *p){ 5140 uint16_t port = 0; 5141 if(qpol_portcon_get_high_port(p, self, &port)) { 5142 SWIG_exception(SWIG_RuntimeError, "Could not get high port for portcon statement"); 5143 } 5144 fail: 5145 return port; 5146 } 5147 SWIGINTERN uint8_t qpol_portcon_protocol(struct qpol_portcon *self,qpol_policy_t *p){ 5148 uint8_t proto = 0; 5149 if (qpol_portcon_get_protocol(p, self, &proto)) { 5150 SWIG_exception(SWIG_RuntimeError, "Could not get protocol for portcon statement"); 5151 } 5152 fail: 5153 return proto; 5154 } 5155 5156 SWIGINTERNINLINE PyObject * 5157 SWIG_From_unsigned_SS_char (unsigned char value) 5158 { 5159 return SWIG_From_unsigned_SS_long (value); 5160 } 5161 5162 SWIGINTERN qpol_context_t const *qpol_portcon_context(struct qpol_portcon *self,qpol_policy_t *p){ 5163 const qpol_context_t *ctx; 5164 if (qpol_portcon_get_context(p, self, &ctx)) { 5165 SWIG_exception(SWIG_ValueError, "Could not get context for portcon statement"); 5166 } 5167 fail: 5168 return ctx; 5169 } 5170 5171 qpol_portcon_t *qpol_portcon_from_void(void *x) { 5172 return (qpol_portcon_t*)x; 5173 }; 5174 5175 SWIGINTERN struct qpol_constraint *new_qpol_constraint(void){ 5176 SWIG_exception(SWIG_RuntimeError, "Cannot directly create qpol_constraint_t objects"); 5177 fail: 5178 return NULL; 5179 } 5180 SWIGINTERN void delete_qpol_constraint(struct qpol_constraint *self){ 5181 free(self); 5182 } 5183 SWIGINTERN qpol_class_t const *qpol_constraint_object_class(struct qpol_constraint *self,qpol_policy_t *p){ 5184 const qpol_class_t *cls; 5185 if (qpol_constraint_get_class(p, self, &cls)) { 5186 SWIG_exception(SWIG_ValueError, "Could not get class for constraint"); 5187 } 5188 fail: 5189 return cls; 5190 } 5191 SWIGINTERN qpol_iterator_t *qpol_constraint_perm_iter(struct qpol_constraint *self,qpol_policy_t *p){ 5192 qpol_iterator_t *iter; 5193 if (qpol_constraint_get_perm_iter(p, self, &iter)) { 5194 SWIG_exception(SWIG_MemoryError, "Out of memory"); 5195 } 5196 fail: 5197 return iter; 5198 } 5199 SWIGINTERN qpol_iterator_t *qpol_constraint_expr_iter(struct qpol_constraint *self,qpol_policy_t *p){ 5200 qpol_iterator_t *iter; 5201 if (qpol_constraint_get_expr_iter(p, self, &iter)) { 5202 SWIG_exception(SWIG_MemoryError, "Out of memory"); 5203 } 5204 fail: 5205 return iter; 5206 } 5207 5208 qpol_constraint_t *qpol_constraint_from_void(void *x) { 5209 return (qpol_constraint_t*)x; 5210 }; 5211 5212 SWIGINTERN struct qpol_validatetrans *new_qpol_validatetrans(void){ 5213 SWIG_exception(SWIG_RuntimeError, "Cannot directly create qpol_validatetrans_t objects"); 5214 fail: 5215 return NULL; 5216 } 5217 SWIGINTERN void delete_qpol_validatetrans(struct qpol_validatetrans *self){ 5218 free(self); 5219 } 5220 SWIGINTERN qpol_class_t const *qpol_validatetrans_object_class(struct qpol_validatetrans *self,qpol_policy_t *p){ 5221 const qpol_class_t *cls; 5222 if (qpol_validatetrans_get_class(p, self, &cls)) { 5223 SWIG_exception(SWIG_ValueError, "Could not get class for validatetrans"); 5224 } 5225 fail: 5226 return cls; 5227 } 5228 SWIGINTERN qpol_iterator_t *qpol_validatetrans_expr_iter(struct qpol_validatetrans *self,qpol_policy_t *p){ 5229 qpol_iterator_t *iter; 5230 if (qpol_validatetrans_get_expr_iter(p, self, &iter)) { 5231 SWIG_exception(SWIG_MemoryError, "Out of memory"); 5232 } 5233 fail: 5234 return iter; 5235 } 5236 5237 qpol_validatetrans_t *qpol_validatetrans_from_void(void *x) { 5238 return (qpol_validatetrans_t*)x; 5239 }; 5240 5241 SWIGINTERN struct qpol_constraint_expr_node *new_qpol_constraint_expr_node(void){ 5242 SWIG_exception(SWIG_RuntimeError, "Cannot directly create qpol_constraint_expr_node_t objects"); 5243 fail: 5244 return NULL; 5245 } 5246 SWIGINTERN void delete_qpol_constraint_expr_node(struct qpol_constraint_expr_node *self){ 5247 /* no op */ 5248 return; 5249 } 5250 SWIGINTERN int qpol_constraint_expr_node_expr_type(struct qpol_constraint_expr_node *self,qpol_policy_t *p){ 5251 uint32_t et; 5252 if (qpol_constraint_expr_node_get_expr_type(p, self, &et)) { 5253 SWIG_exception(SWIG_ValueError, "Could not get expression type for node"); 5254 } 5255 fail: 5256 return (int) et; 5257 } 5258 SWIGINTERN int qpol_constraint_expr_node_sym_type(struct qpol_constraint_expr_node *self,qpol_policy_t *p){ 5259 uint32_t st; 5260 if (qpol_constraint_expr_node_get_sym_type(p, self, &st)) { 5261 SWIG_exception(SWIG_ValueError, "Could not get symbol type for node"); 5262 } 5263 fail: 5264 return (int) st; 5265 } 5266 SWIGINTERN int qpol_constraint_expr_node_op(struct qpol_constraint_expr_node *self,qpol_policy_t *p){ 5267 uint32_t op; 5268 if (qpol_constraint_expr_node_get_op(p, self, &op)) { 5269 SWIG_exception(SWIG_ValueError, "Could not get operator for node"); 5270 } 5271 fail: 5272 return (int) op; 5273 } 5274 SWIGINTERN qpol_iterator_t *qpol_constraint_expr_node_names_iter(struct qpol_constraint_expr_node *self,qpol_policy_t *p){ 5275 qpol_iterator_t *iter; 5276 if (qpol_constraint_expr_node_get_names_iter(p, self, &iter)) { 5277 SWIG_exception(SWIG_MemoryError, "Out of memory"); 5278 } 5279 fail: 5280 return iter; 5281 } 5282 5283 qpol_constraint_expr_node_t *qpol_constraint_expr_node_from_void(void *x) { 5284 return (qpol_constraint_expr_node_t*)x; 5285 }; 5286 5287 SWIGINTERN struct qpol_role_allow *new_qpol_role_allow(void){ 5288 SWIG_exception(SWIG_RuntimeError, "Cannot directly create qpol_role_allow_t objects"); 5289 fail: 5290 return NULL; 5291 } 5292 SWIGINTERN void delete_qpol_role_allow(struct qpol_role_allow *self){ 5293 /* no op */ 5294 return; 5295 } 5296 SWIGINTERN qpol_role_t const *qpol_role_allow_source_role(struct qpol_role_allow *self,qpol_policy_t *p){ 5297 const qpol_role_t *r; 5298 if (qpol_role_allow_get_source_role(p, self, &r)) { 5299 SWIG_exception(SWIG_ValueError, "Could not get source for role allow rule"); 5300 } 5301 fail: 5302 return r; 5303 } 5304 SWIGINTERN qpol_role_t const *qpol_role_allow_target_role(struct qpol_role_allow *self,qpol_policy_t *p){ 5305 const qpol_role_t *r; 5306 if (qpol_role_allow_get_target_role(p, self, &r)) { 5307 SWIG_exception(SWIG_ValueError, "Could not get target for role allow rule"); 5308 } 5309 fail: 5310 return r; 5311 } 5312 5313 qpol_role_allow_t *qpol_role_allow_from_void(void *x) { 5314 return (qpol_role_allow_t*)x; 5315 }; 5316 5317 SWIGINTERN struct qpol_role_trans *new_qpol_role_trans(void){ 5318 SWIG_exception(SWIG_RuntimeError, "Cannot directly create qpol_role_trans_t objects"); 5319 fail: 5320 return NULL; 5321 } 5322 SWIGINTERN void delete_qpol_role_trans(struct qpol_role_trans *self){ 5323 /* no op */ 5324 return; 5325 } 5326 SWIGINTERN qpol_role_t const *qpol_role_trans_source_role(struct qpol_role_trans *self,qpol_policy_t *p){ 5327 const qpol_role_t *r; 5328 if (qpol_role_trans_get_source_role(p, self, &r)) { 5329 SWIG_exception(SWIG_ValueError, "Could not get source for role_transition rule"); 5330 } 5331 fail: 5332 return r; 5333 } 5334 SWIGINTERN qpol_type_t const *qpol_role_trans_target_type(struct qpol_role_trans *self,qpol_policy_t *p){ 5335 const qpol_type_t *t; 5336 if (qpol_role_trans_get_target_type(p, self, &t)) { 5337 SWIG_exception(SWIG_ValueError, "Could not get target for role_transition rule"); 5338 } 5339 fail: 5340 return t; 5341 } 5342 SWIGINTERN qpol_class_t const *qpol_role_trans_object_class(struct qpol_role_trans *self,qpol_policy_t *p){ 5343 const qpol_class_t *c; 5344 if (qpol_role_trans_get_object_class(p, self, &c)) { 5345 SWIG_exception(SWIG_ValueError, "Could not get class for role_transition rule"); 5346 } 5347 fail: 5348 return c; 5349 } 5350 SWIGINTERN qpol_role_t const *qpol_role_trans_default_role(struct qpol_role_trans *self,qpol_policy_t *p){ 5351 const qpol_role_t *r; 5352 if (qpol_role_trans_get_default_role(p, self, &r)) { 5353 SWIG_exception(SWIG_ValueError, "Could not get default for role_transition rule"); 5354 } 5355 fail: 5356 return r; 5357 } 5358 5359 qpol_role_trans_t *qpol_role_trans_from_void(void *x) { 5360 return (qpol_role_trans_t*)x; 5361 }; 5362 5363 SWIGINTERN struct qpol_range_trans *new_qpol_range_trans(void){ 5364 SWIG_exception(SWIG_RuntimeError, "Cannot directly create qpol_range_trans_t objects"); 5365 fail: 5366 return NULL; 5367 } 5368 SWIGINTERN void delete_qpol_range_trans(struct qpol_range_trans *self){ 5369 /* no op */ 5370 return; 5371 } 5372 SWIGINTERN qpol_type_t const *qpol_range_trans_source_type(struct qpol_range_trans *self,qpol_policy_t *p){ 5373 const qpol_type_t *t; 5374 if (qpol_range_trans_get_source_type(p, self, &t)) { 5375 SWIG_exception(SWIG_ValueError, "Could not get source for range_transition rule"); 5376 } 5377 fail: 5378 return t; 5379 } 5380 SWIGINTERN qpol_type_t const *qpol_range_trans_target_type(struct qpol_range_trans *self,qpol_policy_t *p){ 5381 const qpol_type_t *t; 5382 if (qpol_range_trans_get_target_type(p, self, &t)) { 5383 SWIG_exception(SWIG_ValueError, "Could not get target for range_transition rule"); } 5384 fail: 5385 return t; 5386 } 5387 SWIGINTERN qpol_class_t const *qpol_range_trans_object_class(struct qpol_range_trans *self,qpol_policy_t *p){ 5388 const qpol_class_t *cls; 5389 if (qpol_range_trans_get_target_class(p, self, &cls)) { 5390 SWIG_exception(SWIG_ValueError, "Could not get class for range_transition rule"); } 5391 fail: 5392 return cls; 5393 } 5394 SWIGINTERN qpol_mls_range_t const *qpol_range_trans_range(struct qpol_range_trans *self,qpol_policy_t *p){ 5395 const qpol_mls_range_t *r; 5396 if (qpol_range_trans_get_range(p, self, &r)) { 5397 SWIG_exception(SWIG_ValueError, "Could not get range for range_transition rule"); 5398 } 5399 fail: 5400 return r; 5401 } 5402 5403 qpol_range_trans_t *qpol_range_trans_from_void(void *x) { 5404 return (qpol_range_trans_t*)x; 5405 }; 5406 5407 SWIGINTERN struct qpol_avrule *new_qpol_avrule(void){ 5408 SWIG_exception(SWIG_RuntimeError, "Cannot directly create qpol_avrule_t objects"); 5409 fail: 5410 return NULL; 5411 } 5412 SWIGINTERN void delete_qpol_avrule(struct qpol_avrule *self){ 5413 /* no op */ 5414 return; 5415 } 5416 SWIGINTERN char const *qpol_avrule_rule_type(struct qpol_avrule *self,qpol_policy_t *p){ 5417 uint32_t rt; 5418 if (qpol_avrule_get_rule_type(p, self, &rt)) { 5419 SWIG_exception(SWIG_ValueError, "Could not get rule type for av rule"); 5420 } 5421 switch (rt) { 5422 case 0x0001: return "allow"; break; 5423 case 0x0080: return "neverallow"; break; 5424 case 0x0002: return "auditallow"; break; 5425 case 0x0004: return "dontaudit"; break; 5426 case 0x0100: return "allowxperm"; break; 5427 case 0x0800: return "neverallowxperm"; break; 5428 case 0x0200: return "auditallowxperm"; break; 5429 case 0x0400: return "dontauditxperm"; break; 5430 } 5431 fail: 5432 return NULL; 5433 } 5434 SWIGINTERN qpol_type_t const *qpol_avrule_source_type(struct qpol_avrule *self,qpol_policy_t *p){ 5435 const qpol_type_t *t; 5436 if (qpol_avrule_get_source_type(p, self, &t)) { 5437 SWIG_exception(SWIG_ValueError, "Could not get source for av rule"); 5438 } 5439 fail: 5440 return t; 5441 } 5442 SWIGINTERN qpol_type_t const *qpol_avrule_target_type(struct qpol_avrule *self,qpol_policy_t *p){ 5443 const qpol_type_t *t; 5444 if (qpol_avrule_get_target_type(p, self, &t)) { 5445 SWIG_exception(SWIG_ValueError, "Could not get target for av rule"); 5446 } 5447 fail: 5448 return t; 5449 } 5450 SWIGINTERN qpol_class_t const *qpol_avrule_object_class(struct qpol_avrule *self,qpol_policy_t *p){ 5451 const qpol_class_t *cls; 5452 if (qpol_avrule_get_object_class(p, self, &cls)) { 5453 SWIG_exception(SWIG_ValueError, "Could not get class for av rule"); 5454 } 5455 fail: 5456 return cls; 5457 } 5458 SWIGINTERN qpol_iterator_t *qpol_avrule_perm_iter(struct qpol_avrule *self,qpol_policy_t *p){ 5459 qpol_iterator_t *iter; 5460 if (qpol_avrule_get_perm_iter(p, self, &iter)) { 5461 SWIG_exception(SWIG_MemoryError, "Out of memory"); 5462 } 5463 fail: 5464 return iter; 5465 } 5466 SWIGINTERN qpol_iterator_t *qpol_avrule_xperm_iter(struct qpol_avrule *self,qpol_policy_t *p){ 5467 qpol_iterator_t *iter; 5468 if (qpol_avrule_get_xperm_iter(p, self, &iter)) { 5469 SWIG_exception(SWIG_MemoryError, "Out of memory"); 5470 } 5471 fail: 5472 return iter; 5473 } 5474 SWIGINTERN int qpol_avrule_is_extended(struct qpol_avrule *self,qpol_policy_t *p){ 5475 uint32_t e; 5476 if (qpol_avrule_get_is_extended(p, self, &e)) { 5477 SWIG_exception(SWIG_ValueError, "Could not determine if av rule is extended"); 5478 } 5479 fail: 5480 return (int) e; 5481 } 5482 SWIGINTERN char const *qpol_avrule_xperm_type(struct qpol_avrule *self,qpol_policy_t *p){ 5483 char *xt; 5484 if (qpol_avrule_get_xperm_type(p, self, &xt)) { 5485 SWIG_exception(SWIG_ValueError, "Could not get xperm type for av rule"); 5486 } 5487 fail: 5488 return xt; 5489 } 5490 SWIGINTERN qpol_cond_t const *qpol_avrule_cond(struct qpol_avrule *self,qpol_policy_t *p){ 5491 const qpol_cond_t *c; 5492 qpol_avrule_get_cond(p, self, &c); 5493 return c; 5494 } 5495 SWIGINTERN int qpol_avrule_is_enabled(struct qpol_avrule *self,qpol_policy_t *p){ 5496 uint32_t e; 5497 if (qpol_avrule_get_is_enabled(p, self, &e)) { 5498 SWIG_exception(SWIG_ValueError, "Could not determine if av rule is enabled"); 5499 } 5500 fail: 5501 return (int) e; 5502 } 5503 SWIGINTERN int qpol_avrule_which_list(struct qpol_avrule *self,qpol_policy_t *p){ 5504 const qpol_cond_t *c; 5505 uint32_t which = 0; 5506 qpol_avrule_get_cond(p, self, &c); 5507 if (c == NULL) { 5508 return -1; 5509 } else if (qpol_avrule_get_which_list(p, self, &which)) { 5510 return -1; 5511 } 5512 return (int) which; 5513 } 5514 SWIGINTERN qpol_iterator_t *qpol_avrule_syn_avrule_iter(struct qpol_avrule *self,qpol_policy_t *p){ 5515 qpol_iterator_t *iter; 5516 if (qpol_avrule_get_syn_avrule_iter(p, self, &iter)) { 5517 SWIG_exception(SWIG_MemoryError, "Out of memory"); 5518 } 5519 fail: 5520 return iter; 5521 } 5522 5523 qpol_avrule_t *qpol_avrule_from_void(void *x) { 5524 return (qpol_avrule_t*)x; 5525 }; 5526 5527 SWIGINTERN struct qpol_terule *new_qpol_terule(void){ 5528 SWIG_exception(SWIG_RuntimeError, "Cannot directly create qpol_terule_t objects"); 5529 fail: 5530 return NULL; 5531 } 5532 SWIGINTERN void delete_qpol_terule(struct qpol_terule *self){ 5533 /* no op */ 5534 return; 5535 } 5536 SWIGINTERN char const *qpol_terule_rule_type(struct qpol_terule *self,qpol_policy_t *p){ 5537 uint32_t rt; 5538 if (qpol_terule_get_rule_type(p, self, &rt)) { 5539 SWIG_exception(SWIG_ValueError, "Could not get rule type for te rule"); 5540 } 5541 switch (rt) { 5542 case 16: return "type_transition"; break; 5543 case 64: return "type_change"; break; 5544 case 32: return "type_member"; break; 5545 } 5546 fail: 5547 return NULL; 5548 } 5549 SWIGINTERN qpol_type_t const *qpol_terule_source_type(struct qpol_terule *self,qpol_policy_t *p){ 5550 const qpol_type_t *t; 5551 if (qpol_terule_get_source_type(p, self, &t)) { 5552 SWIG_exception(SWIG_ValueError, "Could not get source for te rule"); 5553 } 5554 fail: 5555 return t; 5556 } 5557 SWIGINTERN qpol_type_t const *qpol_terule_target_type(struct qpol_terule *self,qpol_policy_t *p){ 5558 const qpol_type_t *t; 5559 if (qpol_terule_get_target_type(p, self, &t)) { 5560 SWIG_exception(SWIG_ValueError, "Could not get target for te rule"); 5561 } 5562 fail: 5563 return t; 5564 } 5565 SWIGINTERN qpol_class_t const *qpol_terule_object_class(struct qpol_terule *self,qpol_policy_t *p){ 5566 const qpol_class_t *cls; 5567 if (qpol_terule_get_object_class(p, self, &cls)) { 5568 SWIG_exception(SWIG_ValueError, "Could not get class for te rule"); 5569 } 5570 fail: 5571 return cls; 5572 } 5573 SWIGINTERN qpol_type_t const *qpol_terule_default_type(struct qpol_terule *self,qpol_policy_t *p){ 5574 const qpol_type_t *t; 5575 if (qpol_terule_get_default_type(p, self, &t)) { 5576 SWIG_exception(SWIG_ValueError, "Could not get default for te rule"); 5577 } 5578 fail: 5579 return t; 5580 } 5581 SWIGINTERN qpol_cond_t const *qpol_terule_cond(struct qpol_terule *self,qpol_policy_t *p){ 5582 const qpol_cond_t *c; 5583 qpol_terule_get_cond(p, self, &c); 5584 return c; 5585 } 5586 SWIGINTERN int qpol_terule_is_enabled(struct qpol_terule *self,qpol_policy_t *p){ 5587 uint32_t e; 5588 if (qpol_terule_get_is_enabled(p, self, &e)) { 5589 SWIG_exception(SWIG_ValueError, "Could not determine if te rule is enabled"); 5590 } 5591 fail: 5592 return (int) e; 5593 } 5594 SWIGINTERN int qpol_terule_which_list(struct qpol_terule *self,qpol_policy_t *p){ 5595 const qpol_cond_t *c; 5596 uint32_t which = 0; 5597 qpol_terule_get_cond(p, self, &c); 5598 if (c == NULL) { 5599 return -1; 5600 } else if (qpol_terule_get_which_list(p, self, &which)) { 5601 return -1; 5602 } 5603 return (int) which; 5604 } 5605 SWIGINTERN qpol_iterator_t *qpol_terule_syn_terule_iter(struct qpol_terule *self,qpol_policy_t *p){ 5606 qpol_iterator_t *iter; 5607 if (qpol_terule_get_syn_terule_iter(p, self, &iter)) { 5608 SWIG_exception(SWIG_MemoryError, "Out of memory"); 5609 } 5610 fail: 5611 return iter; 5612 } 5613 5614 qpol_terule_t *qpol_terule_from_void(void *x) { 5615 return (qpol_terule_t*)x; 5616 }; 5617 5618 SWIGINTERN struct qpol_cond *new_qpol_cond(void){ 5619 SWIG_exception(SWIG_RuntimeError, "Cannot directly create qpol_cond_t objects"); 5620 fail: 5621 return NULL; 5622 } 5623 SWIGINTERN void delete_qpol_cond(struct qpol_cond *self){ 5624 /* no op */ 5625 return; 5626 } 5627 SWIGINTERN qpol_iterator_t *qpol_cond_expr_node_iter(struct qpol_cond *self,qpol_policy_t *p){ 5628 qpol_iterator_t *iter; 5629 if (qpol_cond_get_expr_node_iter(p, self, &iter)) { 5630 SWIG_exception(SWIG_MemoryError, "Out of memory"); 5631 } 5632 fail: 5633 return iter; 5634 } 5635 SWIGINTERN qpol_iterator_t *qpol_cond_av_true_iter(struct qpol_cond *self,qpol_policy_t *p,int rule_types){ 5636 qpol_iterator_t *iter; 5637 if (qpol_cond_get_av_true_iter(p, self, rule_types, &iter)) { 5638 SWIG_exception(SWIG_MemoryError, "Out of memory"); 5639 } 5640 fail: 5641 return iter; 5642 } 5643 SWIGINTERN qpol_iterator_t *qpol_cond_av_false_iter(struct qpol_cond *self,qpol_policy_t *p,int rule_types){ 5644 qpol_iterator_t *iter; 5645 if (qpol_cond_get_av_false_iter(p, self, rule_types, &iter)) { 5646 SWIG_exception(SWIG_MemoryError, "Out of memory"); 5647 } 5648 fail: 5649 return iter; 5650 } 5651 SWIGINTERN qpol_iterator_t *qpol_cond_te_true_iter(struct qpol_cond *self,qpol_policy_t *p,int rule_types){ 5652 qpol_iterator_t *iter; 5653 if (qpol_cond_get_te_true_iter(p, self, rule_types, &iter)) { 5654 SWIG_exception(SWIG_MemoryError, "Out of memory"); 5655 } 5656 fail: 5657 return iter; 5658 } 5659 SWIGINTERN qpol_iterator_t *qpol_cond_te_false_iter(struct qpol_cond *self,qpol_policy_t *p,int rule_types){ 5660 qpol_iterator_t *iter; 5661 if (qpol_cond_get_te_false_iter(p, self, rule_types, &iter)) { 5662 SWIG_exception(SWIG_MemoryError, "Out of memory"); 5663 } 5664 fail: 5665 return iter; 5666 } 5667 SWIGINTERN int qpol_cond_evaluate(struct qpol_cond *self,qpol_policy_t *p){ 5668 uint32_t e; 5669 if (qpol_cond_eval(p, self, &e)) { 5670 SWIG_exception(SWIG_RuntimeError, "Could not evaluate conditional"); 5671 } 5672 fail: 5673 return (int) e; 5674 } 5675 5676 qpol_cond_t *qpol_cond_from_void(void *x) { 5677 return (qpol_cond_t*)x; 5678 }; 5679 5680 SWIGINTERN struct qpol_cond_expr_node *new_qpol_cond_expr_node(void){ 5681 SWIG_exception(SWIG_RuntimeError, "Cannot directly create qpol_cond_expr_node_t objects"); 5682 fail: 5683 return NULL; 5684 } 5685 SWIGINTERN void delete_qpol_cond_expr_node(struct qpol_cond_expr_node *self){ 5686 /* no op */ 5687 return; 5688 } 5689 SWIGINTERN int qpol_cond_expr_node_expr_type(struct qpol_cond_expr_node *self,qpol_policy_t *p){ 5690 uint32_t et; 5691 if (qpol_cond_expr_node_get_expr_type(p, self, &et)) { 5692 SWIG_exception(SWIG_ValueError, "Could not get node expression type"); 5693 } 5694 fail: 5695 return (int) et; 5696 } 5697 SWIGINTERN qpol_bool_t *qpol_cond_expr_node_get_boolean(struct qpol_cond_expr_node *self,qpol_policy_t *p){ 5698 uint32_t et; 5699 qpol_bool_t *b = NULL; 5700 qpol_cond_expr_node_get_expr_type(p, self, &et); 5701 if (et != 1) { 5702 SWIG_exception(SWIG_TypeError, "Node does not contain a boolean"); 5703 } else if (qpol_cond_expr_node_get_bool(p, self, &b)) { 5704 SWIG_exception(SWIG_ValueError, "Could not get boolean for node"); 5705 } 5706 fail: 5707 return b; 5708 } 5709 5710 qpol_cond_expr_node_t *qpol_cond_expr_node_from_void(void *x) { 5711 return (qpol_cond_expr_node_t*)x; 5712 }; 5713 5714 SWIGINTERN struct qpol_filename_trans *new_qpol_filename_trans(void){ 5715 SWIG_exception(SWIG_RuntimeError, "Cannot directly create qpol_filename_trans_t objects"); 5716 fail: 5717 return NULL; 5718 } 5719 SWIGINTERN void delete_qpol_filename_trans(struct qpol_filename_trans *self){ 5720 /* no op */ 5721 return; 5722 } 5723 SWIGINTERN qpol_type_t const *qpol_filename_trans_source_type(struct qpol_filename_trans *self,qpol_policy_t *p){ 5724 const qpol_type_t *t; 5725 if (qpol_filename_trans_get_source_type(p, self, &t)) { 5726 SWIG_exception(SWIG_ValueError, "Could not get source for filename transition rule"); 5727 } 5728 fail: 5729 return t; 5730 } 5731 SWIGINTERN qpol_type_t const *qpol_filename_trans_target_type(struct qpol_filename_trans *self,qpol_policy_t *p){ 5732 const qpol_type_t *t; 5733 if (qpol_filename_trans_get_target_type(p, self, &t)) { 5734 SWIG_exception(SWIG_ValueError, "Could not get target for filename transition rule"); } 5735 fail: 5736 return t; 5737 } 5738 SWIGINTERN qpol_class_t const *qpol_filename_trans_object_class(struct qpol_filename_trans *self,qpol_policy_t *p){ 5739 const qpol_class_t *cls; 5740 if (qpol_filename_trans_get_object_class(p, self, &cls)) { 5741 SWIG_exception(SWIG_ValueError, "Could not get class for filename transition rule"); } 5742 fail: 5743 return cls; 5744 } 5745 SWIGINTERN qpol_type_t const *qpol_filename_trans_default_type(struct qpol_filename_trans *self,qpol_policy_t *p){ 5746 const qpol_type_t *t; 5747 if (qpol_filename_trans_get_default_type(p, self, &t)) { 5748 SWIG_exception(SWIG_ValueError, "Could not get default for filename transition rule"); 5749 } 5750 fail: 5751 return t; 5752 } 5753 SWIGINTERN char const *qpol_filename_trans_filename(struct qpol_filename_trans *self,qpol_policy_t *p){ 5754 const char *name; 5755 if (qpol_filename_trans_get_filename(p, self, &name)) { 5756 SWIG_exception(SWIG_ValueError, "Could not get file for filename transition rule"); 5757 } 5758 fail: 5759 return name; 5760 } 5761 5762 qpol_filename_trans_t *qpol_filename_trans_from_void(void *x) { 5763 return (qpol_filename_trans_t*)x; 5764 }; 5765 5766 SWIGINTERN struct qpol_polcap *new_qpol_polcap(void){ 5767 SWIG_exception(SWIG_RuntimeError, "Cannot directly create qpol_polcap_t objects"); 5768 fail: 5769 return NULL; 5770 } 5771 SWIGINTERN void delete_qpol_polcap(struct qpol_polcap *self){ 5772 /* no op */ 5773 return; 5774 } 5775 SWIGINTERN char const *qpol_polcap_name(struct qpol_polcap *self,qpol_policy_t *p){ 5776 const char *name; 5777 if (qpol_polcap_get_name(p, self, &name)) { 5778 SWIG_exception(SWIG_ValueError, "Could not get polcap name rule"); 5779 } 5780 fail: 5781 return name; 5782 } 5783 5784 qpol_polcap_t *qpol_polcap_from_void(void *x) { 5785 return (qpol_polcap_t*)x; 5786 }; 5787 5788 SWIGINTERN struct qpol_typebounds *new_qpol_typebounds(void){ 5789 SWIG_exception(SWIG_RuntimeError, "Cannot directly create qpol_typebounds_t objects"); 5790 fail: 5791 return NULL; 5792 } 5793 SWIGINTERN void delete_qpol_typebounds(struct qpol_typebounds *self){ 5794 /* no op */ 5795 return; 5796 } 5797 SWIGINTERN char const *qpol_typebounds_parent_name(struct qpol_typebounds *self,qpol_policy_t *p){ 5798 const char *name; 5799 if (qpol_typebounds_get_parent_name(p, self, &name)) { 5800 SWIG_exception(SWIG_ValueError, "Could not get parent name"); 5801 } 5802 fail: 5803 return name; 5804 } 5805 SWIGINTERN char const *qpol_typebounds_child_name(struct qpol_typebounds *self,qpol_policy_t *p){ 5806 const char *name; 5807 if (qpol_typebounds_get_child_name(p, self, &name)) { 5808 SWIG_exception(SWIG_ValueError, "Could not get child name"); 5809 } 5810 fail: 5811 return name; 5812 } 5813 5814 qpol_typebounds_t *qpol_typebounds_from_void(void *x) { 5815 return (qpol_typebounds_t*)x; 5816 }; 5817 5818 SWIGINTERN struct qpol_rolebounds *new_qpol_rolebounds(void){ 5819 SWIG_exception(SWIG_RuntimeError, "Cannot directly create qpol_rolebounds_t objects"); 5820 fail: 5821 return NULL; 5822 } 5823 SWIGINTERN void delete_qpol_rolebounds(struct qpol_rolebounds *self){ 5824 /* no op */ 5825 return; 5826 } 5827 SWIGINTERN char const *qpol_rolebounds_parent_name(struct qpol_rolebounds *self,qpol_policy_t *p){ 5828 const char *name; 5829 if (qpol_rolebounds_get_parent_name(p, self, &name)) { 5830 SWIG_exception(SWIG_ValueError, "Could not get parent name"); 5831 } 5832 fail: 5833 return name; 5834 } 5835 SWIGINTERN char const *qpol_rolebounds_child_name(struct qpol_rolebounds *self,qpol_policy_t *p){ 5836 const char *name; 5837 if (qpol_rolebounds_get_child_name(p, self, &name)) { 5838 SWIG_exception(SWIG_ValueError, "Could not get child name"); 5839 } 5840 fail: 5841 return name; 5842 } 5843 5844 qpol_rolebounds_t *qpol_rolebounds_from_void(void *x) { 5845 return (qpol_rolebounds_t*)x; 5846 }; 5847 5848 SWIGINTERN struct qpol_userbounds *new_qpol_userbounds(void){ 5849 SWIG_exception(SWIG_RuntimeError, "Cannot directly create qpol_userbounds_t objects"); 5850 fail: 5851 return NULL; 5852 } 5853 SWIGINTERN void delete_qpol_userbounds(struct qpol_userbounds *self){ 5854 /* no op */ 5855 return; 5856 } 5857 SWIGINTERN char const *qpol_userbounds_parent_name(struct qpol_userbounds *self,qpol_policy_t *p){ 5858 const char *name; 5859 if (qpol_userbounds_get_parent_name(p, self, &name)) { 5860 SWIG_exception(SWIG_ValueError, "Could not get parent name"); 5861 } 5862 fail: 5863 return name; 5864 } 5865 SWIGINTERN char const *qpol_userbounds_child_name(struct qpol_userbounds *self,qpol_policy_t *p){ 5866 const char *name; 5867 if (qpol_userbounds_get_child_name(p, self, &name)) { 5868 SWIG_exception(SWIG_ValueError, "Could not get child name"); 5869 } 5870 fail: 5871 return name; 5872 } 5873 5874 qpol_userbounds_t *qpol_userbounds_from_void(void *x) { 5875 return (qpol_userbounds_t*)x; 5876 }; 5877 5878 SWIGINTERN struct qpol_default_object *new_qpol_default_object(void){ 5879 SWIG_exception(SWIG_RuntimeError, "Cannot directly create qpol_default_object_t objects"); 5880 fail: 5881 return NULL; 5882 } 5883 SWIGINTERN void delete_qpol_default_object(struct qpol_default_object *self){ 5884 /* no op */ 5885 return; 5886 } 5887 SWIGINTERN qpol_class_t const *qpol_default_object_object_class(struct qpol_default_object *self,qpol_policy_t *p){ 5888 const qpol_class_t *cls; 5889 if (qpol_default_object_get_class(p, self, &cls)) { 5890 SWIG_exception(SWIG_ValueError, "Could not get class"); 5891 } 5892 fail: 5893 return cls; 5894 } 5895 SWIGINTERN char const *qpol_default_object_user_default(struct qpol_default_object *self,qpol_policy_t *p){ 5896 const char *value; 5897 if (qpol_default_object_get_user_default(p, self, &value)) { 5898 SWIG_exception(SWIG_ValueError, "Could not get user default"); 5899 } 5900 fail: 5901 return value; 5902 } 5903 SWIGINTERN char const *qpol_default_object_role_default(struct qpol_default_object *self,qpol_policy_t *p){ 5904 const char *value; 5905 if (qpol_default_object_get_role_default(p, self, &value)) { 5906 SWIG_exception(SWIG_ValueError, "Could not get role default"); 5907 } 5908 fail: 5909 return value; 5910 } 5911 SWIGINTERN char const *qpol_default_object_type_default(struct qpol_default_object *self,qpol_policy_t *p){ 5912 const char *value; 5913 if (qpol_default_object_get_type_default(p, self, &value)) { 5914 SWIG_exception(SWIG_ValueError, "Could not get type default"); 5915 } 5916 fail: 5917 return value; 5918 } 5919 SWIGINTERN char const *qpol_default_object_range_default(struct qpol_default_object *self,qpol_policy_t *p){ 5920 const char *value; 5921 if (qpol_default_object_get_range_default(p, self, &value)) { 5922 SWIG_exception(SWIG_ValueError, "Could not get range defaults"); 5923 } 5924 fail: 5925 return value; 5926 } 5927 5928 qpol_default_object_t *qpol_default_object_from_void(void *x) { 5929 return (qpol_default_object_t*)x; 5930 }; 5931 5932 5933 SWIGINTERN int 5934 SWIG_AsVal_unsigned_SS_long_SS_long (PyObject *obj, unsigned long long *val) 5935 { 5936 int res = SWIG_TypeError; 5937 if (PyLong_Check(obj)) { 5938 unsigned long long v = PyLong_AsUnsignedLongLong(obj); 5939 if (!PyErr_Occurred()) { 5940 if (val) *val = v; 5941 return SWIG_OK; 5942 } else { 5943 PyErr_Clear(); 5944 } 5945 } else { 5946 unsigned long v; 5947 res = SWIG_AsVal_unsigned_SS_long (obj,&v); 5948 if (SWIG_IsOK(res)) { 5949 if (val) *val = v; 5950 return res; 5951 } 5952 } 5953 #ifdef SWIG_PYTHON_CAST_MODE 5954 { 5955 const double mant_max = 1LL << DBL_MANT_DIG; 5956 double d; 5957 res = SWIG_AsVal_double (obj,&d); 5958 if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, mant_max)) { 5959 if (val) *val = (unsigned long long)(d); 5960 return SWIG_AddCast(res); 5961 } 5962 res = SWIG_TypeError; 5963 } 5964 #endif 5965 return res; 5966 } 5967 5968 SWIGINTERN struct qpol_iomemcon *new_qpol_iomemcon(qpol_policy_t *p,uint64_t low,uint64_t high){ 5969 const qpol_iomemcon_t *qp; 5970 if (qpol_policy_get_iomemcon_by_addr(p, low, high, &qp)) { 5971 SWIG_exception(SWIG_RuntimeError, "iomemcon statement does not exist"); 5972 } 5973 fail: 5974 return (qpol_iomemcon_t*)qp; 5975 } 5976 SWIGINTERN void delete_qpol_iomemcon(struct qpol_iomemcon *self){ 5977 /* no op */ 5978 return; 5979 } 5980 SWIGINTERN uint64_t qpol_iomemcon_low_addr(struct qpol_iomemcon *self,qpol_policy_t *p){ 5981 uint64_t addr = 0; 5982 if(qpol_iomemcon_get_low_addr(p, self, &addr)) { 5983 SWIG_exception(SWIG_RuntimeError, "Could not get low addr for iomemcon statement"); 5984 } 5985 fail: 5986 return addr; 5987 } 5988 5989 SWIGINTERNINLINE PyObject* 5990 SWIG_From_long_SS_long (long long value) 5991 { 5992 return ((value < LONG_MIN) || (value > LONG_MAX)) ? 5993 PyLong_FromLongLong(value) : PyLong_FromLong((long)(value)); 5994 } 5995 5996 5997 SWIGINTERNINLINE PyObject* 5998 SWIG_From_unsigned_SS_long_SS_long (unsigned long long value) 5999 { 6000 return (value > LONG_MAX) ? 6001 PyLong_FromUnsignedLongLong(value) : PyLong_FromLong((long)(value)); 6002 } 6003 6004 SWIGINTERN uint64_t qpol_iomemcon_high_addr(struct qpol_iomemcon *self,qpol_policy_t *p){ 6005 uint64_t addr = 0; 6006 if(qpol_iomemcon_get_high_addr(p, self, &addr)) { 6007 SWIG_exception(SWIG_RuntimeError, "Could not get high addr for iomemcon statement"); 6008 } 6009 fail: 6010 return addr; 6011 } 6012 SWIGINTERN qpol_context_t const *qpol_iomemcon_context(struct qpol_iomemcon *self,qpol_policy_t *p){ 6013 const qpol_context_t *ctx; 6014 if (qpol_iomemcon_get_context(p, self, &ctx)) { 6015 SWIG_exception(SWIG_ValueError, "Could not get context for iomemcon statement"); 6016 } 6017 fail: 6018 return ctx; 6019 } 6020 6021 qpol_iomemcon_t *qpol_iomemcon_from_void(void *x) { 6022 return (qpol_iomemcon_t*)x; 6023 }; 6024 6025 6026 SWIGINTERN int 6027 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val) 6028 { 6029 unsigned long v; 6030 int res = SWIG_AsVal_unsigned_SS_long (obj, &v); 6031 if (SWIG_IsOK(res)) { 6032 if ((v > UINT_MAX)) { 6033 return SWIG_OverflowError; 6034 } else { 6035 if (val) *val = (unsigned int)(v); 6036 } 6037 } 6038 return res; 6039 } 6040 6041 SWIGINTERN struct qpol_ioportcon *new_qpol_ioportcon(qpol_policy_t *p,uint32_t low,uint32_t high){ 6042 const qpol_ioportcon_t *qp; 6043 if (qpol_policy_get_ioportcon_by_port(p, low, high, &qp)) { 6044 SWIG_exception(SWIG_RuntimeError, "ioportcon statement does not exist"); 6045 } 6046 fail: 6047 return (qpol_ioportcon_t*)qp; 6048 } 6049 SWIGINTERN void delete_qpol_ioportcon(struct qpol_ioportcon *self){ 6050 /* no op */ 6051 return; 6052 } 6053 SWIGINTERN uint32_t qpol_ioportcon_low_port(struct qpol_ioportcon *self,qpol_policy_t *p){ 6054 uint32_t port = 0; 6055 if(qpol_ioportcon_get_low_port(p, self, &port)) { 6056 SWIG_exception(SWIG_RuntimeError, "Could not get low port for ioportcon statement"); 6057 } 6058 fail: 6059 return port; 6060 } 6061 SWIGINTERN uint32_t qpol_ioportcon_high_port(struct qpol_ioportcon *self,qpol_policy_t *p){ 6062 uint32_t port = 0; 6063 if(qpol_ioportcon_get_high_port(p, self, &port)) { 6064 SWIG_exception(SWIG_RuntimeError, "Could not get high port for ioportcon statement"); 6065 } 6066 fail: 6067 return port; 6068 } 6069 SWIGINTERN qpol_context_t const *qpol_ioportcon_context(struct qpol_ioportcon *self,qpol_policy_t *p){ 6070 const qpol_context_t *ctx; 6071 if (qpol_ioportcon_get_context(p, self, &ctx)) { 6072 SWIG_exception(SWIG_ValueError, "Could not get context for ioportcon statement"); 6073 } 6074 fail: 6075 return ctx; 6076 } 6077 6078 qpol_ioportcon_t *qpol_ioportcon_from_void(void *x) { 6079 return (qpol_ioportcon_t*)x; 6080 }; 6081 6082 SWIGINTERN struct qpol_pcidevicecon *new_qpol_pcidevicecon(void){ 6083 SWIG_exception(SWIG_RuntimeError, "pcidevicecon statement does not exist"); 6084 fail: 6085 return NULL; 6086 } 6087 SWIGINTERN void delete_qpol_pcidevicecon(struct qpol_pcidevicecon *self){ 6088 return; 6089 } 6090 SWIGINTERN uint32_t qpol_pcidevicecon_device(struct qpol_pcidevicecon *self,qpol_policy_t *p){ 6091 uint32_t device = 0; 6092 if(qpol_pcidevicecon_get_device(p, self, &device)) { 6093 SWIG_exception(SWIG_RuntimeError, "Could not get device for pcidevicecon statement"); 6094 } 6095 fail: 6096 return device; 6097 } 6098 SWIGINTERN qpol_context_t const *qpol_pcidevicecon_context(struct qpol_pcidevicecon *self,qpol_policy_t *p){ 6099 const qpol_context_t *ctx; 6100 if (qpol_pcidevicecon_get_context(p, self, &ctx)) { 6101 SWIG_exception(SWIG_ValueError, "Could not get context for pcidevicecon statement"); 6102 } 6103 fail: 6104 return ctx; 6105 } 6106 6107 qpol_pcidevicecon_t *qpol_pcidevicecon_from_void(void *x) { 6108 return (qpol_pcidevicecon_t*)x; 6109 }; 6110 6111 SWIGINTERN struct qpol_pirqcon *new_qpol_pirqcon(void){ 6112 SWIG_exception(SWIG_RuntimeError, "pirqcon statement does not exist"); 6113 fail: 6114 return NULL; 6115 } 6116 SWIGINTERN void delete_qpol_pirqcon(struct qpol_pirqcon *self){ 6117 return; 6118 } 6119 SWIGINTERN uint32_t qpol_pirqcon_irq(struct qpol_pirqcon *self,qpol_policy_t *p){ 6120 uint16_t irq = 0; 6121 if(qpol_pirqcon_get_irq(p, self, &irq)) { 6122 SWIG_exception(SWIG_RuntimeError, "Could not get irq for pirqcon statement"); 6123 } 6124 fail: 6125 return irq; 6126 } 6127 SWIGINTERN qpol_context_t const *qpol_pirqcon_context(struct qpol_pirqcon *self,qpol_policy_t *p){ 6128 const qpol_context_t *ctx; 6129 if (qpol_pirqcon_get_context(p, self, &ctx)) { 6130 SWIG_exception(SWIG_ValueError, "Could not get context for pirqcon statement"); 6131 } 6132 fail: 6133 return ctx; 6134 } 6135 6136 qpol_pirqcon_t *qpol_pirqcon_from_void(void *x) { 6137 return (qpol_pirqcon_t*)x; 6138 }; 6139 6140 SWIGINTERN struct qpol_devicetreecon *new_qpol_devicetreecon(void){ 6141 6142 SWIG_exception(SWIG_RuntimeError, "devicetreecon statement does not exist"); 6143 6144 fail: 6145 return NULL; 6146 } 6147 SWIGINTERN char *qpol_devicetreecon_path(struct qpol_devicetreecon *self,qpol_policy_t *p){ 6148 char *path = NULL; 6149 if(qpol_devicetreecon_get_path(p, self, &path)) { 6150 SWIG_exception(SWIG_RuntimeError, "Could not get path for devicetreecon statement"); 6151 } 6152 fail: 6153 return path; 6154 } 6155 SWIGINTERN qpol_context_t const *qpol_devicetreecon_context(struct qpol_devicetreecon *self,qpol_policy_t *p){ 6156 const qpol_context_t *ctx; 6157 if (qpol_devicetreecon_get_context(p, self, &ctx)) { 6158 SWIG_exception(SWIG_ValueError, "Could not get context for devicetreecon statement"); 6159 } 6160 fail: 6161 return ctx; 6162 } 6163 6164 qpol_devicetreecon_t *qpol_devicetreecon_from_void(void *x) { 6165 return (qpol_devicetreecon_t*)x; 6166 }; 6167 6168 #ifdef __cplusplus 6169 extern "C" { 6170 #endif 6171 SWIGINTERN PyObject *_wrap_to_str(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 6172 PyObject *resultobj = 0; 6173 void *arg1 = (void *) 0 ; 6174 int res1 ; 6175 PyObject * obj0 = 0 ; 6176 char *result = 0 ; 6177 6178 if (!PyArg_ParseTuple(args,(char *)"O:to_str",&obj0)) SWIG_fail; 6179 res1 = SWIG_ConvertPtr(obj0,SWIG_as_voidptrptr(&arg1), 0, 0); 6180 if (!SWIG_IsOK(res1)) { 6181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "to_str" "', argument " "1"" of type '" "void *""'"); 6182 } 6183 result = (char *)to_str(arg1); 6184 resultobj = SWIG_FromCharPtr((const char *)result); 6185 return resultobj; 6186 fail: 6187 return NULL; 6188 } 6189 6190 6191 SWIGINTERN PyObject *_wrap_to_int_with_free(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 6192 PyObject *resultobj = 0; 6193 void *arg1 = (void *) 0 ; 6194 int res1 ; 6195 PyObject * obj0 = 0 ; 6196 int result; 6197 6198 if (!PyArg_ParseTuple(args,(char *)"O:to_int_with_free",&obj0)) SWIG_fail; 6199 res1 = SWIG_ConvertPtr(obj0,SWIG_as_voidptrptr(&arg1), 0, 0); 6200 if (!SWIG_IsOK(res1)) { 6201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "to_int_with_free" "', argument " "1"" of type '" "void *""'"); 6202 } 6203 result = (int)to_int_with_free(arg1); 6204 resultobj = SWIG_From_int((int)(result)); 6205 return resultobj; 6206 fail: 6207 return NULL; 6208 } 6209 6210 6211 SWIGINTERN PyObject *_wrap_new_qpol_policy_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 6212 PyObject *resultobj = 0; 6213 char *arg1 = (char *) 0 ; 6214 int arg2 ; 6215 PyObject *arg3 = (PyObject *) 0 ; 6216 int res1 ; 6217 char *buf1 = 0 ; 6218 int alloc1 = 0 ; 6219 int val2 ; 6220 int ecode2 = 0 ; 6221 PyObject * obj0 = 0 ; 6222 PyObject * obj1 = 0 ; 6223 PyObject * obj2 = 0 ; 6224 struct qpol_policy *result = 0 ; 6225 6226 if (!PyArg_ParseTuple(args,(char *)"OOO:new_qpol_policy_t",&obj0,&obj1,&obj2)) SWIG_fail; 6227 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); 6228 if (!SWIG_IsOK(res1)) { 6229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_qpol_policy_t" "', argument " "1"" of type '" "char const *""'"); 6230 } 6231 arg1 = (char *)(buf1); 6232 ecode2 = SWIG_AsVal_int(obj1, &val2); 6233 if (!SWIG_IsOK(ecode2)) { 6234 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_qpol_policy_t" "', argument " "2"" of type '" "int""'"); 6235 } 6236 arg2 = (int)(val2); 6237 arg3 = obj2; 6238 { 6239 result = (struct qpol_policy *)new_qpol_policy((char const *)arg1,arg2,arg3); 6240 if (!result) { 6241 if (errno == EINVAL) { 6242 PyErr_SetString(PyExc_SyntaxError, "Invalid policy."); 6243 } else { 6244 PyErr_SetFromErrnoWithFilename(PyExc_OSError, arg1); 6245 } 6246 return NULL; 6247 } 6248 } 6249 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_policy, SWIG_POINTER_NEW | 0 ); 6250 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); 6251 return resultobj; 6252 fail: 6253 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); 6254 return NULL; 6255 } 6256 6257 6258 SWIGINTERN PyObject *_wrap_delete_qpol_policy_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 6259 PyObject *resultobj = 0; 6260 struct qpol_policy *arg1 = (struct qpol_policy *) 0 ; 6261 void *argp1 = 0 ; 6262 int res1 = 0 ; 6263 PyObject * obj0 = 0 ; 6264 6265 if (!PyArg_ParseTuple(args,(char *)"O:delete_qpol_policy_t",&obj0)) SWIG_fail; 6266 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_policy, SWIG_POINTER_DISOWN | 0 ); 6267 if (!SWIG_IsOK(res1)) { 6268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_qpol_policy_t" "', argument " "1"" of type '" "struct qpol_policy *""'"); 6269 } 6270 arg1 = (struct qpol_policy *)(argp1); 6271 delete_qpol_policy(arg1); 6272 resultobj = SWIG_Py_Void(); 6273 return resultobj; 6274 fail: 6275 return NULL; 6276 } 6277 6278 6279 SWIGINTERN PyObject *_wrap_qpol_policy_t_version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 6280 PyObject *resultobj = 0; 6281 struct qpol_policy *arg1 = (struct qpol_policy *) 0 ; 6282 void *argp1 = 0 ; 6283 int res1 = 0 ; 6284 PyObject * obj0 = 0 ; 6285 int result; 6286 6287 if (!PyArg_ParseTuple(args,(char *)"O:qpol_policy_t_version",&obj0)) SWIG_fail; 6288 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_policy, 0 | 0 ); 6289 if (!SWIG_IsOK(res1)) { 6290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_policy_t_version" "', argument " "1"" of type '" "struct qpol_policy *""'"); 6291 } 6292 arg1 = (struct qpol_policy *)(argp1); 6293 result = (int)qpol_policy_version(arg1); 6294 resultobj = SWIG_From_int((int)(result)); 6295 return resultobj; 6296 fail: 6297 return NULL; 6298 } 6299 6300 6301 SWIGINTERN PyObject *_wrap_qpol_policy_t_handle_unknown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 6302 PyObject *resultobj = 0; 6303 struct qpol_policy *arg1 = (struct qpol_policy *) 0 ; 6304 void *argp1 = 0 ; 6305 int res1 = 0 ; 6306 PyObject * obj0 = 0 ; 6307 char *result = 0 ; 6308 6309 if (!PyArg_ParseTuple(args,(char *)"O:qpol_policy_t_handle_unknown",&obj0)) SWIG_fail; 6310 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_policy, 0 | 0 ); 6311 if (!SWIG_IsOK(res1)) { 6312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_policy_t_handle_unknown" "', argument " "1"" of type '" "struct qpol_policy *""'"); 6313 } 6314 arg1 = (struct qpol_policy *)(argp1); 6315 result = (char *)qpol_policy_handle_unknown(arg1); 6316 resultobj = SWIG_FromCharPtr((const char *)result); 6317 return resultobj; 6318 fail: 6319 return NULL; 6320 } 6321 6322 6323 SWIGINTERN PyObject *_wrap_qpol_policy_t_target_platform(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 6324 PyObject *resultobj = 0; 6325 struct qpol_policy *arg1 = (struct qpol_policy *) 0 ; 6326 void *argp1 = 0 ; 6327 int res1 = 0 ; 6328 PyObject * obj0 = 0 ; 6329 char *result = 0 ; 6330 6331 if (!PyArg_ParseTuple(args,(char *)"O:qpol_policy_t_target_platform",&obj0)) SWIG_fail; 6332 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_policy, 0 | 0 ); 6333 if (!SWIG_IsOK(res1)) { 6334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_policy_t_target_platform" "', argument " "1"" of type '" "struct qpol_policy *""'"); 6335 } 6336 arg1 = (struct qpol_policy *)(argp1); 6337 result = (char *)qpol_policy_target_platform(arg1); 6338 resultobj = SWIG_FromCharPtr((const char *)result); 6339 return resultobj; 6340 fail: 6341 return NULL; 6342 } 6343 6344 6345 SWIGINTERN PyObject *_wrap_qpol_policy_t_capability(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 6346 PyObject *resultobj = 0; 6347 struct qpol_policy *arg1 = (struct qpol_policy *) 0 ; 6348 qpol_capability_e arg2 ; 6349 void *argp1 = 0 ; 6350 int res1 = 0 ; 6351 int val2 ; 6352 int ecode2 = 0 ; 6353 PyObject * obj0 = 0 ; 6354 PyObject * obj1 = 0 ; 6355 int result; 6356 6357 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_policy_t_capability",&obj0,&obj1)) SWIG_fail; 6358 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_policy, 0 | 0 ); 6359 if (!SWIG_IsOK(res1)) { 6360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_policy_t_capability" "', argument " "1"" of type '" "struct qpol_policy *""'"); 6361 } 6362 arg1 = (struct qpol_policy *)(argp1); 6363 ecode2 = SWIG_AsVal_int(obj1, &val2); 6364 if (!SWIG_IsOK(ecode2)) { 6365 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "qpol_policy_t_capability" "', argument " "2"" of type '" "qpol_capability_e""'"); 6366 } 6367 arg2 = (qpol_capability_e)(val2); 6368 result = (int)qpol_policy_capability(arg1,arg2); 6369 resultobj = SWIG_From_int((int)(result)); 6370 return resultobj; 6371 fail: 6372 return NULL; 6373 } 6374 6375 6376 SWIGINTERN PyObject *_wrap_qpol_policy_t_type_iter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 6377 PyObject *resultobj = 0; 6378 struct qpol_policy *arg1 = (struct qpol_policy *) 0 ; 6379 void *argp1 = 0 ; 6380 int res1 = 0 ; 6381 PyObject * obj0 = 0 ; 6382 qpol_iterator_t *result = 0 ; 6383 6384 if (!PyArg_ParseTuple(args,(char *)"O:qpol_policy_t_type_iter",&obj0)) SWIG_fail; 6385 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_policy, 0 | 0 ); 6386 if (!SWIG_IsOK(res1)) { 6387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_policy_t_type_iter" "', argument " "1"" of type '" "struct qpol_policy *""'"); 6388 } 6389 arg1 = (struct qpol_policy *)(argp1); 6390 result = (qpol_iterator_t *)qpol_policy_type_iter(arg1); 6391 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_iterator, SWIG_POINTER_OWN | 0 ); 6392 return resultobj; 6393 fail: 6394 return NULL; 6395 } 6396 6397 6398 SWIGINTERN PyObject *_wrap_qpol_policy_t_type_count(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 6399 PyObject *resultobj = 0; 6400 struct qpol_policy *arg1 = (struct qpol_policy *) 0 ; 6401 void *argp1 = 0 ; 6402 int res1 = 0 ; 6403 PyObject * obj0 = 0 ; 6404 size_t result; 6405 6406 if (!PyArg_ParseTuple(args,(char *)"O:qpol_policy_t_type_count",&obj0)) SWIG_fail; 6407 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_policy, 0 | 0 ); 6408 if (!SWIG_IsOK(res1)) { 6409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_policy_t_type_count" "', argument " "1"" of type '" "struct qpol_policy *""'"); 6410 } 6411 arg1 = (struct qpol_policy *)(argp1); 6412 result = (size_t)qpol_policy_type_count(arg1); 6413 resultobj = SWIG_From_size_t((size_t)(result)); 6414 return resultobj; 6415 fail: 6416 return NULL; 6417 } 6418 6419 6420 SWIGINTERN PyObject *_wrap_qpol_policy_t_role_iter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 6421 PyObject *resultobj = 0; 6422 struct qpol_policy *arg1 = (struct qpol_policy *) 0 ; 6423 void *argp1 = 0 ; 6424 int res1 = 0 ; 6425 PyObject * obj0 = 0 ; 6426 qpol_iterator_t *result = 0 ; 6427 6428 if (!PyArg_ParseTuple(args,(char *)"O:qpol_policy_t_role_iter",&obj0)) SWIG_fail; 6429 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_policy, 0 | 0 ); 6430 if (!SWIG_IsOK(res1)) { 6431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_policy_t_role_iter" "', argument " "1"" of type '" "struct qpol_policy *""'"); 6432 } 6433 arg1 = (struct qpol_policy *)(argp1); 6434 result = (qpol_iterator_t *)qpol_policy_role_iter(arg1); 6435 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_iterator, SWIG_POINTER_OWN | 0 ); 6436 return resultobj; 6437 fail: 6438 return NULL; 6439 } 6440 6441 6442 SWIGINTERN PyObject *_wrap_qpol_policy_t_role_count(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 6443 PyObject *resultobj = 0; 6444 struct qpol_policy *arg1 = (struct qpol_policy *) 0 ; 6445 void *argp1 = 0 ; 6446 int res1 = 0 ; 6447 PyObject * obj0 = 0 ; 6448 size_t result; 6449 6450 if (!PyArg_ParseTuple(args,(char *)"O:qpol_policy_t_role_count",&obj0)) SWIG_fail; 6451 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_policy, 0 | 0 ); 6452 if (!SWIG_IsOK(res1)) { 6453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_policy_t_role_count" "', argument " "1"" of type '" "struct qpol_policy *""'"); 6454 } 6455 arg1 = (struct qpol_policy *)(argp1); 6456 result = (size_t)qpol_policy_role_count(arg1); 6457 resultobj = SWIG_From_size_t((size_t)(result)); 6458 return resultobj; 6459 fail: 6460 return NULL; 6461 } 6462 6463 6464 SWIGINTERN PyObject *_wrap_qpol_policy_t_level_iter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 6465 PyObject *resultobj = 0; 6466 struct qpol_policy *arg1 = (struct qpol_policy *) 0 ; 6467 void *argp1 = 0 ; 6468 int res1 = 0 ; 6469 PyObject * obj0 = 0 ; 6470 qpol_iterator_t *result = 0 ; 6471 6472 if (!PyArg_ParseTuple(args,(char *)"O:qpol_policy_t_level_iter",&obj0)) SWIG_fail; 6473 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_policy, 0 | 0 ); 6474 if (!SWIG_IsOK(res1)) { 6475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_policy_t_level_iter" "', argument " "1"" of type '" "struct qpol_policy *""'"); 6476 } 6477 arg1 = (struct qpol_policy *)(argp1); 6478 result = (qpol_iterator_t *)qpol_policy_level_iter(arg1); 6479 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_iterator, SWIG_POINTER_OWN | 0 ); 6480 return resultobj; 6481 fail: 6482 return NULL; 6483 } 6484 6485 6486 SWIGINTERN PyObject *_wrap_qpol_policy_t_level_count(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 6487 PyObject *resultobj = 0; 6488 struct qpol_policy *arg1 = (struct qpol_policy *) 0 ; 6489 void *argp1 = 0 ; 6490 int res1 = 0 ; 6491 PyObject * obj0 = 0 ; 6492 size_t result; 6493 6494 if (!PyArg_ParseTuple(args,(char *)"O:qpol_policy_t_level_count",&obj0)) SWIG_fail; 6495 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_policy, 0 | 0 ); 6496 if (!SWIG_IsOK(res1)) { 6497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_policy_t_level_count" "', argument " "1"" of type '" "struct qpol_policy *""'"); 6498 } 6499 arg1 = (struct qpol_policy *)(argp1); 6500 result = (size_t)qpol_policy_level_count(arg1); 6501 resultobj = SWIG_From_size_t((size_t)(result)); 6502 return resultobj; 6503 fail: 6504 return NULL; 6505 } 6506 6507 6508 SWIGINTERN PyObject *_wrap_qpol_policy_t_cat_iter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 6509 PyObject *resultobj = 0; 6510 struct qpol_policy *arg1 = (struct qpol_policy *) 0 ; 6511 void *argp1 = 0 ; 6512 int res1 = 0 ; 6513 PyObject * obj0 = 0 ; 6514 qpol_iterator_t *result = 0 ; 6515 6516 if (!PyArg_ParseTuple(args,(char *)"O:qpol_policy_t_cat_iter",&obj0)) SWIG_fail; 6517 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_policy, 0 | 0 ); 6518 if (!SWIG_IsOK(res1)) { 6519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_policy_t_cat_iter" "', argument " "1"" of type '" "struct qpol_policy *""'"); 6520 } 6521 arg1 = (struct qpol_policy *)(argp1); 6522 result = (qpol_iterator_t *)qpol_policy_cat_iter(arg1); 6523 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_iterator, SWIG_POINTER_OWN | 0 ); 6524 return resultobj; 6525 fail: 6526 return NULL; 6527 } 6528 6529 6530 SWIGINTERN PyObject *_wrap_qpol_policy_t_cat_count(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 6531 PyObject *resultobj = 0; 6532 struct qpol_policy *arg1 = (struct qpol_policy *) 0 ; 6533 void *argp1 = 0 ; 6534 int res1 = 0 ; 6535 PyObject * obj0 = 0 ; 6536 size_t result; 6537 6538 if (!PyArg_ParseTuple(args,(char *)"O:qpol_policy_t_cat_count",&obj0)) SWIG_fail; 6539 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_policy, 0 | 0 ); 6540 if (!SWIG_IsOK(res1)) { 6541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_policy_t_cat_count" "', argument " "1"" of type '" "struct qpol_policy *""'"); 6542 } 6543 arg1 = (struct qpol_policy *)(argp1); 6544 result = (size_t)qpol_policy_cat_count(arg1); 6545 resultobj = SWIG_From_size_t((size_t)(result)); 6546 return resultobj; 6547 fail: 6548 return NULL; 6549 } 6550 6551 6552 SWIGINTERN PyObject *_wrap_qpol_policy_t_user_iter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 6553 PyObject *resultobj = 0; 6554 struct qpol_policy *arg1 = (struct qpol_policy *) 0 ; 6555 void *argp1 = 0 ; 6556 int res1 = 0 ; 6557 PyObject * obj0 = 0 ; 6558 qpol_iterator_t *result = 0 ; 6559 6560 if (!PyArg_ParseTuple(args,(char *)"O:qpol_policy_t_user_iter",&obj0)) SWIG_fail; 6561 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_policy, 0 | 0 ); 6562 if (!SWIG_IsOK(res1)) { 6563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_policy_t_user_iter" "', argument " "1"" of type '" "struct qpol_policy *""'"); 6564 } 6565 arg1 = (struct qpol_policy *)(argp1); 6566 result = (qpol_iterator_t *)qpol_policy_user_iter(arg1); 6567 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_iterator, SWIG_POINTER_OWN | 0 ); 6568 return resultobj; 6569 fail: 6570 return NULL; 6571 } 6572 6573 6574 SWIGINTERN PyObject *_wrap_qpol_policy_t_user_count(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 6575 PyObject *resultobj = 0; 6576 struct qpol_policy *arg1 = (struct qpol_policy *) 0 ; 6577 void *argp1 = 0 ; 6578 int res1 = 0 ; 6579 PyObject * obj0 = 0 ; 6580 size_t result; 6581 6582 if (!PyArg_ParseTuple(args,(char *)"O:qpol_policy_t_user_count",&obj0)) SWIG_fail; 6583 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_policy, 0 | 0 ); 6584 if (!SWIG_IsOK(res1)) { 6585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_policy_t_user_count" "', argument " "1"" of type '" "struct qpol_policy *""'"); 6586 } 6587 arg1 = (struct qpol_policy *)(argp1); 6588 result = (size_t)qpol_policy_user_count(arg1); 6589 resultobj = SWIG_From_size_t((size_t)(result)); 6590 return resultobj; 6591 fail: 6592 return NULL; 6593 } 6594 6595 6596 SWIGINTERN PyObject *_wrap_qpol_policy_t_bool_iter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 6597 PyObject *resultobj = 0; 6598 struct qpol_policy *arg1 = (struct qpol_policy *) 0 ; 6599 void *argp1 = 0 ; 6600 int res1 = 0 ; 6601 PyObject * obj0 = 0 ; 6602 qpol_iterator_t *result = 0 ; 6603 6604 if (!PyArg_ParseTuple(args,(char *)"O:qpol_policy_t_bool_iter",&obj0)) SWIG_fail; 6605 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_policy, 0 | 0 ); 6606 if (!SWIG_IsOK(res1)) { 6607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_policy_t_bool_iter" "', argument " "1"" of type '" "struct qpol_policy *""'"); 6608 } 6609 arg1 = (struct qpol_policy *)(argp1); 6610 result = (qpol_iterator_t *)qpol_policy_bool_iter(arg1); 6611 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_iterator, SWIG_POINTER_OWN | 0 ); 6612 return resultobj; 6613 fail: 6614 return NULL; 6615 } 6616 6617 6618 SWIGINTERN PyObject *_wrap_qpol_policy_t_bool_count(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 6619 PyObject *resultobj = 0; 6620 struct qpol_policy *arg1 = (struct qpol_policy *) 0 ; 6621 void *argp1 = 0 ; 6622 int res1 = 0 ; 6623 PyObject * obj0 = 0 ; 6624 size_t result; 6625 6626 if (!PyArg_ParseTuple(args,(char *)"O:qpol_policy_t_bool_count",&obj0)) SWIG_fail; 6627 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_policy, 0 | 0 ); 6628 if (!SWIG_IsOK(res1)) { 6629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_policy_t_bool_count" "', argument " "1"" of type '" "struct qpol_policy *""'"); 6630 } 6631 arg1 = (struct qpol_policy *)(argp1); 6632 result = (size_t)qpol_policy_bool_count(arg1); 6633 resultobj = SWIG_From_size_t((size_t)(result)); 6634 return resultobj; 6635 fail: 6636 return NULL; 6637 } 6638 6639 6640 SWIGINTERN PyObject *_wrap_qpol_policy_t_class_iter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 6641 PyObject *resultobj = 0; 6642 struct qpol_policy *arg1 = (struct qpol_policy *) 0 ; 6643 char *arg2 = (char *) NULL ; 6644 void *argp1 = 0 ; 6645 int res1 = 0 ; 6646 int res2 ; 6647 char *buf2 = 0 ; 6648 int alloc2 = 0 ; 6649 PyObject * obj0 = 0 ; 6650 PyObject * obj1 = 0 ; 6651 qpol_iterator_t *result = 0 ; 6652 6653 if (!PyArg_ParseTuple(args,(char *)"O|O:qpol_policy_t_class_iter",&obj0,&obj1)) SWIG_fail; 6654 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_policy, 0 | 0 ); 6655 if (!SWIG_IsOK(res1)) { 6656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_policy_t_class_iter" "', argument " "1"" of type '" "struct qpol_policy *""'"); 6657 } 6658 arg1 = (struct qpol_policy *)(argp1); 6659 if (obj1) { 6660 res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); 6661 if (!SWIG_IsOK(res2)) { 6662 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_policy_t_class_iter" "', argument " "2"" of type '" "char *""'"); 6663 } 6664 arg2 = (char *)(buf2); 6665 } 6666 result = (qpol_iterator_t *)qpol_policy_class_iter(arg1,arg2); 6667 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_iterator, SWIG_POINTER_OWN | 0 ); 6668 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); 6669 return resultobj; 6670 fail: 6671 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); 6672 return NULL; 6673 } 6674 6675 6676 SWIGINTERN PyObject *_wrap_qpol_policy_t_class_count(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 6677 PyObject *resultobj = 0; 6678 struct qpol_policy *arg1 = (struct qpol_policy *) 0 ; 6679 void *argp1 = 0 ; 6680 int res1 = 0 ; 6681 PyObject * obj0 = 0 ; 6682 size_t result; 6683 6684 if (!PyArg_ParseTuple(args,(char *)"O:qpol_policy_t_class_count",&obj0)) SWIG_fail; 6685 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_policy, 0 | 0 ); 6686 if (!SWIG_IsOK(res1)) { 6687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_policy_t_class_count" "', argument " "1"" of type '" "struct qpol_policy *""'"); 6688 } 6689 arg1 = (struct qpol_policy *)(argp1); 6690 result = (size_t)qpol_policy_class_count(arg1); 6691 resultobj = SWIG_From_size_t((size_t)(result)); 6692 return resultobj; 6693 fail: 6694 return NULL; 6695 } 6696 6697 6698 SWIGINTERN PyObject *_wrap_qpol_policy_t_common_iter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 6699 PyObject *resultobj = 0; 6700 struct qpol_policy *arg1 = (struct qpol_policy *) 0 ; 6701 char *arg2 = (char *) NULL ; 6702 void *argp1 = 0 ; 6703 int res1 = 0 ; 6704 int res2 ; 6705 char *buf2 = 0 ; 6706 int alloc2 = 0 ; 6707 PyObject * obj0 = 0 ; 6708 PyObject * obj1 = 0 ; 6709 qpol_iterator_t *result = 0 ; 6710 6711 if (!PyArg_ParseTuple(args,(char *)"O|O:qpol_policy_t_common_iter",&obj0,&obj1)) SWIG_fail; 6712 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_policy, 0 | 0 ); 6713 if (!SWIG_IsOK(res1)) { 6714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_policy_t_common_iter" "', argument " "1"" of type '" "struct qpol_policy *""'"); 6715 } 6716 arg1 = (struct qpol_policy *)(argp1); 6717 if (obj1) { 6718 res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); 6719 if (!SWIG_IsOK(res2)) { 6720 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_policy_t_common_iter" "', argument " "2"" of type '" "char *""'"); 6721 } 6722 arg2 = (char *)(buf2); 6723 } 6724 result = (qpol_iterator_t *)qpol_policy_common_iter(arg1,arg2); 6725 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_iterator, SWIG_POINTER_OWN | 0 ); 6726 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); 6727 return resultobj; 6728 fail: 6729 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); 6730 return NULL; 6731 } 6732 6733 6734 SWIGINTERN PyObject *_wrap_qpol_policy_t_common_count(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 6735 PyObject *resultobj = 0; 6736 struct qpol_policy *arg1 = (struct qpol_policy *) 0 ; 6737 void *argp1 = 0 ; 6738 int res1 = 0 ; 6739 PyObject * obj0 = 0 ; 6740 size_t result; 6741 6742 if (!PyArg_ParseTuple(args,(char *)"O:qpol_policy_t_common_count",&obj0)) SWIG_fail; 6743 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_policy, 0 | 0 ); 6744 if (!SWIG_IsOK(res1)) { 6745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_policy_t_common_count" "', argument " "1"" of type '" "struct qpol_policy *""'"); 6746 } 6747 arg1 = (struct qpol_policy *)(argp1); 6748 result = (size_t)qpol_policy_common_count(arg1); 6749 resultobj = SWIG_From_size_t((size_t)(result)); 6750 return resultobj; 6751 fail: 6752 return NULL; 6753 } 6754 6755 6756 SWIGINTERN PyObject *_wrap_qpol_policy_t_fs_use_iter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 6757 PyObject *resultobj = 0; 6758 struct qpol_policy *arg1 = (struct qpol_policy *) 0 ; 6759 void *argp1 = 0 ; 6760 int res1 = 0 ; 6761 PyObject * obj0 = 0 ; 6762 qpol_iterator_t *result = 0 ; 6763 6764 if (!PyArg_ParseTuple(args,(char *)"O:qpol_policy_t_fs_use_iter",&obj0)) SWIG_fail; 6765 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_policy, 0 | 0 ); 6766 if (!SWIG_IsOK(res1)) { 6767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_policy_t_fs_use_iter" "', argument " "1"" of type '" "struct qpol_policy *""'"); 6768 } 6769 arg1 = (struct qpol_policy *)(argp1); 6770 result = (qpol_iterator_t *)qpol_policy_fs_use_iter(arg1); 6771 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_iterator, SWIG_POINTER_OWN | 0 ); 6772 return resultobj; 6773 fail: 6774 return NULL; 6775 } 6776 6777 6778 SWIGINTERN PyObject *_wrap_qpol_policy_t_fs_use_count(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 6779 PyObject *resultobj = 0; 6780 struct qpol_policy *arg1 = (struct qpol_policy *) 0 ; 6781 void *argp1 = 0 ; 6782 int res1 = 0 ; 6783 PyObject * obj0 = 0 ; 6784 size_t result; 6785 6786 if (!PyArg_ParseTuple(args,(char *)"O:qpol_policy_t_fs_use_count",&obj0)) SWIG_fail; 6787 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_policy, 0 | 0 ); 6788 if (!SWIG_IsOK(res1)) { 6789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_policy_t_fs_use_count" "', argument " "1"" of type '" "struct qpol_policy *""'"); 6790 } 6791 arg1 = (struct qpol_policy *)(argp1); 6792 result = (size_t)qpol_policy_fs_use_count(arg1); 6793 resultobj = SWIG_From_size_t((size_t)(result)); 6794 return resultobj; 6795 fail: 6796 return NULL; 6797 } 6798 6799 6800 SWIGINTERN PyObject *_wrap_qpol_policy_t_genfscon_iter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 6801 PyObject *resultobj = 0; 6802 struct qpol_policy *arg1 = (struct qpol_policy *) 0 ; 6803 void *argp1 = 0 ; 6804 int res1 = 0 ; 6805 PyObject * obj0 = 0 ; 6806 qpol_iterator_t *result = 0 ; 6807 6808 if (!PyArg_ParseTuple(args,(char *)"O:qpol_policy_t_genfscon_iter",&obj0)) SWIG_fail; 6809 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_policy, 0 | 0 ); 6810 if (!SWIG_IsOK(res1)) { 6811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_policy_t_genfscon_iter" "', argument " "1"" of type '" "struct qpol_policy *""'"); 6812 } 6813 arg1 = (struct qpol_policy *)(argp1); 6814 result = (qpol_iterator_t *)qpol_policy_genfscon_iter(arg1); 6815 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_iterator, SWIG_POINTER_OWN | 0 ); 6816 return resultobj; 6817 fail: 6818 return NULL; 6819 } 6820 6821 6822 SWIGINTERN PyObject *_wrap_qpol_policy_t_genfscon_count(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 6823 PyObject *resultobj = 0; 6824 struct qpol_policy *arg1 = (struct qpol_policy *) 0 ; 6825 void *argp1 = 0 ; 6826 int res1 = 0 ; 6827 PyObject * obj0 = 0 ; 6828 size_t result; 6829 6830 if (!PyArg_ParseTuple(args,(char *)"O:qpol_policy_t_genfscon_count",&obj0)) SWIG_fail; 6831 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_policy, 0 | 0 ); 6832 if (!SWIG_IsOK(res1)) { 6833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_policy_t_genfscon_count" "', argument " "1"" of type '" "struct qpol_policy *""'"); 6834 } 6835 arg1 = (struct qpol_policy *)(argp1); 6836 result = (size_t)qpol_policy_genfscon_count(arg1); 6837 resultobj = SWIG_From_size_t((size_t)(result)); 6838 return resultobj; 6839 fail: 6840 return NULL; 6841 } 6842 6843 6844 SWIGINTERN PyObject *_wrap_qpol_policy_t_isid_iter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 6845 PyObject *resultobj = 0; 6846 struct qpol_policy *arg1 = (struct qpol_policy *) 0 ; 6847 void *argp1 = 0 ; 6848 int res1 = 0 ; 6849 PyObject * obj0 = 0 ; 6850 qpol_iterator_t *result = 0 ; 6851 6852 if (!PyArg_ParseTuple(args,(char *)"O:qpol_policy_t_isid_iter",&obj0)) SWIG_fail; 6853 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_policy, 0 | 0 ); 6854 if (!SWIG_IsOK(res1)) { 6855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_policy_t_isid_iter" "', argument " "1"" of type '" "struct qpol_policy *""'"); 6856 } 6857 arg1 = (struct qpol_policy *)(argp1); 6858 result = (qpol_iterator_t *)qpol_policy_isid_iter(arg1); 6859 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_iterator, SWIG_POINTER_OWN | 0 ); 6860 return resultobj; 6861 fail: 6862 return NULL; 6863 } 6864 6865 6866 SWIGINTERN PyObject *_wrap_qpol_policy_t_isid_count(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 6867 PyObject *resultobj = 0; 6868 struct qpol_policy *arg1 = (struct qpol_policy *) 0 ; 6869 void *argp1 = 0 ; 6870 int res1 = 0 ; 6871 PyObject * obj0 = 0 ; 6872 size_t result; 6873 6874 if (!PyArg_ParseTuple(args,(char *)"O:qpol_policy_t_isid_count",&obj0)) SWIG_fail; 6875 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_policy, 0 | 0 ); 6876 if (!SWIG_IsOK(res1)) { 6877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_policy_t_isid_count" "', argument " "1"" of type '" "struct qpol_policy *""'"); 6878 } 6879 arg1 = (struct qpol_policy *)(argp1); 6880 result = (size_t)qpol_policy_isid_count(arg1); 6881 resultobj = SWIG_From_size_t((size_t)(result)); 6882 return resultobj; 6883 fail: 6884 return NULL; 6885 } 6886 6887 6888 SWIGINTERN PyObject *_wrap_qpol_policy_t_netifcon_iter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 6889 PyObject *resultobj = 0; 6890 struct qpol_policy *arg1 = (struct qpol_policy *) 0 ; 6891 void *argp1 = 0 ; 6892 int res1 = 0 ; 6893 PyObject * obj0 = 0 ; 6894 qpol_iterator_t *result = 0 ; 6895 6896 if (!PyArg_ParseTuple(args,(char *)"O:qpol_policy_t_netifcon_iter",&obj0)) SWIG_fail; 6897 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_policy, 0 | 0 ); 6898 if (!SWIG_IsOK(res1)) { 6899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_policy_t_netifcon_iter" "', argument " "1"" of type '" "struct qpol_policy *""'"); 6900 } 6901 arg1 = (struct qpol_policy *)(argp1); 6902 result = (qpol_iterator_t *)qpol_policy_netifcon_iter(arg1); 6903 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_iterator, SWIG_POINTER_OWN | 0 ); 6904 return resultobj; 6905 fail: 6906 return NULL; 6907 } 6908 6909 6910 SWIGINTERN PyObject *_wrap_qpol_policy_t_netifcon_count(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 6911 PyObject *resultobj = 0; 6912 struct qpol_policy *arg1 = (struct qpol_policy *) 0 ; 6913 void *argp1 = 0 ; 6914 int res1 = 0 ; 6915 PyObject * obj0 = 0 ; 6916 size_t result; 6917 6918 if (!PyArg_ParseTuple(args,(char *)"O:qpol_policy_t_netifcon_count",&obj0)) SWIG_fail; 6919 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_policy, 0 | 0 ); 6920 if (!SWIG_IsOK(res1)) { 6921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_policy_t_netifcon_count" "', argument " "1"" of type '" "struct qpol_policy *""'"); 6922 } 6923 arg1 = (struct qpol_policy *)(argp1); 6924 result = (size_t)qpol_policy_netifcon_count(arg1); 6925 resultobj = SWIG_From_size_t((size_t)(result)); 6926 return resultobj; 6927 fail: 6928 return NULL; 6929 } 6930 6931 6932 SWIGINTERN PyObject *_wrap_qpol_policy_t_nodecon_iter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 6933 PyObject *resultobj = 0; 6934 struct qpol_policy *arg1 = (struct qpol_policy *) 0 ; 6935 void *argp1 = 0 ; 6936 int res1 = 0 ; 6937 PyObject * obj0 = 0 ; 6938 qpol_iterator_t *result = 0 ; 6939 6940 if (!PyArg_ParseTuple(args,(char *)"O:qpol_policy_t_nodecon_iter",&obj0)) SWIG_fail; 6941 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_policy, 0 | 0 ); 6942 if (!SWIG_IsOK(res1)) { 6943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_policy_t_nodecon_iter" "', argument " "1"" of type '" "struct qpol_policy *""'"); 6944 } 6945 arg1 = (struct qpol_policy *)(argp1); 6946 result = (qpol_iterator_t *)qpol_policy_nodecon_iter(arg1); 6947 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_iterator, SWIG_POINTER_OWN | 0 ); 6948 return resultobj; 6949 fail: 6950 return NULL; 6951 } 6952 6953 6954 SWIGINTERN PyObject *_wrap_qpol_policy_t_nodecon_count(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 6955 PyObject *resultobj = 0; 6956 struct qpol_policy *arg1 = (struct qpol_policy *) 0 ; 6957 void *argp1 = 0 ; 6958 int res1 = 0 ; 6959 PyObject * obj0 = 0 ; 6960 size_t result; 6961 6962 if (!PyArg_ParseTuple(args,(char *)"O:qpol_policy_t_nodecon_count",&obj0)) SWIG_fail; 6963 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_policy, 0 | 0 ); 6964 if (!SWIG_IsOK(res1)) { 6965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_policy_t_nodecon_count" "', argument " "1"" of type '" "struct qpol_policy *""'"); 6966 } 6967 arg1 = (struct qpol_policy *)(argp1); 6968 result = (size_t)qpol_policy_nodecon_count(arg1); 6969 resultobj = SWIG_From_size_t((size_t)(result)); 6970 return resultobj; 6971 fail: 6972 return NULL; 6973 } 6974 6975 6976 SWIGINTERN PyObject *_wrap_qpol_policy_t_portcon_iter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 6977 PyObject *resultobj = 0; 6978 struct qpol_policy *arg1 = (struct qpol_policy *) 0 ; 6979 void *argp1 = 0 ; 6980 int res1 = 0 ; 6981 PyObject * obj0 = 0 ; 6982 qpol_iterator_t *result = 0 ; 6983 6984 if (!PyArg_ParseTuple(args,(char *)"O:qpol_policy_t_portcon_iter",&obj0)) SWIG_fail; 6985 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_policy, 0 | 0 ); 6986 if (!SWIG_IsOK(res1)) { 6987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_policy_t_portcon_iter" "', argument " "1"" of type '" "struct qpol_policy *""'"); 6988 } 6989 arg1 = (struct qpol_policy *)(argp1); 6990 result = (qpol_iterator_t *)qpol_policy_portcon_iter(arg1); 6991 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_iterator, SWIG_POINTER_OWN | 0 ); 6992 return resultobj; 6993 fail: 6994 return NULL; 6995 } 6996 6997 6998 SWIGINTERN PyObject *_wrap_qpol_policy_t_portcon_count(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 6999 PyObject *resultobj = 0; 7000 struct qpol_policy *arg1 = (struct qpol_policy *) 0 ; 7001 void *argp1 = 0 ; 7002 int res1 = 0 ; 7003 PyObject * obj0 = 0 ; 7004 size_t result; 7005 7006 if (!PyArg_ParseTuple(args,(char *)"O:qpol_policy_t_portcon_count",&obj0)) SWIG_fail; 7007 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_policy, 0 | 0 ); 7008 if (!SWIG_IsOK(res1)) { 7009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_policy_t_portcon_count" "', argument " "1"" of type '" "struct qpol_policy *""'"); 7010 } 7011 arg1 = (struct qpol_policy *)(argp1); 7012 result = (size_t)qpol_policy_portcon_count(arg1); 7013 resultobj = SWIG_From_size_t((size_t)(result)); 7014 return resultobj; 7015 fail: 7016 return NULL; 7017 } 7018 7019 7020 SWIGINTERN PyObject *_wrap_qpol_policy_t_constraint_iter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 7021 PyObject *resultobj = 0; 7022 struct qpol_policy *arg1 = (struct qpol_policy *) 0 ; 7023 void *argp1 = 0 ; 7024 int res1 = 0 ; 7025 PyObject * obj0 = 0 ; 7026 qpol_iterator_t *result = 0 ; 7027 7028 if (!PyArg_ParseTuple(args,(char *)"O:qpol_policy_t_constraint_iter",&obj0)) SWIG_fail; 7029 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_policy, 0 | 0 ); 7030 if (!SWIG_IsOK(res1)) { 7031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_policy_t_constraint_iter" "', argument " "1"" of type '" "struct qpol_policy *""'"); 7032 } 7033 arg1 = (struct qpol_policy *)(argp1); 7034 result = (qpol_iterator_t *)qpol_policy_constraint_iter(arg1); 7035 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_iterator, SWIG_POINTER_OWN | 0 ); 7036 return resultobj; 7037 fail: 7038 return NULL; 7039 } 7040 7041 7042 SWIGINTERN PyObject *_wrap_qpol_policy_t_constraint_count(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 7043 PyObject *resultobj = 0; 7044 struct qpol_policy *arg1 = (struct qpol_policy *) 0 ; 7045 void *argp1 = 0 ; 7046 int res1 = 0 ; 7047 PyObject * obj0 = 0 ; 7048 size_t result; 7049 7050 if (!PyArg_ParseTuple(args,(char *)"O:qpol_policy_t_constraint_count",&obj0)) SWIG_fail; 7051 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_policy, 0 | 0 ); 7052 if (!SWIG_IsOK(res1)) { 7053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_policy_t_constraint_count" "', argument " "1"" of type '" "struct qpol_policy *""'"); 7054 } 7055 arg1 = (struct qpol_policy *)(argp1); 7056 result = (size_t)qpol_policy_constraint_count(arg1); 7057 resultobj = SWIG_From_size_t((size_t)(result)); 7058 return resultobj; 7059 fail: 7060 return NULL; 7061 } 7062 7063 7064 SWIGINTERN PyObject *_wrap_qpol_policy_t_validatetrans_iter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 7065 PyObject *resultobj = 0; 7066 struct qpol_policy *arg1 = (struct qpol_policy *) 0 ; 7067 void *argp1 = 0 ; 7068 int res1 = 0 ; 7069 PyObject * obj0 = 0 ; 7070 qpol_iterator_t *result = 0 ; 7071 7072 if (!PyArg_ParseTuple(args,(char *)"O:qpol_policy_t_validatetrans_iter",&obj0)) SWIG_fail; 7073 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_policy, 0 | 0 ); 7074 if (!SWIG_IsOK(res1)) { 7075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_policy_t_validatetrans_iter" "', argument " "1"" of type '" "struct qpol_policy *""'"); 7076 } 7077 arg1 = (struct qpol_policy *)(argp1); 7078 result = (qpol_iterator_t *)qpol_policy_validatetrans_iter(arg1); 7079 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_iterator, SWIG_POINTER_OWN | 0 ); 7080 return resultobj; 7081 fail: 7082 return NULL; 7083 } 7084 7085 7086 SWIGINTERN PyObject *_wrap_qpol_policy_t_validatetrans_count(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 7087 PyObject *resultobj = 0; 7088 struct qpol_policy *arg1 = (struct qpol_policy *) 0 ; 7089 void *argp1 = 0 ; 7090 int res1 = 0 ; 7091 PyObject * obj0 = 0 ; 7092 size_t result; 7093 7094 if (!PyArg_ParseTuple(args,(char *)"O:qpol_policy_t_validatetrans_count",&obj0)) SWIG_fail; 7095 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_policy, 0 | 0 ); 7096 if (!SWIG_IsOK(res1)) { 7097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_policy_t_validatetrans_count" "', argument " "1"" of type '" "struct qpol_policy *""'"); 7098 } 7099 arg1 = (struct qpol_policy *)(argp1); 7100 result = (size_t)qpol_policy_validatetrans_count(arg1); 7101 resultobj = SWIG_From_size_t((size_t)(result)); 7102 return resultobj; 7103 fail: 7104 return NULL; 7105 } 7106 7107 7108 SWIGINTERN PyObject *_wrap_qpol_policy_t_role_allow_iter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 7109 PyObject *resultobj = 0; 7110 struct qpol_policy *arg1 = (struct qpol_policy *) 0 ; 7111 void *argp1 = 0 ; 7112 int res1 = 0 ; 7113 PyObject * obj0 = 0 ; 7114 qpol_iterator_t *result = 0 ; 7115 7116 if (!PyArg_ParseTuple(args,(char *)"O:qpol_policy_t_role_allow_iter",&obj0)) SWIG_fail; 7117 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_policy, 0 | 0 ); 7118 if (!SWIG_IsOK(res1)) { 7119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_policy_t_role_allow_iter" "', argument " "1"" of type '" "struct qpol_policy *""'"); 7120 } 7121 arg1 = (struct qpol_policy *)(argp1); 7122 result = (qpol_iterator_t *)qpol_policy_role_allow_iter(arg1); 7123 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_iterator, SWIG_POINTER_OWN | 0 ); 7124 return resultobj; 7125 fail: 7126 return NULL; 7127 } 7128 7129 7130 SWIGINTERN PyObject *_wrap_qpol_policy_t_role_allow_count(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 7131 PyObject *resultobj = 0; 7132 struct qpol_policy *arg1 = (struct qpol_policy *) 0 ; 7133 void *argp1 = 0 ; 7134 int res1 = 0 ; 7135 PyObject * obj0 = 0 ; 7136 size_t result; 7137 7138 if (!PyArg_ParseTuple(args,(char *)"O:qpol_policy_t_role_allow_count",&obj0)) SWIG_fail; 7139 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_policy, 0 | 0 ); 7140 if (!SWIG_IsOK(res1)) { 7141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_policy_t_role_allow_count" "', argument " "1"" of type '" "struct qpol_policy *""'"); 7142 } 7143 arg1 = (struct qpol_policy *)(argp1); 7144 result = (size_t)qpol_policy_role_allow_count(arg1); 7145 resultobj = SWIG_From_size_t((size_t)(result)); 7146 return resultobj; 7147 fail: 7148 return NULL; 7149 } 7150 7151 7152 SWIGINTERN PyObject *_wrap_qpol_policy_t_role_trans_iter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 7153 PyObject *resultobj = 0; 7154 struct qpol_policy *arg1 = (struct qpol_policy *) 0 ; 7155 void *argp1 = 0 ; 7156 int res1 = 0 ; 7157 PyObject * obj0 = 0 ; 7158 qpol_iterator_t *result = 0 ; 7159 7160 if (!PyArg_ParseTuple(args,(char *)"O:qpol_policy_t_role_trans_iter",&obj0)) SWIG_fail; 7161 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_policy, 0 | 0 ); 7162 if (!SWIG_IsOK(res1)) { 7163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_policy_t_role_trans_iter" "', argument " "1"" of type '" "struct qpol_policy *""'"); 7164 } 7165 arg1 = (struct qpol_policy *)(argp1); 7166 result = (qpol_iterator_t *)qpol_policy_role_trans_iter(arg1); 7167 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_iterator, SWIG_POINTER_OWN | 0 ); 7168 return resultobj; 7169 fail: 7170 return NULL; 7171 } 7172 7173 7174 SWIGINTERN PyObject *_wrap_qpol_policy_t_role_trans_count(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 7175 PyObject *resultobj = 0; 7176 struct qpol_policy *arg1 = (struct qpol_policy *) 0 ; 7177 void *argp1 = 0 ; 7178 int res1 = 0 ; 7179 PyObject * obj0 = 0 ; 7180 size_t result; 7181 7182 if (!PyArg_ParseTuple(args,(char *)"O:qpol_policy_t_role_trans_count",&obj0)) SWIG_fail; 7183 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_policy, 0 | 0 ); 7184 if (!SWIG_IsOK(res1)) { 7185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_policy_t_role_trans_count" "', argument " "1"" of type '" "struct qpol_policy *""'"); 7186 } 7187 arg1 = (struct qpol_policy *)(argp1); 7188 result = (size_t)qpol_policy_role_trans_count(arg1); 7189 resultobj = SWIG_From_size_t((size_t)(result)); 7190 return resultobj; 7191 fail: 7192 return NULL; 7193 } 7194 7195 7196 SWIGINTERN PyObject *_wrap_qpol_policy_t_range_trans_iter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 7197 PyObject *resultobj = 0; 7198 struct qpol_policy *arg1 = (struct qpol_policy *) 0 ; 7199 void *argp1 = 0 ; 7200 int res1 = 0 ; 7201 PyObject * obj0 = 0 ; 7202 qpol_iterator_t *result = 0 ; 7203 7204 if (!PyArg_ParseTuple(args,(char *)"O:qpol_policy_t_range_trans_iter",&obj0)) SWIG_fail; 7205 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_policy, 0 | 0 ); 7206 if (!SWIG_IsOK(res1)) { 7207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_policy_t_range_trans_iter" "', argument " "1"" of type '" "struct qpol_policy *""'"); 7208 } 7209 arg1 = (struct qpol_policy *)(argp1); 7210 result = (qpol_iterator_t *)qpol_policy_range_trans_iter(arg1); 7211 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_iterator, SWIG_POINTER_OWN | 0 ); 7212 return resultobj; 7213 fail: 7214 return NULL; 7215 } 7216 7217 7218 SWIGINTERN PyObject *_wrap_qpol_policy_t_range_trans_count(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 7219 PyObject *resultobj = 0; 7220 struct qpol_policy *arg1 = (struct qpol_policy *) 0 ; 7221 void *argp1 = 0 ; 7222 int res1 = 0 ; 7223 PyObject * obj0 = 0 ; 7224 size_t result; 7225 7226 if (!PyArg_ParseTuple(args,(char *)"O:qpol_policy_t_range_trans_count",&obj0)) SWIG_fail; 7227 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_policy, 0 | 0 ); 7228 if (!SWIG_IsOK(res1)) { 7229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_policy_t_range_trans_count" "', argument " "1"" of type '" "struct qpol_policy *""'"); 7230 } 7231 arg1 = (struct qpol_policy *)(argp1); 7232 result = (size_t)qpol_policy_range_trans_count(arg1); 7233 resultobj = SWIG_From_size_t((size_t)(result)); 7234 return resultobj; 7235 fail: 7236 return NULL; 7237 } 7238 7239 7240 SWIGINTERN PyObject *_wrap_qpol_policy_t_avrule_iter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 7241 PyObject *resultobj = 0; 7242 struct qpol_policy *arg1 = (struct qpol_policy *) 0 ; 7243 void *argp1 = 0 ; 7244 int res1 = 0 ; 7245 PyObject * obj0 = 0 ; 7246 qpol_iterator_t *result = 0 ; 7247 7248 if (!PyArg_ParseTuple(args,(char *)"O:qpol_policy_t_avrule_iter",&obj0)) SWIG_fail; 7249 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_policy, 0 | 0 ); 7250 if (!SWIG_IsOK(res1)) { 7251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_policy_t_avrule_iter" "', argument " "1"" of type '" "struct qpol_policy *""'"); 7252 } 7253 arg1 = (struct qpol_policy *)(argp1); 7254 result = (qpol_iterator_t *)qpol_policy_avrule_iter(arg1); 7255 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_iterator, 0 | 0 ); 7256 return resultobj; 7257 fail: 7258 return NULL; 7259 } 7260 7261 7262 SWIGINTERN PyObject *_wrap_qpol_policy_t_avrule_allow_count(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 7263 PyObject *resultobj = 0; 7264 struct qpol_policy *arg1 = (struct qpol_policy *) 0 ; 7265 void *argp1 = 0 ; 7266 int res1 = 0 ; 7267 PyObject * obj0 = 0 ; 7268 size_t result; 7269 7270 if (!PyArg_ParseTuple(args,(char *)"O:qpol_policy_t_avrule_allow_count",&obj0)) SWIG_fail; 7271 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_policy, 0 | 0 ); 7272 if (!SWIG_IsOK(res1)) { 7273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_policy_t_avrule_allow_count" "', argument " "1"" of type '" "struct qpol_policy *""'"); 7274 } 7275 arg1 = (struct qpol_policy *)(argp1); 7276 result = (size_t)qpol_policy_avrule_allow_count(arg1); 7277 resultobj = SWIG_From_size_t((size_t)(result)); 7278 return resultobj; 7279 fail: 7280 return NULL; 7281 } 7282 7283 7284 SWIGINTERN PyObject *_wrap_qpol_policy_t_avrule_auditallow_count(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 7285 PyObject *resultobj = 0; 7286 struct qpol_policy *arg1 = (struct qpol_policy *) 0 ; 7287 void *argp1 = 0 ; 7288 int res1 = 0 ; 7289 PyObject * obj0 = 0 ; 7290 size_t result; 7291 7292 if (!PyArg_ParseTuple(args,(char *)"O:qpol_policy_t_avrule_auditallow_count",&obj0)) SWIG_fail; 7293 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_policy, 0 | 0 ); 7294 if (!SWIG_IsOK(res1)) { 7295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_policy_t_avrule_auditallow_count" "', argument " "1"" of type '" "struct qpol_policy *""'"); 7296 } 7297 arg1 = (struct qpol_policy *)(argp1); 7298 result = (size_t)qpol_policy_avrule_auditallow_count(arg1); 7299 resultobj = SWIG_From_size_t((size_t)(result)); 7300 return resultobj; 7301 fail: 7302 return NULL; 7303 } 7304 7305 7306 SWIGINTERN PyObject *_wrap_qpol_policy_t_avrule_neverallow_count(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 7307 PyObject *resultobj = 0; 7308 struct qpol_policy *arg1 = (struct qpol_policy *) 0 ; 7309 void *argp1 = 0 ; 7310 int res1 = 0 ; 7311 PyObject * obj0 = 0 ; 7312 size_t result; 7313 7314 if (!PyArg_ParseTuple(args,(char *)"O:qpol_policy_t_avrule_neverallow_count",&obj0)) SWIG_fail; 7315 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_policy, 0 | 0 ); 7316 if (!SWIG_IsOK(res1)) { 7317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_policy_t_avrule_neverallow_count" "', argument " "1"" of type '" "struct qpol_policy *""'"); 7318 } 7319 arg1 = (struct qpol_policy *)(argp1); 7320 result = (size_t)qpol_policy_avrule_neverallow_count(arg1); 7321 resultobj = SWIG_From_size_t((size_t)(result)); 7322 return resultobj; 7323 fail: 7324 return NULL; 7325 } 7326 7327 7328 SWIGINTERN PyObject *_wrap_qpol_policy_t_avrule_dontaudit_count(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 7329 PyObject *resultobj = 0; 7330 struct qpol_policy *arg1 = (struct qpol_policy *) 0 ; 7331 void *argp1 = 0 ; 7332 int res1 = 0 ; 7333 PyObject * obj0 = 0 ; 7334 size_t result; 7335 7336 if (!PyArg_ParseTuple(args,(char *)"O:qpol_policy_t_avrule_dontaudit_count",&obj0)) SWIG_fail; 7337 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_policy, 0 | 0 ); 7338 if (!SWIG_IsOK(res1)) { 7339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_policy_t_avrule_dontaudit_count" "', argument " "1"" of type '" "struct qpol_policy *""'"); 7340 } 7341 arg1 = (struct qpol_policy *)(argp1); 7342 result = (size_t)qpol_policy_avrule_dontaudit_count(arg1); 7343 resultobj = SWIG_From_size_t((size_t)(result)); 7344 return resultobj; 7345 fail: 7346 return NULL; 7347 } 7348 7349 7350 SWIGINTERN PyObject *_wrap_qpol_policy_t_avrulex_iter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 7351 PyObject *resultobj = 0; 7352 struct qpol_policy *arg1 = (struct qpol_policy *) 0 ; 7353 void *argp1 = 0 ; 7354 int res1 = 0 ; 7355 PyObject * obj0 = 0 ; 7356 qpol_iterator_t *result = 0 ; 7357 7358 if (!PyArg_ParseTuple(args,(char *)"O:qpol_policy_t_avrulex_iter",&obj0)) SWIG_fail; 7359 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_policy, 0 | 0 ); 7360 if (!SWIG_IsOK(res1)) { 7361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_policy_t_avrulex_iter" "', argument " "1"" of type '" "struct qpol_policy *""'"); 7362 } 7363 arg1 = (struct qpol_policy *)(argp1); 7364 result = (qpol_iterator_t *)qpol_policy_avrulex_iter(arg1); 7365 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_iterator, 0 | 0 ); 7366 return resultobj; 7367 fail: 7368 return NULL; 7369 } 7370 7371 7372 SWIGINTERN PyObject *_wrap_qpol_policy_t_avrule_allowx_count(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 7373 PyObject *resultobj = 0; 7374 struct qpol_policy *arg1 = (struct qpol_policy *) 0 ; 7375 void *argp1 = 0 ; 7376 int res1 = 0 ; 7377 PyObject * obj0 = 0 ; 7378 size_t result; 7379 7380 if (!PyArg_ParseTuple(args,(char *)"O:qpol_policy_t_avrule_allowx_count",&obj0)) SWIG_fail; 7381 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_policy, 0 | 0 ); 7382 if (!SWIG_IsOK(res1)) { 7383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_policy_t_avrule_allowx_count" "', argument " "1"" of type '" "struct qpol_policy *""'"); 7384 } 7385 arg1 = (struct qpol_policy *)(argp1); 7386 result = (size_t)qpol_policy_avrule_allowx_count(arg1); 7387 resultobj = SWIG_From_size_t((size_t)(result)); 7388 return resultobj; 7389 fail: 7390 return NULL; 7391 } 7392 7393 7394 SWIGINTERN PyObject *_wrap_qpol_policy_t_avrule_auditallowx_count(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 7395 PyObject *resultobj = 0; 7396 struct qpol_policy *arg1 = (struct qpol_policy *) 0 ; 7397 void *argp1 = 0 ; 7398 int res1 = 0 ; 7399 PyObject * obj0 = 0 ; 7400 size_t result; 7401 7402 if (!PyArg_ParseTuple(args,(char *)"O:qpol_policy_t_avrule_auditallowx_count",&obj0)) SWIG_fail; 7403 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_policy, 0 | 0 ); 7404 if (!SWIG_IsOK(res1)) { 7405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_policy_t_avrule_auditallowx_count" "', argument " "1"" of type '" "struct qpol_policy *""'"); 7406 } 7407 arg1 = (struct qpol_policy *)(argp1); 7408 result = (size_t)qpol_policy_avrule_auditallowx_count(arg1); 7409 resultobj = SWIG_From_size_t((size_t)(result)); 7410 return resultobj; 7411 fail: 7412 return NULL; 7413 } 7414 7415 7416 SWIGINTERN PyObject *_wrap_qpol_policy_t_avrule_neverallowx_count(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 7417 PyObject *resultobj = 0; 7418 struct qpol_policy *arg1 = (struct qpol_policy *) 0 ; 7419 void *argp1 = 0 ; 7420 int res1 = 0 ; 7421 PyObject * obj0 = 0 ; 7422 size_t result; 7423 7424 if (!PyArg_ParseTuple(args,(char *)"O:qpol_policy_t_avrule_neverallowx_count",&obj0)) SWIG_fail; 7425 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_policy, 0 | 0 ); 7426 if (!SWIG_IsOK(res1)) { 7427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_policy_t_avrule_neverallowx_count" "', argument " "1"" of type '" "struct qpol_policy *""'"); 7428 } 7429 arg1 = (struct qpol_policy *)(argp1); 7430 result = (size_t)qpol_policy_avrule_neverallowx_count(arg1); 7431 resultobj = SWIG_From_size_t((size_t)(result)); 7432 return resultobj; 7433 fail: 7434 return NULL; 7435 } 7436 7437 7438 SWIGINTERN PyObject *_wrap_qpol_policy_t_avrule_dontauditx_count(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 7439 PyObject *resultobj = 0; 7440 struct qpol_policy *arg1 = (struct qpol_policy *) 0 ; 7441 void *argp1 = 0 ; 7442 int res1 = 0 ; 7443 PyObject * obj0 = 0 ; 7444 size_t result; 7445 7446 if (!PyArg_ParseTuple(args,(char *)"O:qpol_policy_t_avrule_dontauditx_count",&obj0)) SWIG_fail; 7447 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_policy, 0 | 0 ); 7448 if (!SWIG_IsOK(res1)) { 7449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_policy_t_avrule_dontauditx_count" "', argument " "1"" of type '" "struct qpol_policy *""'"); 7450 } 7451 arg1 = (struct qpol_policy *)(argp1); 7452 result = (size_t)qpol_policy_avrule_dontauditx_count(arg1); 7453 resultobj = SWIG_From_size_t((size_t)(result)); 7454 return resultobj; 7455 fail: 7456 return NULL; 7457 } 7458 7459 7460 SWIGINTERN PyObject *_wrap_qpol_policy_t_terule_iter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 7461 PyObject *resultobj = 0; 7462 struct qpol_policy *arg1 = (struct qpol_policy *) 0 ; 7463 void *argp1 = 0 ; 7464 int res1 = 0 ; 7465 PyObject * obj0 = 0 ; 7466 qpol_iterator_t *result = 0 ; 7467 7468 if (!PyArg_ParseTuple(args,(char *)"O:qpol_policy_t_terule_iter",&obj0)) SWIG_fail; 7469 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_policy, 0 | 0 ); 7470 if (!SWIG_IsOK(res1)) { 7471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_policy_t_terule_iter" "', argument " "1"" of type '" "struct qpol_policy *""'"); 7472 } 7473 arg1 = (struct qpol_policy *)(argp1); 7474 result = (qpol_iterator_t *)qpol_policy_terule_iter(arg1); 7475 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_iterator, 0 | 0 ); 7476 return resultobj; 7477 fail: 7478 return NULL; 7479 } 7480 7481 7482 SWIGINTERN PyObject *_wrap_qpol_policy_t_terule_trans_count(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 7483 PyObject *resultobj = 0; 7484 struct qpol_policy *arg1 = (struct qpol_policy *) 0 ; 7485 void *argp1 = 0 ; 7486 int res1 = 0 ; 7487 PyObject * obj0 = 0 ; 7488 size_t result; 7489 7490 if (!PyArg_ParseTuple(args,(char *)"O:qpol_policy_t_terule_trans_count",&obj0)) SWIG_fail; 7491 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_policy, 0 | 0 ); 7492 if (!SWIG_IsOK(res1)) { 7493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_policy_t_terule_trans_count" "', argument " "1"" of type '" "struct qpol_policy *""'"); 7494 } 7495 arg1 = (struct qpol_policy *)(argp1); 7496 result = (size_t)qpol_policy_terule_trans_count(arg1); 7497 resultobj = SWIG_From_size_t((size_t)(result)); 7498 return resultobj; 7499 fail: 7500 return NULL; 7501 } 7502 7503 7504 SWIGINTERN PyObject *_wrap_qpol_policy_t_terule_change_count(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 7505 PyObject *resultobj = 0; 7506 struct qpol_policy *arg1 = (struct qpol_policy *) 0 ; 7507 void *argp1 = 0 ; 7508 int res1 = 0 ; 7509 PyObject * obj0 = 0 ; 7510 size_t result; 7511 7512 if (!PyArg_ParseTuple(args,(char *)"O:qpol_policy_t_terule_change_count",&obj0)) SWIG_fail; 7513 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_policy, 0 | 0 ); 7514 if (!SWIG_IsOK(res1)) { 7515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_policy_t_terule_change_count" "', argument " "1"" of type '" "struct qpol_policy *""'"); 7516 } 7517 arg1 = (struct qpol_policy *)(argp1); 7518 result = (size_t)qpol_policy_terule_change_count(arg1); 7519 resultobj = SWIG_From_size_t((size_t)(result)); 7520 return resultobj; 7521 fail: 7522 return NULL; 7523 } 7524 7525 7526 SWIGINTERN PyObject *_wrap_qpol_policy_t_terule_member_count(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 7527 PyObject *resultobj = 0; 7528 struct qpol_policy *arg1 = (struct qpol_policy *) 0 ; 7529 void *argp1 = 0 ; 7530 int res1 = 0 ; 7531 PyObject * obj0 = 0 ; 7532 size_t result; 7533 7534 if (!PyArg_ParseTuple(args,(char *)"O:qpol_policy_t_terule_member_count",&obj0)) SWIG_fail; 7535 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_policy, 0 | 0 ); 7536 if (!SWIG_IsOK(res1)) { 7537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_policy_t_terule_member_count" "', argument " "1"" of type '" "struct qpol_policy *""'"); 7538 } 7539 arg1 = (struct qpol_policy *)(argp1); 7540 result = (size_t)qpol_policy_terule_member_count(arg1); 7541 resultobj = SWIG_From_size_t((size_t)(result)); 7542 return resultobj; 7543 fail: 7544 return NULL; 7545 } 7546 7547 7548 SWIGINTERN PyObject *_wrap_qpol_policy_t_cond_iter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 7549 PyObject *resultobj = 0; 7550 struct qpol_policy *arg1 = (struct qpol_policy *) 0 ; 7551 void *argp1 = 0 ; 7552 int res1 = 0 ; 7553 PyObject * obj0 = 0 ; 7554 qpol_iterator_t *result = 0 ; 7555 7556 if (!PyArg_ParseTuple(args,(char *)"O:qpol_policy_t_cond_iter",&obj0)) SWIG_fail; 7557 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_policy, 0 | 0 ); 7558 if (!SWIG_IsOK(res1)) { 7559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_policy_t_cond_iter" "', argument " "1"" of type '" "struct qpol_policy *""'"); 7560 } 7561 arg1 = (struct qpol_policy *)(argp1); 7562 result = (qpol_iterator_t *)qpol_policy_cond_iter(arg1); 7563 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_iterator, SWIG_POINTER_OWN | 0 ); 7564 return resultobj; 7565 fail: 7566 return NULL; 7567 } 7568 7569 7570 SWIGINTERN PyObject *_wrap_qpol_policy_t_cond_count(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 7571 PyObject *resultobj = 0; 7572 struct qpol_policy *arg1 = (struct qpol_policy *) 0 ; 7573 void *argp1 = 0 ; 7574 int res1 = 0 ; 7575 PyObject * obj0 = 0 ; 7576 size_t result; 7577 7578 if (!PyArg_ParseTuple(args,(char *)"O:qpol_policy_t_cond_count",&obj0)) SWIG_fail; 7579 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_policy, 0 | 0 ); 7580 if (!SWIG_IsOK(res1)) { 7581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_policy_t_cond_count" "', argument " "1"" of type '" "struct qpol_policy *""'"); 7582 } 7583 arg1 = (struct qpol_policy *)(argp1); 7584 result = (size_t)qpol_policy_cond_count(arg1); 7585 resultobj = SWIG_From_size_t((size_t)(result)); 7586 return resultobj; 7587 fail: 7588 return NULL; 7589 } 7590 7591 7592 SWIGINTERN PyObject *_wrap_qpol_policy_t_filename_trans_iter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 7593 PyObject *resultobj = 0; 7594 struct qpol_policy *arg1 = (struct qpol_policy *) 0 ; 7595 void *argp1 = 0 ; 7596 int res1 = 0 ; 7597 PyObject * obj0 = 0 ; 7598 qpol_iterator_t *result = 0 ; 7599 7600 if (!PyArg_ParseTuple(args,(char *)"O:qpol_policy_t_filename_trans_iter",&obj0)) SWIG_fail; 7601 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_policy, 0 | 0 ); 7602 if (!SWIG_IsOK(res1)) { 7603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_policy_t_filename_trans_iter" "', argument " "1"" of type '" "struct qpol_policy *""'"); 7604 } 7605 arg1 = (struct qpol_policy *)(argp1); 7606 result = (qpol_iterator_t *)qpol_policy_filename_trans_iter(arg1); 7607 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_iterator, SWIG_POINTER_OWN | 0 ); 7608 return resultobj; 7609 fail: 7610 return NULL; 7611 } 7612 7613 7614 SWIGINTERN PyObject *_wrap_qpol_policy_t_filename_trans_count(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 7615 PyObject *resultobj = 0; 7616 struct qpol_policy *arg1 = (struct qpol_policy *) 0 ; 7617 void *argp1 = 0 ; 7618 int res1 = 0 ; 7619 PyObject * obj0 = 0 ; 7620 size_t result; 7621 7622 if (!PyArg_ParseTuple(args,(char *)"O:qpol_policy_t_filename_trans_count",&obj0)) SWIG_fail; 7623 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_policy, 0 | 0 ); 7624 if (!SWIG_IsOK(res1)) { 7625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_policy_t_filename_trans_count" "', argument " "1"" of type '" "struct qpol_policy *""'"); 7626 } 7627 arg1 = (struct qpol_policy *)(argp1); 7628 result = (size_t)qpol_policy_filename_trans_count(arg1); 7629 resultobj = SWIG_From_size_t((size_t)(result)); 7630 return resultobj; 7631 fail: 7632 return NULL; 7633 } 7634 7635 7636 SWIGINTERN PyObject *_wrap_qpol_policy_t_permissive_iter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 7637 PyObject *resultobj = 0; 7638 struct qpol_policy *arg1 = (struct qpol_policy *) 0 ; 7639 void *argp1 = 0 ; 7640 int res1 = 0 ; 7641 PyObject * obj0 = 0 ; 7642 qpol_iterator_t *result = 0 ; 7643 7644 if (!PyArg_ParseTuple(args,(char *)"O:qpol_policy_t_permissive_iter",&obj0)) SWIG_fail; 7645 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_policy, 0 | 0 ); 7646 if (!SWIG_IsOK(res1)) { 7647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_policy_t_permissive_iter" "', argument " "1"" of type '" "struct qpol_policy *""'"); 7648 } 7649 arg1 = (struct qpol_policy *)(argp1); 7650 result = (qpol_iterator_t *)qpol_policy_permissive_iter(arg1); 7651 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_iterator, SWIG_POINTER_OWN | 0 ); 7652 return resultobj; 7653 fail: 7654 return NULL; 7655 } 7656 7657 7658 SWIGINTERN PyObject *_wrap_qpol_policy_t_permissive_count(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 7659 PyObject *resultobj = 0; 7660 struct qpol_policy *arg1 = (struct qpol_policy *) 0 ; 7661 void *argp1 = 0 ; 7662 int res1 = 0 ; 7663 PyObject * obj0 = 0 ; 7664 size_t result; 7665 7666 if (!PyArg_ParseTuple(args,(char *)"O:qpol_policy_t_permissive_count",&obj0)) SWIG_fail; 7667 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_policy, 0 | 0 ); 7668 if (!SWIG_IsOK(res1)) { 7669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_policy_t_permissive_count" "', argument " "1"" of type '" "struct qpol_policy *""'"); 7670 } 7671 arg1 = (struct qpol_policy *)(argp1); 7672 result = (size_t)qpol_policy_permissive_count(arg1); 7673 resultobj = SWIG_From_size_t((size_t)(result)); 7674 return resultobj; 7675 fail: 7676 return NULL; 7677 } 7678 7679 7680 SWIGINTERN PyObject *_wrap_qpol_policy_t_typebounds_iter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 7681 PyObject *resultobj = 0; 7682 struct qpol_policy *arg1 = (struct qpol_policy *) 0 ; 7683 void *argp1 = 0 ; 7684 int res1 = 0 ; 7685 PyObject * obj0 = 0 ; 7686 qpol_iterator_t *result = 0 ; 7687 7688 if (!PyArg_ParseTuple(args,(char *)"O:qpol_policy_t_typebounds_iter",&obj0)) SWIG_fail; 7689 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_policy, 0 | 0 ); 7690 if (!SWIG_IsOK(res1)) { 7691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_policy_t_typebounds_iter" "', argument " "1"" of type '" "struct qpol_policy *""'"); 7692 } 7693 arg1 = (struct qpol_policy *)(argp1); 7694 result = (qpol_iterator_t *)qpol_policy_typebounds_iter(arg1); 7695 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_iterator, SWIG_POINTER_OWN | 0 ); 7696 return resultobj; 7697 fail: 7698 return NULL; 7699 } 7700 7701 7702 SWIGINTERN PyObject *_wrap_qpol_policy_t_polcap_iter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 7703 PyObject *resultobj = 0; 7704 struct qpol_policy *arg1 = (struct qpol_policy *) 0 ; 7705 void *argp1 = 0 ; 7706 int res1 = 0 ; 7707 PyObject * obj0 = 0 ; 7708 qpol_iterator_t *result = 0 ; 7709 7710 if (!PyArg_ParseTuple(args,(char *)"O:qpol_policy_t_polcap_iter",&obj0)) SWIG_fail; 7711 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_policy, 0 | 0 ); 7712 if (!SWIG_IsOK(res1)) { 7713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_policy_t_polcap_iter" "', argument " "1"" of type '" "struct qpol_policy *""'"); 7714 } 7715 arg1 = (struct qpol_policy *)(argp1); 7716 result = (qpol_iterator_t *)qpol_policy_polcap_iter(arg1); 7717 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_iterator, SWIG_POINTER_OWN | 0 ); 7718 return resultobj; 7719 fail: 7720 return NULL; 7721 } 7722 7723 7724 SWIGINTERN PyObject *_wrap_qpol_policy_t_polcap_count(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 7725 PyObject *resultobj = 0; 7726 struct qpol_policy *arg1 = (struct qpol_policy *) 0 ; 7727 void *argp1 = 0 ; 7728 int res1 = 0 ; 7729 PyObject * obj0 = 0 ; 7730 size_t result; 7731 7732 if (!PyArg_ParseTuple(args,(char *)"O:qpol_policy_t_polcap_count",&obj0)) SWIG_fail; 7733 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_policy, 0 | 0 ); 7734 if (!SWIG_IsOK(res1)) { 7735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_policy_t_polcap_count" "', argument " "1"" of type '" "struct qpol_policy *""'"); 7736 } 7737 arg1 = (struct qpol_policy *)(argp1); 7738 result = (size_t)qpol_policy_polcap_count(arg1); 7739 resultobj = SWIG_From_size_t((size_t)(result)); 7740 return resultobj; 7741 fail: 7742 return NULL; 7743 } 7744 7745 7746 SWIGINTERN PyObject *_wrap_qpol_policy_t_default_iter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 7747 PyObject *resultobj = 0; 7748 struct qpol_policy *arg1 = (struct qpol_policy *) 0 ; 7749 void *argp1 = 0 ; 7750 int res1 = 0 ; 7751 PyObject * obj0 = 0 ; 7752 qpol_iterator_t *result = 0 ; 7753 7754 if (!PyArg_ParseTuple(args,(char *)"O:qpol_policy_t_default_iter",&obj0)) SWIG_fail; 7755 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_policy, 0 | 0 ); 7756 if (!SWIG_IsOK(res1)) { 7757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_policy_t_default_iter" "', argument " "1"" of type '" "struct qpol_policy *""'"); 7758 } 7759 arg1 = (struct qpol_policy *)(argp1); 7760 result = (qpol_iterator_t *)qpol_policy_default_iter(arg1); 7761 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_iterator, SWIG_POINTER_OWN | 0 ); 7762 return resultobj; 7763 fail: 7764 return NULL; 7765 } 7766 7767 7768 SWIGINTERN PyObject *_wrap_qpol_policy_t_iomemcon_iter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 7769 PyObject *resultobj = 0; 7770 struct qpol_policy *arg1 = (struct qpol_policy *) 0 ; 7771 void *argp1 = 0 ; 7772 int res1 = 0 ; 7773 PyObject * obj0 = 0 ; 7774 qpol_iterator_t *result = 0 ; 7775 7776 if (!PyArg_ParseTuple(args,(char *)"O:qpol_policy_t_iomemcon_iter",&obj0)) SWIG_fail; 7777 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_policy, 0 | 0 ); 7778 if (!SWIG_IsOK(res1)) { 7779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_policy_t_iomemcon_iter" "', argument " "1"" of type '" "struct qpol_policy *""'"); 7780 } 7781 arg1 = (struct qpol_policy *)(argp1); 7782 result = (qpol_iterator_t *)qpol_policy_iomemcon_iter(arg1); 7783 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_iterator, SWIG_POINTER_OWN | 0 ); 7784 return resultobj; 7785 fail: 7786 return NULL; 7787 } 7788 7789 7790 SWIGINTERN PyObject *_wrap_qpol_policy_t_iomemcon_count(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 7791 PyObject *resultobj = 0; 7792 struct qpol_policy *arg1 = (struct qpol_policy *) 0 ; 7793 void *argp1 = 0 ; 7794 int res1 = 0 ; 7795 PyObject * obj0 = 0 ; 7796 size_t result; 7797 7798 if (!PyArg_ParseTuple(args,(char *)"O:qpol_policy_t_iomemcon_count",&obj0)) SWIG_fail; 7799 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_policy, 0 | 0 ); 7800 if (!SWIG_IsOK(res1)) { 7801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_policy_t_iomemcon_count" "', argument " "1"" of type '" "struct qpol_policy *""'"); 7802 } 7803 arg1 = (struct qpol_policy *)(argp1); 7804 result = (size_t)qpol_policy_iomemcon_count(arg1); 7805 resultobj = SWIG_From_size_t((size_t)(result)); 7806 return resultobj; 7807 fail: 7808 return NULL; 7809 } 7810 7811 7812 SWIGINTERN PyObject *_wrap_qpol_policy_t_ioportcon_iter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 7813 PyObject *resultobj = 0; 7814 struct qpol_policy *arg1 = (struct qpol_policy *) 0 ; 7815 void *argp1 = 0 ; 7816 int res1 = 0 ; 7817 PyObject * obj0 = 0 ; 7818 qpol_iterator_t *result = 0 ; 7819 7820 if (!PyArg_ParseTuple(args,(char *)"O:qpol_policy_t_ioportcon_iter",&obj0)) SWIG_fail; 7821 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_policy, 0 | 0 ); 7822 if (!SWIG_IsOK(res1)) { 7823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_policy_t_ioportcon_iter" "', argument " "1"" of type '" "struct qpol_policy *""'"); 7824 } 7825 arg1 = (struct qpol_policy *)(argp1); 7826 result = (qpol_iterator_t *)qpol_policy_ioportcon_iter(arg1); 7827 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_iterator, SWIG_POINTER_OWN | 0 ); 7828 return resultobj; 7829 fail: 7830 return NULL; 7831 } 7832 7833 7834 SWIGINTERN PyObject *_wrap_qpol_policy_t_ioportcon_count(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 7835 PyObject *resultobj = 0; 7836 struct qpol_policy *arg1 = (struct qpol_policy *) 0 ; 7837 void *argp1 = 0 ; 7838 int res1 = 0 ; 7839 PyObject * obj0 = 0 ; 7840 size_t result; 7841 7842 if (!PyArg_ParseTuple(args,(char *)"O:qpol_policy_t_ioportcon_count",&obj0)) SWIG_fail; 7843 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_policy, 0 | 0 ); 7844 if (!SWIG_IsOK(res1)) { 7845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_policy_t_ioportcon_count" "', argument " "1"" of type '" "struct qpol_policy *""'"); 7846 } 7847 arg1 = (struct qpol_policy *)(argp1); 7848 result = (size_t)qpol_policy_ioportcon_count(arg1); 7849 resultobj = SWIG_From_size_t((size_t)(result)); 7850 return resultobj; 7851 fail: 7852 return NULL; 7853 } 7854 7855 7856 SWIGINTERN PyObject *_wrap_qpol_policy_t_pcidevicecon_iter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 7857 PyObject *resultobj = 0; 7858 struct qpol_policy *arg1 = (struct qpol_policy *) 0 ; 7859 void *argp1 = 0 ; 7860 int res1 = 0 ; 7861 PyObject * obj0 = 0 ; 7862 qpol_iterator_t *result = 0 ; 7863 7864 if (!PyArg_ParseTuple(args,(char *)"O:qpol_policy_t_pcidevicecon_iter",&obj0)) SWIG_fail; 7865 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_policy, 0 | 0 ); 7866 if (!SWIG_IsOK(res1)) { 7867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_policy_t_pcidevicecon_iter" "', argument " "1"" of type '" "struct qpol_policy *""'"); 7868 } 7869 arg1 = (struct qpol_policy *)(argp1); 7870 result = (qpol_iterator_t *)qpol_policy_pcidevicecon_iter(arg1); 7871 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_iterator, SWIG_POINTER_OWN | 0 ); 7872 return resultobj; 7873 fail: 7874 return NULL; 7875 } 7876 7877 7878 SWIGINTERN PyObject *_wrap_qpol_policy_t_pcidevicecon_count(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 7879 PyObject *resultobj = 0; 7880 struct qpol_policy *arg1 = (struct qpol_policy *) 0 ; 7881 void *argp1 = 0 ; 7882 int res1 = 0 ; 7883 PyObject * obj0 = 0 ; 7884 size_t result; 7885 7886 if (!PyArg_ParseTuple(args,(char *)"O:qpol_policy_t_pcidevicecon_count",&obj0)) SWIG_fail; 7887 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_policy, 0 | 0 ); 7888 if (!SWIG_IsOK(res1)) { 7889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_policy_t_pcidevicecon_count" "', argument " "1"" of type '" "struct qpol_policy *""'"); 7890 } 7891 arg1 = (struct qpol_policy *)(argp1); 7892 result = (size_t)qpol_policy_pcidevicecon_count(arg1); 7893 resultobj = SWIG_From_size_t((size_t)(result)); 7894 return resultobj; 7895 fail: 7896 return NULL; 7897 } 7898 7899 7900 SWIGINTERN PyObject *_wrap_qpol_policy_t_pirqcon_iter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 7901 PyObject *resultobj = 0; 7902 struct qpol_policy *arg1 = (struct qpol_policy *) 0 ; 7903 void *argp1 = 0 ; 7904 int res1 = 0 ; 7905 PyObject * obj0 = 0 ; 7906 qpol_iterator_t *result = 0 ; 7907 7908 if (!PyArg_ParseTuple(args,(char *)"O:qpol_policy_t_pirqcon_iter",&obj0)) SWIG_fail; 7909 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_policy, 0 | 0 ); 7910 if (!SWIG_IsOK(res1)) { 7911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_policy_t_pirqcon_iter" "', argument " "1"" of type '" "struct qpol_policy *""'"); 7912 } 7913 arg1 = (struct qpol_policy *)(argp1); 7914 result = (qpol_iterator_t *)qpol_policy_pirqcon_iter(arg1); 7915 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_iterator, SWIG_POINTER_OWN | 0 ); 7916 return resultobj; 7917 fail: 7918 return NULL; 7919 } 7920 7921 7922 SWIGINTERN PyObject *_wrap_qpol_policy_t_pirqcon_count(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 7923 PyObject *resultobj = 0; 7924 struct qpol_policy *arg1 = (struct qpol_policy *) 0 ; 7925 void *argp1 = 0 ; 7926 int res1 = 0 ; 7927 PyObject * obj0 = 0 ; 7928 size_t result; 7929 7930 if (!PyArg_ParseTuple(args,(char *)"O:qpol_policy_t_pirqcon_count",&obj0)) SWIG_fail; 7931 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_policy, 0 | 0 ); 7932 if (!SWIG_IsOK(res1)) { 7933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_policy_t_pirqcon_count" "', argument " "1"" of type '" "struct qpol_policy *""'"); 7934 } 7935 arg1 = (struct qpol_policy *)(argp1); 7936 result = (size_t)qpol_policy_pirqcon_count(arg1); 7937 resultobj = SWIG_From_size_t((size_t)(result)); 7938 return resultobj; 7939 fail: 7940 return NULL; 7941 } 7942 7943 7944 SWIGINTERN PyObject *_wrap_qpol_policy_t_devicetreecon_iter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 7945 PyObject *resultobj = 0; 7946 struct qpol_policy *arg1 = (struct qpol_policy *) 0 ; 7947 void *argp1 = 0 ; 7948 int res1 = 0 ; 7949 PyObject * obj0 = 0 ; 7950 qpol_iterator_t *result = 0 ; 7951 7952 if (!PyArg_ParseTuple(args,(char *)"O:qpol_policy_t_devicetreecon_iter",&obj0)) SWIG_fail; 7953 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_policy, 0 | 0 ); 7954 if (!SWIG_IsOK(res1)) { 7955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_policy_t_devicetreecon_iter" "', argument " "1"" of type '" "struct qpol_policy *""'"); 7956 } 7957 arg1 = (struct qpol_policy *)(argp1); 7958 result = (qpol_iterator_t *)qpol_policy_devicetreecon_iter(arg1); 7959 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_iterator, SWIG_POINTER_OWN | 0 ); 7960 return resultobj; 7961 fail: 7962 return NULL; 7963 } 7964 7965 7966 SWIGINTERN PyObject *_wrap_qpol_policy_t_devicetreecon_count(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 7967 PyObject *resultobj = 0; 7968 struct qpol_policy *arg1 = (struct qpol_policy *) 0 ; 7969 void *argp1 = 0 ; 7970 int res1 = 0 ; 7971 PyObject * obj0 = 0 ; 7972 size_t result; 7973 7974 if (!PyArg_ParseTuple(args,(char *)"O:qpol_policy_t_devicetreecon_count",&obj0)) SWIG_fail; 7975 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_policy, 0 | 0 ); 7976 if (!SWIG_IsOK(res1)) { 7977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_policy_t_devicetreecon_count" "', argument " "1"" of type '" "struct qpol_policy *""'"); 7978 } 7979 arg1 = (struct qpol_policy *)(argp1); 7980 result = (size_t)qpol_policy_devicetreecon_count(arg1); 7981 resultobj = SWIG_From_size_t((size_t)(result)); 7982 return resultobj; 7983 fail: 7984 return NULL; 7985 } 7986 7987 7988 SWIGINTERN PyObject *qpol_policy_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 7989 PyObject *obj; 7990 if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; 7991 SWIG_TypeNewClientData(SWIGTYPE_p_qpol_policy, SWIG_NewClientData(obj)); 7992 return SWIG_Py_Void(); 7993 } 7994 7995 SWIGINTERN PyObject *_wrap_new_qpol_iterator_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 7996 PyObject *resultobj = 0; 7997 struct qpol_iterator *result = 0 ; 7998 7999 if (!PyArg_ParseTuple(args,(char *)":new_qpol_iterator_t")) SWIG_fail; 8000 result = (struct qpol_iterator *)new_qpol_iterator(); 8001 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_iterator, SWIG_POINTER_NEW | 0 ); 8002 return resultobj; 8003 fail: 8004 return NULL; 8005 } 8006 8007 8008 SWIGINTERN PyObject *_wrap_delete_qpol_iterator_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 8009 PyObject *resultobj = 0; 8010 struct qpol_iterator *arg1 = (struct qpol_iterator *) 0 ; 8011 void *argp1 = 0 ; 8012 int res1 = 0 ; 8013 PyObject * obj0 = 0 ; 8014 8015 if (!PyArg_ParseTuple(args,(char *)"O:delete_qpol_iterator_t",&obj0)) SWIG_fail; 8016 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_iterator, SWIG_POINTER_DISOWN | 0 ); 8017 if (!SWIG_IsOK(res1)) { 8018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_qpol_iterator_t" "', argument " "1"" of type '" "struct qpol_iterator *""'"); 8019 } 8020 arg1 = (struct qpol_iterator *)(argp1); 8021 delete_qpol_iterator(arg1); 8022 resultobj = SWIG_Py_Void(); 8023 return resultobj; 8024 fail: 8025 return NULL; 8026 } 8027 8028 8029 SWIGINTERN PyObject *_wrap_qpol_iterator_t_item(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 8030 PyObject *resultobj = 0; 8031 struct qpol_iterator *arg1 = (struct qpol_iterator *) 0 ; 8032 void *argp1 = 0 ; 8033 int res1 = 0 ; 8034 PyObject * obj0 = 0 ; 8035 void *result = 0 ; 8036 8037 if (!PyArg_ParseTuple(args,(char *)"O:qpol_iterator_t_item",&obj0)) SWIG_fail; 8038 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_iterator, 0 | 0 ); 8039 if (!SWIG_IsOK(res1)) { 8040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_iterator_t_item" "', argument " "1"" of type '" "struct qpol_iterator *""'"); 8041 } 8042 arg1 = (struct qpol_iterator *)(argp1); 8043 result = (void *)qpol_iterator_item(arg1); 8044 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 ); 8045 return resultobj; 8046 fail: 8047 return NULL; 8048 } 8049 8050 8051 SWIGINTERN PyObject *_wrap_qpol_iterator_t_next_(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 8052 PyObject *resultobj = 0; 8053 struct qpol_iterator *arg1 = (struct qpol_iterator *) 0 ; 8054 void *argp1 = 0 ; 8055 int res1 = 0 ; 8056 PyObject * obj0 = 0 ; 8057 8058 if (!PyArg_ParseTuple(args,(char *)"O:qpol_iterator_t_next_",&obj0)) SWIG_fail; 8059 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_iterator, 0 | 0 ); 8060 if (!SWIG_IsOK(res1)) { 8061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_iterator_t_next_" "', argument " "1"" of type '" "struct qpol_iterator *""'"); 8062 } 8063 arg1 = (struct qpol_iterator *)(argp1); 8064 qpol_iterator_next_(arg1); 8065 resultobj = SWIG_Py_Void(); 8066 return resultobj; 8067 fail: 8068 return NULL; 8069 } 8070 8071 8072 SWIGINTERN PyObject *_wrap_qpol_iterator_t_isend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 8073 PyObject *resultobj = 0; 8074 struct qpol_iterator *arg1 = (struct qpol_iterator *) 0 ; 8075 void *argp1 = 0 ; 8076 int res1 = 0 ; 8077 PyObject * obj0 = 0 ; 8078 int result; 8079 8080 if (!PyArg_ParseTuple(args,(char *)"O:qpol_iterator_t_isend",&obj0)) SWIG_fail; 8081 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_iterator, 0 | 0 ); 8082 if (!SWIG_IsOK(res1)) { 8083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_iterator_t_isend" "', argument " "1"" of type '" "struct qpol_iterator *""'"); 8084 } 8085 arg1 = (struct qpol_iterator *)(argp1); 8086 result = (int)qpol_iterator_isend(arg1); 8087 resultobj = SWIG_From_int((int)(result)); 8088 return resultobj; 8089 fail: 8090 return NULL; 8091 } 8092 8093 8094 SWIGINTERN PyObject *_wrap_qpol_iterator_t_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 8095 PyObject *resultobj = 0; 8096 struct qpol_iterator *arg1 = (struct qpol_iterator *) 0 ; 8097 void *argp1 = 0 ; 8098 int res1 = 0 ; 8099 PyObject * obj0 = 0 ; 8100 size_t result; 8101 8102 if (!PyArg_ParseTuple(args,(char *)"O:qpol_iterator_t_size",&obj0)) SWIG_fail; 8103 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_iterator, 0 | 0 ); 8104 if (!SWIG_IsOK(res1)) { 8105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_iterator_t_size" "', argument " "1"" of type '" "struct qpol_iterator *""'"); 8106 } 8107 arg1 = (struct qpol_iterator *)(argp1); 8108 result = (size_t)qpol_iterator_size(arg1); 8109 resultobj = SWIG_From_size_t((size_t)(result)); 8110 return resultobj; 8111 fail: 8112 return NULL; 8113 } 8114 8115 8116 SWIGINTERN PyObject *qpol_iterator_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 8117 PyObject *obj; 8118 if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; 8119 SWIG_TypeNewClientData(SWIGTYPE_p_qpol_iterator, SWIG_NewClientData(obj)); 8120 return SWIG_Py_Void(); 8121 } 8122 8123 SWIGINTERN PyObject *_wrap_new_qpol_type_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 8124 PyObject *resultobj = 0; 8125 qpol_policy_t *arg1 = (qpol_policy_t *) 0 ; 8126 char *arg2 = (char *) 0 ; 8127 void *argp1 = 0 ; 8128 int res1 = 0 ; 8129 int res2 ; 8130 char *buf2 = 0 ; 8131 int alloc2 = 0 ; 8132 PyObject * obj0 = 0 ; 8133 PyObject * obj1 = 0 ; 8134 struct qpol_type *result = 0 ; 8135 8136 if (!PyArg_ParseTuple(args,(char *)"OO:new_qpol_type_t",&obj0,&obj1)) SWIG_fail; 8137 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_policy, 0 | 0 ); 8138 if (!SWIG_IsOK(res1)) { 8139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_qpol_type_t" "', argument " "1"" of type '" "qpol_policy_t *""'"); 8140 } 8141 arg1 = (qpol_policy_t *)(argp1); 8142 res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); 8143 if (!SWIG_IsOK(res2)) { 8144 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_qpol_type_t" "', argument " "2"" of type '" "char const *""'"); 8145 } 8146 arg2 = (char *)(buf2); 8147 { 8148 result = (struct qpol_type *)new_qpol_type(arg1,(char const *)arg2); 8149 if (!result) { 8150 PyErr_SetString(PyExc_ValueError, "Invalid type or attribute."); 8151 return NULL; 8152 } 8153 } 8154 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_type, SWIG_POINTER_NEW | 0 ); 8155 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); 8156 return resultobj; 8157 fail: 8158 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); 8159 return NULL; 8160 } 8161 8162 8163 SWIGINTERN PyObject *_wrap_delete_qpol_type_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 8164 PyObject *resultobj = 0; 8165 struct qpol_type *arg1 = (struct qpol_type *) 0 ; 8166 void *argp1 = 0 ; 8167 int res1 = 0 ; 8168 PyObject * obj0 = 0 ; 8169 8170 if (!PyArg_ParseTuple(args,(char *)"O:delete_qpol_type_t",&obj0)) SWIG_fail; 8171 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_type, SWIG_POINTER_DISOWN | 0 ); 8172 if (!SWIG_IsOK(res1)) { 8173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_qpol_type_t" "', argument " "1"" of type '" "struct qpol_type *""'"); 8174 } 8175 arg1 = (struct qpol_type *)(argp1); 8176 delete_qpol_type(arg1); 8177 resultobj = SWIG_Py_Void(); 8178 return resultobj; 8179 fail: 8180 return NULL; 8181 } 8182 8183 8184 SWIGINTERN PyObject *_wrap_qpol_type_t_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 8185 PyObject *resultobj = 0; 8186 struct qpol_type *arg1 = (struct qpol_type *) 0 ; 8187 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 8188 void *argp1 = 0 ; 8189 int res1 = 0 ; 8190 void *argp2 = 0 ; 8191 int res2 = 0 ; 8192 PyObject * obj0 = 0 ; 8193 PyObject * obj1 = 0 ; 8194 char *result = 0 ; 8195 8196 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_type_t_name",&obj0,&obj1)) SWIG_fail; 8197 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_type, 0 | 0 ); 8198 if (!SWIG_IsOK(res1)) { 8199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_type_t_name" "', argument " "1"" of type '" "struct qpol_type *""'"); 8200 } 8201 arg1 = (struct qpol_type *)(argp1); 8202 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 8203 if (!SWIG_IsOK(res2)) { 8204 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_type_t_name" "', argument " "2"" of type '" "qpol_policy_t *""'"); 8205 } 8206 arg2 = (qpol_policy_t *)(argp2); 8207 result = (char *)qpol_type_name(arg1,arg2); 8208 resultobj = SWIG_FromCharPtr((const char *)result); 8209 return resultobj; 8210 fail: 8211 return NULL; 8212 } 8213 8214 8215 SWIGINTERN PyObject *_wrap_qpol_type_t_value(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 8216 PyObject *resultobj = 0; 8217 struct qpol_type *arg1 = (struct qpol_type *) 0 ; 8218 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 8219 void *argp1 = 0 ; 8220 int res1 = 0 ; 8221 void *argp2 = 0 ; 8222 int res2 = 0 ; 8223 PyObject * obj0 = 0 ; 8224 PyObject * obj1 = 0 ; 8225 int result; 8226 8227 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_type_t_value",&obj0,&obj1)) SWIG_fail; 8228 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_type, 0 | 0 ); 8229 if (!SWIG_IsOK(res1)) { 8230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_type_t_value" "', argument " "1"" of type '" "struct qpol_type *""'"); 8231 } 8232 arg1 = (struct qpol_type *)(argp1); 8233 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 8234 if (!SWIG_IsOK(res2)) { 8235 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_type_t_value" "', argument " "2"" of type '" "qpol_policy_t *""'"); 8236 } 8237 arg2 = (qpol_policy_t *)(argp2); 8238 result = (int)qpol_type_value(arg1,arg2); 8239 resultobj = SWIG_From_int((int)(result)); 8240 return resultobj; 8241 fail: 8242 return NULL; 8243 } 8244 8245 8246 SWIGINTERN PyObject *_wrap_qpol_type_t_isalias(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 8247 PyObject *resultobj = 0; 8248 struct qpol_type *arg1 = (struct qpol_type *) 0 ; 8249 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 8250 void *argp1 = 0 ; 8251 int res1 = 0 ; 8252 void *argp2 = 0 ; 8253 int res2 = 0 ; 8254 PyObject * obj0 = 0 ; 8255 PyObject * obj1 = 0 ; 8256 int result; 8257 8258 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_type_t_isalias",&obj0,&obj1)) SWIG_fail; 8259 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_type, 0 | 0 ); 8260 if (!SWIG_IsOK(res1)) { 8261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_type_t_isalias" "', argument " "1"" of type '" "struct qpol_type *""'"); 8262 } 8263 arg1 = (struct qpol_type *)(argp1); 8264 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 8265 if (!SWIG_IsOK(res2)) { 8266 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_type_t_isalias" "', argument " "2"" of type '" "qpol_policy_t *""'"); 8267 } 8268 arg2 = (qpol_policy_t *)(argp2); 8269 result = (int)qpol_type_isalias(arg1,arg2); 8270 resultobj = SWIG_From_int((int)(result)); 8271 return resultobj; 8272 fail: 8273 return NULL; 8274 } 8275 8276 8277 SWIGINTERN PyObject *_wrap_qpol_type_t_isattr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 8278 PyObject *resultobj = 0; 8279 struct qpol_type *arg1 = (struct qpol_type *) 0 ; 8280 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 8281 void *argp1 = 0 ; 8282 int res1 = 0 ; 8283 void *argp2 = 0 ; 8284 int res2 = 0 ; 8285 PyObject * obj0 = 0 ; 8286 PyObject * obj1 = 0 ; 8287 int result; 8288 8289 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_type_t_isattr",&obj0,&obj1)) SWIG_fail; 8290 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_type, 0 | 0 ); 8291 if (!SWIG_IsOK(res1)) { 8292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_type_t_isattr" "', argument " "1"" of type '" "struct qpol_type *""'"); 8293 } 8294 arg1 = (struct qpol_type *)(argp1); 8295 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 8296 if (!SWIG_IsOK(res2)) { 8297 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_type_t_isattr" "', argument " "2"" of type '" "qpol_policy_t *""'"); 8298 } 8299 arg2 = (qpol_policy_t *)(argp2); 8300 result = (int)qpol_type_isattr(arg1,arg2); 8301 resultobj = SWIG_From_int((int)(result)); 8302 return resultobj; 8303 fail: 8304 return NULL; 8305 } 8306 8307 8308 SWIGINTERN PyObject *_wrap_qpol_type_t_ispermissive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 8309 PyObject *resultobj = 0; 8310 struct qpol_type *arg1 = (struct qpol_type *) 0 ; 8311 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 8312 void *argp1 = 0 ; 8313 int res1 = 0 ; 8314 void *argp2 = 0 ; 8315 int res2 = 0 ; 8316 PyObject * obj0 = 0 ; 8317 PyObject * obj1 = 0 ; 8318 int result; 8319 8320 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_type_t_ispermissive",&obj0,&obj1)) SWIG_fail; 8321 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_type, 0 | 0 ); 8322 if (!SWIG_IsOK(res1)) { 8323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_type_t_ispermissive" "', argument " "1"" of type '" "struct qpol_type *""'"); 8324 } 8325 arg1 = (struct qpol_type *)(argp1); 8326 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 8327 if (!SWIG_IsOK(res2)) { 8328 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_type_t_ispermissive" "', argument " "2"" of type '" "qpol_policy_t *""'"); 8329 } 8330 arg2 = (qpol_policy_t *)(argp2); 8331 result = (int)qpol_type_ispermissive(arg1,arg2); 8332 resultobj = SWIG_From_int((int)(result)); 8333 return resultobj; 8334 fail: 8335 return NULL; 8336 } 8337 8338 8339 SWIGINTERN PyObject *_wrap_qpol_type_t_type_iter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 8340 PyObject *resultobj = 0; 8341 struct qpol_type *arg1 = (struct qpol_type *) 0 ; 8342 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 8343 void *argp1 = 0 ; 8344 int res1 = 0 ; 8345 void *argp2 = 0 ; 8346 int res2 = 0 ; 8347 PyObject * obj0 = 0 ; 8348 PyObject * obj1 = 0 ; 8349 qpol_iterator_t *result = 0 ; 8350 8351 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_type_t_type_iter",&obj0,&obj1)) SWIG_fail; 8352 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_type, 0 | 0 ); 8353 if (!SWIG_IsOK(res1)) { 8354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_type_t_type_iter" "', argument " "1"" of type '" "struct qpol_type *""'"); 8355 } 8356 arg1 = (struct qpol_type *)(argp1); 8357 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 8358 if (!SWIG_IsOK(res2)) { 8359 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_type_t_type_iter" "', argument " "2"" of type '" "qpol_policy_t *""'"); 8360 } 8361 arg2 = (qpol_policy_t *)(argp2); 8362 result = (qpol_iterator_t *)qpol_type_type_iter(arg1,arg2); 8363 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_iterator, SWIG_POINTER_OWN | 0 ); 8364 return resultobj; 8365 fail: 8366 return NULL; 8367 } 8368 8369 8370 SWIGINTERN PyObject *_wrap_qpol_type_t_attr_iter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 8371 PyObject *resultobj = 0; 8372 struct qpol_type *arg1 = (struct qpol_type *) 0 ; 8373 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 8374 void *argp1 = 0 ; 8375 int res1 = 0 ; 8376 void *argp2 = 0 ; 8377 int res2 = 0 ; 8378 PyObject * obj0 = 0 ; 8379 PyObject * obj1 = 0 ; 8380 qpol_iterator_t *result = 0 ; 8381 8382 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_type_t_attr_iter",&obj0,&obj1)) SWIG_fail; 8383 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_type, 0 | 0 ); 8384 if (!SWIG_IsOK(res1)) { 8385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_type_t_attr_iter" "', argument " "1"" of type '" "struct qpol_type *""'"); 8386 } 8387 arg1 = (struct qpol_type *)(argp1); 8388 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 8389 if (!SWIG_IsOK(res2)) { 8390 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_type_t_attr_iter" "', argument " "2"" of type '" "qpol_policy_t *""'"); 8391 } 8392 arg2 = (qpol_policy_t *)(argp2); 8393 result = (qpol_iterator_t *)qpol_type_attr_iter(arg1,arg2); 8394 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_iterator, SWIG_POINTER_OWN | 0 ); 8395 return resultobj; 8396 fail: 8397 return NULL; 8398 } 8399 8400 8401 SWIGINTERN PyObject *_wrap_qpol_type_t_alias_iter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 8402 PyObject *resultobj = 0; 8403 struct qpol_type *arg1 = (struct qpol_type *) 0 ; 8404 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 8405 void *argp1 = 0 ; 8406 int res1 = 0 ; 8407 void *argp2 = 0 ; 8408 int res2 = 0 ; 8409 PyObject * obj0 = 0 ; 8410 PyObject * obj1 = 0 ; 8411 qpol_iterator_t *result = 0 ; 8412 8413 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_type_t_alias_iter",&obj0,&obj1)) SWIG_fail; 8414 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_type, 0 | 0 ); 8415 if (!SWIG_IsOK(res1)) { 8416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_type_t_alias_iter" "', argument " "1"" of type '" "struct qpol_type *""'"); 8417 } 8418 arg1 = (struct qpol_type *)(argp1); 8419 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 8420 if (!SWIG_IsOK(res2)) { 8421 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_type_t_alias_iter" "', argument " "2"" of type '" "qpol_policy_t *""'"); 8422 } 8423 arg2 = (qpol_policy_t *)(argp2); 8424 result = (qpol_iterator_t *)qpol_type_alias_iter(arg1,arg2); 8425 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_iterator, SWIG_POINTER_OWN | 0 ); 8426 return resultobj; 8427 fail: 8428 return NULL; 8429 } 8430 8431 8432 SWIGINTERN PyObject *qpol_type_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 8433 PyObject *obj; 8434 if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; 8435 SWIG_TypeNewClientData(SWIGTYPE_p_qpol_type, SWIG_NewClientData(obj)); 8436 return SWIG_Py_Void(); 8437 } 8438 8439 SWIGINTERN PyObject *_wrap_qpol_type_from_void(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 8440 PyObject *resultobj = 0; 8441 void *arg1 = (void *) 0 ; 8442 int res1 ; 8443 PyObject * obj0 = 0 ; 8444 qpol_type_t *result = 0 ; 8445 8446 if (!PyArg_ParseTuple(args,(char *)"O:qpol_type_from_void",&obj0)) SWIG_fail; 8447 res1 = SWIG_ConvertPtr(obj0,SWIG_as_voidptrptr(&arg1), 0, 0); 8448 if (!SWIG_IsOK(res1)) { 8449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_type_from_void" "', argument " "1"" of type '" "void *""'"); 8450 } 8451 result = (qpol_type_t *)qpol_type_from_void(arg1); 8452 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_type, 0 | 0 ); 8453 return resultobj; 8454 fail: 8455 return NULL; 8456 } 8457 8458 8459 SWIGINTERN PyObject *_wrap_new_qpol_role_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 8460 PyObject *resultobj = 0; 8461 qpol_policy_t *arg1 = (qpol_policy_t *) 0 ; 8462 char *arg2 = (char *) 0 ; 8463 void *argp1 = 0 ; 8464 int res1 = 0 ; 8465 int res2 ; 8466 char *buf2 = 0 ; 8467 int alloc2 = 0 ; 8468 PyObject * obj0 = 0 ; 8469 PyObject * obj1 = 0 ; 8470 struct qpol_role *result = 0 ; 8471 8472 if (!PyArg_ParseTuple(args,(char *)"OO:new_qpol_role_t",&obj0,&obj1)) SWIG_fail; 8473 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_policy, 0 | 0 ); 8474 if (!SWIG_IsOK(res1)) { 8475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_qpol_role_t" "', argument " "1"" of type '" "qpol_policy_t *""'"); 8476 } 8477 arg1 = (qpol_policy_t *)(argp1); 8478 res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); 8479 if (!SWIG_IsOK(res2)) { 8480 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_qpol_role_t" "', argument " "2"" of type '" "char const *""'"); 8481 } 8482 arg2 = (char *)(buf2); 8483 { 8484 result = (struct qpol_role *)new_qpol_role(arg1,(char const *)arg2); 8485 if (!result) { 8486 PyErr_SetString(PyExc_ValueError, "Invalid type or attribute."); 8487 return NULL; 8488 } 8489 } 8490 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_role, SWIG_POINTER_NEW | 0 ); 8491 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); 8492 return resultobj; 8493 fail: 8494 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); 8495 return NULL; 8496 } 8497 8498 8499 SWIGINTERN PyObject *_wrap_delete_qpol_role_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 8500 PyObject *resultobj = 0; 8501 struct qpol_role *arg1 = (struct qpol_role *) 0 ; 8502 void *argp1 = 0 ; 8503 int res1 = 0 ; 8504 PyObject * obj0 = 0 ; 8505 8506 if (!PyArg_ParseTuple(args,(char *)"O:delete_qpol_role_t",&obj0)) SWIG_fail; 8507 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_role, SWIG_POINTER_DISOWN | 0 ); 8508 if (!SWIG_IsOK(res1)) { 8509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_qpol_role_t" "', argument " "1"" of type '" "struct qpol_role *""'"); 8510 } 8511 arg1 = (struct qpol_role *)(argp1); 8512 delete_qpol_role(arg1); 8513 resultobj = SWIG_Py_Void(); 8514 return resultobj; 8515 fail: 8516 return NULL; 8517 } 8518 8519 8520 SWIGINTERN PyObject *_wrap_qpol_role_t_value(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 8521 PyObject *resultobj = 0; 8522 struct qpol_role *arg1 = (struct qpol_role *) 0 ; 8523 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 8524 void *argp1 = 0 ; 8525 int res1 = 0 ; 8526 void *argp2 = 0 ; 8527 int res2 = 0 ; 8528 PyObject * obj0 = 0 ; 8529 PyObject * obj1 = 0 ; 8530 int result; 8531 8532 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_role_t_value",&obj0,&obj1)) SWIG_fail; 8533 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_role, 0 | 0 ); 8534 if (!SWIG_IsOK(res1)) { 8535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_role_t_value" "', argument " "1"" of type '" "struct qpol_role *""'"); 8536 } 8537 arg1 = (struct qpol_role *)(argp1); 8538 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 8539 if (!SWIG_IsOK(res2)) { 8540 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_role_t_value" "', argument " "2"" of type '" "qpol_policy_t *""'"); 8541 } 8542 arg2 = (qpol_policy_t *)(argp2); 8543 result = (int)qpol_role_value(arg1,arg2); 8544 resultobj = SWIG_From_int((int)(result)); 8545 return resultobj; 8546 fail: 8547 return NULL; 8548 } 8549 8550 8551 SWIGINTERN PyObject *_wrap_qpol_role_t_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 8552 PyObject *resultobj = 0; 8553 struct qpol_role *arg1 = (struct qpol_role *) 0 ; 8554 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 8555 void *argp1 = 0 ; 8556 int res1 = 0 ; 8557 void *argp2 = 0 ; 8558 int res2 = 0 ; 8559 PyObject * obj0 = 0 ; 8560 PyObject * obj1 = 0 ; 8561 char *result = 0 ; 8562 8563 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_role_t_name",&obj0,&obj1)) SWIG_fail; 8564 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_role, 0 | 0 ); 8565 if (!SWIG_IsOK(res1)) { 8566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_role_t_name" "', argument " "1"" of type '" "struct qpol_role *""'"); 8567 } 8568 arg1 = (struct qpol_role *)(argp1); 8569 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 8570 if (!SWIG_IsOK(res2)) { 8571 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_role_t_name" "', argument " "2"" of type '" "qpol_policy_t *""'"); 8572 } 8573 arg2 = (qpol_policy_t *)(argp2); 8574 result = (char *)qpol_role_name(arg1,arg2); 8575 resultobj = SWIG_FromCharPtr((const char *)result); 8576 return resultobj; 8577 fail: 8578 return NULL; 8579 } 8580 8581 8582 SWIGINTERN PyObject *_wrap_qpol_role_t_type_iter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 8583 PyObject *resultobj = 0; 8584 struct qpol_role *arg1 = (struct qpol_role *) 0 ; 8585 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 8586 void *argp1 = 0 ; 8587 int res1 = 0 ; 8588 void *argp2 = 0 ; 8589 int res2 = 0 ; 8590 PyObject * obj0 = 0 ; 8591 PyObject * obj1 = 0 ; 8592 qpol_iterator_t *result = 0 ; 8593 8594 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_role_t_type_iter",&obj0,&obj1)) SWIG_fail; 8595 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_role, 0 | 0 ); 8596 if (!SWIG_IsOK(res1)) { 8597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_role_t_type_iter" "', argument " "1"" of type '" "struct qpol_role *""'"); 8598 } 8599 arg1 = (struct qpol_role *)(argp1); 8600 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 8601 if (!SWIG_IsOK(res2)) { 8602 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_role_t_type_iter" "', argument " "2"" of type '" "qpol_policy_t *""'"); 8603 } 8604 arg2 = (qpol_policy_t *)(argp2); 8605 result = (qpol_iterator_t *)qpol_role_type_iter(arg1,arg2); 8606 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_iterator, SWIG_POINTER_OWN | 0 ); 8607 return resultobj; 8608 fail: 8609 return NULL; 8610 } 8611 8612 8613 SWIGINTERN PyObject *_wrap_qpol_role_t_dominate_iter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 8614 PyObject *resultobj = 0; 8615 struct qpol_role *arg1 = (struct qpol_role *) 0 ; 8616 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 8617 void *argp1 = 0 ; 8618 int res1 = 0 ; 8619 void *argp2 = 0 ; 8620 int res2 = 0 ; 8621 PyObject * obj0 = 0 ; 8622 PyObject * obj1 = 0 ; 8623 qpol_iterator_t *result = 0 ; 8624 8625 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_role_t_dominate_iter",&obj0,&obj1)) SWIG_fail; 8626 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_role, 0 | 0 ); 8627 if (!SWIG_IsOK(res1)) { 8628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_role_t_dominate_iter" "', argument " "1"" of type '" "struct qpol_role *""'"); 8629 } 8630 arg1 = (struct qpol_role *)(argp1); 8631 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 8632 if (!SWIG_IsOK(res2)) { 8633 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_role_t_dominate_iter" "', argument " "2"" of type '" "qpol_policy_t *""'"); 8634 } 8635 arg2 = (qpol_policy_t *)(argp2); 8636 result = (qpol_iterator_t *)qpol_role_dominate_iter(arg1,arg2); 8637 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_iterator, SWIG_POINTER_OWN | 0 ); 8638 return resultobj; 8639 fail: 8640 return NULL; 8641 } 8642 8643 8644 SWIGINTERN PyObject *qpol_role_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 8645 PyObject *obj; 8646 if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; 8647 SWIG_TypeNewClientData(SWIGTYPE_p_qpol_role, SWIG_NewClientData(obj)); 8648 return SWIG_Py_Void(); 8649 } 8650 8651 SWIGINTERN PyObject *_wrap_qpol_role_from_void(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 8652 PyObject *resultobj = 0; 8653 void *arg1 = (void *) 0 ; 8654 int res1 ; 8655 PyObject * obj0 = 0 ; 8656 qpol_role_t *result = 0 ; 8657 8658 if (!PyArg_ParseTuple(args,(char *)"O:qpol_role_from_void",&obj0)) SWIG_fail; 8659 res1 = SWIG_ConvertPtr(obj0,SWIG_as_voidptrptr(&arg1), 0, 0); 8660 if (!SWIG_IsOK(res1)) { 8661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_role_from_void" "', argument " "1"" of type '" "void *""'"); 8662 } 8663 result = (qpol_role_t *)qpol_role_from_void(arg1); 8664 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_role, 0 | 0 ); 8665 return resultobj; 8666 fail: 8667 return NULL; 8668 } 8669 8670 8671 SWIGINTERN PyObject *_wrap_new_qpol_level_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 8672 PyObject *resultobj = 0; 8673 qpol_policy_t *arg1 = (qpol_policy_t *) 0 ; 8674 char *arg2 = (char *) 0 ; 8675 void *argp1 = 0 ; 8676 int res1 = 0 ; 8677 int res2 ; 8678 char *buf2 = 0 ; 8679 int alloc2 = 0 ; 8680 PyObject * obj0 = 0 ; 8681 PyObject * obj1 = 0 ; 8682 struct qpol_level *result = 0 ; 8683 8684 if (!PyArg_ParseTuple(args,(char *)"OO:new_qpol_level_t",&obj0,&obj1)) SWIG_fail; 8685 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_policy, 0 | 0 ); 8686 if (!SWIG_IsOK(res1)) { 8687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_qpol_level_t" "', argument " "1"" of type '" "qpol_policy_t *""'"); 8688 } 8689 arg1 = (qpol_policy_t *)(argp1); 8690 res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); 8691 if (!SWIG_IsOK(res2)) { 8692 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_qpol_level_t" "', argument " "2"" of type '" "char const *""'"); 8693 } 8694 arg2 = (char *)(buf2); 8695 { 8696 result = (struct qpol_level *)new_qpol_level(arg1,(char const *)arg2); 8697 if (!result) { 8698 if (errno == EINVAL) { 8699 PyErr_SetString(PyExc_ValueError, "Invalid level."); 8700 } else { 8701 PyErr_SetFromErrno(PyExc_OSError); 8702 } 8703 8704 return NULL; 8705 } 8706 } 8707 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_level, SWIG_POINTER_NEW | 0 ); 8708 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); 8709 return resultobj; 8710 fail: 8711 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); 8712 return NULL; 8713 } 8714 8715 8716 SWIGINTERN PyObject *_wrap_delete_qpol_level_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 8717 PyObject *resultobj = 0; 8718 struct qpol_level *arg1 = (struct qpol_level *) 0 ; 8719 void *argp1 = 0 ; 8720 int res1 = 0 ; 8721 PyObject * obj0 = 0 ; 8722 8723 if (!PyArg_ParseTuple(args,(char *)"O:delete_qpol_level_t",&obj0)) SWIG_fail; 8724 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_level, SWIG_POINTER_DISOWN | 0 ); 8725 if (!SWIG_IsOK(res1)) { 8726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_qpol_level_t" "', argument " "1"" of type '" "struct qpol_level *""'"); 8727 } 8728 arg1 = (struct qpol_level *)(argp1); 8729 delete_qpol_level(arg1); 8730 resultobj = SWIG_Py_Void(); 8731 return resultobj; 8732 fail: 8733 return NULL; 8734 } 8735 8736 8737 SWIGINTERN PyObject *_wrap_qpol_level_t_isalias(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 8738 PyObject *resultobj = 0; 8739 struct qpol_level *arg1 = (struct qpol_level *) 0 ; 8740 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 8741 void *argp1 = 0 ; 8742 int res1 = 0 ; 8743 void *argp2 = 0 ; 8744 int res2 = 0 ; 8745 PyObject * obj0 = 0 ; 8746 PyObject * obj1 = 0 ; 8747 int result; 8748 8749 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_level_t_isalias",&obj0,&obj1)) SWIG_fail; 8750 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_level, 0 | 0 ); 8751 if (!SWIG_IsOK(res1)) { 8752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_level_t_isalias" "', argument " "1"" of type '" "struct qpol_level *""'"); 8753 } 8754 arg1 = (struct qpol_level *)(argp1); 8755 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 8756 if (!SWIG_IsOK(res2)) { 8757 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_level_t_isalias" "', argument " "2"" of type '" "qpol_policy_t *""'"); 8758 } 8759 arg2 = (qpol_policy_t *)(argp2); 8760 result = (int)qpol_level_isalias(arg1,arg2); 8761 resultobj = SWIG_From_int((int)(result)); 8762 return resultobj; 8763 fail: 8764 return NULL; 8765 } 8766 8767 8768 SWIGINTERN PyObject *_wrap_qpol_level_t_value(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 8769 PyObject *resultobj = 0; 8770 struct qpol_level *arg1 = (struct qpol_level *) 0 ; 8771 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 8772 void *argp1 = 0 ; 8773 int res1 = 0 ; 8774 void *argp2 = 0 ; 8775 int res2 = 0 ; 8776 PyObject * obj0 = 0 ; 8777 PyObject * obj1 = 0 ; 8778 int result; 8779 8780 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_level_t_value",&obj0,&obj1)) SWIG_fail; 8781 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_level, 0 | 0 ); 8782 if (!SWIG_IsOK(res1)) { 8783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_level_t_value" "', argument " "1"" of type '" "struct qpol_level *""'"); 8784 } 8785 arg1 = (struct qpol_level *)(argp1); 8786 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 8787 if (!SWIG_IsOK(res2)) { 8788 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_level_t_value" "', argument " "2"" of type '" "qpol_policy_t *""'"); 8789 } 8790 arg2 = (qpol_policy_t *)(argp2); 8791 result = (int)qpol_level_value(arg1,arg2); 8792 resultobj = SWIG_From_int((int)(result)); 8793 return resultobj; 8794 fail: 8795 return NULL; 8796 } 8797 8798 8799 SWIGINTERN PyObject *_wrap_qpol_level_t_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 8800 PyObject *resultobj = 0; 8801 struct qpol_level *arg1 = (struct qpol_level *) 0 ; 8802 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 8803 void *argp1 = 0 ; 8804 int res1 = 0 ; 8805 void *argp2 = 0 ; 8806 int res2 = 0 ; 8807 PyObject * obj0 = 0 ; 8808 PyObject * obj1 = 0 ; 8809 char *result = 0 ; 8810 8811 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_level_t_name",&obj0,&obj1)) SWIG_fail; 8812 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_level, 0 | 0 ); 8813 if (!SWIG_IsOK(res1)) { 8814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_level_t_name" "', argument " "1"" of type '" "struct qpol_level *""'"); 8815 } 8816 arg1 = (struct qpol_level *)(argp1); 8817 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 8818 if (!SWIG_IsOK(res2)) { 8819 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_level_t_name" "', argument " "2"" of type '" "qpol_policy_t *""'"); 8820 } 8821 arg2 = (qpol_policy_t *)(argp2); 8822 result = (char *)qpol_level_name(arg1,arg2); 8823 resultobj = SWIG_FromCharPtr((const char *)result); 8824 return resultobj; 8825 fail: 8826 return NULL; 8827 } 8828 8829 8830 SWIGINTERN PyObject *_wrap_qpol_level_t_cat_iter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 8831 PyObject *resultobj = 0; 8832 struct qpol_level *arg1 = (struct qpol_level *) 0 ; 8833 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 8834 void *argp1 = 0 ; 8835 int res1 = 0 ; 8836 void *argp2 = 0 ; 8837 int res2 = 0 ; 8838 PyObject * obj0 = 0 ; 8839 PyObject * obj1 = 0 ; 8840 qpol_iterator_t *result = 0 ; 8841 8842 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_level_t_cat_iter",&obj0,&obj1)) SWIG_fail; 8843 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_level, 0 | 0 ); 8844 if (!SWIG_IsOK(res1)) { 8845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_level_t_cat_iter" "', argument " "1"" of type '" "struct qpol_level *""'"); 8846 } 8847 arg1 = (struct qpol_level *)(argp1); 8848 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 8849 if (!SWIG_IsOK(res2)) { 8850 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_level_t_cat_iter" "', argument " "2"" of type '" "qpol_policy_t *""'"); 8851 } 8852 arg2 = (qpol_policy_t *)(argp2); 8853 result = (qpol_iterator_t *)qpol_level_cat_iter(arg1,arg2); 8854 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_iterator, SWIG_POINTER_OWN | 0 ); 8855 return resultobj; 8856 fail: 8857 return NULL; 8858 } 8859 8860 8861 SWIGINTERN PyObject *_wrap_qpol_level_t_alias_iter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 8862 PyObject *resultobj = 0; 8863 struct qpol_level *arg1 = (struct qpol_level *) 0 ; 8864 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 8865 void *argp1 = 0 ; 8866 int res1 = 0 ; 8867 void *argp2 = 0 ; 8868 int res2 = 0 ; 8869 PyObject * obj0 = 0 ; 8870 PyObject * obj1 = 0 ; 8871 qpol_iterator_t *result = 0 ; 8872 8873 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_level_t_alias_iter",&obj0,&obj1)) SWIG_fail; 8874 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_level, 0 | 0 ); 8875 if (!SWIG_IsOK(res1)) { 8876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_level_t_alias_iter" "', argument " "1"" of type '" "struct qpol_level *""'"); 8877 } 8878 arg1 = (struct qpol_level *)(argp1); 8879 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 8880 if (!SWIG_IsOK(res2)) { 8881 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_level_t_alias_iter" "', argument " "2"" of type '" "qpol_policy_t *""'"); 8882 } 8883 arg2 = (qpol_policy_t *)(argp2); 8884 result = (qpol_iterator_t *)qpol_level_alias_iter(arg1,arg2); 8885 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_iterator, SWIG_POINTER_OWN | 0 ); 8886 return resultobj; 8887 fail: 8888 return NULL; 8889 } 8890 8891 8892 SWIGINTERN PyObject *qpol_level_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 8893 PyObject *obj; 8894 if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; 8895 SWIG_TypeNewClientData(SWIGTYPE_p_qpol_level, SWIG_NewClientData(obj)); 8896 return SWIG_Py_Void(); 8897 } 8898 8899 SWIGINTERN PyObject *_wrap_qpol_level_from_void(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 8900 PyObject *resultobj = 0; 8901 void *arg1 = (void *) 0 ; 8902 int res1 ; 8903 PyObject * obj0 = 0 ; 8904 qpol_level_t *result = 0 ; 8905 8906 if (!PyArg_ParseTuple(args,(char *)"O:qpol_level_from_void",&obj0)) SWIG_fail; 8907 res1 = SWIG_ConvertPtr(obj0,SWIG_as_voidptrptr(&arg1), 0, 0); 8908 if (!SWIG_IsOK(res1)) { 8909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_level_from_void" "', argument " "1"" of type '" "void *""'"); 8910 } 8911 result = (qpol_level_t *)qpol_level_from_void(arg1); 8912 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_level, 0 | 0 ); 8913 return resultobj; 8914 fail: 8915 return NULL; 8916 } 8917 8918 8919 SWIGINTERN PyObject *_wrap_new_qpol_cat_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 8920 PyObject *resultobj = 0; 8921 qpol_policy_t *arg1 = (qpol_policy_t *) 0 ; 8922 char *arg2 = (char *) 0 ; 8923 void *argp1 = 0 ; 8924 int res1 = 0 ; 8925 int res2 ; 8926 char *buf2 = 0 ; 8927 int alloc2 = 0 ; 8928 PyObject * obj0 = 0 ; 8929 PyObject * obj1 = 0 ; 8930 struct qpol_cat *result = 0 ; 8931 8932 if (!PyArg_ParseTuple(args,(char *)"OO:new_qpol_cat_t",&obj0,&obj1)) SWIG_fail; 8933 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_policy, 0 | 0 ); 8934 if (!SWIG_IsOK(res1)) { 8935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_qpol_cat_t" "', argument " "1"" of type '" "qpol_policy_t *""'"); 8936 } 8937 arg1 = (qpol_policy_t *)(argp1); 8938 res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); 8939 if (!SWIG_IsOK(res2)) { 8940 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_qpol_cat_t" "', argument " "2"" of type '" "char const *""'"); 8941 } 8942 arg2 = (char *)(buf2); 8943 { 8944 result = (struct qpol_cat *)new_qpol_cat(arg1,(char const *)arg2); 8945 if (!result) { 8946 if (errno == EINVAL) { 8947 PyErr_SetString(PyExc_ValueError, "Invalid category."); 8948 } else { 8949 PyErr_SetFromErrno(PyExc_OSError); 8950 } 8951 8952 return NULL; 8953 } 8954 } 8955 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_cat, SWIG_POINTER_NEW | 0 ); 8956 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); 8957 return resultobj; 8958 fail: 8959 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); 8960 return NULL; 8961 } 8962 8963 8964 SWIGINTERN PyObject *_wrap_delete_qpol_cat_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 8965 PyObject *resultobj = 0; 8966 struct qpol_cat *arg1 = (struct qpol_cat *) 0 ; 8967 void *argp1 = 0 ; 8968 int res1 = 0 ; 8969 PyObject * obj0 = 0 ; 8970 8971 if (!PyArg_ParseTuple(args,(char *)"O:delete_qpol_cat_t",&obj0)) SWIG_fail; 8972 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_cat, SWIG_POINTER_DISOWN | 0 ); 8973 if (!SWIG_IsOK(res1)) { 8974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_qpol_cat_t" "', argument " "1"" of type '" "struct qpol_cat *""'"); 8975 } 8976 arg1 = (struct qpol_cat *)(argp1); 8977 delete_qpol_cat(arg1); 8978 resultobj = SWIG_Py_Void(); 8979 return resultobj; 8980 fail: 8981 return NULL; 8982 } 8983 8984 8985 SWIGINTERN PyObject *_wrap_qpol_cat_t_isalias(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 8986 PyObject *resultobj = 0; 8987 struct qpol_cat *arg1 = (struct qpol_cat *) 0 ; 8988 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 8989 void *argp1 = 0 ; 8990 int res1 = 0 ; 8991 void *argp2 = 0 ; 8992 int res2 = 0 ; 8993 PyObject * obj0 = 0 ; 8994 PyObject * obj1 = 0 ; 8995 int result; 8996 8997 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_cat_t_isalias",&obj0,&obj1)) SWIG_fail; 8998 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_cat, 0 | 0 ); 8999 if (!SWIG_IsOK(res1)) { 9000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_cat_t_isalias" "', argument " "1"" of type '" "struct qpol_cat *""'"); 9001 } 9002 arg1 = (struct qpol_cat *)(argp1); 9003 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 9004 if (!SWIG_IsOK(res2)) { 9005 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_cat_t_isalias" "', argument " "2"" of type '" "qpol_policy_t *""'"); 9006 } 9007 arg2 = (qpol_policy_t *)(argp2); 9008 result = (int)qpol_cat_isalias(arg1,arg2); 9009 resultobj = SWIG_From_int((int)(result)); 9010 return resultobj; 9011 fail: 9012 return NULL; 9013 } 9014 9015 9016 SWIGINTERN PyObject *_wrap_qpol_cat_t_value(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 9017 PyObject *resultobj = 0; 9018 struct qpol_cat *arg1 = (struct qpol_cat *) 0 ; 9019 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 9020 void *argp1 = 0 ; 9021 int res1 = 0 ; 9022 void *argp2 = 0 ; 9023 int res2 = 0 ; 9024 PyObject * obj0 = 0 ; 9025 PyObject * obj1 = 0 ; 9026 int result; 9027 9028 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_cat_t_value",&obj0,&obj1)) SWIG_fail; 9029 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_cat, 0 | 0 ); 9030 if (!SWIG_IsOK(res1)) { 9031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_cat_t_value" "', argument " "1"" of type '" "struct qpol_cat *""'"); 9032 } 9033 arg1 = (struct qpol_cat *)(argp1); 9034 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 9035 if (!SWIG_IsOK(res2)) { 9036 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_cat_t_value" "', argument " "2"" of type '" "qpol_policy_t *""'"); 9037 } 9038 arg2 = (qpol_policy_t *)(argp2); 9039 result = (int)qpol_cat_value(arg1,arg2); 9040 resultobj = SWIG_From_int((int)(result)); 9041 return resultobj; 9042 fail: 9043 return NULL; 9044 } 9045 9046 9047 SWIGINTERN PyObject *_wrap_qpol_cat_t_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 9048 PyObject *resultobj = 0; 9049 struct qpol_cat *arg1 = (struct qpol_cat *) 0 ; 9050 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 9051 void *argp1 = 0 ; 9052 int res1 = 0 ; 9053 void *argp2 = 0 ; 9054 int res2 = 0 ; 9055 PyObject * obj0 = 0 ; 9056 PyObject * obj1 = 0 ; 9057 char *result = 0 ; 9058 9059 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_cat_t_name",&obj0,&obj1)) SWIG_fail; 9060 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_cat, 0 | 0 ); 9061 if (!SWIG_IsOK(res1)) { 9062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_cat_t_name" "', argument " "1"" of type '" "struct qpol_cat *""'"); 9063 } 9064 arg1 = (struct qpol_cat *)(argp1); 9065 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 9066 if (!SWIG_IsOK(res2)) { 9067 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_cat_t_name" "', argument " "2"" of type '" "qpol_policy_t *""'"); 9068 } 9069 arg2 = (qpol_policy_t *)(argp2); 9070 result = (char *)qpol_cat_name(arg1,arg2); 9071 resultobj = SWIG_FromCharPtr((const char *)result); 9072 return resultobj; 9073 fail: 9074 return NULL; 9075 } 9076 9077 9078 SWIGINTERN PyObject *_wrap_qpol_cat_t_alias_iter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 9079 PyObject *resultobj = 0; 9080 struct qpol_cat *arg1 = (struct qpol_cat *) 0 ; 9081 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 9082 void *argp1 = 0 ; 9083 int res1 = 0 ; 9084 void *argp2 = 0 ; 9085 int res2 = 0 ; 9086 PyObject * obj0 = 0 ; 9087 PyObject * obj1 = 0 ; 9088 qpol_iterator_t *result = 0 ; 9089 9090 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_cat_t_alias_iter",&obj0,&obj1)) SWIG_fail; 9091 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_cat, 0 | 0 ); 9092 if (!SWIG_IsOK(res1)) { 9093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_cat_t_alias_iter" "', argument " "1"" of type '" "struct qpol_cat *""'"); 9094 } 9095 arg1 = (struct qpol_cat *)(argp1); 9096 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 9097 if (!SWIG_IsOK(res2)) { 9098 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_cat_t_alias_iter" "', argument " "2"" of type '" "qpol_policy_t *""'"); 9099 } 9100 arg2 = (qpol_policy_t *)(argp2); 9101 result = (qpol_iterator_t *)qpol_cat_alias_iter(arg1,arg2); 9102 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_iterator, SWIG_POINTER_OWN | 0 ); 9103 return resultobj; 9104 fail: 9105 return NULL; 9106 } 9107 9108 9109 SWIGINTERN PyObject *qpol_cat_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 9110 PyObject *obj; 9111 if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; 9112 SWIG_TypeNewClientData(SWIGTYPE_p_qpol_cat, SWIG_NewClientData(obj)); 9113 return SWIG_Py_Void(); 9114 } 9115 9116 SWIGINTERN PyObject *_wrap_qpol_cat_from_void(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 9117 PyObject *resultobj = 0; 9118 void *arg1 = (void *) 0 ; 9119 int res1 ; 9120 PyObject * obj0 = 0 ; 9121 qpol_cat_t *result = 0 ; 9122 9123 if (!PyArg_ParseTuple(args,(char *)"O:qpol_cat_from_void",&obj0)) SWIG_fail; 9124 res1 = SWIG_ConvertPtr(obj0,SWIG_as_voidptrptr(&arg1), 0, 0); 9125 if (!SWIG_IsOK(res1)) { 9126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_cat_from_void" "', argument " "1"" of type '" "void *""'"); 9127 } 9128 result = (qpol_cat_t *)qpol_cat_from_void(arg1); 9129 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_cat, 0 | 0 ); 9130 return resultobj; 9131 fail: 9132 return NULL; 9133 } 9134 9135 9136 SWIGINTERN PyObject *_wrap_new_qpol_mls_range_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 9137 PyObject *resultobj = 0; 9138 qpol_policy_t *arg1 = (qpol_policy_t *) 0 ; 9139 qpol_mls_level_t *arg2 = (qpol_mls_level_t *) 0 ; 9140 qpol_mls_level_t *arg3 = (qpol_mls_level_t *) 0 ; 9141 void *argp1 = 0 ; 9142 int res1 = 0 ; 9143 void *argp2 = 0 ; 9144 int res2 = 0 ; 9145 void *argp3 = 0 ; 9146 int res3 = 0 ; 9147 PyObject * obj0 = 0 ; 9148 PyObject * obj1 = 0 ; 9149 PyObject * obj2 = 0 ; 9150 struct qpol_mls_range *result = 0 ; 9151 9152 if (!PyArg_ParseTuple(args,(char *)"OOO:new_qpol_mls_range_t",&obj0,&obj1,&obj2)) SWIG_fail; 9153 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_policy, 0 | 0 ); 9154 if (!SWIG_IsOK(res1)) { 9155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_qpol_mls_range_t" "', argument " "1"" of type '" "qpol_policy_t *""'"); 9156 } 9157 arg1 = (qpol_policy_t *)(argp1); 9158 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_mls_level, 0 | 0 ); 9159 if (!SWIG_IsOK(res2)) { 9160 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_qpol_mls_range_t" "', argument " "2"" of type '" "qpol_mls_level_t *""'"); 9161 } 9162 arg2 = (qpol_mls_level_t *)(argp2); 9163 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_qpol_mls_level, 0 | 0 ); 9164 if (!SWIG_IsOK(res3)) { 9165 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_qpol_mls_range_t" "', argument " "3"" of type '" "qpol_mls_level_t *""'"); 9166 } 9167 arg3 = (qpol_mls_level_t *)(argp3); 9168 { 9169 result = (struct qpol_mls_range *)new_qpol_mls_range(arg1,arg2,arg3); 9170 if (!result) { 9171 if (errno == EINVAL) { 9172 PyErr_SetString(PyExc_ValueError, "Invalid range."); 9173 } else { 9174 PyErr_SetFromErrno(PyExc_OSError); 9175 } 9176 9177 return NULL; 9178 } 9179 } 9180 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_mls_range, SWIG_POINTER_NEW | 0 ); 9181 return resultobj; 9182 fail: 9183 return NULL; 9184 } 9185 9186 9187 SWIGINTERN PyObject *_wrap_delete_qpol_mls_range_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 9188 PyObject *resultobj = 0; 9189 struct qpol_mls_range *arg1 = (struct qpol_mls_range *) 0 ; 9190 void *argp1 = 0 ; 9191 int res1 = 0 ; 9192 PyObject * obj0 = 0 ; 9193 9194 if (!PyArg_ParseTuple(args,(char *)"O:delete_qpol_mls_range_t",&obj0)) SWIG_fail; 9195 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_mls_range, SWIG_POINTER_DISOWN | 0 ); 9196 if (!SWIG_IsOK(res1)) { 9197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_qpol_mls_range_t" "', argument " "1"" of type '" "struct qpol_mls_range *""'"); 9198 } 9199 arg1 = (struct qpol_mls_range *)(argp1); 9200 delete_qpol_mls_range(arg1); 9201 resultobj = SWIG_Py_Void(); 9202 return resultobj; 9203 fail: 9204 return NULL; 9205 } 9206 9207 9208 SWIGINTERN PyObject *_wrap_qpol_mls_range_t_high_level(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 9209 PyObject *resultobj = 0; 9210 struct qpol_mls_range *arg1 = (struct qpol_mls_range *) 0 ; 9211 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 9212 void *argp1 = 0 ; 9213 int res1 = 0 ; 9214 void *argp2 = 0 ; 9215 int res2 = 0 ; 9216 PyObject * obj0 = 0 ; 9217 PyObject * obj1 = 0 ; 9218 qpol_mls_level_t *result = 0 ; 9219 9220 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_mls_range_t_high_level",&obj0,&obj1)) SWIG_fail; 9221 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_mls_range, 0 | 0 ); 9222 if (!SWIG_IsOK(res1)) { 9223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_mls_range_t_high_level" "', argument " "1"" of type '" "struct qpol_mls_range *""'"); 9224 } 9225 arg1 = (struct qpol_mls_range *)(argp1); 9226 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 9227 if (!SWIG_IsOK(res2)) { 9228 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_mls_range_t_high_level" "', argument " "2"" of type '" "qpol_policy_t *""'"); 9229 } 9230 arg2 = (qpol_policy_t *)(argp2); 9231 result = (qpol_mls_level_t *)qpol_mls_range_high_level(arg1,arg2); 9232 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_mls_level, 0 | 0 ); 9233 return resultobj; 9234 fail: 9235 return NULL; 9236 } 9237 9238 9239 SWIGINTERN PyObject *_wrap_qpol_mls_range_t_low_level(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 9240 PyObject *resultobj = 0; 9241 struct qpol_mls_range *arg1 = (struct qpol_mls_range *) 0 ; 9242 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 9243 void *argp1 = 0 ; 9244 int res1 = 0 ; 9245 void *argp2 = 0 ; 9246 int res2 = 0 ; 9247 PyObject * obj0 = 0 ; 9248 PyObject * obj1 = 0 ; 9249 qpol_mls_level_t *result = 0 ; 9250 9251 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_mls_range_t_low_level",&obj0,&obj1)) SWIG_fail; 9252 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_mls_range, 0 | 0 ); 9253 if (!SWIG_IsOK(res1)) { 9254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_mls_range_t_low_level" "', argument " "1"" of type '" "struct qpol_mls_range *""'"); 9255 } 9256 arg1 = (struct qpol_mls_range *)(argp1); 9257 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 9258 if (!SWIG_IsOK(res2)) { 9259 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_mls_range_t_low_level" "', argument " "2"" of type '" "qpol_policy_t *""'"); 9260 } 9261 arg2 = (qpol_policy_t *)(argp2); 9262 result = (qpol_mls_level_t *)qpol_mls_range_low_level(arg1,arg2); 9263 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_mls_level, 0 | 0 ); 9264 return resultobj; 9265 fail: 9266 return NULL; 9267 } 9268 9269 9270 SWIGINTERN PyObject *qpol_mls_range_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 9271 PyObject *obj; 9272 if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; 9273 SWIG_TypeNewClientData(SWIGTYPE_p_qpol_mls_range, SWIG_NewClientData(obj)); 9274 return SWIG_Py_Void(); 9275 } 9276 9277 SWIGINTERN PyObject *_wrap_qpol_mls_range_from_void(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 9278 PyObject *resultobj = 0; 9279 void *arg1 = (void *) 0 ; 9280 int res1 ; 9281 PyObject * obj0 = 0 ; 9282 qpol_mls_range_t *result = 0 ; 9283 9284 if (!PyArg_ParseTuple(args,(char *)"O:qpol_mls_range_from_void",&obj0)) SWIG_fail; 9285 res1 = SWIG_ConvertPtr(obj0,SWIG_as_voidptrptr(&arg1), 0, 0); 9286 if (!SWIG_IsOK(res1)) { 9287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_mls_range_from_void" "', argument " "1"" of type '" "void *""'"); 9288 } 9289 result = (qpol_mls_range_t *)qpol_mls_range_from_void(arg1); 9290 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_mls_range, 0 | 0 ); 9291 return resultobj; 9292 fail: 9293 return NULL; 9294 } 9295 9296 9297 SWIGINTERN PyObject *_wrap_new_qpol_semantic_level_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 9298 PyObject *resultobj = 0; 9299 qpol_policy_t *arg1 = (qpol_policy_t *) 0 ; 9300 char *arg2 = (char *) 0 ; 9301 void *argp1 = 0 ; 9302 int res1 = 0 ; 9303 int res2 ; 9304 char *buf2 = 0 ; 9305 int alloc2 = 0 ; 9306 PyObject * obj0 = 0 ; 9307 PyObject * obj1 = 0 ; 9308 struct qpol_semantic_level *result = 0 ; 9309 9310 if (!PyArg_ParseTuple(args,(char *)"OO:new_qpol_semantic_level_t",&obj0,&obj1)) SWIG_fail; 9311 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_policy, 0 | 0 ); 9312 if (!SWIG_IsOK(res1)) { 9313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_qpol_semantic_level_t" "', argument " "1"" of type '" "qpol_policy_t *""'"); 9314 } 9315 arg1 = (qpol_policy_t *)(argp1); 9316 res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); 9317 if (!SWIG_IsOK(res2)) { 9318 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_qpol_semantic_level_t" "', argument " "2"" of type '" "char const *""'"); 9319 } 9320 arg2 = (char *)(buf2); 9321 { 9322 result = (struct qpol_semantic_level *)new_qpol_semantic_level(arg1,(char const *)arg2); 9323 if (!result) { 9324 PyErr_SetString(PyExc_ValueError, "Invalid sensitivity name."); 9325 return NULL; 9326 } 9327 } 9328 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_semantic_level, SWIG_POINTER_NEW | 0 ); 9329 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); 9330 return resultobj; 9331 fail: 9332 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); 9333 return NULL; 9334 } 9335 9336 9337 SWIGINTERN PyObject *_wrap_delete_qpol_semantic_level_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 9338 PyObject *resultobj = 0; 9339 struct qpol_semantic_level *arg1 = (struct qpol_semantic_level *) 0 ; 9340 void *argp1 = 0 ; 9341 int res1 = 0 ; 9342 PyObject * obj0 = 0 ; 9343 9344 if (!PyArg_ParseTuple(args,(char *)"O:delete_qpol_semantic_level_t",&obj0)) SWIG_fail; 9345 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_semantic_level, SWIG_POINTER_DISOWN | 0 ); 9346 if (!SWIG_IsOK(res1)) { 9347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_qpol_semantic_level_t" "', argument " "1"" of type '" "struct qpol_semantic_level *""'"); 9348 } 9349 arg1 = (struct qpol_semantic_level *)(argp1); 9350 delete_qpol_semantic_level(arg1); 9351 resultobj = SWIG_Py_Void(); 9352 return resultobj; 9353 fail: 9354 return NULL; 9355 } 9356 9357 9358 SWIGINTERN PyObject *_wrap_qpol_semantic_level_t_add_cats(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 9359 PyObject *resultobj = 0; 9360 struct qpol_semantic_level *arg1 = (struct qpol_semantic_level *) 0 ; 9361 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 9362 char *arg3 = (char *) 0 ; 9363 char *arg4 = (char *) 0 ; 9364 void *argp1 = 0 ; 9365 int res1 = 0 ; 9366 void *argp2 = 0 ; 9367 int res2 = 0 ; 9368 int res3 ; 9369 char *buf3 = 0 ; 9370 int alloc3 = 0 ; 9371 int res4 ; 9372 char *buf4 = 0 ; 9373 int alloc4 = 0 ; 9374 PyObject * obj0 = 0 ; 9375 PyObject * obj1 = 0 ; 9376 PyObject * obj2 = 0 ; 9377 PyObject * obj3 = 0 ; 9378 int result; 9379 9380 if (!PyArg_ParseTuple(args,(char *)"OOOO:qpol_semantic_level_t_add_cats",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; 9381 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_semantic_level, 0 | 0 ); 9382 if (!SWIG_IsOK(res1)) { 9383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_semantic_level_t_add_cats" "', argument " "1"" of type '" "struct qpol_semantic_level *""'"); 9384 } 9385 arg1 = (struct qpol_semantic_level *)(argp1); 9386 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 9387 if (!SWIG_IsOK(res2)) { 9388 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_semantic_level_t_add_cats" "', argument " "2"" of type '" "qpol_policy_t *""'"); 9389 } 9390 arg2 = (qpol_policy_t *)(argp2); 9391 res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3); 9392 if (!SWIG_IsOK(res3)) { 9393 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "qpol_semantic_level_t_add_cats" "', argument " "3"" of type '" "char const *""'"); 9394 } 9395 arg3 = (char *)(buf3); 9396 res4 = SWIG_AsCharPtrAndSize(obj3, &buf4, NULL, &alloc4); 9397 if (!SWIG_IsOK(res4)) { 9398 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "qpol_semantic_level_t_add_cats" "', argument " "4"" of type '" "char const *""'"); 9399 } 9400 arg4 = (char *)(buf4); 9401 { 9402 result = (int)qpol_semantic_level_add_cats(arg1,arg2,(char const *)arg3,(char const *)arg4); 9403 if (result) { 9404 PyErr_SetString(PyExc_ValueError, "Invalid category name or category range."); 9405 return NULL; 9406 } 9407 } 9408 resultobj = SWIG_From_int((int)(result)); 9409 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3); 9410 if (alloc4 == SWIG_NEWOBJ) free((char*)buf4); 9411 return resultobj; 9412 fail: 9413 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3); 9414 if (alloc4 == SWIG_NEWOBJ) free((char*)buf4); 9415 return NULL; 9416 } 9417 9418 9419 SWIGINTERN PyObject *qpol_semantic_level_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 9420 PyObject *obj; 9421 if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; 9422 SWIG_TypeNewClientData(SWIGTYPE_p_qpol_semantic_level, SWIG_NewClientData(obj)); 9423 return SWIG_Py_Void(); 9424 } 9425 9426 SWIGINTERN PyObject *_wrap_new_qpol_mls_level_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 9427 PyObject *resultobj = 0; 9428 qpol_policy_t *arg1 = (qpol_policy_t *) 0 ; 9429 qpol_semantic_level_t *arg2 = (qpol_semantic_level_t *) 0 ; 9430 void *argp1 = 0 ; 9431 int res1 = 0 ; 9432 void *argp2 = 0 ; 9433 int res2 = 0 ; 9434 PyObject * obj0 = 0 ; 9435 PyObject * obj1 = 0 ; 9436 struct qpol_mls_level *result = 0 ; 9437 9438 if (!PyArg_ParseTuple(args,(char *)"OO:new_qpol_mls_level_t",&obj0,&obj1)) SWIG_fail; 9439 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_policy, 0 | 0 ); 9440 if (!SWIG_IsOK(res1)) { 9441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_qpol_mls_level_t" "', argument " "1"" of type '" "qpol_policy_t *""'"); 9442 } 9443 arg1 = (qpol_policy_t *)(argp1); 9444 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_semantic_level, 0 | 0 ); 9445 if (!SWIG_IsOK(res2)) { 9446 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_qpol_mls_level_t" "', argument " "2"" of type '" "qpol_semantic_level_t *""'"); 9447 } 9448 arg2 = (qpol_semantic_level_t *)(argp2); 9449 { 9450 result = (struct qpol_mls_level *)new_qpol_mls_level(arg1,arg2); 9451 if (!result) { 9452 PyErr_SetString(PyExc_ValueError, "Invalid level."); 9453 return NULL; 9454 } 9455 } 9456 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_mls_level, SWIG_POINTER_NEW | 0 ); 9457 return resultobj; 9458 fail: 9459 return NULL; 9460 } 9461 9462 9463 SWIGINTERN PyObject *_wrap_delete_qpol_mls_level_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 9464 PyObject *resultobj = 0; 9465 struct qpol_mls_level *arg1 = (struct qpol_mls_level *) 0 ; 9466 void *argp1 = 0 ; 9467 int res1 = 0 ; 9468 PyObject * obj0 = 0 ; 9469 9470 if (!PyArg_ParseTuple(args,(char *)"O:delete_qpol_mls_level_t",&obj0)) SWIG_fail; 9471 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_mls_level, SWIG_POINTER_DISOWN | 0 ); 9472 if (!SWIG_IsOK(res1)) { 9473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_qpol_mls_level_t" "', argument " "1"" of type '" "struct qpol_mls_level *""'"); 9474 } 9475 arg1 = (struct qpol_mls_level *)(argp1); 9476 delete_qpol_mls_level(arg1); 9477 resultobj = SWIG_Py_Void(); 9478 return resultobj; 9479 fail: 9480 return NULL; 9481 } 9482 9483 9484 SWIGINTERN PyObject *_wrap_qpol_mls_level_t_sens_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 9485 PyObject *resultobj = 0; 9486 struct qpol_mls_level *arg1 = (struct qpol_mls_level *) 0 ; 9487 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 9488 void *argp1 = 0 ; 9489 int res1 = 0 ; 9490 void *argp2 = 0 ; 9491 int res2 = 0 ; 9492 PyObject * obj0 = 0 ; 9493 PyObject * obj1 = 0 ; 9494 char *result = 0 ; 9495 9496 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_mls_level_t_sens_name",&obj0,&obj1)) SWIG_fail; 9497 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_mls_level, 0 | 0 ); 9498 if (!SWIG_IsOK(res1)) { 9499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_mls_level_t_sens_name" "', argument " "1"" of type '" "struct qpol_mls_level *""'"); 9500 } 9501 arg1 = (struct qpol_mls_level *)(argp1); 9502 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 9503 if (!SWIG_IsOK(res2)) { 9504 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_mls_level_t_sens_name" "', argument " "2"" of type '" "qpol_policy_t *""'"); 9505 } 9506 arg2 = (qpol_policy_t *)(argp2); 9507 result = (char *)qpol_mls_level_sens_name(arg1,arg2); 9508 resultobj = SWIG_FromCharPtr((const char *)result); 9509 return resultobj; 9510 fail: 9511 return NULL; 9512 } 9513 9514 9515 SWIGINTERN PyObject *_wrap_qpol_mls_level_t_cat_iter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 9516 PyObject *resultobj = 0; 9517 struct qpol_mls_level *arg1 = (struct qpol_mls_level *) 0 ; 9518 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 9519 void *argp1 = 0 ; 9520 int res1 = 0 ; 9521 void *argp2 = 0 ; 9522 int res2 = 0 ; 9523 PyObject * obj0 = 0 ; 9524 PyObject * obj1 = 0 ; 9525 qpol_iterator_t *result = 0 ; 9526 9527 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_mls_level_t_cat_iter",&obj0,&obj1)) SWIG_fail; 9528 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_mls_level, 0 | 0 ); 9529 if (!SWIG_IsOK(res1)) { 9530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_mls_level_t_cat_iter" "', argument " "1"" of type '" "struct qpol_mls_level *""'"); 9531 } 9532 arg1 = (struct qpol_mls_level *)(argp1); 9533 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 9534 if (!SWIG_IsOK(res2)) { 9535 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_mls_level_t_cat_iter" "', argument " "2"" of type '" "qpol_policy_t *""'"); 9536 } 9537 arg2 = (qpol_policy_t *)(argp2); 9538 result = (qpol_iterator_t *)qpol_mls_level_cat_iter(arg1,arg2); 9539 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_iterator, SWIG_POINTER_OWN | 0 ); 9540 return resultobj; 9541 fail: 9542 return NULL; 9543 } 9544 9545 9546 SWIGINTERN PyObject *qpol_mls_level_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 9547 PyObject *obj; 9548 if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; 9549 SWIG_TypeNewClientData(SWIGTYPE_p_qpol_mls_level, SWIG_NewClientData(obj)); 9550 return SWIG_Py_Void(); 9551 } 9552 9553 SWIGINTERN PyObject *_wrap_qpol_mls_level_from_void(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 9554 PyObject *resultobj = 0; 9555 void *arg1 = (void *) 0 ; 9556 int res1 ; 9557 PyObject * obj0 = 0 ; 9558 qpol_mls_level_t *result = 0 ; 9559 9560 if (!PyArg_ParseTuple(args,(char *)"O:qpol_mls_level_from_void",&obj0)) SWIG_fail; 9561 res1 = SWIG_ConvertPtr(obj0,SWIG_as_voidptrptr(&arg1), 0, 0); 9562 if (!SWIG_IsOK(res1)) { 9563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_mls_level_from_void" "', argument " "1"" of type '" "void *""'"); 9564 } 9565 result = (qpol_mls_level_t *)qpol_mls_level_from_void(arg1); 9566 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_mls_level, 0 | 0 ); 9567 return resultobj; 9568 fail: 9569 return NULL; 9570 } 9571 9572 9573 SWIGINTERN PyObject *_wrap_new_qpol_user_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 9574 PyObject *resultobj = 0; 9575 qpol_policy_t *arg1 = (qpol_policy_t *) 0 ; 9576 char *arg2 = (char *) 0 ; 9577 void *argp1 = 0 ; 9578 int res1 = 0 ; 9579 int res2 ; 9580 char *buf2 = 0 ; 9581 int alloc2 = 0 ; 9582 PyObject * obj0 = 0 ; 9583 PyObject * obj1 = 0 ; 9584 struct qpol_user *result = 0 ; 9585 9586 if (!PyArg_ParseTuple(args,(char *)"OO:new_qpol_user_t",&obj0,&obj1)) SWIG_fail; 9587 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_policy, 0 | 0 ); 9588 if (!SWIG_IsOK(res1)) { 9589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_qpol_user_t" "', argument " "1"" of type '" "qpol_policy_t *""'"); 9590 } 9591 arg1 = (qpol_policy_t *)(argp1); 9592 res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); 9593 if (!SWIG_IsOK(res2)) { 9594 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_qpol_user_t" "', argument " "2"" of type '" "char const *""'"); 9595 } 9596 arg2 = (char *)(buf2); 9597 { 9598 result = (struct qpol_user *)new_qpol_user(arg1,(char const *)arg2); 9599 if (!result) { 9600 PyErr_SetString(PyExc_ValueError, "Invalid user."); 9601 return NULL; 9602 } 9603 } 9604 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_user, SWIG_POINTER_NEW | 0 ); 9605 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); 9606 return resultobj; 9607 fail: 9608 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); 9609 return NULL; 9610 } 9611 9612 9613 SWIGINTERN PyObject *_wrap_delete_qpol_user_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 9614 PyObject *resultobj = 0; 9615 struct qpol_user *arg1 = (struct qpol_user *) 0 ; 9616 void *argp1 = 0 ; 9617 int res1 = 0 ; 9618 PyObject * obj0 = 0 ; 9619 9620 if (!PyArg_ParseTuple(args,(char *)"O:delete_qpol_user_t",&obj0)) SWIG_fail; 9621 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_user, SWIG_POINTER_DISOWN | 0 ); 9622 if (!SWIG_IsOK(res1)) { 9623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_qpol_user_t" "', argument " "1"" of type '" "struct qpol_user *""'"); 9624 } 9625 arg1 = (struct qpol_user *)(argp1); 9626 delete_qpol_user(arg1); 9627 resultobj = SWIG_Py_Void(); 9628 return resultobj; 9629 fail: 9630 return NULL; 9631 } 9632 9633 9634 SWIGINTERN PyObject *_wrap_qpol_user_t_value(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 9635 PyObject *resultobj = 0; 9636 struct qpol_user *arg1 = (struct qpol_user *) 0 ; 9637 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 9638 void *argp1 = 0 ; 9639 int res1 = 0 ; 9640 void *argp2 = 0 ; 9641 int res2 = 0 ; 9642 PyObject * obj0 = 0 ; 9643 PyObject * obj1 = 0 ; 9644 int result; 9645 9646 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_user_t_value",&obj0,&obj1)) SWIG_fail; 9647 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_user, 0 | 0 ); 9648 if (!SWIG_IsOK(res1)) { 9649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_user_t_value" "', argument " "1"" of type '" "struct qpol_user *""'"); 9650 } 9651 arg1 = (struct qpol_user *)(argp1); 9652 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 9653 if (!SWIG_IsOK(res2)) { 9654 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_user_t_value" "', argument " "2"" of type '" "qpol_policy_t *""'"); 9655 } 9656 arg2 = (qpol_policy_t *)(argp2); 9657 result = (int)qpol_user_value(arg1,arg2); 9658 resultobj = SWIG_From_int((int)(result)); 9659 return resultobj; 9660 fail: 9661 return NULL; 9662 } 9663 9664 9665 SWIGINTERN PyObject *_wrap_qpol_user_t_role_iter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 9666 PyObject *resultobj = 0; 9667 struct qpol_user *arg1 = (struct qpol_user *) 0 ; 9668 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 9669 void *argp1 = 0 ; 9670 int res1 = 0 ; 9671 void *argp2 = 0 ; 9672 int res2 = 0 ; 9673 PyObject * obj0 = 0 ; 9674 PyObject * obj1 = 0 ; 9675 qpol_iterator_t *result = 0 ; 9676 9677 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_user_t_role_iter",&obj0,&obj1)) SWIG_fail; 9678 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_user, 0 | 0 ); 9679 if (!SWIG_IsOK(res1)) { 9680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_user_t_role_iter" "', argument " "1"" of type '" "struct qpol_user *""'"); 9681 } 9682 arg1 = (struct qpol_user *)(argp1); 9683 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 9684 if (!SWIG_IsOK(res2)) { 9685 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_user_t_role_iter" "', argument " "2"" of type '" "qpol_policy_t *""'"); 9686 } 9687 arg2 = (qpol_policy_t *)(argp2); 9688 result = (qpol_iterator_t *)qpol_user_role_iter(arg1,arg2); 9689 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_iterator, SWIG_POINTER_OWN | 0 ); 9690 return resultobj; 9691 fail: 9692 return NULL; 9693 } 9694 9695 9696 SWIGINTERN PyObject *_wrap_qpol_user_t_range(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 9697 PyObject *resultobj = 0; 9698 struct qpol_user *arg1 = (struct qpol_user *) 0 ; 9699 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 9700 void *argp1 = 0 ; 9701 int res1 = 0 ; 9702 void *argp2 = 0 ; 9703 int res2 = 0 ; 9704 PyObject * obj0 = 0 ; 9705 PyObject * obj1 = 0 ; 9706 qpol_mls_range_t *result = 0 ; 9707 9708 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_user_t_range",&obj0,&obj1)) SWIG_fail; 9709 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_user, 0 | 0 ); 9710 if (!SWIG_IsOK(res1)) { 9711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_user_t_range" "', argument " "1"" of type '" "struct qpol_user *""'"); 9712 } 9713 arg1 = (struct qpol_user *)(argp1); 9714 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 9715 if (!SWIG_IsOK(res2)) { 9716 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_user_t_range" "', argument " "2"" of type '" "qpol_policy_t *""'"); 9717 } 9718 arg2 = (qpol_policy_t *)(argp2); 9719 result = (qpol_mls_range_t *)qpol_user_range(arg1,arg2); 9720 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_mls_range, 0 | 0 ); 9721 return resultobj; 9722 fail: 9723 return NULL; 9724 } 9725 9726 9727 SWIGINTERN PyObject *_wrap_qpol_user_t_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 9728 PyObject *resultobj = 0; 9729 struct qpol_user *arg1 = (struct qpol_user *) 0 ; 9730 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 9731 void *argp1 = 0 ; 9732 int res1 = 0 ; 9733 void *argp2 = 0 ; 9734 int res2 = 0 ; 9735 PyObject * obj0 = 0 ; 9736 PyObject * obj1 = 0 ; 9737 char *result = 0 ; 9738 9739 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_user_t_name",&obj0,&obj1)) SWIG_fail; 9740 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_user, 0 | 0 ); 9741 if (!SWIG_IsOK(res1)) { 9742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_user_t_name" "', argument " "1"" of type '" "struct qpol_user *""'"); 9743 } 9744 arg1 = (struct qpol_user *)(argp1); 9745 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 9746 if (!SWIG_IsOK(res2)) { 9747 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_user_t_name" "', argument " "2"" of type '" "qpol_policy_t *""'"); 9748 } 9749 arg2 = (qpol_policy_t *)(argp2); 9750 result = (char *)qpol_user_name(arg1,arg2); 9751 resultobj = SWIG_FromCharPtr((const char *)result); 9752 return resultobj; 9753 fail: 9754 return NULL; 9755 } 9756 9757 9758 SWIGINTERN PyObject *_wrap_qpol_user_t_dfltlevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 9759 PyObject *resultobj = 0; 9760 struct qpol_user *arg1 = (struct qpol_user *) 0 ; 9761 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 9762 void *argp1 = 0 ; 9763 int res1 = 0 ; 9764 void *argp2 = 0 ; 9765 int res2 = 0 ; 9766 PyObject * obj0 = 0 ; 9767 PyObject * obj1 = 0 ; 9768 qpol_mls_level_t *result = 0 ; 9769 9770 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_user_t_dfltlevel",&obj0,&obj1)) SWIG_fail; 9771 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_user, 0 | 0 ); 9772 if (!SWIG_IsOK(res1)) { 9773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_user_t_dfltlevel" "', argument " "1"" of type '" "struct qpol_user *""'"); 9774 } 9775 arg1 = (struct qpol_user *)(argp1); 9776 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 9777 if (!SWIG_IsOK(res2)) { 9778 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_user_t_dfltlevel" "', argument " "2"" of type '" "qpol_policy_t *""'"); 9779 } 9780 arg2 = (qpol_policy_t *)(argp2); 9781 result = (qpol_mls_level_t *)qpol_user_dfltlevel(arg1,arg2); 9782 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_mls_level, 0 | 0 ); 9783 return resultobj; 9784 fail: 9785 return NULL; 9786 } 9787 9788 9789 SWIGINTERN PyObject *qpol_user_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 9790 PyObject *obj; 9791 if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; 9792 SWIG_TypeNewClientData(SWIGTYPE_p_qpol_user, SWIG_NewClientData(obj)); 9793 return SWIG_Py_Void(); 9794 } 9795 9796 SWIGINTERN PyObject *_wrap_qpol_user_from_void(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 9797 PyObject *resultobj = 0; 9798 void *arg1 = (void *) 0 ; 9799 int res1 ; 9800 PyObject * obj0 = 0 ; 9801 qpol_user_t *result = 0 ; 9802 9803 if (!PyArg_ParseTuple(args,(char *)"O:qpol_user_from_void",&obj0)) SWIG_fail; 9804 res1 = SWIG_ConvertPtr(obj0,SWIG_as_voidptrptr(&arg1), 0, 0); 9805 if (!SWIG_IsOK(res1)) { 9806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_user_from_void" "', argument " "1"" of type '" "void *""'"); 9807 } 9808 result = (qpol_user_t *)qpol_user_from_void(arg1); 9809 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_user, 0 | 0 ); 9810 return resultobj; 9811 fail: 9812 return NULL; 9813 } 9814 9815 9816 SWIGINTERN PyObject *_wrap_new_qpol_bool_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 9817 PyObject *resultobj = 0; 9818 qpol_policy_t *arg1 = (qpol_policy_t *) 0 ; 9819 char *arg2 = (char *) 0 ; 9820 void *argp1 = 0 ; 9821 int res1 = 0 ; 9822 int res2 ; 9823 char *buf2 = 0 ; 9824 int alloc2 = 0 ; 9825 PyObject * obj0 = 0 ; 9826 PyObject * obj1 = 0 ; 9827 struct qpol_bool *result = 0 ; 9828 9829 if (!PyArg_ParseTuple(args,(char *)"OO:new_qpol_bool_t",&obj0,&obj1)) SWIG_fail; 9830 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_policy, 0 | 0 ); 9831 if (!SWIG_IsOK(res1)) { 9832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_qpol_bool_t" "', argument " "1"" of type '" "qpol_policy_t *""'"); 9833 } 9834 arg1 = (qpol_policy_t *)(argp1); 9835 res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); 9836 if (!SWIG_IsOK(res2)) { 9837 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_qpol_bool_t" "', argument " "2"" of type '" "char const *""'"); 9838 } 9839 arg2 = (char *)(buf2); 9840 result = (struct qpol_bool *)new_qpol_bool(arg1,(char const *)arg2); 9841 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_bool, SWIG_POINTER_NEW | 0 ); 9842 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); 9843 return resultobj; 9844 fail: 9845 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); 9846 return NULL; 9847 } 9848 9849 9850 SWIGINTERN PyObject *_wrap_delete_qpol_bool_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 9851 PyObject *resultobj = 0; 9852 struct qpol_bool *arg1 = (struct qpol_bool *) 0 ; 9853 void *argp1 = 0 ; 9854 int res1 = 0 ; 9855 PyObject * obj0 = 0 ; 9856 9857 if (!PyArg_ParseTuple(args,(char *)"O:delete_qpol_bool_t",&obj0)) SWIG_fail; 9858 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_bool, SWIG_POINTER_DISOWN | 0 ); 9859 if (!SWIG_IsOK(res1)) { 9860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_qpol_bool_t" "', argument " "1"" of type '" "struct qpol_bool *""'"); 9861 } 9862 arg1 = (struct qpol_bool *)(argp1); 9863 delete_qpol_bool(arg1); 9864 resultobj = SWIG_Py_Void(); 9865 return resultobj; 9866 fail: 9867 return NULL; 9868 } 9869 9870 9871 SWIGINTERN PyObject *_wrap_qpol_bool_t_value(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 9872 PyObject *resultobj = 0; 9873 struct qpol_bool *arg1 = (struct qpol_bool *) 0 ; 9874 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 9875 void *argp1 = 0 ; 9876 int res1 = 0 ; 9877 void *argp2 = 0 ; 9878 int res2 = 0 ; 9879 PyObject * obj0 = 0 ; 9880 PyObject * obj1 = 0 ; 9881 int result; 9882 9883 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_bool_t_value",&obj0,&obj1)) SWIG_fail; 9884 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_bool, 0 | 0 ); 9885 if (!SWIG_IsOK(res1)) { 9886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_bool_t_value" "', argument " "1"" of type '" "struct qpol_bool *""'"); 9887 } 9888 arg1 = (struct qpol_bool *)(argp1); 9889 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 9890 if (!SWIG_IsOK(res2)) { 9891 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_bool_t_value" "', argument " "2"" of type '" "qpol_policy_t *""'"); 9892 } 9893 arg2 = (qpol_policy_t *)(argp2); 9894 result = (int)qpol_bool_value(arg1,arg2); 9895 resultobj = SWIG_From_int((int)(result)); 9896 return resultobj; 9897 fail: 9898 return NULL; 9899 } 9900 9901 9902 SWIGINTERN PyObject *_wrap_qpol_bool_t_state(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 9903 PyObject *resultobj = 0; 9904 struct qpol_bool *arg1 = (struct qpol_bool *) 0 ; 9905 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 9906 void *argp1 = 0 ; 9907 int res1 = 0 ; 9908 void *argp2 = 0 ; 9909 int res2 = 0 ; 9910 PyObject * obj0 = 0 ; 9911 PyObject * obj1 = 0 ; 9912 int result; 9913 9914 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_bool_t_state",&obj0,&obj1)) SWIG_fail; 9915 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_bool, 0 | 0 ); 9916 if (!SWIG_IsOK(res1)) { 9917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_bool_t_state" "', argument " "1"" of type '" "struct qpol_bool *""'"); 9918 } 9919 arg1 = (struct qpol_bool *)(argp1); 9920 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 9921 if (!SWIG_IsOK(res2)) { 9922 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_bool_t_state" "', argument " "2"" of type '" "qpol_policy_t *""'"); 9923 } 9924 arg2 = (qpol_policy_t *)(argp2); 9925 result = (int)qpol_bool_state(arg1,arg2); 9926 resultobj = SWIG_From_int((int)(result)); 9927 return resultobj; 9928 fail: 9929 return NULL; 9930 } 9931 9932 9933 SWIGINTERN PyObject *_wrap_qpol_bool_t_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 9934 PyObject *resultobj = 0; 9935 struct qpol_bool *arg1 = (struct qpol_bool *) 0 ; 9936 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 9937 void *argp1 = 0 ; 9938 int res1 = 0 ; 9939 void *argp2 = 0 ; 9940 int res2 = 0 ; 9941 PyObject * obj0 = 0 ; 9942 PyObject * obj1 = 0 ; 9943 char *result = 0 ; 9944 9945 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_bool_t_name",&obj0,&obj1)) SWIG_fail; 9946 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_bool, 0 | 0 ); 9947 if (!SWIG_IsOK(res1)) { 9948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_bool_t_name" "', argument " "1"" of type '" "struct qpol_bool *""'"); 9949 } 9950 arg1 = (struct qpol_bool *)(argp1); 9951 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 9952 if (!SWIG_IsOK(res2)) { 9953 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_bool_t_name" "', argument " "2"" of type '" "qpol_policy_t *""'"); 9954 } 9955 arg2 = (qpol_policy_t *)(argp2); 9956 result = (char *)qpol_bool_name(arg1,arg2); 9957 resultobj = SWIG_FromCharPtr((const char *)result); 9958 return resultobj; 9959 fail: 9960 return NULL; 9961 } 9962 9963 9964 SWIGINTERN PyObject *qpol_bool_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 9965 PyObject *obj; 9966 if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; 9967 SWIG_TypeNewClientData(SWIGTYPE_p_qpol_bool, SWIG_NewClientData(obj)); 9968 return SWIG_Py_Void(); 9969 } 9970 9971 SWIGINTERN PyObject *_wrap_qpol_bool_from_void(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 9972 PyObject *resultobj = 0; 9973 void *arg1 = (void *) 0 ; 9974 int res1 ; 9975 PyObject * obj0 = 0 ; 9976 qpol_bool_t *result = 0 ; 9977 9978 if (!PyArg_ParseTuple(args,(char *)"O:qpol_bool_from_void",&obj0)) SWIG_fail; 9979 res1 = SWIG_ConvertPtr(obj0,SWIG_as_voidptrptr(&arg1), 0, 0); 9980 if (!SWIG_IsOK(res1)) { 9981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_bool_from_void" "', argument " "1"" of type '" "void *""'"); 9982 } 9983 result = (qpol_bool_t *)qpol_bool_from_void(arg1); 9984 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_bool, 0 | 0 ); 9985 return resultobj; 9986 fail: 9987 return NULL; 9988 } 9989 9990 9991 SWIGINTERN PyObject *_wrap_new_qpol_context_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 9992 PyObject *resultobj = 0; 9993 struct qpol_context *result = 0 ; 9994 9995 if (!PyArg_ParseTuple(args,(char *)":new_qpol_context_t")) SWIG_fail; 9996 result = (struct qpol_context *)new_qpol_context(); 9997 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_context, SWIG_POINTER_NEW | 0 ); 9998 return resultobj; 9999 fail: 10000 return NULL; 10001 } 10002 10003 10004 SWIGINTERN PyObject *_wrap_delete_qpol_context_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 10005 PyObject *resultobj = 0; 10006 struct qpol_context *arg1 = (struct qpol_context *) 0 ; 10007 void *argp1 = 0 ; 10008 int res1 = 0 ; 10009 PyObject * obj0 = 0 ; 10010 10011 if (!PyArg_ParseTuple(args,(char *)"O:delete_qpol_context_t",&obj0)) SWIG_fail; 10012 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_context, SWIG_POINTER_DISOWN | 0 ); 10013 if (!SWIG_IsOK(res1)) { 10014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_qpol_context_t" "', argument " "1"" of type '" "struct qpol_context *""'"); 10015 } 10016 arg1 = (struct qpol_context *)(argp1); 10017 delete_qpol_context(arg1); 10018 resultobj = SWIG_Py_Void(); 10019 return resultobj; 10020 fail: 10021 return NULL; 10022 } 10023 10024 10025 SWIGINTERN PyObject *_wrap_qpol_context_t_user(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 10026 PyObject *resultobj = 0; 10027 struct qpol_context *arg1 = (struct qpol_context *) 0 ; 10028 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 10029 void *argp1 = 0 ; 10030 int res1 = 0 ; 10031 void *argp2 = 0 ; 10032 int res2 = 0 ; 10033 PyObject * obj0 = 0 ; 10034 PyObject * obj1 = 0 ; 10035 qpol_user_t *result = 0 ; 10036 10037 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_context_t_user",&obj0,&obj1)) SWIG_fail; 10038 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_context, 0 | 0 ); 10039 if (!SWIG_IsOK(res1)) { 10040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_context_t_user" "', argument " "1"" of type '" "struct qpol_context *""'"); 10041 } 10042 arg1 = (struct qpol_context *)(argp1); 10043 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 10044 if (!SWIG_IsOK(res2)) { 10045 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_context_t_user" "', argument " "2"" of type '" "qpol_policy_t *""'"); 10046 } 10047 arg2 = (qpol_policy_t *)(argp2); 10048 result = (qpol_user_t *)qpol_context_user(arg1,arg2); 10049 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_user, 0 | 0 ); 10050 return resultobj; 10051 fail: 10052 return NULL; 10053 } 10054 10055 10056 SWIGINTERN PyObject *_wrap_qpol_context_t_role(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 10057 PyObject *resultobj = 0; 10058 struct qpol_context *arg1 = (struct qpol_context *) 0 ; 10059 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 10060 void *argp1 = 0 ; 10061 int res1 = 0 ; 10062 void *argp2 = 0 ; 10063 int res2 = 0 ; 10064 PyObject * obj0 = 0 ; 10065 PyObject * obj1 = 0 ; 10066 qpol_role_t *result = 0 ; 10067 10068 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_context_t_role",&obj0,&obj1)) SWIG_fail; 10069 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_context, 0 | 0 ); 10070 if (!SWIG_IsOK(res1)) { 10071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_context_t_role" "', argument " "1"" of type '" "struct qpol_context *""'"); 10072 } 10073 arg1 = (struct qpol_context *)(argp1); 10074 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 10075 if (!SWIG_IsOK(res2)) { 10076 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_context_t_role" "', argument " "2"" of type '" "qpol_policy_t *""'"); 10077 } 10078 arg2 = (qpol_policy_t *)(argp2); 10079 result = (qpol_role_t *)qpol_context_role(arg1,arg2); 10080 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_role, 0 | 0 ); 10081 return resultobj; 10082 fail: 10083 return NULL; 10084 } 10085 10086 10087 SWIGINTERN PyObject *_wrap_qpol_context_t_type_(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 10088 PyObject *resultobj = 0; 10089 struct qpol_context *arg1 = (struct qpol_context *) 0 ; 10090 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 10091 void *argp1 = 0 ; 10092 int res1 = 0 ; 10093 void *argp2 = 0 ; 10094 int res2 = 0 ; 10095 PyObject * obj0 = 0 ; 10096 PyObject * obj1 = 0 ; 10097 qpol_type_t *result = 0 ; 10098 10099 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_context_t_type_",&obj0,&obj1)) SWIG_fail; 10100 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_context, 0 | 0 ); 10101 if (!SWIG_IsOK(res1)) { 10102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_context_t_type_" "', argument " "1"" of type '" "struct qpol_context *""'"); 10103 } 10104 arg1 = (struct qpol_context *)(argp1); 10105 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 10106 if (!SWIG_IsOK(res2)) { 10107 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_context_t_type_" "', argument " "2"" of type '" "qpol_policy_t *""'"); 10108 } 10109 arg2 = (qpol_policy_t *)(argp2); 10110 result = (qpol_type_t *)qpol_context_type_(arg1,arg2); 10111 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_type, 0 | 0 ); 10112 return resultobj; 10113 fail: 10114 return NULL; 10115 } 10116 10117 10118 SWIGINTERN PyObject *_wrap_qpol_context_t_range(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 10119 PyObject *resultobj = 0; 10120 struct qpol_context *arg1 = (struct qpol_context *) 0 ; 10121 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 10122 void *argp1 = 0 ; 10123 int res1 = 0 ; 10124 void *argp2 = 0 ; 10125 int res2 = 0 ; 10126 PyObject * obj0 = 0 ; 10127 PyObject * obj1 = 0 ; 10128 qpol_mls_range_t *result = 0 ; 10129 10130 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_context_t_range",&obj0,&obj1)) SWIG_fail; 10131 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_context, 0 | 0 ); 10132 if (!SWIG_IsOK(res1)) { 10133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_context_t_range" "', argument " "1"" of type '" "struct qpol_context *""'"); 10134 } 10135 arg1 = (struct qpol_context *)(argp1); 10136 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 10137 if (!SWIG_IsOK(res2)) { 10138 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_context_t_range" "', argument " "2"" of type '" "qpol_policy_t *""'"); 10139 } 10140 arg2 = (qpol_policy_t *)(argp2); 10141 result = (qpol_mls_range_t *)qpol_context_range(arg1,arg2); 10142 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_mls_range, 0 | 0 ); 10143 return resultobj; 10144 fail: 10145 return NULL; 10146 } 10147 10148 10149 SWIGINTERN PyObject *qpol_context_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 10150 PyObject *obj; 10151 if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; 10152 SWIG_TypeNewClientData(SWIGTYPE_p_qpol_context, SWIG_NewClientData(obj)); 10153 return SWIG_Py_Void(); 10154 } 10155 10156 SWIGINTERN PyObject *_wrap_qpol_context_from_void(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 10157 PyObject *resultobj = 0; 10158 void *arg1 = (void *) 0 ; 10159 int res1 ; 10160 PyObject * obj0 = 0 ; 10161 qpol_context_t *result = 0 ; 10162 10163 if (!PyArg_ParseTuple(args,(char *)"O:qpol_context_from_void",&obj0)) SWIG_fail; 10164 res1 = SWIG_ConvertPtr(obj0,SWIG_as_voidptrptr(&arg1), 0, 0); 10165 if (!SWIG_IsOK(res1)) { 10166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_context_from_void" "', argument " "1"" of type '" "void *""'"); 10167 } 10168 result = (qpol_context_t *)qpol_context_from_void(arg1); 10169 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_context, 0 | 0 ); 10170 return resultobj; 10171 fail: 10172 return NULL; 10173 } 10174 10175 10176 SWIGINTERN PyObject *_wrap_new_qpol_class_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 10177 PyObject *resultobj = 0; 10178 qpol_policy_t *arg1 = (qpol_policy_t *) 0 ; 10179 char *arg2 = (char *) 0 ; 10180 void *argp1 = 0 ; 10181 int res1 = 0 ; 10182 int res2 ; 10183 char *buf2 = 0 ; 10184 int alloc2 = 0 ; 10185 PyObject * obj0 = 0 ; 10186 PyObject * obj1 = 0 ; 10187 struct qpol_class *result = 0 ; 10188 10189 if (!PyArg_ParseTuple(args,(char *)"OO:new_qpol_class_t",&obj0,&obj1)) SWIG_fail; 10190 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_policy, 0 | 0 ); 10191 if (!SWIG_IsOK(res1)) { 10192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_qpol_class_t" "', argument " "1"" of type '" "qpol_policy_t *""'"); 10193 } 10194 arg1 = (qpol_policy_t *)(argp1); 10195 res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); 10196 if (!SWIG_IsOK(res2)) { 10197 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_qpol_class_t" "', argument " "2"" of type '" "char const *""'"); 10198 } 10199 arg2 = (char *)(buf2); 10200 { 10201 result = (struct qpol_class *)new_qpol_class(arg1,(char const *)arg2); 10202 if (!result) { 10203 if (errno == EINVAL) { 10204 PyErr_SetString(PyExc_ValueError, "Invalid class."); 10205 } else { 10206 PyErr_SetFromErrno(PyExc_OSError); 10207 } 10208 10209 return NULL; 10210 } 10211 } 10212 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_class, SWIG_POINTER_NEW | 0 ); 10213 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); 10214 return resultobj; 10215 fail: 10216 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); 10217 return NULL; 10218 } 10219 10220 10221 SWIGINTERN PyObject *_wrap_delete_qpol_class_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 10222 PyObject *resultobj = 0; 10223 struct qpol_class *arg1 = (struct qpol_class *) 0 ; 10224 void *argp1 = 0 ; 10225 int res1 = 0 ; 10226 PyObject * obj0 = 0 ; 10227 10228 if (!PyArg_ParseTuple(args,(char *)"O:delete_qpol_class_t",&obj0)) SWIG_fail; 10229 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_class, SWIG_POINTER_DISOWN | 0 ); 10230 if (!SWIG_IsOK(res1)) { 10231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_qpol_class_t" "', argument " "1"" of type '" "struct qpol_class *""'"); 10232 } 10233 arg1 = (struct qpol_class *)(argp1); 10234 delete_qpol_class(arg1); 10235 resultobj = SWIG_Py_Void(); 10236 return resultobj; 10237 fail: 10238 return NULL; 10239 } 10240 10241 10242 SWIGINTERN PyObject *_wrap_qpol_class_t_value(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 10243 PyObject *resultobj = 0; 10244 struct qpol_class *arg1 = (struct qpol_class *) 0 ; 10245 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 10246 void *argp1 = 0 ; 10247 int res1 = 0 ; 10248 void *argp2 = 0 ; 10249 int res2 = 0 ; 10250 PyObject * obj0 = 0 ; 10251 PyObject * obj1 = 0 ; 10252 int result; 10253 10254 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_class_t_value",&obj0,&obj1)) SWIG_fail; 10255 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_class, 0 | 0 ); 10256 if (!SWIG_IsOK(res1)) { 10257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_class_t_value" "', argument " "1"" of type '" "struct qpol_class *""'"); 10258 } 10259 arg1 = (struct qpol_class *)(argp1); 10260 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 10261 if (!SWIG_IsOK(res2)) { 10262 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_class_t_value" "', argument " "2"" of type '" "qpol_policy_t *""'"); 10263 } 10264 arg2 = (qpol_policy_t *)(argp2); 10265 result = (int)qpol_class_value(arg1,arg2); 10266 resultobj = SWIG_From_int((int)(result)); 10267 return resultobj; 10268 fail: 10269 return NULL; 10270 } 10271 10272 10273 SWIGINTERN PyObject *_wrap_qpol_class_t_common(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 10274 PyObject *resultobj = 0; 10275 struct qpol_class *arg1 = (struct qpol_class *) 0 ; 10276 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 10277 void *argp1 = 0 ; 10278 int res1 = 0 ; 10279 void *argp2 = 0 ; 10280 int res2 = 0 ; 10281 PyObject * obj0 = 0 ; 10282 PyObject * obj1 = 0 ; 10283 qpol_common_t *result = 0 ; 10284 10285 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_class_t_common",&obj0,&obj1)) SWIG_fail; 10286 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_class, 0 | 0 ); 10287 if (!SWIG_IsOK(res1)) { 10288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_class_t_common" "', argument " "1"" of type '" "struct qpol_class *""'"); 10289 } 10290 arg1 = (struct qpol_class *)(argp1); 10291 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 10292 if (!SWIG_IsOK(res2)) { 10293 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_class_t_common" "', argument " "2"" of type '" "qpol_policy_t *""'"); 10294 } 10295 arg2 = (qpol_policy_t *)(argp2); 10296 { 10297 result = (qpol_common_t *)qpol_class_common(arg1,arg2); 10298 if (!result) { 10299 PyErr_SetString(PyExc_ValueError, "Class does not inherit a common."); 10300 return NULL; 10301 } 10302 } 10303 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_common, 0 | 0 ); 10304 return resultobj; 10305 fail: 10306 return NULL; 10307 } 10308 10309 10310 SWIGINTERN PyObject *_wrap_qpol_class_t_perm_iter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 10311 PyObject *resultobj = 0; 10312 struct qpol_class *arg1 = (struct qpol_class *) 0 ; 10313 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 10314 void *argp1 = 0 ; 10315 int res1 = 0 ; 10316 void *argp2 = 0 ; 10317 int res2 = 0 ; 10318 PyObject * obj0 = 0 ; 10319 PyObject * obj1 = 0 ; 10320 qpol_iterator_t *result = 0 ; 10321 10322 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_class_t_perm_iter",&obj0,&obj1)) SWIG_fail; 10323 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_class, 0 | 0 ); 10324 if (!SWIG_IsOK(res1)) { 10325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_class_t_perm_iter" "', argument " "1"" of type '" "struct qpol_class *""'"); 10326 } 10327 arg1 = (struct qpol_class *)(argp1); 10328 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 10329 if (!SWIG_IsOK(res2)) { 10330 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_class_t_perm_iter" "', argument " "2"" of type '" "qpol_policy_t *""'"); 10331 } 10332 arg2 = (qpol_policy_t *)(argp2); 10333 result = (qpol_iterator_t *)qpol_class_perm_iter(arg1,arg2); 10334 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_iterator, SWIG_POINTER_OWN | 0 ); 10335 return resultobj; 10336 fail: 10337 return NULL; 10338 } 10339 10340 10341 SWIGINTERN PyObject *_wrap_qpol_class_t_constraint_iter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 10342 PyObject *resultobj = 0; 10343 struct qpol_class *arg1 = (struct qpol_class *) 0 ; 10344 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 10345 void *argp1 = 0 ; 10346 int res1 = 0 ; 10347 void *argp2 = 0 ; 10348 int res2 = 0 ; 10349 PyObject * obj0 = 0 ; 10350 PyObject * obj1 = 0 ; 10351 qpol_iterator_t *result = 0 ; 10352 10353 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_class_t_constraint_iter",&obj0,&obj1)) SWIG_fail; 10354 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_class, 0 | 0 ); 10355 if (!SWIG_IsOK(res1)) { 10356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_class_t_constraint_iter" "', argument " "1"" of type '" "struct qpol_class *""'"); 10357 } 10358 arg1 = (struct qpol_class *)(argp1); 10359 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 10360 if (!SWIG_IsOK(res2)) { 10361 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_class_t_constraint_iter" "', argument " "2"" of type '" "qpol_policy_t *""'"); 10362 } 10363 arg2 = (qpol_policy_t *)(argp2); 10364 result = (qpol_iterator_t *)qpol_class_constraint_iter(arg1,arg2); 10365 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_iterator, SWIG_POINTER_OWN | 0 ); 10366 return resultobj; 10367 fail: 10368 return NULL; 10369 } 10370 10371 10372 SWIGINTERN PyObject *_wrap_qpol_class_t_validatetrans_iter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 10373 PyObject *resultobj = 0; 10374 struct qpol_class *arg1 = (struct qpol_class *) 0 ; 10375 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 10376 void *argp1 = 0 ; 10377 int res1 = 0 ; 10378 void *argp2 = 0 ; 10379 int res2 = 0 ; 10380 PyObject * obj0 = 0 ; 10381 PyObject * obj1 = 0 ; 10382 qpol_iterator_t *result = 0 ; 10383 10384 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_class_t_validatetrans_iter",&obj0,&obj1)) SWIG_fail; 10385 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_class, 0 | 0 ); 10386 if (!SWIG_IsOK(res1)) { 10387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_class_t_validatetrans_iter" "', argument " "1"" of type '" "struct qpol_class *""'"); 10388 } 10389 arg1 = (struct qpol_class *)(argp1); 10390 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 10391 if (!SWIG_IsOK(res2)) { 10392 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_class_t_validatetrans_iter" "', argument " "2"" of type '" "qpol_policy_t *""'"); 10393 } 10394 arg2 = (qpol_policy_t *)(argp2); 10395 result = (qpol_iterator_t *)qpol_class_validatetrans_iter(arg1,arg2); 10396 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_iterator, SWIG_POINTER_OWN | 0 ); 10397 return resultobj; 10398 fail: 10399 return NULL; 10400 } 10401 10402 10403 SWIGINTERN PyObject *_wrap_qpol_class_t_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 10404 PyObject *resultobj = 0; 10405 struct qpol_class *arg1 = (struct qpol_class *) 0 ; 10406 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 10407 void *argp1 = 0 ; 10408 int res1 = 0 ; 10409 void *argp2 = 0 ; 10410 int res2 = 0 ; 10411 PyObject * obj0 = 0 ; 10412 PyObject * obj1 = 0 ; 10413 char *result = 0 ; 10414 10415 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_class_t_name",&obj0,&obj1)) SWIG_fail; 10416 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_class, 0 | 0 ); 10417 if (!SWIG_IsOK(res1)) { 10418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_class_t_name" "', argument " "1"" of type '" "struct qpol_class *""'"); 10419 } 10420 arg1 = (struct qpol_class *)(argp1); 10421 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 10422 if (!SWIG_IsOK(res2)) { 10423 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_class_t_name" "', argument " "2"" of type '" "qpol_policy_t *""'"); 10424 } 10425 arg2 = (qpol_policy_t *)(argp2); 10426 result = (char *)qpol_class_name(arg1,arg2); 10427 resultobj = SWIG_FromCharPtr((const char *)result); 10428 return resultobj; 10429 fail: 10430 return NULL; 10431 } 10432 10433 10434 SWIGINTERN PyObject *qpol_class_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 10435 PyObject *obj; 10436 if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; 10437 SWIG_TypeNewClientData(SWIGTYPE_p_qpol_class, SWIG_NewClientData(obj)); 10438 return SWIG_Py_Void(); 10439 } 10440 10441 SWIGINTERN PyObject *_wrap_qpol_class_from_void(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 10442 PyObject *resultobj = 0; 10443 void *arg1 = (void *) 0 ; 10444 int res1 ; 10445 PyObject * obj0 = 0 ; 10446 qpol_class_t *result = 0 ; 10447 10448 if (!PyArg_ParseTuple(args,(char *)"O:qpol_class_from_void",&obj0)) SWIG_fail; 10449 res1 = SWIG_ConvertPtr(obj0,SWIG_as_voidptrptr(&arg1), 0, 0); 10450 if (!SWIG_IsOK(res1)) { 10451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_class_from_void" "', argument " "1"" of type '" "void *""'"); 10452 } 10453 result = (qpol_class_t *)qpol_class_from_void(arg1); 10454 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_class, 0 | 0 ); 10455 return resultobj; 10456 fail: 10457 return NULL; 10458 } 10459 10460 10461 SWIGINTERN PyObject *_wrap_new_qpol_common_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 10462 PyObject *resultobj = 0; 10463 qpol_policy_t *arg1 = (qpol_policy_t *) 0 ; 10464 char *arg2 = (char *) 0 ; 10465 void *argp1 = 0 ; 10466 int res1 = 0 ; 10467 int res2 ; 10468 char *buf2 = 0 ; 10469 int alloc2 = 0 ; 10470 PyObject * obj0 = 0 ; 10471 PyObject * obj1 = 0 ; 10472 struct qpol_common *result = 0 ; 10473 10474 if (!PyArg_ParseTuple(args,(char *)"OO:new_qpol_common_t",&obj0,&obj1)) SWIG_fail; 10475 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_policy, 0 | 0 ); 10476 if (!SWIG_IsOK(res1)) { 10477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_qpol_common_t" "', argument " "1"" of type '" "qpol_policy_t *""'"); 10478 } 10479 arg1 = (qpol_policy_t *)(argp1); 10480 res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); 10481 if (!SWIG_IsOK(res2)) { 10482 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_qpol_common_t" "', argument " "2"" of type '" "char const *""'"); 10483 } 10484 arg2 = (char *)(buf2); 10485 { 10486 result = (struct qpol_common *)new_qpol_common(arg1,(char const *)arg2); 10487 if (!result) { 10488 if (errno == EINVAL) { 10489 PyErr_SetString(PyExc_ValueError, "Invalid common."); 10490 } else { 10491 PyErr_SetFromErrno(PyExc_OSError); 10492 } 10493 10494 return NULL; 10495 } 10496 } 10497 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_common, SWIG_POINTER_NEW | 0 ); 10498 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); 10499 return resultobj; 10500 fail: 10501 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); 10502 return NULL; 10503 } 10504 10505 10506 SWIGINTERN PyObject *_wrap_delete_qpol_common_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 10507 PyObject *resultobj = 0; 10508 struct qpol_common *arg1 = (struct qpol_common *) 0 ; 10509 void *argp1 = 0 ; 10510 int res1 = 0 ; 10511 PyObject * obj0 = 0 ; 10512 10513 if (!PyArg_ParseTuple(args,(char *)"O:delete_qpol_common_t",&obj0)) SWIG_fail; 10514 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_common, SWIG_POINTER_DISOWN | 0 ); 10515 if (!SWIG_IsOK(res1)) { 10516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_qpol_common_t" "', argument " "1"" of type '" "struct qpol_common *""'"); 10517 } 10518 arg1 = (struct qpol_common *)(argp1); 10519 delete_qpol_common(arg1); 10520 resultobj = SWIG_Py_Void(); 10521 return resultobj; 10522 fail: 10523 return NULL; 10524 } 10525 10526 10527 SWIGINTERN PyObject *_wrap_qpol_common_t_value(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 10528 PyObject *resultobj = 0; 10529 struct qpol_common *arg1 = (struct qpol_common *) 0 ; 10530 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 10531 void *argp1 = 0 ; 10532 int res1 = 0 ; 10533 void *argp2 = 0 ; 10534 int res2 = 0 ; 10535 PyObject * obj0 = 0 ; 10536 PyObject * obj1 = 0 ; 10537 int result; 10538 10539 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_common_t_value",&obj0,&obj1)) SWIG_fail; 10540 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_common, 0 | 0 ); 10541 if (!SWIG_IsOK(res1)) { 10542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_common_t_value" "', argument " "1"" of type '" "struct qpol_common *""'"); 10543 } 10544 arg1 = (struct qpol_common *)(argp1); 10545 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 10546 if (!SWIG_IsOK(res2)) { 10547 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_common_t_value" "', argument " "2"" of type '" "qpol_policy_t *""'"); 10548 } 10549 arg2 = (qpol_policy_t *)(argp2); 10550 result = (int)qpol_common_value(arg1,arg2); 10551 resultobj = SWIG_From_int((int)(result)); 10552 return resultobj; 10553 fail: 10554 return NULL; 10555 } 10556 10557 10558 SWIGINTERN PyObject *_wrap_qpol_common_t_perm_iter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 10559 PyObject *resultobj = 0; 10560 struct qpol_common *arg1 = (struct qpol_common *) 0 ; 10561 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 10562 void *argp1 = 0 ; 10563 int res1 = 0 ; 10564 void *argp2 = 0 ; 10565 int res2 = 0 ; 10566 PyObject * obj0 = 0 ; 10567 PyObject * obj1 = 0 ; 10568 qpol_iterator_t *result = 0 ; 10569 10570 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_common_t_perm_iter",&obj0,&obj1)) SWIG_fail; 10571 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_common, 0 | 0 ); 10572 if (!SWIG_IsOK(res1)) { 10573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_common_t_perm_iter" "', argument " "1"" of type '" "struct qpol_common *""'"); 10574 } 10575 arg1 = (struct qpol_common *)(argp1); 10576 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 10577 if (!SWIG_IsOK(res2)) { 10578 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_common_t_perm_iter" "', argument " "2"" of type '" "qpol_policy_t *""'"); 10579 } 10580 arg2 = (qpol_policy_t *)(argp2); 10581 result = (qpol_iterator_t *)qpol_common_perm_iter(arg1,arg2); 10582 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_iterator, SWIG_POINTER_OWN | 0 ); 10583 return resultobj; 10584 fail: 10585 return NULL; 10586 } 10587 10588 10589 SWIGINTERN PyObject *_wrap_qpol_common_t_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 10590 PyObject *resultobj = 0; 10591 struct qpol_common *arg1 = (struct qpol_common *) 0 ; 10592 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 10593 void *argp1 = 0 ; 10594 int res1 = 0 ; 10595 void *argp2 = 0 ; 10596 int res2 = 0 ; 10597 PyObject * obj0 = 0 ; 10598 PyObject * obj1 = 0 ; 10599 char *result = 0 ; 10600 10601 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_common_t_name",&obj0,&obj1)) SWIG_fail; 10602 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_common, 0 | 0 ); 10603 if (!SWIG_IsOK(res1)) { 10604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_common_t_name" "', argument " "1"" of type '" "struct qpol_common *""'"); 10605 } 10606 arg1 = (struct qpol_common *)(argp1); 10607 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 10608 if (!SWIG_IsOK(res2)) { 10609 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_common_t_name" "', argument " "2"" of type '" "qpol_policy_t *""'"); 10610 } 10611 arg2 = (qpol_policy_t *)(argp2); 10612 result = (char *)qpol_common_name(arg1,arg2); 10613 resultobj = SWIG_FromCharPtr((const char *)result); 10614 return resultobj; 10615 fail: 10616 return NULL; 10617 } 10618 10619 10620 SWIGINTERN PyObject *qpol_common_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 10621 PyObject *obj; 10622 if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; 10623 SWIG_TypeNewClientData(SWIGTYPE_p_qpol_common, SWIG_NewClientData(obj)); 10624 return SWIG_Py_Void(); 10625 } 10626 10627 SWIGINTERN PyObject *_wrap_qpol_common_from_void(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 10628 PyObject *resultobj = 0; 10629 void *arg1 = (void *) 0 ; 10630 int res1 ; 10631 PyObject * obj0 = 0 ; 10632 qpol_common_t *result = 0 ; 10633 10634 if (!PyArg_ParseTuple(args,(char *)"O:qpol_common_from_void",&obj0)) SWIG_fail; 10635 res1 = SWIG_ConvertPtr(obj0,SWIG_as_voidptrptr(&arg1), 0, 0); 10636 if (!SWIG_IsOK(res1)) { 10637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_common_from_void" "', argument " "1"" of type '" "void *""'"); 10638 } 10639 result = (qpol_common_t *)qpol_common_from_void(arg1); 10640 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_common, 0 | 0 ); 10641 return resultobj; 10642 fail: 10643 return NULL; 10644 } 10645 10646 10647 SWIGINTERN PyObject *_wrap_new_qpol_fs_use_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 10648 PyObject *resultobj = 0; 10649 qpol_policy_t *arg1 = (qpol_policy_t *) 0 ; 10650 char *arg2 = (char *) 0 ; 10651 void *argp1 = 0 ; 10652 int res1 = 0 ; 10653 int res2 ; 10654 char *buf2 = 0 ; 10655 int alloc2 = 0 ; 10656 PyObject * obj0 = 0 ; 10657 PyObject * obj1 = 0 ; 10658 struct qpol_fs_use *result = 0 ; 10659 10660 if (!PyArg_ParseTuple(args,(char *)"OO:new_qpol_fs_use_t",&obj0,&obj1)) SWIG_fail; 10661 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_policy, 0 | 0 ); 10662 if (!SWIG_IsOK(res1)) { 10663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_qpol_fs_use_t" "', argument " "1"" of type '" "qpol_policy_t *""'"); 10664 } 10665 arg1 = (qpol_policy_t *)(argp1); 10666 res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); 10667 if (!SWIG_IsOK(res2)) { 10668 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_qpol_fs_use_t" "', argument " "2"" of type '" "char const *""'"); 10669 } 10670 arg2 = (char *)(buf2); 10671 result = (struct qpol_fs_use *)new_qpol_fs_use(arg1,(char const *)arg2); 10672 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_fs_use, SWIG_POINTER_NEW | 0 ); 10673 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); 10674 return resultobj; 10675 fail: 10676 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); 10677 return NULL; 10678 } 10679 10680 10681 SWIGINTERN PyObject *_wrap_delete_qpol_fs_use_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 10682 PyObject *resultobj = 0; 10683 struct qpol_fs_use *arg1 = (struct qpol_fs_use *) 0 ; 10684 void *argp1 = 0 ; 10685 int res1 = 0 ; 10686 PyObject * obj0 = 0 ; 10687 10688 if (!PyArg_ParseTuple(args,(char *)"O:delete_qpol_fs_use_t",&obj0)) SWIG_fail; 10689 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_fs_use, SWIG_POINTER_DISOWN | 0 ); 10690 if (!SWIG_IsOK(res1)) { 10691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_qpol_fs_use_t" "', argument " "1"" of type '" "struct qpol_fs_use *""'"); 10692 } 10693 arg1 = (struct qpol_fs_use *)(argp1); 10694 delete_qpol_fs_use(arg1); 10695 resultobj = SWIG_Py_Void(); 10696 return resultobj; 10697 fail: 10698 return NULL; 10699 } 10700 10701 10702 SWIGINTERN PyObject *_wrap_qpol_fs_use_t_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 10703 PyObject *resultobj = 0; 10704 struct qpol_fs_use *arg1 = (struct qpol_fs_use *) 0 ; 10705 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 10706 void *argp1 = 0 ; 10707 int res1 = 0 ; 10708 void *argp2 = 0 ; 10709 int res2 = 0 ; 10710 PyObject * obj0 = 0 ; 10711 PyObject * obj1 = 0 ; 10712 char *result = 0 ; 10713 10714 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_fs_use_t_name",&obj0,&obj1)) SWIG_fail; 10715 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_fs_use, 0 | 0 ); 10716 if (!SWIG_IsOK(res1)) { 10717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_fs_use_t_name" "', argument " "1"" of type '" "struct qpol_fs_use *""'"); 10718 } 10719 arg1 = (struct qpol_fs_use *)(argp1); 10720 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 10721 if (!SWIG_IsOK(res2)) { 10722 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_fs_use_t_name" "', argument " "2"" of type '" "qpol_policy_t *""'"); 10723 } 10724 arg2 = (qpol_policy_t *)(argp2); 10725 result = (char *)qpol_fs_use_name(arg1,arg2); 10726 resultobj = SWIG_FromCharPtr((const char *)result); 10727 return resultobj; 10728 fail: 10729 return NULL; 10730 } 10731 10732 10733 SWIGINTERN PyObject *_wrap_qpol_fs_use_t_behavior(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 10734 PyObject *resultobj = 0; 10735 struct qpol_fs_use *arg1 = (struct qpol_fs_use *) 0 ; 10736 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 10737 void *argp1 = 0 ; 10738 int res1 = 0 ; 10739 void *argp2 = 0 ; 10740 int res2 = 0 ; 10741 PyObject * obj0 = 0 ; 10742 PyObject * obj1 = 0 ; 10743 int result; 10744 10745 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_fs_use_t_behavior",&obj0,&obj1)) SWIG_fail; 10746 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_fs_use, 0 | 0 ); 10747 if (!SWIG_IsOK(res1)) { 10748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_fs_use_t_behavior" "', argument " "1"" of type '" "struct qpol_fs_use *""'"); 10749 } 10750 arg1 = (struct qpol_fs_use *)(argp1); 10751 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 10752 if (!SWIG_IsOK(res2)) { 10753 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_fs_use_t_behavior" "', argument " "2"" of type '" "qpol_policy_t *""'"); 10754 } 10755 arg2 = (qpol_policy_t *)(argp2); 10756 result = (int)qpol_fs_use_behavior(arg1,arg2); 10757 resultobj = SWIG_From_int((int)(result)); 10758 return resultobj; 10759 fail: 10760 return NULL; 10761 } 10762 10763 10764 SWIGINTERN PyObject *_wrap_qpol_fs_use_t_context(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 10765 PyObject *resultobj = 0; 10766 struct qpol_fs_use *arg1 = (struct qpol_fs_use *) 0 ; 10767 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 10768 void *argp1 = 0 ; 10769 int res1 = 0 ; 10770 void *argp2 = 0 ; 10771 int res2 = 0 ; 10772 PyObject * obj0 = 0 ; 10773 PyObject * obj1 = 0 ; 10774 qpol_context_t *result = 0 ; 10775 10776 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_fs_use_t_context",&obj0,&obj1)) SWIG_fail; 10777 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_fs_use, 0 | 0 ); 10778 if (!SWIG_IsOK(res1)) { 10779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_fs_use_t_context" "', argument " "1"" of type '" "struct qpol_fs_use *""'"); 10780 } 10781 arg1 = (struct qpol_fs_use *)(argp1); 10782 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 10783 if (!SWIG_IsOK(res2)) { 10784 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_fs_use_t_context" "', argument " "2"" of type '" "qpol_policy_t *""'"); 10785 } 10786 arg2 = (qpol_policy_t *)(argp2); 10787 result = (qpol_context_t *)qpol_fs_use_context(arg1,arg2); 10788 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_context, 0 | 0 ); 10789 return resultobj; 10790 fail: 10791 return NULL; 10792 } 10793 10794 10795 SWIGINTERN PyObject *qpol_fs_use_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 10796 PyObject *obj; 10797 if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; 10798 SWIG_TypeNewClientData(SWIGTYPE_p_qpol_fs_use, SWIG_NewClientData(obj)); 10799 return SWIG_Py_Void(); 10800 } 10801 10802 SWIGINTERN PyObject *_wrap_qpol_fs_use_from_void(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 10803 PyObject *resultobj = 0; 10804 void *arg1 = (void *) 0 ; 10805 int res1 ; 10806 PyObject * obj0 = 0 ; 10807 qpol_fs_use_t *result = 0 ; 10808 10809 if (!PyArg_ParseTuple(args,(char *)"O:qpol_fs_use_from_void",&obj0)) SWIG_fail; 10810 res1 = SWIG_ConvertPtr(obj0,SWIG_as_voidptrptr(&arg1), 0, 0); 10811 if (!SWIG_IsOK(res1)) { 10812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_fs_use_from_void" "', argument " "1"" of type '" "void *""'"); 10813 } 10814 result = (qpol_fs_use_t *)qpol_fs_use_from_void(arg1); 10815 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_fs_use, 0 | 0 ); 10816 return resultobj; 10817 fail: 10818 return NULL; 10819 } 10820 10821 10822 SWIGINTERN PyObject *_wrap_new_qpol_genfscon_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 10823 PyObject *resultobj = 0; 10824 qpol_policy_t *arg1 = (qpol_policy_t *) 0 ; 10825 char *arg2 = (char *) 0 ; 10826 char *arg3 = (char *) 0 ; 10827 void *argp1 = 0 ; 10828 int res1 = 0 ; 10829 int res2 ; 10830 char *buf2 = 0 ; 10831 int alloc2 = 0 ; 10832 int res3 ; 10833 char *buf3 = 0 ; 10834 int alloc3 = 0 ; 10835 PyObject * obj0 = 0 ; 10836 PyObject * obj1 = 0 ; 10837 PyObject * obj2 = 0 ; 10838 struct qpol_genfscon *result = 0 ; 10839 10840 if (!PyArg_ParseTuple(args,(char *)"OOO:new_qpol_genfscon_t",&obj0,&obj1,&obj2)) SWIG_fail; 10841 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_policy, 0 | 0 ); 10842 if (!SWIG_IsOK(res1)) { 10843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_qpol_genfscon_t" "', argument " "1"" of type '" "qpol_policy_t *""'"); 10844 } 10845 arg1 = (qpol_policy_t *)(argp1); 10846 res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); 10847 if (!SWIG_IsOK(res2)) { 10848 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_qpol_genfscon_t" "', argument " "2"" of type '" "char const *""'"); 10849 } 10850 arg2 = (char *)(buf2); 10851 res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3); 10852 if (!SWIG_IsOK(res3)) { 10853 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_qpol_genfscon_t" "', argument " "3"" of type '" "char const *""'"); 10854 } 10855 arg3 = (char *)(buf3); 10856 result = (struct qpol_genfscon *)new_qpol_genfscon(arg1,(char const *)arg2,(char const *)arg3); 10857 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_genfscon, SWIG_POINTER_NEW | 0 ); 10858 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); 10859 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3); 10860 return resultobj; 10861 fail: 10862 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); 10863 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3); 10864 return NULL; 10865 } 10866 10867 10868 SWIGINTERN PyObject *_wrap_delete_qpol_genfscon_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 10869 PyObject *resultobj = 0; 10870 struct qpol_genfscon *arg1 = (struct qpol_genfscon *) 0 ; 10871 void *argp1 = 0 ; 10872 int res1 = 0 ; 10873 PyObject * obj0 = 0 ; 10874 10875 if (!PyArg_ParseTuple(args,(char *)"O:delete_qpol_genfscon_t",&obj0)) SWIG_fail; 10876 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_genfscon, SWIG_POINTER_DISOWN | 0 ); 10877 if (!SWIG_IsOK(res1)) { 10878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_qpol_genfscon_t" "', argument " "1"" of type '" "struct qpol_genfscon *""'"); 10879 } 10880 arg1 = (struct qpol_genfscon *)(argp1); 10881 delete_qpol_genfscon(arg1); 10882 resultobj = SWIG_Py_Void(); 10883 return resultobj; 10884 fail: 10885 return NULL; 10886 } 10887 10888 10889 SWIGINTERN PyObject *_wrap_qpol_genfscon_t_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 10890 PyObject *resultobj = 0; 10891 struct qpol_genfscon *arg1 = (struct qpol_genfscon *) 0 ; 10892 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 10893 void *argp1 = 0 ; 10894 int res1 = 0 ; 10895 void *argp2 = 0 ; 10896 int res2 = 0 ; 10897 PyObject * obj0 = 0 ; 10898 PyObject * obj1 = 0 ; 10899 char *result = 0 ; 10900 10901 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_genfscon_t_name",&obj0,&obj1)) SWIG_fail; 10902 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_genfscon, 0 | 0 ); 10903 if (!SWIG_IsOK(res1)) { 10904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_genfscon_t_name" "', argument " "1"" of type '" "struct qpol_genfscon *""'"); 10905 } 10906 arg1 = (struct qpol_genfscon *)(argp1); 10907 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 10908 if (!SWIG_IsOK(res2)) { 10909 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_genfscon_t_name" "', argument " "2"" of type '" "qpol_policy_t *""'"); 10910 } 10911 arg2 = (qpol_policy_t *)(argp2); 10912 result = (char *)qpol_genfscon_name(arg1,arg2); 10913 resultobj = SWIG_FromCharPtr((const char *)result); 10914 return resultobj; 10915 fail: 10916 return NULL; 10917 } 10918 10919 10920 SWIGINTERN PyObject *_wrap_qpol_genfscon_t_path(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 10921 PyObject *resultobj = 0; 10922 struct qpol_genfscon *arg1 = (struct qpol_genfscon *) 0 ; 10923 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 10924 void *argp1 = 0 ; 10925 int res1 = 0 ; 10926 void *argp2 = 0 ; 10927 int res2 = 0 ; 10928 PyObject * obj0 = 0 ; 10929 PyObject * obj1 = 0 ; 10930 char *result = 0 ; 10931 10932 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_genfscon_t_path",&obj0,&obj1)) SWIG_fail; 10933 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_genfscon, 0 | 0 ); 10934 if (!SWIG_IsOK(res1)) { 10935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_genfscon_t_path" "', argument " "1"" of type '" "struct qpol_genfscon *""'"); 10936 } 10937 arg1 = (struct qpol_genfscon *)(argp1); 10938 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 10939 if (!SWIG_IsOK(res2)) { 10940 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_genfscon_t_path" "', argument " "2"" of type '" "qpol_policy_t *""'"); 10941 } 10942 arg2 = (qpol_policy_t *)(argp2); 10943 result = (char *)qpol_genfscon_path(arg1,arg2); 10944 resultobj = SWIG_FromCharPtr((const char *)result); 10945 return resultobj; 10946 fail: 10947 return NULL; 10948 } 10949 10950 10951 SWIGINTERN PyObject *_wrap_qpol_genfscon_t_object_class(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 10952 PyObject *resultobj = 0; 10953 struct qpol_genfscon *arg1 = (struct qpol_genfscon *) 0 ; 10954 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 10955 void *argp1 = 0 ; 10956 int res1 = 0 ; 10957 void *argp2 = 0 ; 10958 int res2 = 0 ; 10959 PyObject * obj0 = 0 ; 10960 PyObject * obj1 = 0 ; 10961 unsigned int result; 10962 10963 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_genfscon_t_object_class",&obj0,&obj1)) SWIG_fail; 10964 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_genfscon, 0 | 0 ); 10965 if (!SWIG_IsOK(res1)) { 10966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_genfscon_t_object_class" "', argument " "1"" of type '" "struct qpol_genfscon *""'"); 10967 } 10968 arg1 = (struct qpol_genfscon *)(argp1); 10969 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 10970 if (!SWIG_IsOK(res2)) { 10971 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_genfscon_t_object_class" "', argument " "2"" of type '" "qpol_policy_t *""'"); 10972 } 10973 arg2 = (qpol_policy_t *)(argp2); 10974 result = (unsigned int)qpol_genfscon_object_class(arg1,arg2); 10975 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); 10976 return resultobj; 10977 fail: 10978 return NULL; 10979 } 10980 10981 10982 SWIGINTERN PyObject *_wrap_qpol_genfscon_t_context(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 10983 PyObject *resultobj = 0; 10984 struct qpol_genfscon *arg1 = (struct qpol_genfscon *) 0 ; 10985 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 10986 void *argp1 = 0 ; 10987 int res1 = 0 ; 10988 void *argp2 = 0 ; 10989 int res2 = 0 ; 10990 PyObject * obj0 = 0 ; 10991 PyObject * obj1 = 0 ; 10992 qpol_context_t *result = 0 ; 10993 10994 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_genfscon_t_context",&obj0,&obj1)) SWIG_fail; 10995 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_genfscon, 0 | 0 ); 10996 if (!SWIG_IsOK(res1)) { 10997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_genfscon_t_context" "', argument " "1"" of type '" "struct qpol_genfscon *""'"); 10998 } 10999 arg1 = (struct qpol_genfscon *)(argp1); 11000 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 11001 if (!SWIG_IsOK(res2)) { 11002 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_genfscon_t_context" "', argument " "2"" of type '" "qpol_policy_t *""'"); 11003 } 11004 arg2 = (qpol_policy_t *)(argp2); 11005 result = (qpol_context_t *)qpol_genfscon_context(arg1,arg2); 11006 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_context, 0 | 0 ); 11007 return resultobj; 11008 fail: 11009 return NULL; 11010 } 11011 11012 11013 SWIGINTERN PyObject *qpol_genfscon_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 11014 PyObject *obj; 11015 if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; 11016 SWIG_TypeNewClientData(SWIGTYPE_p_qpol_genfscon, SWIG_NewClientData(obj)); 11017 return SWIG_Py_Void(); 11018 } 11019 11020 SWIGINTERN PyObject *_wrap_qpol_genfscon_from_void(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 11021 PyObject *resultobj = 0; 11022 void *arg1 = (void *) 0 ; 11023 int res1 ; 11024 PyObject * obj0 = 0 ; 11025 qpol_genfscon_t *result = 0 ; 11026 11027 if (!PyArg_ParseTuple(args,(char *)"O:qpol_genfscon_from_void",&obj0)) SWIG_fail; 11028 res1 = SWIG_ConvertPtr(obj0,SWIG_as_voidptrptr(&arg1), 0, 0); 11029 if (!SWIG_IsOK(res1)) { 11030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_genfscon_from_void" "', argument " "1"" of type '" "void *""'"); 11031 } 11032 result = (qpol_genfscon_t *)qpol_genfscon_from_void(arg1); 11033 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_genfscon, 0 | 0 ); 11034 return resultobj; 11035 fail: 11036 return NULL; 11037 } 11038 11039 11040 SWIGINTERN PyObject *_wrap_new_qpol_isid_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 11041 PyObject *resultobj = 0; 11042 qpol_policy_t *arg1 = (qpol_policy_t *) 0 ; 11043 char *arg2 = (char *) 0 ; 11044 void *argp1 = 0 ; 11045 int res1 = 0 ; 11046 int res2 ; 11047 char *buf2 = 0 ; 11048 int alloc2 = 0 ; 11049 PyObject * obj0 = 0 ; 11050 PyObject * obj1 = 0 ; 11051 struct qpol_isid *result = 0 ; 11052 11053 if (!PyArg_ParseTuple(args,(char *)"OO:new_qpol_isid_t",&obj0,&obj1)) SWIG_fail; 11054 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_policy, 0 | 0 ); 11055 if (!SWIG_IsOK(res1)) { 11056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_qpol_isid_t" "', argument " "1"" of type '" "qpol_policy_t *""'"); 11057 } 11058 arg1 = (qpol_policy_t *)(argp1); 11059 res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); 11060 if (!SWIG_IsOK(res2)) { 11061 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_qpol_isid_t" "', argument " "2"" of type '" "char const *""'"); 11062 } 11063 arg2 = (char *)(buf2); 11064 { 11065 result = (struct qpol_isid *)new_qpol_isid(arg1,(char const *)arg2); 11066 if (!result) { 11067 if (errno == EINVAL) { 11068 PyErr_SetString(PyExc_ValueError, "Invalid initial sid name."); 11069 } else { 11070 PyErr_SetFromErrno(PyExc_OSError); 11071 } 11072 11073 return NULL; 11074 } 11075 } 11076 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_isid, SWIG_POINTER_NEW | 0 ); 11077 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); 11078 return resultobj; 11079 fail: 11080 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); 11081 return NULL; 11082 } 11083 11084 11085 SWIGINTERN PyObject *_wrap_delete_qpol_isid_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 11086 PyObject *resultobj = 0; 11087 struct qpol_isid *arg1 = (struct qpol_isid *) 0 ; 11088 void *argp1 = 0 ; 11089 int res1 = 0 ; 11090 PyObject * obj0 = 0 ; 11091 11092 if (!PyArg_ParseTuple(args,(char *)"O:delete_qpol_isid_t",&obj0)) SWIG_fail; 11093 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_isid, SWIG_POINTER_DISOWN | 0 ); 11094 if (!SWIG_IsOK(res1)) { 11095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_qpol_isid_t" "', argument " "1"" of type '" "struct qpol_isid *""'"); 11096 } 11097 arg1 = (struct qpol_isid *)(argp1); 11098 delete_qpol_isid(arg1); 11099 resultobj = SWIG_Py_Void(); 11100 return resultobj; 11101 fail: 11102 return NULL; 11103 } 11104 11105 11106 SWIGINTERN PyObject *_wrap_qpol_isid_t_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 11107 PyObject *resultobj = 0; 11108 struct qpol_isid *arg1 = (struct qpol_isid *) 0 ; 11109 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 11110 void *argp1 = 0 ; 11111 int res1 = 0 ; 11112 void *argp2 = 0 ; 11113 int res2 = 0 ; 11114 PyObject * obj0 = 0 ; 11115 PyObject * obj1 = 0 ; 11116 char *result = 0 ; 11117 11118 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_isid_t_name",&obj0,&obj1)) SWIG_fail; 11119 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_isid, 0 | 0 ); 11120 if (!SWIG_IsOK(res1)) { 11121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_isid_t_name" "', argument " "1"" of type '" "struct qpol_isid *""'"); 11122 } 11123 arg1 = (struct qpol_isid *)(argp1); 11124 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 11125 if (!SWIG_IsOK(res2)) { 11126 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_isid_t_name" "', argument " "2"" of type '" "qpol_policy_t *""'"); 11127 } 11128 arg2 = (qpol_policy_t *)(argp2); 11129 result = (char *)qpol_isid_name(arg1,arg2); 11130 resultobj = SWIG_FromCharPtr((const char *)result); 11131 return resultobj; 11132 fail: 11133 return NULL; 11134 } 11135 11136 11137 SWIGINTERN PyObject *_wrap_qpol_isid_t_context(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 11138 PyObject *resultobj = 0; 11139 struct qpol_isid *arg1 = (struct qpol_isid *) 0 ; 11140 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 11141 void *argp1 = 0 ; 11142 int res1 = 0 ; 11143 void *argp2 = 0 ; 11144 int res2 = 0 ; 11145 PyObject * obj0 = 0 ; 11146 PyObject * obj1 = 0 ; 11147 qpol_context_t *result = 0 ; 11148 11149 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_isid_t_context",&obj0,&obj1)) SWIG_fail; 11150 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_isid, 0 | 0 ); 11151 if (!SWIG_IsOK(res1)) { 11152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_isid_t_context" "', argument " "1"" of type '" "struct qpol_isid *""'"); 11153 } 11154 arg1 = (struct qpol_isid *)(argp1); 11155 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 11156 if (!SWIG_IsOK(res2)) { 11157 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_isid_t_context" "', argument " "2"" of type '" "qpol_policy_t *""'"); 11158 } 11159 arg2 = (qpol_policy_t *)(argp2); 11160 result = (qpol_context_t *)qpol_isid_context(arg1,arg2); 11161 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_context, 0 | 0 ); 11162 return resultobj; 11163 fail: 11164 return NULL; 11165 } 11166 11167 11168 SWIGINTERN PyObject *qpol_isid_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 11169 PyObject *obj; 11170 if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; 11171 SWIG_TypeNewClientData(SWIGTYPE_p_qpol_isid, SWIG_NewClientData(obj)); 11172 return SWIG_Py_Void(); 11173 } 11174 11175 SWIGINTERN PyObject *_wrap_qpol_isid_from_void(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 11176 PyObject *resultobj = 0; 11177 void *arg1 = (void *) 0 ; 11178 int res1 ; 11179 PyObject * obj0 = 0 ; 11180 qpol_isid_t *result = 0 ; 11181 11182 if (!PyArg_ParseTuple(args,(char *)"O:qpol_isid_from_void",&obj0)) SWIG_fail; 11183 res1 = SWIG_ConvertPtr(obj0,SWIG_as_voidptrptr(&arg1), 0, 0); 11184 if (!SWIG_IsOK(res1)) { 11185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_isid_from_void" "', argument " "1"" of type '" "void *""'"); 11186 } 11187 result = (qpol_isid_t *)qpol_isid_from_void(arg1); 11188 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_isid, 0 | 0 ); 11189 return resultobj; 11190 fail: 11191 return NULL; 11192 } 11193 11194 11195 SWIGINTERN PyObject *_wrap_new_qpol_netifcon_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 11196 PyObject *resultobj = 0; 11197 qpol_policy_t *arg1 = (qpol_policy_t *) 0 ; 11198 char *arg2 = (char *) 0 ; 11199 void *argp1 = 0 ; 11200 int res1 = 0 ; 11201 int res2 ; 11202 char *buf2 = 0 ; 11203 int alloc2 = 0 ; 11204 PyObject * obj0 = 0 ; 11205 PyObject * obj1 = 0 ; 11206 struct qpol_netifcon *result = 0 ; 11207 11208 if (!PyArg_ParseTuple(args,(char *)"OO:new_qpol_netifcon_t",&obj0,&obj1)) SWIG_fail; 11209 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_policy, 0 | 0 ); 11210 if (!SWIG_IsOK(res1)) { 11211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_qpol_netifcon_t" "', argument " "1"" of type '" "qpol_policy_t *""'"); 11212 } 11213 arg1 = (qpol_policy_t *)(argp1); 11214 res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); 11215 if (!SWIG_IsOK(res2)) { 11216 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_qpol_netifcon_t" "', argument " "2"" of type '" "char const *""'"); 11217 } 11218 arg2 = (char *)(buf2); 11219 result = (struct qpol_netifcon *)new_qpol_netifcon(arg1,(char const *)arg2); 11220 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_netifcon, SWIG_POINTER_NEW | 0 ); 11221 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); 11222 return resultobj; 11223 fail: 11224 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); 11225 return NULL; 11226 } 11227 11228 11229 SWIGINTERN PyObject *_wrap_delete_qpol_netifcon_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 11230 PyObject *resultobj = 0; 11231 struct qpol_netifcon *arg1 = (struct qpol_netifcon *) 0 ; 11232 void *argp1 = 0 ; 11233 int res1 = 0 ; 11234 PyObject * obj0 = 0 ; 11235 11236 if (!PyArg_ParseTuple(args,(char *)"O:delete_qpol_netifcon_t",&obj0)) SWIG_fail; 11237 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_netifcon, SWIG_POINTER_DISOWN | 0 ); 11238 if (!SWIG_IsOK(res1)) { 11239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_qpol_netifcon_t" "', argument " "1"" of type '" "struct qpol_netifcon *""'"); 11240 } 11241 arg1 = (struct qpol_netifcon *)(argp1); 11242 delete_qpol_netifcon(arg1); 11243 resultobj = SWIG_Py_Void(); 11244 return resultobj; 11245 fail: 11246 return NULL; 11247 } 11248 11249 11250 SWIGINTERN PyObject *_wrap_qpol_netifcon_t_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 11251 PyObject *resultobj = 0; 11252 struct qpol_netifcon *arg1 = (struct qpol_netifcon *) 0 ; 11253 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 11254 void *argp1 = 0 ; 11255 int res1 = 0 ; 11256 void *argp2 = 0 ; 11257 int res2 = 0 ; 11258 PyObject * obj0 = 0 ; 11259 PyObject * obj1 = 0 ; 11260 char *result = 0 ; 11261 11262 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_netifcon_t_name",&obj0,&obj1)) SWIG_fail; 11263 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_netifcon, 0 | 0 ); 11264 if (!SWIG_IsOK(res1)) { 11265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_netifcon_t_name" "', argument " "1"" of type '" "struct qpol_netifcon *""'"); 11266 } 11267 arg1 = (struct qpol_netifcon *)(argp1); 11268 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 11269 if (!SWIG_IsOK(res2)) { 11270 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_netifcon_t_name" "', argument " "2"" of type '" "qpol_policy_t *""'"); 11271 } 11272 arg2 = (qpol_policy_t *)(argp2); 11273 result = (char *)qpol_netifcon_name(arg1,arg2); 11274 resultobj = SWIG_FromCharPtr((const char *)result); 11275 return resultobj; 11276 fail: 11277 return NULL; 11278 } 11279 11280 11281 SWIGINTERN PyObject *_wrap_qpol_netifcon_t_msg_con(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 11282 PyObject *resultobj = 0; 11283 struct qpol_netifcon *arg1 = (struct qpol_netifcon *) 0 ; 11284 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 11285 void *argp1 = 0 ; 11286 int res1 = 0 ; 11287 void *argp2 = 0 ; 11288 int res2 = 0 ; 11289 PyObject * obj0 = 0 ; 11290 PyObject * obj1 = 0 ; 11291 qpol_context_t *result = 0 ; 11292 11293 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_netifcon_t_msg_con",&obj0,&obj1)) SWIG_fail; 11294 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_netifcon, 0 | 0 ); 11295 if (!SWIG_IsOK(res1)) { 11296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_netifcon_t_msg_con" "', argument " "1"" of type '" "struct qpol_netifcon *""'"); 11297 } 11298 arg1 = (struct qpol_netifcon *)(argp1); 11299 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 11300 if (!SWIG_IsOK(res2)) { 11301 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_netifcon_t_msg_con" "', argument " "2"" of type '" "qpol_policy_t *""'"); 11302 } 11303 arg2 = (qpol_policy_t *)(argp2); 11304 result = (qpol_context_t *)qpol_netifcon_msg_con(arg1,arg2); 11305 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_context, 0 | 0 ); 11306 return resultobj; 11307 fail: 11308 return NULL; 11309 } 11310 11311 11312 SWIGINTERN PyObject *_wrap_qpol_netifcon_t_if_con(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 11313 PyObject *resultobj = 0; 11314 struct qpol_netifcon *arg1 = (struct qpol_netifcon *) 0 ; 11315 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 11316 void *argp1 = 0 ; 11317 int res1 = 0 ; 11318 void *argp2 = 0 ; 11319 int res2 = 0 ; 11320 PyObject * obj0 = 0 ; 11321 PyObject * obj1 = 0 ; 11322 qpol_context_t *result = 0 ; 11323 11324 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_netifcon_t_if_con",&obj0,&obj1)) SWIG_fail; 11325 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_netifcon, 0 | 0 ); 11326 if (!SWIG_IsOK(res1)) { 11327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_netifcon_t_if_con" "', argument " "1"" of type '" "struct qpol_netifcon *""'"); 11328 } 11329 arg1 = (struct qpol_netifcon *)(argp1); 11330 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 11331 if (!SWIG_IsOK(res2)) { 11332 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_netifcon_t_if_con" "', argument " "2"" of type '" "qpol_policy_t *""'"); 11333 } 11334 arg2 = (qpol_policy_t *)(argp2); 11335 result = (qpol_context_t *)qpol_netifcon_if_con(arg1,arg2); 11336 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_context, 0 | 0 ); 11337 return resultobj; 11338 fail: 11339 return NULL; 11340 } 11341 11342 11343 SWIGINTERN PyObject *qpol_netifcon_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 11344 PyObject *obj; 11345 if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; 11346 SWIG_TypeNewClientData(SWIGTYPE_p_qpol_netifcon, SWIG_NewClientData(obj)); 11347 return SWIG_Py_Void(); 11348 } 11349 11350 SWIGINTERN PyObject *_wrap_qpol_netifcon_from_void(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 11351 PyObject *resultobj = 0; 11352 void *arg1 = (void *) 0 ; 11353 int res1 ; 11354 PyObject * obj0 = 0 ; 11355 qpol_netifcon_t *result = 0 ; 11356 11357 if (!PyArg_ParseTuple(args,(char *)"O:qpol_netifcon_from_void",&obj0)) SWIG_fail; 11358 res1 = SWIG_ConvertPtr(obj0,SWIG_as_voidptrptr(&arg1), 0, 0); 11359 if (!SWIG_IsOK(res1)) { 11360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_netifcon_from_void" "', argument " "1"" of type '" "void *""'"); 11361 } 11362 result = (qpol_netifcon_t *)qpol_netifcon_from_void(arg1); 11363 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_netifcon, 0 | 0 ); 11364 return resultobj; 11365 fail: 11366 return NULL; 11367 } 11368 11369 11370 SWIGINTERN PyObject *_wrap_new_qpol_nodecon_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 11371 PyObject *resultobj = 0; 11372 qpol_policy_t *arg1 = (qpol_policy_t *) 0 ; 11373 int *arg2 ; 11374 int *arg3 ; 11375 int arg4 ; 11376 void *argp1 = 0 ; 11377 int res1 = 0 ; 11378 void *argp2 = 0 ; 11379 int res2 = 0 ; 11380 void *argp3 = 0 ; 11381 int res3 = 0 ; 11382 int val4 ; 11383 int ecode4 = 0 ; 11384 PyObject * obj0 = 0 ; 11385 PyObject * obj1 = 0 ; 11386 PyObject * obj2 = 0 ; 11387 PyObject * obj3 = 0 ; 11388 struct qpol_nodecon *result = 0 ; 11389 11390 if (!PyArg_ParseTuple(args,(char *)"OOOO:new_qpol_nodecon_t",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; 11391 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_policy, 0 | 0 ); 11392 if (!SWIG_IsOK(res1)) { 11393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_qpol_nodecon_t" "', argument " "1"" of type '" "qpol_policy_t *""'"); 11394 } 11395 arg1 = (qpol_policy_t *)(argp1); 11396 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_int, 0 | 0 ); 11397 if (!SWIG_IsOK(res2)) { 11398 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_qpol_nodecon_t" "', argument " "2"" of type '" "int [4]""'"); 11399 } 11400 arg2 = (int *)(argp2); 11401 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_int, 0 | 0 ); 11402 if (!SWIG_IsOK(res3)) { 11403 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_qpol_nodecon_t" "', argument " "3"" of type '" "int [4]""'"); 11404 } 11405 arg3 = (int *)(argp3); 11406 ecode4 = SWIG_AsVal_int(obj3, &val4); 11407 if (!SWIG_IsOK(ecode4)) { 11408 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_qpol_nodecon_t" "', argument " "4"" of type '" "int""'"); 11409 } 11410 arg4 = (int)(val4); 11411 result = (struct qpol_nodecon *)new_qpol_nodecon(arg1,arg2,arg3,arg4); 11412 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_nodecon, SWIG_POINTER_NEW | 0 ); 11413 return resultobj; 11414 fail: 11415 return NULL; 11416 } 11417 11418 11419 SWIGINTERN PyObject *_wrap_delete_qpol_nodecon_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 11420 PyObject *resultobj = 0; 11421 struct qpol_nodecon *arg1 = (struct qpol_nodecon *) 0 ; 11422 void *argp1 = 0 ; 11423 int res1 = 0 ; 11424 PyObject * obj0 = 0 ; 11425 11426 if (!PyArg_ParseTuple(args,(char *)"O:delete_qpol_nodecon_t",&obj0)) SWIG_fail; 11427 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_nodecon, SWIG_POINTER_DISOWN | 0 ); 11428 if (!SWIG_IsOK(res1)) { 11429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_qpol_nodecon_t" "', argument " "1"" of type '" "struct qpol_nodecon *""'"); 11430 } 11431 arg1 = (struct qpol_nodecon *)(argp1); 11432 delete_qpol_nodecon(arg1); 11433 resultobj = SWIG_Py_Void(); 11434 return resultobj; 11435 fail: 11436 return NULL; 11437 } 11438 11439 11440 SWIGINTERN PyObject *_wrap_qpol_nodecon_t_addr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 11441 PyObject *resultobj = 0; 11442 struct qpol_nodecon *arg1 = (struct qpol_nodecon *) 0 ; 11443 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 11444 void *argp1 = 0 ; 11445 int res1 = 0 ; 11446 void *argp2 = 0 ; 11447 int res2 = 0 ; 11448 PyObject * obj0 = 0 ; 11449 PyObject * obj1 = 0 ; 11450 char *result = 0 ; 11451 11452 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_nodecon_t_addr",&obj0,&obj1)) SWIG_fail; 11453 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_nodecon, 0 | 0 ); 11454 if (!SWIG_IsOK(res1)) { 11455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_nodecon_t_addr" "', argument " "1"" of type '" "struct qpol_nodecon *""'"); 11456 } 11457 arg1 = (struct qpol_nodecon *)(argp1); 11458 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 11459 if (!SWIG_IsOK(res2)) { 11460 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_nodecon_t_addr" "', argument " "2"" of type '" "qpol_policy_t *""'"); 11461 } 11462 arg2 = (qpol_policy_t *)(argp2); 11463 result = (char *)qpol_nodecon_addr(arg1,arg2); 11464 resultobj = SWIG_FromCharPtr((const char *)result); 11465 return resultobj; 11466 fail: 11467 return NULL; 11468 } 11469 11470 11471 SWIGINTERN PyObject *_wrap_qpol_nodecon_t_mask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 11472 PyObject *resultobj = 0; 11473 struct qpol_nodecon *arg1 = (struct qpol_nodecon *) 0 ; 11474 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 11475 void *argp1 = 0 ; 11476 int res1 = 0 ; 11477 void *argp2 = 0 ; 11478 int res2 = 0 ; 11479 PyObject * obj0 = 0 ; 11480 PyObject * obj1 = 0 ; 11481 char *result = 0 ; 11482 11483 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_nodecon_t_mask",&obj0,&obj1)) SWIG_fail; 11484 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_nodecon, 0 | 0 ); 11485 if (!SWIG_IsOK(res1)) { 11486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_nodecon_t_mask" "', argument " "1"" of type '" "struct qpol_nodecon *""'"); 11487 } 11488 arg1 = (struct qpol_nodecon *)(argp1); 11489 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 11490 if (!SWIG_IsOK(res2)) { 11491 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_nodecon_t_mask" "', argument " "2"" of type '" "qpol_policy_t *""'"); 11492 } 11493 arg2 = (qpol_policy_t *)(argp2); 11494 result = (char *)qpol_nodecon_mask(arg1,arg2); 11495 resultobj = SWIG_FromCharPtr((const char *)result); 11496 return resultobj; 11497 fail: 11498 return NULL; 11499 } 11500 11501 11502 SWIGINTERN PyObject *_wrap_qpol_nodecon_t_protocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 11503 PyObject *resultobj = 0; 11504 struct qpol_nodecon *arg1 = (struct qpol_nodecon *) 0 ; 11505 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 11506 void *argp1 = 0 ; 11507 int res1 = 0 ; 11508 void *argp2 = 0 ; 11509 int res2 = 0 ; 11510 PyObject * obj0 = 0 ; 11511 PyObject * obj1 = 0 ; 11512 int result; 11513 11514 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_nodecon_t_protocol",&obj0,&obj1)) SWIG_fail; 11515 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_nodecon, 0 | 0 ); 11516 if (!SWIG_IsOK(res1)) { 11517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_nodecon_t_protocol" "', argument " "1"" of type '" "struct qpol_nodecon *""'"); 11518 } 11519 arg1 = (struct qpol_nodecon *)(argp1); 11520 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 11521 if (!SWIG_IsOK(res2)) { 11522 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_nodecon_t_protocol" "', argument " "2"" of type '" "qpol_policy_t *""'"); 11523 } 11524 arg2 = (qpol_policy_t *)(argp2); 11525 result = (int)qpol_nodecon_protocol(arg1,arg2); 11526 resultobj = SWIG_From_int((int)(result)); 11527 return resultobj; 11528 fail: 11529 return NULL; 11530 } 11531 11532 11533 SWIGINTERN PyObject *_wrap_qpol_nodecon_t_context(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 11534 PyObject *resultobj = 0; 11535 struct qpol_nodecon *arg1 = (struct qpol_nodecon *) 0 ; 11536 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 11537 void *argp1 = 0 ; 11538 int res1 = 0 ; 11539 void *argp2 = 0 ; 11540 int res2 = 0 ; 11541 PyObject * obj0 = 0 ; 11542 PyObject * obj1 = 0 ; 11543 qpol_context_t *result = 0 ; 11544 11545 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_nodecon_t_context",&obj0,&obj1)) SWIG_fail; 11546 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_nodecon, 0 | 0 ); 11547 if (!SWIG_IsOK(res1)) { 11548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_nodecon_t_context" "', argument " "1"" of type '" "struct qpol_nodecon *""'"); 11549 } 11550 arg1 = (struct qpol_nodecon *)(argp1); 11551 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 11552 if (!SWIG_IsOK(res2)) { 11553 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_nodecon_t_context" "', argument " "2"" of type '" "qpol_policy_t *""'"); 11554 } 11555 arg2 = (qpol_policy_t *)(argp2); 11556 result = (qpol_context_t *)qpol_nodecon_context(arg1,arg2); 11557 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_context, 0 | 0 ); 11558 return resultobj; 11559 fail: 11560 return NULL; 11561 } 11562 11563 11564 SWIGINTERN PyObject *qpol_nodecon_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 11565 PyObject *obj; 11566 if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; 11567 SWIG_TypeNewClientData(SWIGTYPE_p_qpol_nodecon, SWIG_NewClientData(obj)); 11568 return SWIG_Py_Void(); 11569 } 11570 11571 SWIGINTERN PyObject *_wrap_qpol_nodecon_from_void(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 11572 PyObject *resultobj = 0; 11573 void *arg1 = (void *) 0 ; 11574 int res1 ; 11575 PyObject * obj0 = 0 ; 11576 qpol_nodecon_t *result = 0 ; 11577 11578 if (!PyArg_ParseTuple(args,(char *)"O:qpol_nodecon_from_void",&obj0)) SWIG_fail; 11579 res1 = SWIG_ConvertPtr(obj0,SWIG_as_voidptrptr(&arg1), 0, 0); 11580 if (!SWIG_IsOK(res1)) { 11581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_nodecon_from_void" "', argument " "1"" of type '" "void *""'"); 11582 } 11583 result = (qpol_nodecon_t *)qpol_nodecon_from_void(arg1); 11584 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_nodecon, 0 | 0 ); 11585 return resultobj; 11586 fail: 11587 return NULL; 11588 } 11589 11590 11591 SWIGINTERN PyObject *_wrap_new_qpol_portcon_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 11592 PyObject *resultobj = 0; 11593 qpol_policy_t *arg1 = (qpol_policy_t *) 0 ; 11594 uint16_t arg2 ; 11595 uint16_t arg3 ; 11596 uint8_t arg4 ; 11597 void *argp1 = 0 ; 11598 int res1 = 0 ; 11599 unsigned short val2 ; 11600 int ecode2 = 0 ; 11601 unsigned short val3 ; 11602 int ecode3 = 0 ; 11603 unsigned char val4 ; 11604 int ecode4 = 0 ; 11605 PyObject * obj0 = 0 ; 11606 PyObject * obj1 = 0 ; 11607 PyObject * obj2 = 0 ; 11608 PyObject * obj3 = 0 ; 11609 struct qpol_portcon *result = 0 ; 11610 11611 if (!PyArg_ParseTuple(args,(char *)"OOOO:new_qpol_portcon_t",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; 11612 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_policy, 0 | 0 ); 11613 if (!SWIG_IsOK(res1)) { 11614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_qpol_portcon_t" "', argument " "1"" of type '" "qpol_policy_t *""'"); 11615 } 11616 arg1 = (qpol_policy_t *)(argp1); 11617 ecode2 = SWIG_AsVal_unsigned_SS_short(obj1, &val2); 11618 if (!SWIG_IsOK(ecode2)) { 11619 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_qpol_portcon_t" "', argument " "2"" of type '" "uint16_t""'"); 11620 } 11621 arg2 = (uint16_t)(val2); 11622 ecode3 = SWIG_AsVal_unsigned_SS_short(obj2, &val3); 11623 if (!SWIG_IsOK(ecode3)) { 11624 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_qpol_portcon_t" "', argument " "3"" of type '" "uint16_t""'"); 11625 } 11626 arg3 = (uint16_t)(val3); 11627 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4); 11628 if (!SWIG_IsOK(ecode4)) { 11629 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_qpol_portcon_t" "', argument " "4"" of type '" "uint8_t""'"); 11630 } 11631 arg4 = (uint8_t)(val4); 11632 result = (struct qpol_portcon *)new_qpol_portcon(arg1,arg2,arg3,arg4); 11633 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_portcon, SWIG_POINTER_NEW | 0 ); 11634 return resultobj; 11635 fail: 11636 return NULL; 11637 } 11638 11639 11640 SWIGINTERN PyObject *_wrap_delete_qpol_portcon_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 11641 PyObject *resultobj = 0; 11642 struct qpol_portcon *arg1 = (struct qpol_portcon *) 0 ; 11643 void *argp1 = 0 ; 11644 int res1 = 0 ; 11645 PyObject * obj0 = 0 ; 11646 11647 if (!PyArg_ParseTuple(args,(char *)"O:delete_qpol_portcon_t",&obj0)) SWIG_fail; 11648 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_portcon, SWIG_POINTER_DISOWN | 0 ); 11649 if (!SWIG_IsOK(res1)) { 11650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_qpol_portcon_t" "', argument " "1"" of type '" "struct qpol_portcon *""'"); 11651 } 11652 arg1 = (struct qpol_portcon *)(argp1); 11653 delete_qpol_portcon(arg1); 11654 resultobj = SWIG_Py_Void(); 11655 return resultobj; 11656 fail: 11657 return NULL; 11658 } 11659 11660 11661 SWIGINTERN PyObject *_wrap_qpol_portcon_t_low_port(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 11662 PyObject *resultobj = 0; 11663 struct qpol_portcon *arg1 = (struct qpol_portcon *) 0 ; 11664 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 11665 void *argp1 = 0 ; 11666 int res1 = 0 ; 11667 void *argp2 = 0 ; 11668 int res2 = 0 ; 11669 PyObject * obj0 = 0 ; 11670 PyObject * obj1 = 0 ; 11671 uint16_t result; 11672 11673 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_portcon_t_low_port",&obj0,&obj1)) SWIG_fail; 11674 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_portcon, 0 | 0 ); 11675 if (!SWIG_IsOK(res1)) { 11676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_portcon_t_low_port" "', argument " "1"" of type '" "struct qpol_portcon *""'"); 11677 } 11678 arg1 = (struct qpol_portcon *)(argp1); 11679 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 11680 if (!SWIG_IsOK(res2)) { 11681 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_portcon_t_low_port" "', argument " "2"" of type '" "qpol_policy_t *""'"); 11682 } 11683 arg2 = (qpol_policy_t *)(argp2); 11684 result = (uint16_t)qpol_portcon_low_port(arg1,arg2); 11685 resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result)); 11686 return resultobj; 11687 fail: 11688 return NULL; 11689 } 11690 11691 11692 SWIGINTERN PyObject *_wrap_qpol_portcon_t_high_port(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 11693 PyObject *resultobj = 0; 11694 struct qpol_portcon *arg1 = (struct qpol_portcon *) 0 ; 11695 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 11696 void *argp1 = 0 ; 11697 int res1 = 0 ; 11698 void *argp2 = 0 ; 11699 int res2 = 0 ; 11700 PyObject * obj0 = 0 ; 11701 PyObject * obj1 = 0 ; 11702 uint16_t result; 11703 11704 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_portcon_t_high_port",&obj0,&obj1)) SWIG_fail; 11705 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_portcon, 0 | 0 ); 11706 if (!SWIG_IsOK(res1)) { 11707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_portcon_t_high_port" "', argument " "1"" of type '" "struct qpol_portcon *""'"); 11708 } 11709 arg1 = (struct qpol_portcon *)(argp1); 11710 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 11711 if (!SWIG_IsOK(res2)) { 11712 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_portcon_t_high_port" "', argument " "2"" of type '" "qpol_policy_t *""'"); 11713 } 11714 arg2 = (qpol_policy_t *)(argp2); 11715 result = (uint16_t)qpol_portcon_high_port(arg1,arg2); 11716 resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result)); 11717 return resultobj; 11718 fail: 11719 return NULL; 11720 } 11721 11722 11723 SWIGINTERN PyObject *_wrap_qpol_portcon_t_protocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 11724 PyObject *resultobj = 0; 11725 struct qpol_portcon *arg1 = (struct qpol_portcon *) 0 ; 11726 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 11727 void *argp1 = 0 ; 11728 int res1 = 0 ; 11729 void *argp2 = 0 ; 11730 int res2 = 0 ; 11731 PyObject * obj0 = 0 ; 11732 PyObject * obj1 = 0 ; 11733 uint8_t result; 11734 11735 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_portcon_t_protocol",&obj0,&obj1)) SWIG_fail; 11736 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_portcon, 0 | 0 ); 11737 if (!SWIG_IsOK(res1)) { 11738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_portcon_t_protocol" "', argument " "1"" of type '" "struct qpol_portcon *""'"); 11739 } 11740 arg1 = (struct qpol_portcon *)(argp1); 11741 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 11742 if (!SWIG_IsOK(res2)) { 11743 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_portcon_t_protocol" "', argument " "2"" of type '" "qpol_policy_t *""'"); 11744 } 11745 arg2 = (qpol_policy_t *)(argp2); 11746 result = (uint8_t)qpol_portcon_protocol(arg1,arg2); 11747 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result)); 11748 return resultobj; 11749 fail: 11750 return NULL; 11751 } 11752 11753 11754 SWIGINTERN PyObject *_wrap_qpol_portcon_t_context(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 11755 PyObject *resultobj = 0; 11756 struct qpol_portcon *arg1 = (struct qpol_portcon *) 0 ; 11757 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 11758 void *argp1 = 0 ; 11759 int res1 = 0 ; 11760 void *argp2 = 0 ; 11761 int res2 = 0 ; 11762 PyObject * obj0 = 0 ; 11763 PyObject * obj1 = 0 ; 11764 qpol_context_t *result = 0 ; 11765 11766 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_portcon_t_context",&obj0,&obj1)) SWIG_fail; 11767 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_portcon, 0 | 0 ); 11768 if (!SWIG_IsOK(res1)) { 11769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_portcon_t_context" "', argument " "1"" of type '" "struct qpol_portcon *""'"); 11770 } 11771 arg1 = (struct qpol_portcon *)(argp1); 11772 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 11773 if (!SWIG_IsOK(res2)) { 11774 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_portcon_t_context" "', argument " "2"" of type '" "qpol_policy_t *""'"); 11775 } 11776 arg2 = (qpol_policy_t *)(argp2); 11777 result = (qpol_context_t *)qpol_portcon_context(arg1,arg2); 11778 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_context, 0 | 0 ); 11779 return resultobj; 11780 fail: 11781 return NULL; 11782 } 11783 11784 11785 SWIGINTERN PyObject *qpol_portcon_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 11786 PyObject *obj; 11787 if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; 11788 SWIG_TypeNewClientData(SWIGTYPE_p_qpol_portcon, SWIG_NewClientData(obj)); 11789 return SWIG_Py_Void(); 11790 } 11791 11792 SWIGINTERN PyObject *_wrap_qpol_portcon_from_void(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 11793 PyObject *resultobj = 0; 11794 void *arg1 = (void *) 0 ; 11795 int res1 ; 11796 PyObject * obj0 = 0 ; 11797 qpol_portcon_t *result = 0 ; 11798 11799 if (!PyArg_ParseTuple(args,(char *)"O:qpol_portcon_from_void",&obj0)) SWIG_fail; 11800 res1 = SWIG_ConvertPtr(obj0,SWIG_as_voidptrptr(&arg1), 0, 0); 11801 if (!SWIG_IsOK(res1)) { 11802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_portcon_from_void" "', argument " "1"" of type '" "void *""'"); 11803 } 11804 result = (qpol_portcon_t *)qpol_portcon_from_void(arg1); 11805 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_portcon, 0 | 0 ); 11806 return resultobj; 11807 fail: 11808 return NULL; 11809 } 11810 11811 11812 SWIGINTERN PyObject *_wrap_new_qpol_constraint_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 11813 PyObject *resultobj = 0; 11814 struct qpol_constraint *result = 0 ; 11815 11816 if (!PyArg_ParseTuple(args,(char *)":new_qpol_constraint_t")) SWIG_fail; 11817 result = (struct qpol_constraint *)new_qpol_constraint(); 11818 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_constraint, SWIG_POINTER_NEW | 0 ); 11819 return resultobj; 11820 fail: 11821 return NULL; 11822 } 11823 11824 11825 SWIGINTERN PyObject *_wrap_delete_qpol_constraint_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 11826 PyObject *resultobj = 0; 11827 struct qpol_constraint *arg1 = (struct qpol_constraint *) 0 ; 11828 void *argp1 = 0 ; 11829 int res1 = 0 ; 11830 PyObject * obj0 = 0 ; 11831 11832 if (!PyArg_ParseTuple(args,(char *)"O:delete_qpol_constraint_t",&obj0)) SWIG_fail; 11833 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_constraint, SWIG_POINTER_DISOWN | 0 ); 11834 if (!SWIG_IsOK(res1)) { 11835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_qpol_constraint_t" "', argument " "1"" of type '" "struct qpol_constraint *""'"); 11836 } 11837 arg1 = (struct qpol_constraint *)(argp1); 11838 delete_qpol_constraint(arg1); 11839 resultobj = SWIG_Py_Void(); 11840 return resultobj; 11841 fail: 11842 return NULL; 11843 } 11844 11845 11846 SWIGINTERN PyObject *_wrap_qpol_constraint_t_object_class(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 11847 PyObject *resultobj = 0; 11848 struct qpol_constraint *arg1 = (struct qpol_constraint *) 0 ; 11849 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 11850 void *argp1 = 0 ; 11851 int res1 = 0 ; 11852 void *argp2 = 0 ; 11853 int res2 = 0 ; 11854 PyObject * obj0 = 0 ; 11855 PyObject * obj1 = 0 ; 11856 qpol_class_t *result = 0 ; 11857 11858 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_constraint_t_object_class",&obj0,&obj1)) SWIG_fail; 11859 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_constraint, 0 | 0 ); 11860 if (!SWIG_IsOK(res1)) { 11861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_constraint_t_object_class" "', argument " "1"" of type '" "struct qpol_constraint *""'"); 11862 } 11863 arg1 = (struct qpol_constraint *)(argp1); 11864 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 11865 if (!SWIG_IsOK(res2)) { 11866 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_constraint_t_object_class" "', argument " "2"" of type '" "qpol_policy_t *""'"); 11867 } 11868 arg2 = (qpol_policy_t *)(argp2); 11869 result = (qpol_class_t *)qpol_constraint_object_class(arg1,arg2); 11870 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_class, 0 | 0 ); 11871 return resultobj; 11872 fail: 11873 return NULL; 11874 } 11875 11876 11877 SWIGINTERN PyObject *_wrap_qpol_constraint_t_perm_iter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 11878 PyObject *resultobj = 0; 11879 struct qpol_constraint *arg1 = (struct qpol_constraint *) 0 ; 11880 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 11881 void *argp1 = 0 ; 11882 int res1 = 0 ; 11883 void *argp2 = 0 ; 11884 int res2 = 0 ; 11885 PyObject * obj0 = 0 ; 11886 PyObject * obj1 = 0 ; 11887 qpol_iterator_t *result = 0 ; 11888 11889 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_constraint_t_perm_iter",&obj0,&obj1)) SWIG_fail; 11890 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_constraint, 0 | 0 ); 11891 if (!SWIG_IsOK(res1)) { 11892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_constraint_t_perm_iter" "', argument " "1"" of type '" "struct qpol_constraint *""'"); 11893 } 11894 arg1 = (struct qpol_constraint *)(argp1); 11895 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 11896 if (!SWIG_IsOK(res2)) { 11897 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_constraint_t_perm_iter" "', argument " "2"" of type '" "qpol_policy_t *""'"); 11898 } 11899 arg2 = (qpol_policy_t *)(argp2); 11900 result = (qpol_iterator_t *)qpol_constraint_perm_iter(arg1,arg2); 11901 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_iterator, SWIG_POINTER_OWN | 0 ); 11902 return resultobj; 11903 fail: 11904 return NULL; 11905 } 11906 11907 11908 SWIGINTERN PyObject *_wrap_qpol_constraint_t_expr_iter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 11909 PyObject *resultobj = 0; 11910 struct qpol_constraint *arg1 = (struct qpol_constraint *) 0 ; 11911 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 11912 void *argp1 = 0 ; 11913 int res1 = 0 ; 11914 void *argp2 = 0 ; 11915 int res2 = 0 ; 11916 PyObject * obj0 = 0 ; 11917 PyObject * obj1 = 0 ; 11918 qpol_iterator_t *result = 0 ; 11919 11920 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_constraint_t_expr_iter",&obj0,&obj1)) SWIG_fail; 11921 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_constraint, 0 | 0 ); 11922 if (!SWIG_IsOK(res1)) { 11923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_constraint_t_expr_iter" "', argument " "1"" of type '" "struct qpol_constraint *""'"); 11924 } 11925 arg1 = (struct qpol_constraint *)(argp1); 11926 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 11927 if (!SWIG_IsOK(res2)) { 11928 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_constraint_t_expr_iter" "', argument " "2"" of type '" "qpol_policy_t *""'"); 11929 } 11930 arg2 = (qpol_policy_t *)(argp2); 11931 result = (qpol_iterator_t *)qpol_constraint_expr_iter(arg1,arg2); 11932 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_iterator, SWIG_POINTER_OWN | 0 ); 11933 return resultobj; 11934 fail: 11935 return NULL; 11936 } 11937 11938 11939 SWIGINTERN PyObject *qpol_constraint_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 11940 PyObject *obj; 11941 if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; 11942 SWIG_TypeNewClientData(SWIGTYPE_p_qpol_constraint, SWIG_NewClientData(obj)); 11943 return SWIG_Py_Void(); 11944 } 11945 11946 SWIGINTERN PyObject *_wrap_qpol_constraint_from_void(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 11947 PyObject *resultobj = 0; 11948 void *arg1 = (void *) 0 ; 11949 int res1 ; 11950 PyObject * obj0 = 0 ; 11951 qpol_constraint_t *result = 0 ; 11952 11953 if (!PyArg_ParseTuple(args,(char *)"O:qpol_constraint_from_void",&obj0)) SWIG_fail; 11954 res1 = SWIG_ConvertPtr(obj0,SWIG_as_voidptrptr(&arg1), 0, 0); 11955 if (!SWIG_IsOK(res1)) { 11956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_constraint_from_void" "', argument " "1"" of type '" "void *""'"); 11957 } 11958 result = (qpol_constraint_t *)qpol_constraint_from_void(arg1); 11959 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_constraint, 0 | 0 ); 11960 return resultobj; 11961 fail: 11962 return NULL; 11963 } 11964 11965 11966 SWIGINTERN PyObject *_wrap_new_qpol_validatetrans_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 11967 PyObject *resultobj = 0; 11968 struct qpol_validatetrans *result = 0 ; 11969 11970 if (!PyArg_ParseTuple(args,(char *)":new_qpol_validatetrans_t")) SWIG_fail; 11971 result = (struct qpol_validatetrans *)new_qpol_validatetrans(); 11972 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_validatetrans, SWIG_POINTER_NEW | 0 ); 11973 return resultobj; 11974 fail: 11975 return NULL; 11976 } 11977 11978 11979 SWIGINTERN PyObject *_wrap_delete_qpol_validatetrans_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 11980 PyObject *resultobj = 0; 11981 struct qpol_validatetrans *arg1 = (struct qpol_validatetrans *) 0 ; 11982 void *argp1 = 0 ; 11983 int res1 = 0 ; 11984 PyObject * obj0 = 0 ; 11985 11986 if (!PyArg_ParseTuple(args,(char *)"O:delete_qpol_validatetrans_t",&obj0)) SWIG_fail; 11987 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_validatetrans, SWIG_POINTER_DISOWN | 0 ); 11988 if (!SWIG_IsOK(res1)) { 11989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_qpol_validatetrans_t" "', argument " "1"" of type '" "struct qpol_validatetrans *""'"); 11990 } 11991 arg1 = (struct qpol_validatetrans *)(argp1); 11992 delete_qpol_validatetrans(arg1); 11993 resultobj = SWIG_Py_Void(); 11994 return resultobj; 11995 fail: 11996 return NULL; 11997 } 11998 11999 12000 SWIGINTERN PyObject *_wrap_qpol_validatetrans_t_object_class(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 12001 PyObject *resultobj = 0; 12002 struct qpol_validatetrans *arg1 = (struct qpol_validatetrans *) 0 ; 12003 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 12004 void *argp1 = 0 ; 12005 int res1 = 0 ; 12006 void *argp2 = 0 ; 12007 int res2 = 0 ; 12008 PyObject * obj0 = 0 ; 12009 PyObject * obj1 = 0 ; 12010 qpol_class_t *result = 0 ; 12011 12012 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_validatetrans_t_object_class",&obj0,&obj1)) SWIG_fail; 12013 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_validatetrans, 0 | 0 ); 12014 if (!SWIG_IsOK(res1)) { 12015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_validatetrans_t_object_class" "', argument " "1"" of type '" "struct qpol_validatetrans *""'"); 12016 } 12017 arg1 = (struct qpol_validatetrans *)(argp1); 12018 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 12019 if (!SWIG_IsOK(res2)) { 12020 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_validatetrans_t_object_class" "', argument " "2"" of type '" "qpol_policy_t *""'"); 12021 } 12022 arg2 = (qpol_policy_t *)(argp2); 12023 result = (qpol_class_t *)qpol_validatetrans_object_class(arg1,arg2); 12024 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_class, 0 | 0 ); 12025 return resultobj; 12026 fail: 12027 return NULL; 12028 } 12029 12030 12031 SWIGINTERN PyObject *_wrap_qpol_validatetrans_t_expr_iter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 12032 PyObject *resultobj = 0; 12033 struct qpol_validatetrans *arg1 = (struct qpol_validatetrans *) 0 ; 12034 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 12035 void *argp1 = 0 ; 12036 int res1 = 0 ; 12037 void *argp2 = 0 ; 12038 int res2 = 0 ; 12039 PyObject * obj0 = 0 ; 12040 PyObject * obj1 = 0 ; 12041 qpol_iterator_t *result = 0 ; 12042 12043 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_validatetrans_t_expr_iter",&obj0,&obj1)) SWIG_fail; 12044 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_validatetrans, 0 | 0 ); 12045 if (!SWIG_IsOK(res1)) { 12046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_validatetrans_t_expr_iter" "', argument " "1"" of type '" "struct qpol_validatetrans *""'"); 12047 } 12048 arg1 = (struct qpol_validatetrans *)(argp1); 12049 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 12050 if (!SWIG_IsOK(res2)) { 12051 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_validatetrans_t_expr_iter" "', argument " "2"" of type '" "qpol_policy_t *""'"); 12052 } 12053 arg2 = (qpol_policy_t *)(argp2); 12054 result = (qpol_iterator_t *)qpol_validatetrans_expr_iter(arg1,arg2); 12055 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_iterator, SWIG_POINTER_OWN | 0 ); 12056 return resultobj; 12057 fail: 12058 return NULL; 12059 } 12060 12061 12062 SWIGINTERN PyObject *qpol_validatetrans_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 12063 PyObject *obj; 12064 if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; 12065 SWIG_TypeNewClientData(SWIGTYPE_p_qpol_validatetrans, SWIG_NewClientData(obj)); 12066 return SWIG_Py_Void(); 12067 } 12068 12069 SWIGINTERN PyObject *_wrap_qpol_validatetrans_from_void(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 12070 PyObject *resultobj = 0; 12071 void *arg1 = (void *) 0 ; 12072 int res1 ; 12073 PyObject * obj0 = 0 ; 12074 qpol_validatetrans_t *result = 0 ; 12075 12076 if (!PyArg_ParseTuple(args,(char *)"O:qpol_validatetrans_from_void",&obj0)) SWIG_fail; 12077 res1 = SWIG_ConvertPtr(obj0,SWIG_as_voidptrptr(&arg1), 0, 0); 12078 if (!SWIG_IsOK(res1)) { 12079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_validatetrans_from_void" "', argument " "1"" of type '" "void *""'"); 12080 } 12081 result = (qpol_validatetrans_t *)qpol_validatetrans_from_void(arg1); 12082 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_validatetrans, 0 | 0 ); 12083 return resultobj; 12084 fail: 12085 return NULL; 12086 } 12087 12088 12089 SWIGINTERN PyObject *_wrap_new_qpol_constraint_expr_node_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 12090 PyObject *resultobj = 0; 12091 struct qpol_constraint_expr_node *result = 0 ; 12092 12093 if (!PyArg_ParseTuple(args,(char *)":new_qpol_constraint_expr_node_t")) SWIG_fail; 12094 result = (struct qpol_constraint_expr_node *)new_qpol_constraint_expr_node(); 12095 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_constraint_expr_node, SWIG_POINTER_NEW | 0 ); 12096 return resultobj; 12097 fail: 12098 return NULL; 12099 } 12100 12101 12102 SWIGINTERN PyObject *_wrap_delete_qpol_constraint_expr_node_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 12103 PyObject *resultobj = 0; 12104 struct qpol_constraint_expr_node *arg1 = (struct qpol_constraint_expr_node *) 0 ; 12105 void *argp1 = 0 ; 12106 int res1 = 0 ; 12107 PyObject * obj0 = 0 ; 12108 12109 if (!PyArg_ParseTuple(args,(char *)"O:delete_qpol_constraint_expr_node_t",&obj0)) SWIG_fail; 12110 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_constraint_expr_node, SWIG_POINTER_DISOWN | 0 ); 12111 if (!SWIG_IsOK(res1)) { 12112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_qpol_constraint_expr_node_t" "', argument " "1"" of type '" "struct qpol_constraint_expr_node *""'"); 12113 } 12114 arg1 = (struct qpol_constraint_expr_node *)(argp1); 12115 delete_qpol_constraint_expr_node(arg1); 12116 resultobj = SWIG_Py_Void(); 12117 return resultobj; 12118 fail: 12119 return NULL; 12120 } 12121 12122 12123 SWIGINTERN PyObject *_wrap_qpol_constraint_expr_node_t_expr_type(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 12124 PyObject *resultobj = 0; 12125 struct qpol_constraint_expr_node *arg1 = (struct qpol_constraint_expr_node *) 0 ; 12126 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 12127 void *argp1 = 0 ; 12128 int res1 = 0 ; 12129 void *argp2 = 0 ; 12130 int res2 = 0 ; 12131 PyObject * obj0 = 0 ; 12132 PyObject * obj1 = 0 ; 12133 int result; 12134 12135 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_constraint_expr_node_t_expr_type",&obj0,&obj1)) SWIG_fail; 12136 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_constraint_expr_node, 0 | 0 ); 12137 if (!SWIG_IsOK(res1)) { 12138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_constraint_expr_node_t_expr_type" "', argument " "1"" of type '" "struct qpol_constraint_expr_node *""'"); 12139 } 12140 arg1 = (struct qpol_constraint_expr_node *)(argp1); 12141 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 12142 if (!SWIG_IsOK(res2)) { 12143 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_constraint_expr_node_t_expr_type" "', argument " "2"" of type '" "qpol_policy_t *""'"); 12144 } 12145 arg2 = (qpol_policy_t *)(argp2); 12146 result = (int)qpol_constraint_expr_node_expr_type(arg1,arg2); 12147 resultobj = SWIG_From_int((int)(result)); 12148 return resultobj; 12149 fail: 12150 return NULL; 12151 } 12152 12153 12154 SWIGINTERN PyObject *_wrap_qpol_constraint_expr_node_t_sym_type(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 12155 PyObject *resultobj = 0; 12156 struct qpol_constraint_expr_node *arg1 = (struct qpol_constraint_expr_node *) 0 ; 12157 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 12158 void *argp1 = 0 ; 12159 int res1 = 0 ; 12160 void *argp2 = 0 ; 12161 int res2 = 0 ; 12162 PyObject * obj0 = 0 ; 12163 PyObject * obj1 = 0 ; 12164 int result; 12165 12166 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_constraint_expr_node_t_sym_type",&obj0,&obj1)) SWIG_fail; 12167 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_constraint_expr_node, 0 | 0 ); 12168 if (!SWIG_IsOK(res1)) { 12169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_constraint_expr_node_t_sym_type" "', argument " "1"" of type '" "struct qpol_constraint_expr_node *""'"); 12170 } 12171 arg1 = (struct qpol_constraint_expr_node *)(argp1); 12172 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 12173 if (!SWIG_IsOK(res2)) { 12174 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_constraint_expr_node_t_sym_type" "', argument " "2"" of type '" "qpol_policy_t *""'"); 12175 } 12176 arg2 = (qpol_policy_t *)(argp2); 12177 result = (int)qpol_constraint_expr_node_sym_type(arg1,arg2); 12178 resultobj = SWIG_From_int((int)(result)); 12179 return resultobj; 12180 fail: 12181 return NULL; 12182 } 12183 12184 12185 SWIGINTERN PyObject *_wrap_qpol_constraint_expr_node_t_op(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 12186 PyObject *resultobj = 0; 12187 struct qpol_constraint_expr_node *arg1 = (struct qpol_constraint_expr_node *) 0 ; 12188 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 12189 void *argp1 = 0 ; 12190 int res1 = 0 ; 12191 void *argp2 = 0 ; 12192 int res2 = 0 ; 12193 PyObject * obj0 = 0 ; 12194 PyObject * obj1 = 0 ; 12195 int result; 12196 12197 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_constraint_expr_node_t_op",&obj0,&obj1)) SWIG_fail; 12198 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_constraint_expr_node, 0 | 0 ); 12199 if (!SWIG_IsOK(res1)) { 12200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_constraint_expr_node_t_op" "', argument " "1"" of type '" "struct qpol_constraint_expr_node *""'"); 12201 } 12202 arg1 = (struct qpol_constraint_expr_node *)(argp1); 12203 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 12204 if (!SWIG_IsOK(res2)) { 12205 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_constraint_expr_node_t_op" "', argument " "2"" of type '" "qpol_policy_t *""'"); 12206 } 12207 arg2 = (qpol_policy_t *)(argp2); 12208 result = (int)qpol_constraint_expr_node_op(arg1,arg2); 12209 resultobj = SWIG_From_int((int)(result)); 12210 return resultobj; 12211 fail: 12212 return NULL; 12213 } 12214 12215 12216 SWIGINTERN PyObject *_wrap_qpol_constraint_expr_node_t_names_iter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 12217 PyObject *resultobj = 0; 12218 struct qpol_constraint_expr_node *arg1 = (struct qpol_constraint_expr_node *) 0 ; 12219 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 12220 void *argp1 = 0 ; 12221 int res1 = 0 ; 12222 void *argp2 = 0 ; 12223 int res2 = 0 ; 12224 PyObject * obj0 = 0 ; 12225 PyObject * obj1 = 0 ; 12226 qpol_iterator_t *result = 0 ; 12227 12228 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_constraint_expr_node_t_names_iter",&obj0,&obj1)) SWIG_fail; 12229 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_constraint_expr_node, 0 | 0 ); 12230 if (!SWIG_IsOK(res1)) { 12231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_constraint_expr_node_t_names_iter" "', argument " "1"" of type '" "struct qpol_constraint_expr_node *""'"); 12232 } 12233 arg1 = (struct qpol_constraint_expr_node *)(argp1); 12234 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 12235 if (!SWIG_IsOK(res2)) { 12236 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_constraint_expr_node_t_names_iter" "', argument " "2"" of type '" "qpol_policy_t *""'"); 12237 } 12238 arg2 = (qpol_policy_t *)(argp2); 12239 result = (qpol_iterator_t *)qpol_constraint_expr_node_names_iter(arg1,arg2); 12240 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_iterator, SWIG_POINTER_OWN | 0 ); 12241 return resultobj; 12242 fail: 12243 return NULL; 12244 } 12245 12246 12247 SWIGINTERN PyObject *qpol_constraint_expr_node_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 12248 PyObject *obj; 12249 if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; 12250 SWIG_TypeNewClientData(SWIGTYPE_p_qpol_constraint_expr_node, SWIG_NewClientData(obj)); 12251 return SWIG_Py_Void(); 12252 } 12253 12254 SWIGINTERN PyObject *_wrap_qpol_constraint_expr_node_from_void(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 12255 PyObject *resultobj = 0; 12256 void *arg1 = (void *) 0 ; 12257 int res1 ; 12258 PyObject * obj0 = 0 ; 12259 qpol_constraint_expr_node_t *result = 0 ; 12260 12261 if (!PyArg_ParseTuple(args,(char *)"O:qpol_constraint_expr_node_from_void",&obj0)) SWIG_fail; 12262 res1 = SWIG_ConvertPtr(obj0,SWIG_as_voidptrptr(&arg1), 0, 0); 12263 if (!SWIG_IsOK(res1)) { 12264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_constraint_expr_node_from_void" "', argument " "1"" of type '" "void *""'"); 12265 } 12266 result = (qpol_constraint_expr_node_t *)qpol_constraint_expr_node_from_void(arg1); 12267 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_constraint_expr_node, 0 | 0 ); 12268 return resultobj; 12269 fail: 12270 return NULL; 12271 } 12272 12273 12274 SWIGINTERN PyObject *_wrap_new_qpol_role_allow_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 12275 PyObject *resultobj = 0; 12276 struct qpol_role_allow *result = 0 ; 12277 12278 if (!PyArg_ParseTuple(args,(char *)":new_qpol_role_allow_t")) SWIG_fail; 12279 result = (struct qpol_role_allow *)new_qpol_role_allow(); 12280 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_role_allow, SWIG_POINTER_NEW | 0 ); 12281 return resultobj; 12282 fail: 12283 return NULL; 12284 } 12285 12286 12287 SWIGINTERN PyObject *_wrap_delete_qpol_role_allow_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 12288 PyObject *resultobj = 0; 12289 struct qpol_role_allow *arg1 = (struct qpol_role_allow *) 0 ; 12290 void *argp1 = 0 ; 12291 int res1 = 0 ; 12292 PyObject * obj0 = 0 ; 12293 12294 if (!PyArg_ParseTuple(args,(char *)"O:delete_qpol_role_allow_t",&obj0)) SWIG_fail; 12295 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_role_allow, SWIG_POINTER_DISOWN | 0 ); 12296 if (!SWIG_IsOK(res1)) { 12297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_qpol_role_allow_t" "', argument " "1"" of type '" "struct qpol_role_allow *""'"); 12298 } 12299 arg1 = (struct qpol_role_allow *)(argp1); 12300 delete_qpol_role_allow(arg1); 12301 resultobj = SWIG_Py_Void(); 12302 return resultobj; 12303 fail: 12304 return NULL; 12305 } 12306 12307 12308 SWIGINTERN PyObject *_wrap_qpol_role_allow_t_source_role(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 12309 PyObject *resultobj = 0; 12310 struct qpol_role_allow *arg1 = (struct qpol_role_allow *) 0 ; 12311 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 12312 void *argp1 = 0 ; 12313 int res1 = 0 ; 12314 void *argp2 = 0 ; 12315 int res2 = 0 ; 12316 PyObject * obj0 = 0 ; 12317 PyObject * obj1 = 0 ; 12318 qpol_role_t *result = 0 ; 12319 12320 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_role_allow_t_source_role",&obj0,&obj1)) SWIG_fail; 12321 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_role_allow, 0 | 0 ); 12322 if (!SWIG_IsOK(res1)) { 12323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_role_allow_t_source_role" "', argument " "1"" of type '" "struct qpol_role_allow *""'"); 12324 } 12325 arg1 = (struct qpol_role_allow *)(argp1); 12326 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 12327 if (!SWIG_IsOK(res2)) { 12328 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_role_allow_t_source_role" "', argument " "2"" of type '" "qpol_policy_t *""'"); 12329 } 12330 arg2 = (qpol_policy_t *)(argp2); 12331 result = (qpol_role_t *)qpol_role_allow_source_role(arg1,arg2); 12332 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_role, 0 | 0 ); 12333 return resultobj; 12334 fail: 12335 return NULL; 12336 } 12337 12338 12339 SWIGINTERN PyObject *_wrap_qpol_role_allow_t_target_role(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 12340 PyObject *resultobj = 0; 12341 struct qpol_role_allow *arg1 = (struct qpol_role_allow *) 0 ; 12342 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 12343 void *argp1 = 0 ; 12344 int res1 = 0 ; 12345 void *argp2 = 0 ; 12346 int res2 = 0 ; 12347 PyObject * obj0 = 0 ; 12348 PyObject * obj1 = 0 ; 12349 qpol_role_t *result = 0 ; 12350 12351 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_role_allow_t_target_role",&obj0,&obj1)) SWIG_fail; 12352 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_role_allow, 0 | 0 ); 12353 if (!SWIG_IsOK(res1)) { 12354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_role_allow_t_target_role" "', argument " "1"" of type '" "struct qpol_role_allow *""'"); 12355 } 12356 arg1 = (struct qpol_role_allow *)(argp1); 12357 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 12358 if (!SWIG_IsOK(res2)) { 12359 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_role_allow_t_target_role" "', argument " "2"" of type '" "qpol_policy_t *""'"); 12360 } 12361 arg2 = (qpol_policy_t *)(argp2); 12362 result = (qpol_role_t *)qpol_role_allow_target_role(arg1,arg2); 12363 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_role, 0 | 0 ); 12364 return resultobj; 12365 fail: 12366 return NULL; 12367 } 12368 12369 12370 SWIGINTERN PyObject *qpol_role_allow_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 12371 PyObject *obj; 12372 if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; 12373 SWIG_TypeNewClientData(SWIGTYPE_p_qpol_role_allow, SWIG_NewClientData(obj)); 12374 return SWIG_Py_Void(); 12375 } 12376 12377 SWIGINTERN PyObject *_wrap_qpol_role_allow_from_void(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 12378 PyObject *resultobj = 0; 12379 void *arg1 = (void *) 0 ; 12380 int res1 ; 12381 PyObject * obj0 = 0 ; 12382 qpol_role_allow_t *result = 0 ; 12383 12384 if (!PyArg_ParseTuple(args,(char *)"O:qpol_role_allow_from_void",&obj0)) SWIG_fail; 12385 res1 = SWIG_ConvertPtr(obj0,SWIG_as_voidptrptr(&arg1), 0, 0); 12386 if (!SWIG_IsOK(res1)) { 12387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_role_allow_from_void" "', argument " "1"" of type '" "void *""'"); 12388 } 12389 result = (qpol_role_allow_t *)qpol_role_allow_from_void(arg1); 12390 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_role_allow, 0 | 0 ); 12391 return resultobj; 12392 fail: 12393 return NULL; 12394 } 12395 12396 12397 SWIGINTERN PyObject *_wrap_new_qpol_role_trans_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 12398 PyObject *resultobj = 0; 12399 struct qpol_role_trans *result = 0 ; 12400 12401 if (!PyArg_ParseTuple(args,(char *)":new_qpol_role_trans_t")) SWIG_fail; 12402 result = (struct qpol_role_trans *)new_qpol_role_trans(); 12403 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_role_trans, SWIG_POINTER_NEW | 0 ); 12404 return resultobj; 12405 fail: 12406 return NULL; 12407 } 12408 12409 12410 SWIGINTERN PyObject *_wrap_delete_qpol_role_trans_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 12411 PyObject *resultobj = 0; 12412 struct qpol_role_trans *arg1 = (struct qpol_role_trans *) 0 ; 12413 void *argp1 = 0 ; 12414 int res1 = 0 ; 12415 PyObject * obj0 = 0 ; 12416 12417 if (!PyArg_ParseTuple(args,(char *)"O:delete_qpol_role_trans_t",&obj0)) SWIG_fail; 12418 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_role_trans, SWIG_POINTER_DISOWN | 0 ); 12419 if (!SWIG_IsOK(res1)) { 12420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_qpol_role_trans_t" "', argument " "1"" of type '" "struct qpol_role_trans *""'"); 12421 } 12422 arg1 = (struct qpol_role_trans *)(argp1); 12423 delete_qpol_role_trans(arg1); 12424 resultobj = SWIG_Py_Void(); 12425 return resultobj; 12426 fail: 12427 return NULL; 12428 } 12429 12430 12431 SWIGINTERN PyObject *_wrap_qpol_role_trans_t_source_role(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 12432 PyObject *resultobj = 0; 12433 struct qpol_role_trans *arg1 = (struct qpol_role_trans *) 0 ; 12434 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 12435 void *argp1 = 0 ; 12436 int res1 = 0 ; 12437 void *argp2 = 0 ; 12438 int res2 = 0 ; 12439 PyObject * obj0 = 0 ; 12440 PyObject * obj1 = 0 ; 12441 qpol_role_t *result = 0 ; 12442 12443 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_role_trans_t_source_role",&obj0,&obj1)) SWIG_fail; 12444 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_role_trans, 0 | 0 ); 12445 if (!SWIG_IsOK(res1)) { 12446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_role_trans_t_source_role" "', argument " "1"" of type '" "struct qpol_role_trans *""'"); 12447 } 12448 arg1 = (struct qpol_role_trans *)(argp1); 12449 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 12450 if (!SWIG_IsOK(res2)) { 12451 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_role_trans_t_source_role" "', argument " "2"" of type '" "qpol_policy_t *""'"); 12452 } 12453 arg2 = (qpol_policy_t *)(argp2); 12454 result = (qpol_role_t *)qpol_role_trans_source_role(arg1,arg2); 12455 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_role, 0 | 0 ); 12456 return resultobj; 12457 fail: 12458 return NULL; 12459 } 12460 12461 12462 SWIGINTERN PyObject *_wrap_qpol_role_trans_t_target_type(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 12463 PyObject *resultobj = 0; 12464 struct qpol_role_trans *arg1 = (struct qpol_role_trans *) 0 ; 12465 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 12466 void *argp1 = 0 ; 12467 int res1 = 0 ; 12468 void *argp2 = 0 ; 12469 int res2 = 0 ; 12470 PyObject * obj0 = 0 ; 12471 PyObject * obj1 = 0 ; 12472 qpol_type_t *result = 0 ; 12473 12474 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_role_trans_t_target_type",&obj0,&obj1)) SWIG_fail; 12475 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_role_trans, 0 | 0 ); 12476 if (!SWIG_IsOK(res1)) { 12477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_role_trans_t_target_type" "', argument " "1"" of type '" "struct qpol_role_trans *""'"); 12478 } 12479 arg1 = (struct qpol_role_trans *)(argp1); 12480 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 12481 if (!SWIG_IsOK(res2)) { 12482 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_role_trans_t_target_type" "', argument " "2"" of type '" "qpol_policy_t *""'"); 12483 } 12484 arg2 = (qpol_policy_t *)(argp2); 12485 result = (qpol_type_t *)qpol_role_trans_target_type(arg1,arg2); 12486 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_type, 0 | 0 ); 12487 return resultobj; 12488 fail: 12489 return NULL; 12490 } 12491 12492 12493 SWIGINTERN PyObject *_wrap_qpol_role_trans_t_object_class(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 12494 PyObject *resultobj = 0; 12495 struct qpol_role_trans *arg1 = (struct qpol_role_trans *) 0 ; 12496 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 12497 void *argp1 = 0 ; 12498 int res1 = 0 ; 12499 void *argp2 = 0 ; 12500 int res2 = 0 ; 12501 PyObject * obj0 = 0 ; 12502 PyObject * obj1 = 0 ; 12503 qpol_class_t *result = 0 ; 12504 12505 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_role_trans_t_object_class",&obj0,&obj1)) SWIG_fail; 12506 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_role_trans, 0 | 0 ); 12507 if (!SWIG_IsOK(res1)) { 12508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_role_trans_t_object_class" "', argument " "1"" of type '" "struct qpol_role_trans *""'"); 12509 } 12510 arg1 = (struct qpol_role_trans *)(argp1); 12511 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 12512 if (!SWIG_IsOK(res2)) { 12513 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_role_trans_t_object_class" "', argument " "2"" of type '" "qpol_policy_t *""'"); 12514 } 12515 arg2 = (qpol_policy_t *)(argp2); 12516 result = (qpol_class_t *)qpol_role_trans_object_class(arg1,arg2); 12517 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_class, 0 | 0 ); 12518 return resultobj; 12519 fail: 12520 return NULL; 12521 } 12522 12523 12524 SWIGINTERN PyObject *_wrap_qpol_role_trans_t_default_role(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 12525 PyObject *resultobj = 0; 12526 struct qpol_role_trans *arg1 = (struct qpol_role_trans *) 0 ; 12527 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 12528 void *argp1 = 0 ; 12529 int res1 = 0 ; 12530 void *argp2 = 0 ; 12531 int res2 = 0 ; 12532 PyObject * obj0 = 0 ; 12533 PyObject * obj1 = 0 ; 12534 qpol_role_t *result = 0 ; 12535 12536 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_role_trans_t_default_role",&obj0,&obj1)) SWIG_fail; 12537 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_role_trans, 0 | 0 ); 12538 if (!SWIG_IsOK(res1)) { 12539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_role_trans_t_default_role" "', argument " "1"" of type '" "struct qpol_role_trans *""'"); 12540 } 12541 arg1 = (struct qpol_role_trans *)(argp1); 12542 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 12543 if (!SWIG_IsOK(res2)) { 12544 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_role_trans_t_default_role" "', argument " "2"" of type '" "qpol_policy_t *""'"); 12545 } 12546 arg2 = (qpol_policy_t *)(argp2); 12547 result = (qpol_role_t *)qpol_role_trans_default_role(arg1,arg2); 12548 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_role, 0 | 0 ); 12549 return resultobj; 12550 fail: 12551 return NULL; 12552 } 12553 12554 12555 SWIGINTERN PyObject *qpol_role_trans_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 12556 PyObject *obj; 12557 if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; 12558 SWIG_TypeNewClientData(SWIGTYPE_p_qpol_role_trans, SWIG_NewClientData(obj)); 12559 return SWIG_Py_Void(); 12560 } 12561 12562 SWIGINTERN PyObject *_wrap_qpol_role_trans_from_void(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 12563 PyObject *resultobj = 0; 12564 void *arg1 = (void *) 0 ; 12565 int res1 ; 12566 PyObject * obj0 = 0 ; 12567 qpol_role_trans_t *result = 0 ; 12568 12569 if (!PyArg_ParseTuple(args,(char *)"O:qpol_role_trans_from_void",&obj0)) SWIG_fail; 12570 res1 = SWIG_ConvertPtr(obj0,SWIG_as_voidptrptr(&arg1), 0, 0); 12571 if (!SWIG_IsOK(res1)) { 12572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_role_trans_from_void" "', argument " "1"" of type '" "void *""'"); 12573 } 12574 result = (qpol_role_trans_t *)qpol_role_trans_from_void(arg1); 12575 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_role_trans, 0 | 0 ); 12576 return resultobj; 12577 fail: 12578 return NULL; 12579 } 12580 12581 12582 SWIGINTERN PyObject *_wrap_new_qpol_range_trans_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 12583 PyObject *resultobj = 0; 12584 struct qpol_range_trans *result = 0 ; 12585 12586 if (!PyArg_ParseTuple(args,(char *)":new_qpol_range_trans_t")) SWIG_fail; 12587 result = (struct qpol_range_trans *)new_qpol_range_trans(); 12588 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_range_trans, SWIG_POINTER_NEW | 0 ); 12589 return resultobj; 12590 fail: 12591 return NULL; 12592 } 12593 12594 12595 SWIGINTERN PyObject *_wrap_delete_qpol_range_trans_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 12596 PyObject *resultobj = 0; 12597 struct qpol_range_trans *arg1 = (struct qpol_range_trans *) 0 ; 12598 void *argp1 = 0 ; 12599 int res1 = 0 ; 12600 PyObject * obj0 = 0 ; 12601 12602 if (!PyArg_ParseTuple(args,(char *)"O:delete_qpol_range_trans_t",&obj0)) SWIG_fail; 12603 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_range_trans, SWIG_POINTER_DISOWN | 0 ); 12604 if (!SWIG_IsOK(res1)) { 12605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_qpol_range_trans_t" "', argument " "1"" of type '" "struct qpol_range_trans *""'"); 12606 } 12607 arg1 = (struct qpol_range_trans *)(argp1); 12608 delete_qpol_range_trans(arg1); 12609 resultobj = SWIG_Py_Void(); 12610 return resultobj; 12611 fail: 12612 return NULL; 12613 } 12614 12615 12616 SWIGINTERN PyObject *_wrap_qpol_range_trans_t_source_type(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 12617 PyObject *resultobj = 0; 12618 struct qpol_range_trans *arg1 = (struct qpol_range_trans *) 0 ; 12619 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 12620 void *argp1 = 0 ; 12621 int res1 = 0 ; 12622 void *argp2 = 0 ; 12623 int res2 = 0 ; 12624 PyObject * obj0 = 0 ; 12625 PyObject * obj1 = 0 ; 12626 qpol_type_t *result = 0 ; 12627 12628 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_range_trans_t_source_type",&obj0,&obj1)) SWIG_fail; 12629 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_range_trans, 0 | 0 ); 12630 if (!SWIG_IsOK(res1)) { 12631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_range_trans_t_source_type" "', argument " "1"" of type '" "struct qpol_range_trans *""'"); 12632 } 12633 arg1 = (struct qpol_range_trans *)(argp1); 12634 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 12635 if (!SWIG_IsOK(res2)) { 12636 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_range_trans_t_source_type" "', argument " "2"" of type '" "qpol_policy_t *""'"); 12637 } 12638 arg2 = (qpol_policy_t *)(argp2); 12639 result = (qpol_type_t *)qpol_range_trans_source_type(arg1,arg2); 12640 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_type, 0 | 0 ); 12641 return resultobj; 12642 fail: 12643 return NULL; 12644 } 12645 12646 12647 SWIGINTERN PyObject *_wrap_qpol_range_trans_t_target_type(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 12648 PyObject *resultobj = 0; 12649 struct qpol_range_trans *arg1 = (struct qpol_range_trans *) 0 ; 12650 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 12651 void *argp1 = 0 ; 12652 int res1 = 0 ; 12653 void *argp2 = 0 ; 12654 int res2 = 0 ; 12655 PyObject * obj0 = 0 ; 12656 PyObject * obj1 = 0 ; 12657 qpol_type_t *result = 0 ; 12658 12659 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_range_trans_t_target_type",&obj0,&obj1)) SWIG_fail; 12660 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_range_trans, 0 | 0 ); 12661 if (!SWIG_IsOK(res1)) { 12662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_range_trans_t_target_type" "', argument " "1"" of type '" "struct qpol_range_trans *""'"); 12663 } 12664 arg1 = (struct qpol_range_trans *)(argp1); 12665 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 12666 if (!SWIG_IsOK(res2)) { 12667 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_range_trans_t_target_type" "', argument " "2"" of type '" "qpol_policy_t *""'"); 12668 } 12669 arg2 = (qpol_policy_t *)(argp2); 12670 result = (qpol_type_t *)qpol_range_trans_target_type(arg1,arg2); 12671 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_type, 0 | 0 ); 12672 return resultobj; 12673 fail: 12674 return NULL; 12675 } 12676 12677 12678 SWIGINTERN PyObject *_wrap_qpol_range_trans_t_object_class(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 12679 PyObject *resultobj = 0; 12680 struct qpol_range_trans *arg1 = (struct qpol_range_trans *) 0 ; 12681 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 12682 void *argp1 = 0 ; 12683 int res1 = 0 ; 12684 void *argp2 = 0 ; 12685 int res2 = 0 ; 12686 PyObject * obj0 = 0 ; 12687 PyObject * obj1 = 0 ; 12688 qpol_class_t *result = 0 ; 12689 12690 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_range_trans_t_object_class",&obj0,&obj1)) SWIG_fail; 12691 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_range_trans, 0 | 0 ); 12692 if (!SWIG_IsOK(res1)) { 12693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_range_trans_t_object_class" "', argument " "1"" of type '" "struct qpol_range_trans *""'"); 12694 } 12695 arg1 = (struct qpol_range_trans *)(argp1); 12696 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 12697 if (!SWIG_IsOK(res2)) { 12698 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_range_trans_t_object_class" "', argument " "2"" of type '" "qpol_policy_t *""'"); 12699 } 12700 arg2 = (qpol_policy_t *)(argp2); 12701 result = (qpol_class_t *)qpol_range_trans_object_class(arg1,arg2); 12702 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_class, 0 | 0 ); 12703 return resultobj; 12704 fail: 12705 return NULL; 12706 } 12707 12708 12709 SWIGINTERN PyObject *_wrap_qpol_range_trans_t_range(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 12710 PyObject *resultobj = 0; 12711 struct qpol_range_trans *arg1 = (struct qpol_range_trans *) 0 ; 12712 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 12713 void *argp1 = 0 ; 12714 int res1 = 0 ; 12715 void *argp2 = 0 ; 12716 int res2 = 0 ; 12717 PyObject * obj0 = 0 ; 12718 PyObject * obj1 = 0 ; 12719 qpol_mls_range_t *result = 0 ; 12720 12721 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_range_trans_t_range",&obj0,&obj1)) SWIG_fail; 12722 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_range_trans, 0 | 0 ); 12723 if (!SWIG_IsOK(res1)) { 12724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_range_trans_t_range" "', argument " "1"" of type '" "struct qpol_range_trans *""'"); 12725 } 12726 arg1 = (struct qpol_range_trans *)(argp1); 12727 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 12728 if (!SWIG_IsOK(res2)) { 12729 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_range_trans_t_range" "', argument " "2"" of type '" "qpol_policy_t *""'"); 12730 } 12731 arg2 = (qpol_policy_t *)(argp2); 12732 result = (qpol_mls_range_t *)qpol_range_trans_range(arg1,arg2); 12733 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_mls_range, 0 | 0 ); 12734 return resultobj; 12735 fail: 12736 return NULL; 12737 } 12738 12739 12740 SWIGINTERN PyObject *qpol_range_trans_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 12741 PyObject *obj; 12742 if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; 12743 SWIG_TypeNewClientData(SWIGTYPE_p_qpol_range_trans, SWIG_NewClientData(obj)); 12744 return SWIG_Py_Void(); 12745 } 12746 12747 SWIGINTERN PyObject *_wrap_qpol_range_trans_from_void(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 12748 PyObject *resultobj = 0; 12749 void *arg1 = (void *) 0 ; 12750 int res1 ; 12751 PyObject * obj0 = 0 ; 12752 qpol_range_trans_t *result = 0 ; 12753 12754 if (!PyArg_ParseTuple(args,(char *)"O:qpol_range_trans_from_void",&obj0)) SWIG_fail; 12755 res1 = SWIG_ConvertPtr(obj0,SWIG_as_voidptrptr(&arg1), 0, 0); 12756 if (!SWIG_IsOK(res1)) { 12757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_range_trans_from_void" "', argument " "1"" of type '" "void *""'"); 12758 } 12759 result = (qpol_range_trans_t *)qpol_range_trans_from_void(arg1); 12760 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_range_trans, 0 | 0 ); 12761 return resultobj; 12762 fail: 12763 return NULL; 12764 } 12765 12766 12767 SWIGINTERN PyObject *_wrap_new_qpol_avrule_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 12768 PyObject *resultobj = 0; 12769 struct qpol_avrule *result = 0 ; 12770 12771 if (!PyArg_ParseTuple(args,(char *)":new_qpol_avrule_t")) SWIG_fail; 12772 result = (struct qpol_avrule *)new_qpol_avrule(); 12773 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_avrule, SWIG_POINTER_NEW | 0 ); 12774 return resultobj; 12775 fail: 12776 return NULL; 12777 } 12778 12779 12780 SWIGINTERN PyObject *_wrap_delete_qpol_avrule_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 12781 PyObject *resultobj = 0; 12782 struct qpol_avrule *arg1 = (struct qpol_avrule *) 0 ; 12783 void *argp1 = 0 ; 12784 int res1 = 0 ; 12785 PyObject * obj0 = 0 ; 12786 12787 if (!PyArg_ParseTuple(args,(char *)"O:delete_qpol_avrule_t",&obj0)) SWIG_fail; 12788 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_avrule, SWIG_POINTER_DISOWN | 0 ); 12789 if (!SWIG_IsOK(res1)) { 12790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_qpol_avrule_t" "', argument " "1"" of type '" "struct qpol_avrule *""'"); 12791 } 12792 arg1 = (struct qpol_avrule *)(argp1); 12793 delete_qpol_avrule(arg1); 12794 resultobj = SWIG_Py_Void(); 12795 return resultobj; 12796 fail: 12797 return NULL; 12798 } 12799 12800 12801 SWIGINTERN PyObject *_wrap_qpol_avrule_t_rule_type(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 12802 PyObject *resultobj = 0; 12803 struct qpol_avrule *arg1 = (struct qpol_avrule *) 0 ; 12804 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 12805 void *argp1 = 0 ; 12806 int res1 = 0 ; 12807 void *argp2 = 0 ; 12808 int res2 = 0 ; 12809 PyObject * obj0 = 0 ; 12810 PyObject * obj1 = 0 ; 12811 char *result = 0 ; 12812 12813 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_avrule_t_rule_type",&obj0,&obj1)) SWIG_fail; 12814 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_avrule, 0 | 0 ); 12815 if (!SWIG_IsOK(res1)) { 12816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_avrule_t_rule_type" "', argument " "1"" of type '" "struct qpol_avrule *""'"); 12817 } 12818 arg1 = (struct qpol_avrule *)(argp1); 12819 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 12820 if (!SWIG_IsOK(res2)) { 12821 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_avrule_t_rule_type" "', argument " "2"" of type '" "qpol_policy_t *""'"); 12822 } 12823 arg2 = (qpol_policy_t *)(argp2); 12824 result = (char *)qpol_avrule_rule_type(arg1,arg2); 12825 resultobj = SWIG_FromCharPtr((const char *)result); 12826 return resultobj; 12827 fail: 12828 return NULL; 12829 } 12830 12831 12832 SWIGINTERN PyObject *_wrap_qpol_avrule_t_source_type(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 12833 PyObject *resultobj = 0; 12834 struct qpol_avrule *arg1 = (struct qpol_avrule *) 0 ; 12835 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 12836 void *argp1 = 0 ; 12837 int res1 = 0 ; 12838 void *argp2 = 0 ; 12839 int res2 = 0 ; 12840 PyObject * obj0 = 0 ; 12841 PyObject * obj1 = 0 ; 12842 qpol_type_t *result = 0 ; 12843 12844 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_avrule_t_source_type",&obj0,&obj1)) SWIG_fail; 12845 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_avrule, 0 | 0 ); 12846 if (!SWIG_IsOK(res1)) { 12847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_avrule_t_source_type" "', argument " "1"" of type '" "struct qpol_avrule *""'"); 12848 } 12849 arg1 = (struct qpol_avrule *)(argp1); 12850 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 12851 if (!SWIG_IsOK(res2)) { 12852 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_avrule_t_source_type" "', argument " "2"" of type '" "qpol_policy_t *""'"); 12853 } 12854 arg2 = (qpol_policy_t *)(argp2); 12855 result = (qpol_type_t *)qpol_avrule_source_type(arg1,arg2); 12856 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_type, 0 | 0 ); 12857 return resultobj; 12858 fail: 12859 return NULL; 12860 } 12861 12862 12863 SWIGINTERN PyObject *_wrap_qpol_avrule_t_target_type(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 12864 PyObject *resultobj = 0; 12865 struct qpol_avrule *arg1 = (struct qpol_avrule *) 0 ; 12866 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 12867 void *argp1 = 0 ; 12868 int res1 = 0 ; 12869 void *argp2 = 0 ; 12870 int res2 = 0 ; 12871 PyObject * obj0 = 0 ; 12872 PyObject * obj1 = 0 ; 12873 qpol_type_t *result = 0 ; 12874 12875 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_avrule_t_target_type",&obj0,&obj1)) SWIG_fail; 12876 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_avrule, 0 | 0 ); 12877 if (!SWIG_IsOK(res1)) { 12878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_avrule_t_target_type" "', argument " "1"" of type '" "struct qpol_avrule *""'"); 12879 } 12880 arg1 = (struct qpol_avrule *)(argp1); 12881 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 12882 if (!SWIG_IsOK(res2)) { 12883 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_avrule_t_target_type" "', argument " "2"" of type '" "qpol_policy_t *""'"); 12884 } 12885 arg2 = (qpol_policy_t *)(argp2); 12886 result = (qpol_type_t *)qpol_avrule_target_type(arg1,arg2); 12887 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_type, 0 | 0 ); 12888 return resultobj; 12889 fail: 12890 return NULL; 12891 } 12892 12893 12894 SWIGINTERN PyObject *_wrap_qpol_avrule_t_object_class(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 12895 PyObject *resultobj = 0; 12896 struct qpol_avrule *arg1 = (struct qpol_avrule *) 0 ; 12897 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 12898 void *argp1 = 0 ; 12899 int res1 = 0 ; 12900 void *argp2 = 0 ; 12901 int res2 = 0 ; 12902 PyObject * obj0 = 0 ; 12903 PyObject * obj1 = 0 ; 12904 qpol_class_t *result = 0 ; 12905 12906 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_avrule_t_object_class",&obj0,&obj1)) SWIG_fail; 12907 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_avrule, 0 | 0 ); 12908 if (!SWIG_IsOK(res1)) { 12909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_avrule_t_object_class" "', argument " "1"" of type '" "struct qpol_avrule *""'"); 12910 } 12911 arg1 = (struct qpol_avrule *)(argp1); 12912 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 12913 if (!SWIG_IsOK(res2)) { 12914 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_avrule_t_object_class" "', argument " "2"" of type '" "qpol_policy_t *""'"); 12915 } 12916 arg2 = (qpol_policy_t *)(argp2); 12917 result = (qpol_class_t *)qpol_avrule_object_class(arg1,arg2); 12918 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_class, 0 | 0 ); 12919 return resultobj; 12920 fail: 12921 return NULL; 12922 } 12923 12924 12925 SWIGINTERN PyObject *_wrap_qpol_avrule_t_perm_iter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 12926 PyObject *resultobj = 0; 12927 struct qpol_avrule *arg1 = (struct qpol_avrule *) 0 ; 12928 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 12929 void *argp1 = 0 ; 12930 int res1 = 0 ; 12931 void *argp2 = 0 ; 12932 int res2 = 0 ; 12933 PyObject * obj0 = 0 ; 12934 PyObject * obj1 = 0 ; 12935 qpol_iterator_t *result = 0 ; 12936 12937 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_avrule_t_perm_iter",&obj0,&obj1)) SWIG_fail; 12938 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_avrule, 0 | 0 ); 12939 if (!SWIG_IsOK(res1)) { 12940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_avrule_t_perm_iter" "', argument " "1"" of type '" "struct qpol_avrule *""'"); 12941 } 12942 arg1 = (struct qpol_avrule *)(argp1); 12943 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 12944 if (!SWIG_IsOK(res2)) { 12945 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_avrule_t_perm_iter" "', argument " "2"" of type '" "qpol_policy_t *""'"); 12946 } 12947 arg2 = (qpol_policy_t *)(argp2); 12948 result = (qpol_iterator_t *)qpol_avrule_perm_iter(arg1,arg2); 12949 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_iterator, SWIG_POINTER_OWN | 0 ); 12950 return resultobj; 12951 fail: 12952 return NULL; 12953 } 12954 12955 12956 SWIGINTERN PyObject *_wrap_qpol_avrule_t_xperm_iter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 12957 PyObject *resultobj = 0; 12958 struct qpol_avrule *arg1 = (struct qpol_avrule *) 0 ; 12959 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 12960 void *argp1 = 0 ; 12961 int res1 = 0 ; 12962 void *argp2 = 0 ; 12963 int res2 = 0 ; 12964 PyObject * obj0 = 0 ; 12965 PyObject * obj1 = 0 ; 12966 qpol_iterator_t *result = 0 ; 12967 12968 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_avrule_t_xperm_iter",&obj0,&obj1)) SWIG_fail; 12969 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_avrule, 0 | 0 ); 12970 if (!SWIG_IsOK(res1)) { 12971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_avrule_t_xperm_iter" "', argument " "1"" of type '" "struct qpol_avrule *""'"); 12972 } 12973 arg1 = (struct qpol_avrule *)(argp1); 12974 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 12975 if (!SWIG_IsOK(res2)) { 12976 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_avrule_t_xperm_iter" "', argument " "2"" of type '" "qpol_policy_t *""'"); 12977 } 12978 arg2 = (qpol_policy_t *)(argp2); 12979 result = (qpol_iterator_t *)qpol_avrule_xperm_iter(arg1,arg2); 12980 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_iterator, SWIG_POINTER_OWN | 0 ); 12981 return resultobj; 12982 fail: 12983 return NULL; 12984 } 12985 12986 12987 SWIGINTERN PyObject *_wrap_qpol_avrule_t_is_extended(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 12988 PyObject *resultobj = 0; 12989 struct qpol_avrule *arg1 = (struct qpol_avrule *) 0 ; 12990 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 12991 void *argp1 = 0 ; 12992 int res1 = 0 ; 12993 void *argp2 = 0 ; 12994 int res2 = 0 ; 12995 PyObject * obj0 = 0 ; 12996 PyObject * obj1 = 0 ; 12997 int result; 12998 12999 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_avrule_t_is_extended",&obj0,&obj1)) SWIG_fail; 13000 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_avrule, 0 | 0 ); 13001 if (!SWIG_IsOK(res1)) { 13002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_avrule_t_is_extended" "', argument " "1"" of type '" "struct qpol_avrule *""'"); 13003 } 13004 arg1 = (struct qpol_avrule *)(argp1); 13005 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 13006 if (!SWIG_IsOK(res2)) { 13007 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_avrule_t_is_extended" "', argument " "2"" of type '" "qpol_policy_t *""'"); 13008 } 13009 arg2 = (qpol_policy_t *)(argp2); 13010 result = (int)qpol_avrule_is_extended(arg1,arg2); 13011 resultobj = SWIG_From_int((int)(result)); 13012 return resultobj; 13013 fail: 13014 return NULL; 13015 } 13016 13017 13018 SWIGINTERN PyObject *_wrap_qpol_avrule_t_xperm_type(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 13019 PyObject *resultobj = 0; 13020 struct qpol_avrule *arg1 = (struct qpol_avrule *) 0 ; 13021 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 13022 void *argp1 = 0 ; 13023 int res1 = 0 ; 13024 void *argp2 = 0 ; 13025 int res2 = 0 ; 13026 PyObject * obj0 = 0 ; 13027 PyObject * obj1 = 0 ; 13028 char *result = 0 ; 13029 13030 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_avrule_t_xperm_type",&obj0,&obj1)) SWIG_fail; 13031 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_avrule, 0 | 0 ); 13032 if (!SWIG_IsOK(res1)) { 13033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_avrule_t_xperm_type" "', argument " "1"" of type '" "struct qpol_avrule *""'"); 13034 } 13035 arg1 = (struct qpol_avrule *)(argp1); 13036 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 13037 if (!SWIG_IsOK(res2)) { 13038 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_avrule_t_xperm_type" "', argument " "2"" of type '" "qpol_policy_t *""'"); 13039 } 13040 arg2 = (qpol_policy_t *)(argp2); 13041 result = (char *)qpol_avrule_xperm_type(arg1,arg2); 13042 resultobj = SWIG_FromCharPtr((const char *)result); 13043 return resultobj; 13044 fail: 13045 return NULL; 13046 } 13047 13048 13049 SWIGINTERN PyObject *_wrap_qpol_avrule_t_cond(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 13050 PyObject *resultobj = 0; 13051 struct qpol_avrule *arg1 = (struct qpol_avrule *) 0 ; 13052 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 13053 void *argp1 = 0 ; 13054 int res1 = 0 ; 13055 void *argp2 = 0 ; 13056 int res2 = 0 ; 13057 PyObject * obj0 = 0 ; 13058 PyObject * obj1 = 0 ; 13059 qpol_cond_t *result = 0 ; 13060 13061 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_avrule_t_cond",&obj0,&obj1)) SWIG_fail; 13062 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_avrule, 0 | 0 ); 13063 if (!SWIG_IsOK(res1)) { 13064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_avrule_t_cond" "', argument " "1"" of type '" "struct qpol_avrule *""'"); 13065 } 13066 arg1 = (struct qpol_avrule *)(argp1); 13067 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 13068 if (!SWIG_IsOK(res2)) { 13069 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_avrule_t_cond" "', argument " "2"" of type '" "qpol_policy_t *""'"); 13070 } 13071 arg2 = (qpol_policy_t *)(argp2); 13072 { 13073 result = (qpol_cond_t *)qpol_avrule_cond(arg1,arg2); 13074 if (!result) { 13075 PyErr_SetString(PyExc_AttributeError, "Rule is not conditional."); 13076 return NULL; 13077 } 13078 } 13079 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_cond, 0 | 0 ); 13080 return resultobj; 13081 fail: 13082 return NULL; 13083 } 13084 13085 13086 SWIGINTERN PyObject *_wrap_qpol_avrule_t_is_enabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 13087 PyObject *resultobj = 0; 13088 struct qpol_avrule *arg1 = (struct qpol_avrule *) 0 ; 13089 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 13090 void *argp1 = 0 ; 13091 int res1 = 0 ; 13092 void *argp2 = 0 ; 13093 int res2 = 0 ; 13094 PyObject * obj0 = 0 ; 13095 PyObject * obj1 = 0 ; 13096 int result; 13097 13098 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_avrule_t_is_enabled",&obj0,&obj1)) SWIG_fail; 13099 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_avrule, 0 | 0 ); 13100 if (!SWIG_IsOK(res1)) { 13101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_avrule_t_is_enabled" "', argument " "1"" of type '" "struct qpol_avrule *""'"); 13102 } 13103 arg1 = (struct qpol_avrule *)(argp1); 13104 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 13105 if (!SWIG_IsOK(res2)) { 13106 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_avrule_t_is_enabled" "', argument " "2"" of type '" "qpol_policy_t *""'"); 13107 } 13108 arg2 = (qpol_policy_t *)(argp2); 13109 result = (int)qpol_avrule_is_enabled(arg1,arg2); 13110 resultobj = SWIG_From_int((int)(result)); 13111 return resultobj; 13112 fail: 13113 return NULL; 13114 } 13115 13116 13117 SWIGINTERN PyObject *_wrap_qpol_avrule_t_which_list(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 13118 PyObject *resultobj = 0; 13119 struct qpol_avrule *arg1 = (struct qpol_avrule *) 0 ; 13120 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 13121 void *argp1 = 0 ; 13122 int res1 = 0 ; 13123 void *argp2 = 0 ; 13124 int res2 = 0 ; 13125 PyObject * obj0 = 0 ; 13126 PyObject * obj1 = 0 ; 13127 int result; 13128 13129 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_avrule_t_which_list",&obj0,&obj1)) SWIG_fail; 13130 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_avrule, 0 | 0 ); 13131 if (!SWIG_IsOK(res1)) { 13132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_avrule_t_which_list" "', argument " "1"" of type '" "struct qpol_avrule *""'"); 13133 } 13134 arg1 = (struct qpol_avrule *)(argp1); 13135 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 13136 if (!SWIG_IsOK(res2)) { 13137 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_avrule_t_which_list" "', argument " "2"" of type '" "qpol_policy_t *""'"); 13138 } 13139 arg2 = (qpol_policy_t *)(argp2); 13140 { 13141 result = (int)qpol_avrule_which_list(arg1,arg2); 13142 if (result < 0) { 13143 PyErr_SetString(PyExc_AttributeError, "Rule is not conditional."); 13144 return NULL; 13145 } 13146 } 13147 resultobj = SWIG_From_int((int)(result)); 13148 return resultobj; 13149 fail: 13150 return NULL; 13151 } 13152 13153 13154 SWIGINTERN PyObject *_wrap_qpol_avrule_t_syn_avrule_iter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 13155 PyObject *resultobj = 0; 13156 struct qpol_avrule *arg1 = (struct qpol_avrule *) 0 ; 13157 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 13158 void *argp1 = 0 ; 13159 int res1 = 0 ; 13160 void *argp2 = 0 ; 13161 int res2 = 0 ; 13162 PyObject * obj0 = 0 ; 13163 PyObject * obj1 = 0 ; 13164 qpol_iterator_t *result = 0 ; 13165 13166 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_avrule_t_syn_avrule_iter",&obj0,&obj1)) SWIG_fail; 13167 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_avrule, 0 | 0 ); 13168 if (!SWIG_IsOK(res1)) { 13169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_avrule_t_syn_avrule_iter" "', argument " "1"" of type '" "struct qpol_avrule *""'"); 13170 } 13171 arg1 = (struct qpol_avrule *)(argp1); 13172 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 13173 if (!SWIG_IsOK(res2)) { 13174 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_avrule_t_syn_avrule_iter" "', argument " "2"" of type '" "qpol_policy_t *""'"); 13175 } 13176 arg2 = (qpol_policy_t *)(argp2); 13177 result = (qpol_iterator_t *)qpol_avrule_syn_avrule_iter(arg1,arg2); 13178 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_iterator, SWIG_POINTER_OWN | 0 ); 13179 return resultobj; 13180 fail: 13181 return NULL; 13182 } 13183 13184 13185 SWIGINTERN PyObject *qpol_avrule_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 13186 PyObject *obj; 13187 if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; 13188 SWIG_TypeNewClientData(SWIGTYPE_p_qpol_avrule, SWIG_NewClientData(obj)); 13189 return SWIG_Py_Void(); 13190 } 13191 13192 SWIGINTERN PyObject *_wrap_qpol_avrule_from_void(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 13193 PyObject *resultobj = 0; 13194 void *arg1 = (void *) 0 ; 13195 int res1 ; 13196 PyObject * obj0 = 0 ; 13197 qpol_avrule_t *result = 0 ; 13198 13199 if (!PyArg_ParseTuple(args,(char *)"O:qpol_avrule_from_void",&obj0)) SWIG_fail; 13200 res1 = SWIG_ConvertPtr(obj0,SWIG_as_voidptrptr(&arg1), 0, 0); 13201 if (!SWIG_IsOK(res1)) { 13202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_avrule_from_void" "', argument " "1"" of type '" "void *""'"); 13203 } 13204 result = (qpol_avrule_t *)qpol_avrule_from_void(arg1); 13205 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_avrule, 0 | 0 ); 13206 return resultobj; 13207 fail: 13208 return NULL; 13209 } 13210 13211 13212 SWIGINTERN PyObject *_wrap_new_qpol_terule_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 13213 PyObject *resultobj = 0; 13214 struct qpol_terule *result = 0 ; 13215 13216 if (!PyArg_ParseTuple(args,(char *)":new_qpol_terule_t")) SWIG_fail; 13217 result = (struct qpol_terule *)new_qpol_terule(); 13218 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_terule, SWIG_POINTER_NEW | 0 ); 13219 return resultobj; 13220 fail: 13221 return NULL; 13222 } 13223 13224 13225 SWIGINTERN PyObject *_wrap_delete_qpol_terule_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 13226 PyObject *resultobj = 0; 13227 struct qpol_terule *arg1 = (struct qpol_terule *) 0 ; 13228 void *argp1 = 0 ; 13229 int res1 = 0 ; 13230 PyObject * obj0 = 0 ; 13231 13232 if (!PyArg_ParseTuple(args,(char *)"O:delete_qpol_terule_t",&obj0)) SWIG_fail; 13233 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_terule, SWIG_POINTER_DISOWN | 0 ); 13234 if (!SWIG_IsOK(res1)) { 13235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_qpol_terule_t" "', argument " "1"" of type '" "struct qpol_terule *""'"); 13236 } 13237 arg1 = (struct qpol_terule *)(argp1); 13238 delete_qpol_terule(arg1); 13239 resultobj = SWIG_Py_Void(); 13240 return resultobj; 13241 fail: 13242 return NULL; 13243 } 13244 13245 13246 SWIGINTERN PyObject *_wrap_qpol_terule_t_rule_type(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 13247 PyObject *resultobj = 0; 13248 struct qpol_terule *arg1 = (struct qpol_terule *) 0 ; 13249 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 13250 void *argp1 = 0 ; 13251 int res1 = 0 ; 13252 void *argp2 = 0 ; 13253 int res2 = 0 ; 13254 PyObject * obj0 = 0 ; 13255 PyObject * obj1 = 0 ; 13256 char *result = 0 ; 13257 13258 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_terule_t_rule_type",&obj0,&obj1)) SWIG_fail; 13259 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_terule, 0 | 0 ); 13260 if (!SWIG_IsOK(res1)) { 13261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_terule_t_rule_type" "', argument " "1"" of type '" "struct qpol_terule *""'"); 13262 } 13263 arg1 = (struct qpol_terule *)(argp1); 13264 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 13265 if (!SWIG_IsOK(res2)) { 13266 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_terule_t_rule_type" "', argument " "2"" of type '" "qpol_policy_t *""'"); 13267 } 13268 arg2 = (qpol_policy_t *)(argp2); 13269 result = (char *)qpol_terule_rule_type(arg1,arg2); 13270 resultobj = SWIG_FromCharPtr((const char *)result); 13271 return resultobj; 13272 fail: 13273 return NULL; 13274 } 13275 13276 13277 SWIGINTERN PyObject *_wrap_qpol_terule_t_source_type(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 13278 PyObject *resultobj = 0; 13279 struct qpol_terule *arg1 = (struct qpol_terule *) 0 ; 13280 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 13281 void *argp1 = 0 ; 13282 int res1 = 0 ; 13283 void *argp2 = 0 ; 13284 int res2 = 0 ; 13285 PyObject * obj0 = 0 ; 13286 PyObject * obj1 = 0 ; 13287 qpol_type_t *result = 0 ; 13288 13289 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_terule_t_source_type",&obj0,&obj1)) SWIG_fail; 13290 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_terule, 0 | 0 ); 13291 if (!SWIG_IsOK(res1)) { 13292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_terule_t_source_type" "', argument " "1"" of type '" "struct qpol_terule *""'"); 13293 } 13294 arg1 = (struct qpol_terule *)(argp1); 13295 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 13296 if (!SWIG_IsOK(res2)) { 13297 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_terule_t_source_type" "', argument " "2"" of type '" "qpol_policy_t *""'"); 13298 } 13299 arg2 = (qpol_policy_t *)(argp2); 13300 result = (qpol_type_t *)qpol_terule_source_type(arg1,arg2); 13301 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_type, 0 | 0 ); 13302 return resultobj; 13303 fail: 13304 return NULL; 13305 } 13306 13307 13308 SWIGINTERN PyObject *_wrap_qpol_terule_t_target_type(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 13309 PyObject *resultobj = 0; 13310 struct qpol_terule *arg1 = (struct qpol_terule *) 0 ; 13311 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 13312 void *argp1 = 0 ; 13313 int res1 = 0 ; 13314 void *argp2 = 0 ; 13315 int res2 = 0 ; 13316 PyObject * obj0 = 0 ; 13317 PyObject * obj1 = 0 ; 13318 qpol_type_t *result = 0 ; 13319 13320 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_terule_t_target_type",&obj0,&obj1)) SWIG_fail; 13321 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_terule, 0 | 0 ); 13322 if (!SWIG_IsOK(res1)) { 13323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_terule_t_target_type" "', argument " "1"" of type '" "struct qpol_terule *""'"); 13324 } 13325 arg1 = (struct qpol_terule *)(argp1); 13326 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 13327 if (!SWIG_IsOK(res2)) { 13328 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_terule_t_target_type" "', argument " "2"" of type '" "qpol_policy_t *""'"); 13329 } 13330 arg2 = (qpol_policy_t *)(argp2); 13331 result = (qpol_type_t *)qpol_terule_target_type(arg1,arg2); 13332 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_type, 0 | 0 ); 13333 return resultobj; 13334 fail: 13335 return NULL; 13336 } 13337 13338 13339 SWIGINTERN PyObject *_wrap_qpol_terule_t_object_class(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 13340 PyObject *resultobj = 0; 13341 struct qpol_terule *arg1 = (struct qpol_terule *) 0 ; 13342 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 13343 void *argp1 = 0 ; 13344 int res1 = 0 ; 13345 void *argp2 = 0 ; 13346 int res2 = 0 ; 13347 PyObject * obj0 = 0 ; 13348 PyObject * obj1 = 0 ; 13349 qpol_class_t *result = 0 ; 13350 13351 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_terule_t_object_class",&obj0,&obj1)) SWIG_fail; 13352 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_terule, 0 | 0 ); 13353 if (!SWIG_IsOK(res1)) { 13354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_terule_t_object_class" "', argument " "1"" of type '" "struct qpol_terule *""'"); 13355 } 13356 arg1 = (struct qpol_terule *)(argp1); 13357 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 13358 if (!SWIG_IsOK(res2)) { 13359 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_terule_t_object_class" "', argument " "2"" of type '" "qpol_policy_t *""'"); 13360 } 13361 arg2 = (qpol_policy_t *)(argp2); 13362 result = (qpol_class_t *)qpol_terule_object_class(arg1,arg2); 13363 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_class, 0 | 0 ); 13364 return resultobj; 13365 fail: 13366 return NULL; 13367 } 13368 13369 13370 SWIGINTERN PyObject *_wrap_qpol_terule_t_default_type(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 13371 PyObject *resultobj = 0; 13372 struct qpol_terule *arg1 = (struct qpol_terule *) 0 ; 13373 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 13374 void *argp1 = 0 ; 13375 int res1 = 0 ; 13376 void *argp2 = 0 ; 13377 int res2 = 0 ; 13378 PyObject * obj0 = 0 ; 13379 PyObject * obj1 = 0 ; 13380 qpol_type_t *result = 0 ; 13381 13382 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_terule_t_default_type",&obj0,&obj1)) SWIG_fail; 13383 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_terule, 0 | 0 ); 13384 if (!SWIG_IsOK(res1)) { 13385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_terule_t_default_type" "', argument " "1"" of type '" "struct qpol_terule *""'"); 13386 } 13387 arg1 = (struct qpol_terule *)(argp1); 13388 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 13389 if (!SWIG_IsOK(res2)) { 13390 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_terule_t_default_type" "', argument " "2"" of type '" "qpol_policy_t *""'"); 13391 } 13392 arg2 = (qpol_policy_t *)(argp2); 13393 result = (qpol_type_t *)qpol_terule_default_type(arg1,arg2); 13394 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_type, 0 | 0 ); 13395 return resultobj; 13396 fail: 13397 return NULL; 13398 } 13399 13400 13401 SWIGINTERN PyObject *_wrap_qpol_terule_t_cond(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 13402 PyObject *resultobj = 0; 13403 struct qpol_terule *arg1 = (struct qpol_terule *) 0 ; 13404 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 13405 void *argp1 = 0 ; 13406 int res1 = 0 ; 13407 void *argp2 = 0 ; 13408 int res2 = 0 ; 13409 PyObject * obj0 = 0 ; 13410 PyObject * obj1 = 0 ; 13411 qpol_cond_t *result = 0 ; 13412 13413 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_terule_t_cond",&obj0,&obj1)) SWIG_fail; 13414 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_terule, 0 | 0 ); 13415 if (!SWIG_IsOK(res1)) { 13416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_terule_t_cond" "', argument " "1"" of type '" "struct qpol_terule *""'"); 13417 } 13418 arg1 = (struct qpol_terule *)(argp1); 13419 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 13420 if (!SWIG_IsOK(res2)) { 13421 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_terule_t_cond" "', argument " "2"" of type '" "qpol_policy_t *""'"); 13422 } 13423 arg2 = (qpol_policy_t *)(argp2); 13424 { 13425 result = (qpol_cond_t *)qpol_terule_cond(arg1,arg2); 13426 if (!result) { 13427 PyErr_SetString(PyExc_AttributeError, "Rule is not conditional."); 13428 return NULL; 13429 } 13430 } 13431 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_cond, 0 | 0 ); 13432 return resultobj; 13433 fail: 13434 return NULL; 13435 } 13436 13437 13438 SWIGINTERN PyObject *_wrap_qpol_terule_t_is_enabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 13439 PyObject *resultobj = 0; 13440 struct qpol_terule *arg1 = (struct qpol_terule *) 0 ; 13441 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 13442 void *argp1 = 0 ; 13443 int res1 = 0 ; 13444 void *argp2 = 0 ; 13445 int res2 = 0 ; 13446 PyObject * obj0 = 0 ; 13447 PyObject * obj1 = 0 ; 13448 int result; 13449 13450 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_terule_t_is_enabled",&obj0,&obj1)) SWIG_fail; 13451 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_terule, 0 | 0 ); 13452 if (!SWIG_IsOK(res1)) { 13453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_terule_t_is_enabled" "', argument " "1"" of type '" "struct qpol_terule *""'"); 13454 } 13455 arg1 = (struct qpol_terule *)(argp1); 13456 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 13457 if (!SWIG_IsOK(res2)) { 13458 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_terule_t_is_enabled" "', argument " "2"" of type '" "qpol_policy_t *""'"); 13459 } 13460 arg2 = (qpol_policy_t *)(argp2); 13461 result = (int)qpol_terule_is_enabled(arg1,arg2); 13462 resultobj = SWIG_From_int((int)(result)); 13463 return resultobj; 13464 fail: 13465 return NULL; 13466 } 13467 13468 13469 SWIGINTERN PyObject *_wrap_qpol_terule_t_which_list(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 13470 PyObject *resultobj = 0; 13471 struct qpol_terule *arg1 = (struct qpol_terule *) 0 ; 13472 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 13473 void *argp1 = 0 ; 13474 int res1 = 0 ; 13475 void *argp2 = 0 ; 13476 int res2 = 0 ; 13477 PyObject * obj0 = 0 ; 13478 PyObject * obj1 = 0 ; 13479 int result; 13480 13481 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_terule_t_which_list",&obj0,&obj1)) SWIG_fail; 13482 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_terule, 0 | 0 ); 13483 if (!SWIG_IsOK(res1)) { 13484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_terule_t_which_list" "', argument " "1"" of type '" "struct qpol_terule *""'"); 13485 } 13486 arg1 = (struct qpol_terule *)(argp1); 13487 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 13488 if (!SWIG_IsOK(res2)) { 13489 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_terule_t_which_list" "', argument " "2"" of type '" "qpol_policy_t *""'"); 13490 } 13491 arg2 = (qpol_policy_t *)(argp2); 13492 { 13493 result = (int)qpol_terule_which_list(arg1,arg2); 13494 if (result < 0) { 13495 PyErr_SetString(PyExc_AttributeError, "Rule is not conditional."); 13496 return NULL; 13497 } 13498 } 13499 resultobj = SWIG_From_int((int)(result)); 13500 return resultobj; 13501 fail: 13502 return NULL; 13503 } 13504 13505 13506 SWIGINTERN PyObject *_wrap_qpol_terule_t_syn_terule_iter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 13507 PyObject *resultobj = 0; 13508 struct qpol_terule *arg1 = (struct qpol_terule *) 0 ; 13509 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 13510 void *argp1 = 0 ; 13511 int res1 = 0 ; 13512 void *argp2 = 0 ; 13513 int res2 = 0 ; 13514 PyObject * obj0 = 0 ; 13515 PyObject * obj1 = 0 ; 13516 qpol_iterator_t *result = 0 ; 13517 13518 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_terule_t_syn_terule_iter",&obj0,&obj1)) SWIG_fail; 13519 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_terule, 0 | 0 ); 13520 if (!SWIG_IsOK(res1)) { 13521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_terule_t_syn_terule_iter" "', argument " "1"" of type '" "struct qpol_terule *""'"); 13522 } 13523 arg1 = (struct qpol_terule *)(argp1); 13524 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 13525 if (!SWIG_IsOK(res2)) { 13526 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_terule_t_syn_terule_iter" "', argument " "2"" of type '" "qpol_policy_t *""'"); 13527 } 13528 arg2 = (qpol_policy_t *)(argp2); 13529 result = (qpol_iterator_t *)qpol_terule_syn_terule_iter(arg1,arg2); 13530 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_iterator, SWIG_POINTER_OWN | 0 ); 13531 return resultobj; 13532 fail: 13533 return NULL; 13534 } 13535 13536 13537 SWIGINTERN PyObject *qpol_terule_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 13538 PyObject *obj; 13539 if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; 13540 SWIG_TypeNewClientData(SWIGTYPE_p_qpol_terule, SWIG_NewClientData(obj)); 13541 return SWIG_Py_Void(); 13542 } 13543 13544 SWIGINTERN PyObject *_wrap_qpol_terule_from_void(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 13545 PyObject *resultobj = 0; 13546 void *arg1 = (void *) 0 ; 13547 int res1 ; 13548 PyObject * obj0 = 0 ; 13549 qpol_terule_t *result = 0 ; 13550 13551 if (!PyArg_ParseTuple(args,(char *)"O:qpol_terule_from_void",&obj0)) SWIG_fail; 13552 res1 = SWIG_ConvertPtr(obj0,SWIG_as_voidptrptr(&arg1), 0, 0); 13553 if (!SWIG_IsOK(res1)) { 13554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_terule_from_void" "', argument " "1"" of type '" "void *""'"); 13555 } 13556 result = (qpol_terule_t *)qpol_terule_from_void(arg1); 13557 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_terule, 0 | 0 ); 13558 return resultobj; 13559 fail: 13560 return NULL; 13561 } 13562 13563 13564 SWIGINTERN PyObject *_wrap_new_qpol_cond_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 13565 PyObject *resultobj = 0; 13566 struct qpol_cond *result = 0 ; 13567 13568 if (!PyArg_ParseTuple(args,(char *)":new_qpol_cond_t")) SWIG_fail; 13569 result = (struct qpol_cond *)new_qpol_cond(); 13570 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_cond, SWIG_POINTER_NEW | 0 ); 13571 return resultobj; 13572 fail: 13573 return NULL; 13574 } 13575 13576 13577 SWIGINTERN PyObject *_wrap_delete_qpol_cond_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 13578 PyObject *resultobj = 0; 13579 struct qpol_cond *arg1 = (struct qpol_cond *) 0 ; 13580 void *argp1 = 0 ; 13581 int res1 = 0 ; 13582 PyObject * obj0 = 0 ; 13583 13584 if (!PyArg_ParseTuple(args,(char *)"O:delete_qpol_cond_t",&obj0)) SWIG_fail; 13585 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_cond, SWIG_POINTER_DISOWN | 0 ); 13586 if (!SWIG_IsOK(res1)) { 13587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_qpol_cond_t" "', argument " "1"" of type '" "struct qpol_cond *""'"); 13588 } 13589 arg1 = (struct qpol_cond *)(argp1); 13590 delete_qpol_cond(arg1); 13591 resultobj = SWIG_Py_Void(); 13592 return resultobj; 13593 fail: 13594 return NULL; 13595 } 13596 13597 13598 SWIGINTERN PyObject *_wrap_qpol_cond_t_expr_node_iter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 13599 PyObject *resultobj = 0; 13600 struct qpol_cond *arg1 = (struct qpol_cond *) 0 ; 13601 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 13602 void *argp1 = 0 ; 13603 int res1 = 0 ; 13604 void *argp2 = 0 ; 13605 int res2 = 0 ; 13606 PyObject * obj0 = 0 ; 13607 PyObject * obj1 = 0 ; 13608 qpol_iterator_t *result = 0 ; 13609 13610 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_cond_t_expr_node_iter",&obj0,&obj1)) SWIG_fail; 13611 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_cond, 0 | 0 ); 13612 if (!SWIG_IsOK(res1)) { 13613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_cond_t_expr_node_iter" "', argument " "1"" of type '" "struct qpol_cond *""'"); 13614 } 13615 arg1 = (struct qpol_cond *)(argp1); 13616 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 13617 if (!SWIG_IsOK(res2)) { 13618 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_cond_t_expr_node_iter" "', argument " "2"" of type '" "qpol_policy_t *""'"); 13619 } 13620 arg2 = (qpol_policy_t *)(argp2); 13621 result = (qpol_iterator_t *)qpol_cond_expr_node_iter(arg1,arg2); 13622 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_iterator, SWIG_POINTER_OWN | 0 ); 13623 return resultobj; 13624 fail: 13625 return NULL; 13626 } 13627 13628 13629 SWIGINTERN PyObject *_wrap_qpol_cond_t_av_true_iter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 13630 PyObject *resultobj = 0; 13631 struct qpol_cond *arg1 = (struct qpol_cond *) 0 ; 13632 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 13633 int arg3 ; 13634 void *argp1 = 0 ; 13635 int res1 = 0 ; 13636 void *argp2 = 0 ; 13637 int res2 = 0 ; 13638 int val3 ; 13639 int ecode3 = 0 ; 13640 PyObject * obj0 = 0 ; 13641 PyObject * obj1 = 0 ; 13642 PyObject * obj2 = 0 ; 13643 qpol_iterator_t *result = 0 ; 13644 13645 if (!PyArg_ParseTuple(args,(char *)"OOO:qpol_cond_t_av_true_iter",&obj0,&obj1,&obj2)) SWIG_fail; 13646 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_cond, 0 | 0 ); 13647 if (!SWIG_IsOK(res1)) { 13648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_cond_t_av_true_iter" "', argument " "1"" of type '" "struct qpol_cond *""'"); 13649 } 13650 arg1 = (struct qpol_cond *)(argp1); 13651 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 13652 if (!SWIG_IsOK(res2)) { 13653 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_cond_t_av_true_iter" "', argument " "2"" of type '" "qpol_policy_t *""'"); 13654 } 13655 arg2 = (qpol_policy_t *)(argp2); 13656 ecode3 = SWIG_AsVal_int(obj2, &val3); 13657 if (!SWIG_IsOK(ecode3)) { 13658 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "qpol_cond_t_av_true_iter" "', argument " "3"" of type '" "int""'"); 13659 } 13660 arg3 = (int)(val3); 13661 result = (qpol_iterator_t *)qpol_cond_av_true_iter(arg1,arg2,arg3); 13662 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_iterator, SWIG_POINTER_OWN | 0 ); 13663 return resultobj; 13664 fail: 13665 return NULL; 13666 } 13667 13668 13669 SWIGINTERN PyObject *_wrap_qpol_cond_t_av_false_iter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 13670 PyObject *resultobj = 0; 13671 struct qpol_cond *arg1 = (struct qpol_cond *) 0 ; 13672 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 13673 int arg3 ; 13674 void *argp1 = 0 ; 13675 int res1 = 0 ; 13676 void *argp2 = 0 ; 13677 int res2 = 0 ; 13678 int val3 ; 13679 int ecode3 = 0 ; 13680 PyObject * obj0 = 0 ; 13681 PyObject * obj1 = 0 ; 13682 PyObject * obj2 = 0 ; 13683 qpol_iterator_t *result = 0 ; 13684 13685 if (!PyArg_ParseTuple(args,(char *)"OOO:qpol_cond_t_av_false_iter",&obj0,&obj1,&obj2)) SWIG_fail; 13686 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_cond, 0 | 0 ); 13687 if (!SWIG_IsOK(res1)) { 13688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_cond_t_av_false_iter" "', argument " "1"" of type '" "struct qpol_cond *""'"); 13689 } 13690 arg1 = (struct qpol_cond *)(argp1); 13691 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 13692 if (!SWIG_IsOK(res2)) { 13693 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_cond_t_av_false_iter" "', argument " "2"" of type '" "qpol_policy_t *""'"); 13694 } 13695 arg2 = (qpol_policy_t *)(argp2); 13696 ecode3 = SWIG_AsVal_int(obj2, &val3); 13697 if (!SWIG_IsOK(ecode3)) { 13698 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "qpol_cond_t_av_false_iter" "', argument " "3"" of type '" "int""'"); 13699 } 13700 arg3 = (int)(val3); 13701 result = (qpol_iterator_t *)qpol_cond_av_false_iter(arg1,arg2,arg3); 13702 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_iterator, SWIG_POINTER_OWN | 0 ); 13703 return resultobj; 13704 fail: 13705 return NULL; 13706 } 13707 13708 13709 SWIGINTERN PyObject *_wrap_qpol_cond_t_te_true_iter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 13710 PyObject *resultobj = 0; 13711 struct qpol_cond *arg1 = (struct qpol_cond *) 0 ; 13712 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 13713 int arg3 ; 13714 void *argp1 = 0 ; 13715 int res1 = 0 ; 13716 void *argp2 = 0 ; 13717 int res2 = 0 ; 13718 int val3 ; 13719 int ecode3 = 0 ; 13720 PyObject * obj0 = 0 ; 13721 PyObject * obj1 = 0 ; 13722 PyObject * obj2 = 0 ; 13723 qpol_iterator_t *result = 0 ; 13724 13725 if (!PyArg_ParseTuple(args,(char *)"OOO:qpol_cond_t_te_true_iter",&obj0,&obj1,&obj2)) SWIG_fail; 13726 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_cond, 0 | 0 ); 13727 if (!SWIG_IsOK(res1)) { 13728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_cond_t_te_true_iter" "', argument " "1"" of type '" "struct qpol_cond *""'"); 13729 } 13730 arg1 = (struct qpol_cond *)(argp1); 13731 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 13732 if (!SWIG_IsOK(res2)) { 13733 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_cond_t_te_true_iter" "', argument " "2"" of type '" "qpol_policy_t *""'"); 13734 } 13735 arg2 = (qpol_policy_t *)(argp2); 13736 ecode3 = SWIG_AsVal_int(obj2, &val3); 13737 if (!SWIG_IsOK(ecode3)) { 13738 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "qpol_cond_t_te_true_iter" "', argument " "3"" of type '" "int""'"); 13739 } 13740 arg3 = (int)(val3); 13741 result = (qpol_iterator_t *)qpol_cond_te_true_iter(arg1,arg2,arg3); 13742 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_iterator, SWIG_POINTER_OWN | 0 ); 13743 return resultobj; 13744 fail: 13745 return NULL; 13746 } 13747 13748 13749 SWIGINTERN PyObject *_wrap_qpol_cond_t_te_false_iter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 13750 PyObject *resultobj = 0; 13751 struct qpol_cond *arg1 = (struct qpol_cond *) 0 ; 13752 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 13753 int arg3 ; 13754 void *argp1 = 0 ; 13755 int res1 = 0 ; 13756 void *argp2 = 0 ; 13757 int res2 = 0 ; 13758 int val3 ; 13759 int ecode3 = 0 ; 13760 PyObject * obj0 = 0 ; 13761 PyObject * obj1 = 0 ; 13762 PyObject * obj2 = 0 ; 13763 qpol_iterator_t *result = 0 ; 13764 13765 if (!PyArg_ParseTuple(args,(char *)"OOO:qpol_cond_t_te_false_iter",&obj0,&obj1,&obj2)) SWIG_fail; 13766 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_cond, 0 | 0 ); 13767 if (!SWIG_IsOK(res1)) { 13768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_cond_t_te_false_iter" "', argument " "1"" of type '" "struct qpol_cond *""'"); 13769 } 13770 arg1 = (struct qpol_cond *)(argp1); 13771 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 13772 if (!SWIG_IsOK(res2)) { 13773 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_cond_t_te_false_iter" "', argument " "2"" of type '" "qpol_policy_t *""'"); 13774 } 13775 arg2 = (qpol_policy_t *)(argp2); 13776 ecode3 = SWIG_AsVal_int(obj2, &val3); 13777 if (!SWIG_IsOK(ecode3)) { 13778 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "qpol_cond_t_te_false_iter" "', argument " "3"" of type '" "int""'"); 13779 } 13780 arg3 = (int)(val3); 13781 result = (qpol_iterator_t *)qpol_cond_te_false_iter(arg1,arg2,arg3); 13782 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_iterator, SWIG_POINTER_OWN | 0 ); 13783 return resultobj; 13784 fail: 13785 return NULL; 13786 } 13787 13788 13789 SWIGINTERN PyObject *_wrap_qpol_cond_t_evaluate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 13790 PyObject *resultobj = 0; 13791 struct qpol_cond *arg1 = (struct qpol_cond *) 0 ; 13792 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 13793 void *argp1 = 0 ; 13794 int res1 = 0 ; 13795 void *argp2 = 0 ; 13796 int res2 = 0 ; 13797 PyObject * obj0 = 0 ; 13798 PyObject * obj1 = 0 ; 13799 int result; 13800 13801 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_cond_t_evaluate",&obj0,&obj1)) SWIG_fail; 13802 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_cond, 0 | 0 ); 13803 if (!SWIG_IsOK(res1)) { 13804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_cond_t_evaluate" "', argument " "1"" of type '" "struct qpol_cond *""'"); 13805 } 13806 arg1 = (struct qpol_cond *)(argp1); 13807 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 13808 if (!SWIG_IsOK(res2)) { 13809 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_cond_t_evaluate" "', argument " "2"" of type '" "qpol_policy_t *""'"); 13810 } 13811 arg2 = (qpol_policy_t *)(argp2); 13812 result = (int)qpol_cond_evaluate(arg1,arg2); 13813 resultobj = SWIG_From_int((int)(result)); 13814 return resultobj; 13815 fail: 13816 return NULL; 13817 } 13818 13819 13820 SWIGINTERN PyObject *qpol_cond_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 13821 PyObject *obj; 13822 if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; 13823 SWIG_TypeNewClientData(SWIGTYPE_p_qpol_cond, SWIG_NewClientData(obj)); 13824 return SWIG_Py_Void(); 13825 } 13826 13827 SWIGINTERN PyObject *_wrap_qpol_cond_from_void(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 13828 PyObject *resultobj = 0; 13829 void *arg1 = (void *) 0 ; 13830 int res1 ; 13831 PyObject * obj0 = 0 ; 13832 qpol_cond_t *result = 0 ; 13833 13834 if (!PyArg_ParseTuple(args,(char *)"O:qpol_cond_from_void",&obj0)) SWIG_fail; 13835 res1 = SWIG_ConvertPtr(obj0,SWIG_as_voidptrptr(&arg1), 0, 0); 13836 if (!SWIG_IsOK(res1)) { 13837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_cond_from_void" "', argument " "1"" of type '" "void *""'"); 13838 } 13839 result = (qpol_cond_t *)qpol_cond_from_void(arg1); 13840 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_cond, 0 | 0 ); 13841 return resultobj; 13842 fail: 13843 return NULL; 13844 } 13845 13846 13847 SWIGINTERN PyObject *_wrap_new_qpol_cond_expr_node_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 13848 PyObject *resultobj = 0; 13849 struct qpol_cond_expr_node *result = 0 ; 13850 13851 if (!PyArg_ParseTuple(args,(char *)":new_qpol_cond_expr_node_t")) SWIG_fail; 13852 result = (struct qpol_cond_expr_node *)new_qpol_cond_expr_node(); 13853 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_cond_expr_node, SWIG_POINTER_NEW | 0 ); 13854 return resultobj; 13855 fail: 13856 return NULL; 13857 } 13858 13859 13860 SWIGINTERN PyObject *_wrap_delete_qpol_cond_expr_node_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 13861 PyObject *resultobj = 0; 13862 struct qpol_cond_expr_node *arg1 = (struct qpol_cond_expr_node *) 0 ; 13863 void *argp1 = 0 ; 13864 int res1 = 0 ; 13865 PyObject * obj0 = 0 ; 13866 13867 if (!PyArg_ParseTuple(args,(char *)"O:delete_qpol_cond_expr_node_t",&obj0)) SWIG_fail; 13868 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_cond_expr_node, SWIG_POINTER_DISOWN | 0 ); 13869 if (!SWIG_IsOK(res1)) { 13870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_qpol_cond_expr_node_t" "', argument " "1"" of type '" "struct qpol_cond_expr_node *""'"); 13871 } 13872 arg1 = (struct qpol_cond_expr_node *)(argp1); 13873 delete_qpol_cond_expr_node(arg1); 13874 resultobj = SWIG_Py_Void(); 13875 return resultobj; 13876 fail: 13877 return NULL; 13878 } 13879 13880 13881 SWIGINTERN PyObject *_wrap_qpol_cond_expr_node_t_expr_type(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 13882 PyObject *resultobj = 0; 13883 struct qpol_cond_expr_node *arg1 = (struct qpol_cond_expr_node *) 0 ; 13884 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 13885 void *argp1 = 0 ; 13886 int res1 = 0 ; 13887 void *argp2 = 0 ; 13888 int res2 = 0 ; 13889 PyObject * obj0 = 0 ; 13890 PyObject * obj1 = 0 ; 13891 int result; 13892 13893 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_cond_expr_node_t_expr_type",&obj0,&obj1)) SWIG_fail; 13894 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_cond_expr_node, 0 | 0 ); 13895 if (!SWIG_IsOK(res1)) { 13896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_cond_expr_node_t_expr_type" "', argument " "1"" of type '" "struct qpol_cond_expr_node *""'"); 13897 } 13898 arg1 = (struct qpol_cond_expr_node *)(argp1); 13899 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 13900 if (!SWIG_IsOK(res2)) { 13901 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_cond_expr_node_t_expr_type" "', argument " "2"" of type '" "qpol_policy_t *""'"); 13902 } 13903 arg2 = (qpol_policy_t *)(argp2); 13904 result = (int)qpol_cond_expr_node_expr_type(arg1,arg2); 13905 resultobj = SWIG_From_int((int)(result)); 13906 return resultobj; 13907 fail: 13908 return NULL; 13909 } 13910 13911 13912 SWIGINTERN PyObject *_wrap_qpol_cond_expr_node_t_get_boolean(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 13913 PyObject *resultobj = 0; 13914 struct qpol_cond_expr_node *arg1 = (struct qpol_cond_expr_node *) 0 ; 13915 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 13916 void *argp1 = 0 ; 13917 int res1 = 0 ; 13918 void *argp2 = 0 ; 13919 int res2 = 0 ; 13920 PyObject * obj0 = 0 ; 13921 PyObject * obj1 = 0 ; 13922 qpol_bool_t *result = 0 ; 13923 13924 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_cond_expr_node_t_get_boolean",&obj0,&obj1)) SWIG_fail; 13925 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_cond_expr_node, 0 | 0 ); 13926 if (!SWIG_IsOK(res1)) { 13927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_cond_expr_node_t_get_boolean" "', argument " "1"" of type '" "struct qpol_cond_expr_node *""'"); 13928 } 13929 arg1 = (struct qpol_cond_expr_node *)(argp1); 13930 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 13931 if (!SWIG_IsOK(res2)) { 13932 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_cond_expr_node_t_get_boolean" "', argument " "2"" of type '" "qpol_policy_t *""'"); 13933 } 13934 arg2 = (qpol_policy_t *)(argp2); 13935 result = (qpol_bool_t *)qpol_cond_expr_node_get_boolean(arg1,arg2); 13936 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_bool, 0 | 0 ); 13937 return resultobj; 13938 fail: 13939 return NULL; 13940 } 13941 13942 13943 SWIGINTERN PyObject *qpol_cond_expr_node_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 13944 PyObject *obj; 13945 if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; 13946 SWIG_TypeNewClientData(SWIGTYPE_p_qpol_cond_expr_node, SWIG_NewClientData(obj)); 13947 return SWIG_Py_Void(); 13948 } 13949 13950 SWIGINTERN PyObject *_wrap_qpol_cond_expr_node_from_void(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 13951 PyObject *resultobj = 0; 13952 void *arg1 = (void *) 0 ; 13953 int res1 ; 13954 PyObject * obj0 = 0 ; 13955 qpol_cond_expr_node_t *result = 0 ; 13956 13957 if (!PyArg_ParseTuple(args,(char *)"O:qpol_cond_expr_node_from_void",&obj0)) SWIG_fail; 13958 res1 = SWIG_ConvertPtr(obj0,SWIG_as_voidptrptr(&arg1), 0, 0); 13959 if (!SWIG_IsOK(res1)) { 13960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_cond_expr_node_from_void" "', argument " "1"" of type '" "void *""'"); 13961 } 13962 result = (qpol_cond_expr_node_t *)qpol_cond_expr_node_from_void(arg1); 13963 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_cond_expr_node, 0 | 0 ); 13964 return resultobj; 13965 fail: 13966 return NULL; 13967 } 13968 13969 13970 SWIGINTERN PyObject *_wrap_new_qpol_filename_trans_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 13971 PyObject *resultobj = 0; 13972 struct qpol_filename_trans *result = 0 ; 13973 13974 if (!PyArg_ParseTuple(args,(char *)":new_qpol_filename_trans_t")) SWIG_fail; 13975 result = (struct qpol_filename_trans *)new_qpol_filename_trans(); 13976 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_filename_trans, SWIG_POINTER_NEW | 0 ); 13977 return resultobj; 13978 fail: 13979 return NULL; 13980 } 13981 13982 13983 SWIGINTERN PyObject *_wrap_delete_qpol_filename_trans_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 13984 PyObject *resultobj = 0; 13985 struct qpol_filename_trans *arg1 = (struct qpol_filename_trans *) 0 ; 13986 void *argp1 = 0 ; 13987 int res1 = 0 ; 13988 PyObject * obj0 = 0 ; 13989 13990 if (!PyArg_ParseTuple(args,(char *)"O:delete_qpol_filename_trans_t",&obj0)) SWIG_fail; 13991 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_filename_trans, SWIG_POINTER_DISOWN | 0 ); 13992 if (!SWIG_IsOK(res1)) { 13993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_qpol_filename_trans_t" "', argument " "1"" of type '" "struct qpol_filename_trans *""'"); 13994 } 13995 arg1 = (struct qpol_filename_trans *)(argp1); 13996 delete_qpol_filename_trans(arg1); 13997 resultobj = SWIG_Py_Void(); 13998 return resultobj; 13999 fail: 14000 return NULL; 14001 } 14002 14003 14004 SWIGINTERN PyObject *_wrap_qpol_filename_trans_t_source_type(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 14005 PyObject *resultobj = 0; 14006 struct qpol_filename_trans *arg1 = (struct qpol_filename_trans *) 0 ; 14007 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 14008 void *argp1 = 0 ; 14009 int res1 = 0 ; 14010 void *argp2 = 0 ; 14011 int res2 = 0 ; 14012 PyObject * obj0 = 0 ; 14013 PyObject * obj1 = 0 ; 14014 qpol_type_t *result = 0 ; 14015 14016 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_filename_trans_t_source_type",&obj0,&obj1)) SWIG_fail; 14017 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_filename_trans, 0 | 0 ); 14018 if (!SWIG_IsOK(res1)) { 14019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_filename_trans_t_source_type" "', argument " "1"" of type '" "struct qpol_filename_trans *""'"); 14020 } 14021 arg1 = (struct qpol_filename_trans *)(argp1); 14022 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 14023 if (!SWIG_IsOK(res2)) { 14024 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_filename_trans_t_source_type" "', argument " "2"" of type '" "qpol_policy_t *""'"); 14025 } 14026 arg2 = (qpol_policy_t *)(argp2); 14027 result = (qpol_type_t *)qpol_filename_trans_source_type(arg1,arg2); 14028 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_type, 0 | 0 ); 14029 return resultobj; 14030 fail: 14031 return NULL; 14032 } 14033 14034 14035 SWIGINTERN PyObject *_wrap_qpol_filename_trans_t_target_type(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 14036 PyObject *resultobj = 0; 14037 struct qpol_filename_trans *arg1 = (struct qpol_filename_trans *) 0 ; 14038 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 14039 void *argp1 = 0 ; 14040 int res1 = 0 ; 14041 void *argp2 = 0 ; 14042 int res2 = 0 ; 14043 PyObject * obj0 = 0 ; 14044 PyObject * obj1 = 0 ; 14045 qpol_type_t *result = 0 ; 14046 14047 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_filename_trans_t_target_type",&obj0,&obj1)) SWIG_fail; 14048 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_filename_trans, 0 | 0 ); 14049 if (!SWIG_IsOK(res1)) { 14050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_filename_trans_t_target_type" "', argument " "1"" of type '" "struct qpol_filename_trans *""'"); 14051 } 14052 arg1 = (struct qpol_filename_trans *)(argp1); 14053 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 14054 if (!SWIG_IsOK(res2)) { 14055 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_filename_trans_t_target_type" "', argument " "2"" of type '" "qpol_policy_t *""'"); 14056 } 14057 arg2 = (qpol_policy_t *)(argp2); 14058 result = (qpol_type_t *)qpol_filename_trans_target_type(arg1,arg2); 14059 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_type, 0 | 0 ); 14060 return resultobj; 14061 fail: 14062 return NULL; 14063 } 14064 14065 14066 SWIGINTERN PyObject *_wrap_qpol_filename_trans_t_object_class(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 14067 PyObject *resultobj = 0; 14068 struct qpol_filename_trans *arg1 = (struct qpol_filename_trans *) 0 ; 14069 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 14070 void *argp1 = 0 ; 14071 int res1 = 0 ; 14072 void *argp2 = 0 ; 14073 int res2 = 0 ; 14074 PyObject * obj0 = 0 ; 14075 PyObject * obj1 = 0 ; 14076 qpol_class_t *result = 0 ; 14077 14078 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_filename_trans_t_object_class",&obj0,&obj1)) SWIG_fail; 14079 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_filename_trans, 0 | 0 ); 14080 if (!SWIG_IsOK(res1)) { 14081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_filename_trans_t_object_class" "', argument " "1"" of type '" "struct qpol_filename_trans *""'"); 14082 } 14083 arg1 = (struct qpol_filename_trans *)(argp1); 14084 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 14085 if (!SWIG_IsOK(res2)) { 14086 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_filename_trans_t_object_class" "', argument " "2"" of type '" "qpol_policy_t *""'"); 14087 } 14088 arg2 = (qpol_policy_t *)(argp2); 14089 result = (qpol_class_t *)qpol_filename_trans_object_class(arg1,arg2); 14090 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_class, 0 | 0 ); 14091 return resultobj; 14092 fail: 14093 return NULL; 14094 } 14095 14096 14097 SWIGINTERN PyObject *_wrap_qpol_filename_trans_t_default_type(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 14098 PyObject *resultobj = 0; 14099 struct qpol_filename_trans *arg1 = (struct qpol_filename_trans *) 0 ; 14100 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 14101 void *argp1 = 0 ; 14102 int res1 = 0 ; 14103 void *argp2 = 0 ; 14104 int res2 = 0 ; 14105 PyObject * obj0 = 0 ; 14106 PyObject * obj1 = 0 ; 14107 qpol_type_t *result = 0 ; 14108 14109 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_filename_trans_t_default_type",&obj0,&obj1)) SWIG_fail; 14110 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_filename_trans, 0 | 0 ); 14111 if (!SWIG_IsOK(res1)) { 14112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_filename_trans_t_default_type" "', argument " "1"" of type '" "struct qpol_filename_trans *""'"); 14113 } 14114 arg1 = (struct qpol_filename_trans *)(argp1); 14115 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 14116 if (!SWIG_IsOK(res2)) { 14117 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_filename_trans_t_default_type" "', argument " "2"" of type '" "qpol_policy_t *""'"); 14118 } 14119 arg2 = (qpol_policy_t *)(argp2); 14120 result = (qpol_type_t *)qpol_filename_trans_default_type(arg1,arg2); 14121 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_type, 0 | 0 ); 14122 return resultobj; 14123 fail: 14124 return NULL; 14125 } 14126 14127 14128 SWIGINTERN PyObject *_wrap_qpol_filename_trans_t_filename(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 14129 PyObject *resultobj = 0; 14130 struct qpol_filename_trans *arg1 = (struct qpol_filename_trans *) 0 ; 14131 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 14132 void *argp1 = 0 ; 14133 int res1 = 0 ; 14134 void *argp2 = 0 ; 14135 int res2 = 0 ; 14136 PyObject * obj0 = 0 ; 14137 PyObject * obj1 = 0 ; 14138 char *result = 0 ; 14139 14140 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_filename_trans_t_filename",&obj0,&obj1)) SWIG_fail; 14141 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_filename_trans, 0 | 0 ); 14142 if (!SWIG_IsOK(res1)) { 14143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_filename_trans_t_filename" "', argument " "1"" of type '" "struct qpol_filename_trans *""'"); 14144 } 14145 arg1 = (struct qpol_filename_trans *)(argp1); 14146 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 14147 if (!SWIG_IsOK(res2)) { 14148 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_filename_trans_t_filename" "', argument " "2"" of type '" "qpol_policy_t *""'"); 14149 } 14150 arg2 = (qpol_policy_t *)(argp2); 14151 result = (char *)qpol_filename_trans_filename(arg1,arg2); 14152 resultobj = SWIG_FromCharPtr((const char *)result); 14153 return resultobj; 14154 fail: 14155 return NULL; 14156 } 14157 14158 14159 SWIGINTERN PyObject *qpol_filename_trans_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 14160 PyObject *obj; 14161 if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; 14162 SWIG_TypeNewClientData(SWIGTYPE_p_qpol_filename_trans, SWIG_NewClientData(obj)); 14163 return SWIG_Py_Void(); 14164 } 14165 14166 SWIGINTERN PyObject *_wrap_qpol_filename_trans_from_void(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 14167 PyObject *resultobj = 0; 14168 void *arg1 = (void *) 0 ; 14169 int res1 ; 14170 PyObject * obj0 = 0 ; 14171 qpol_filename_trans_t *result = 0 ; 14172 14173 if (!PyArg_ParseTuple(args,(char *)"O:qpol_filename_trans_from_void",&obj0)) SWIG_fail; 14174 res1 = SWIG_ConvertPtr(obj0,SWIG_as_voidptrptr(&arg1), 0, 0); 14175 if (!SWIG_IsOK(res1)) { 14176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_filename_trans_from_void" "', argument " "1"" of type '" "void *""'"); 14177 } 14178 result = (qpol_filename_trans_t *)qpol_filename_trans_from_void(arg1); 14179 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_filename_trans, 0 | 0 ); 14180 return resultobj; 14181 fail: 14182 return NULL; 14183 } 14184 14185 14186 SWIGINTERN PyObject *_wrap_new_qpol_polcap_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 14187 PyObject *resultobj = 0; 14188 struct qpol_polcap *result = 0 ; 14189 14190 if (!PyArg_ParseTuple(args,(char *)":new_qpol_polcap_t")) SWIG_fail; 14191 result = (struct qpol_polcap *)new_qpol_polcap(); 14192 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_polcap, SWIG_POINTER_NEW | 0 ); 14193 return resultobj; 14194 fail: 14195 return NULL; 14196 } 14197 14198 14199 SWIGINTERN PyObject *_wrap_delete_qpol_polcap_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 14200 PyObject *resultobj = 0; 14201 struct qpol_polcap *arg1 = (struct qpol_polcap *) 0 ; 14202 void *argp1 = 0 ; 14203 int res1 = 0 ; 14204 PyObject * obj0 = 0 ; 14205 14206 if (!PyArg_ParseTuple(args,(char *)"O:delete_qpol_polcap_t",&obj0)) SWIG_fail; 14207 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_polcap, SWIG_POINTER_DISOWN | 0 ); 14208 if (!SWIG_IsOK(res1)) { 14209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_qpol_polcap_t" "', argument " "1"" of type '" "struct qpol_polcap *""'"); 14210 } 14211 arg1 = (struct qpol_polcap *)(argp1); 14212 delete_qpol_polcap(arg1); 14213 resultobj = SWIG_Py_Void(); 14214 return resultobj; 14215 fail: 14216 return NULL; 14217 } 14218 14219 14220 SWIGINTERN PyObject *_wrap_qpol_polcap_t_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 14221 PyObject *resultobj = 0; 14222 struct qpol_polcap *arg1 = (struct qpol_polcap *) 0 ; 14223 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 14224 void *argp1 = 0 ; 14225 int res1 = 0 ; 14226 void *argp2 = 0 ; 14227 int res2 = 0 ; 14228 PyObject * obj0 = 0 ; 14229 PyObject * obj1 = 0 ; 14230 char *result = 0 ; 14231 14232 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_polcap_t_name",&obj0,&obj1)) SWIG_fail; 14233 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_polcap, 0 | 0 ); 14234 if (!SWIG_IsOK(res1)) { 14235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_polcap_t_name" "', argument " "1"" of type '" "struct qpol_polcap *""'"); 14236 } 14237 arg1 = (struct qpol_polcap *)(argp1); 14238 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 14239 if (!SWIG_IsOK(res2)) { 14240 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_polcap_t_name" "', argument " "2"" of type '" "qpol_policy_t *""'"); 14241 } 14242 arg2 = (qpol_policy_t *)(argp2); 14243 result = (char *)qpol_polcap_name(arg1,arg2); 14244 resultobj = SWIG_FromCharPtr((const char *)result); 14245 return resultobj; 14246 fail: 14247 return NULL; 14248 } 14249 14250 14251 SWIGINTERN PyObject *qpol_polcap_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 14252 PyObject *obj; 14253 if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; 14254 SWIG_TypeNewClientData(SWIGTYPE_p_qpol_polcap, SWIG_NewClientData(obj)); 14255 return SWIG_Py_Void(); 14256 } 14257 14258 SWIGINTERN PyObject *_wrap_qpol_polcap_from_void(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 14259 PyObject *resultobj = 0; 14260 void *arg1 = (void *) 0 ; 14261 int res1 ; 14262 PyObject * obj0 = 0 ; 14263 qpol_polcap_t *result = 0 ; 14264 14265 if (!PyArg_ParseTuple(args,(char *)"O:qpol_polcap_from_void",&obj0)) SWIG_fail; 14266 res1 = SWIG_ConvertPtr(obj0,SWIG_as_voidptrptr(&arg1), 0, 0); 14267 if (!SWIG_IsOK(res1)) { 14268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_polcap_from_void" "', argument " "1"" of type '" "void *""'"); 14269 } 14270 result = (qpol_polcap_t *)qpol_polcap_from_void(arg1); 14271 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_polcap, 0 | 0 ); 14272 return resultobj; 14273 fail: 14274 return NULL; 14275 } 14276 14277 14278 SWIGINTERN PyObject *_wrap_new_qpol_typebounds_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 14279 PyObject *resultobj = 0; 14280 struct qpol_typebounds *result = 0 ; 14281 14282 if (!PyArg_ParseTuple(args,(char *)":new_qpol_typebounds_t")) SWIG_fail; 14283 result = (struct qpol_typebounds *)new_qpol_typebounds(); 14284 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_typebounds, SWIG_POINTER_NEW | 0 ); 14285 return resultobj; 14286 fail: 14287 return NULL; 14288 } 14289 14290 14291 SWIGINTERN PyObject *_wrap_delete_qpol_typebounds_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 14292 PyObject *resultobj = 0; 14293 struct qpol_typebounds *arg1 = (struct qpol_typebounds *) 0 ; 14294 void *argp1 = 0 ; 14295 int res1 = 0 ; 14296 PyObject * obj0 = 0 ; 14297 14298 if (!PyArg_ParseTuple(args,(char *)"O:delete_qpol_typebounds_t",&obj0)) SWIG_fail; 14299 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_typebounds, SWIG_POINTER_DISOWN | 0 ); 14300 if (!SWIG_IsOK(res1)) { 14301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_qpol_typebounds_t" "', argument " "1"" of type '" "struct qpol_typebounds *""'"); 14302 } 14303 arg1 = (struct qpol_typebounds *)(argp1); 14304 delete_qpol_typebounds(arg1); 14305 resultobj = SWIG_Py_Void(); 14306 return resultobj; 14307 fail: 14308 return NULL; 14309 } 14310 14311 14312 SWIGINTERN PyObject *_wrap_qpol_typebounds_t_parent_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 14313 PyObject *resultobj = 0; 14314 struct qpol_typebounds *arg1 = (struct qpol_typebounds *) 0 ; 14315 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 14316 void *argp1 = 0 ; 14317 int res1 = 0 ; 14318 void *argp2 = 0 ; 14319 int res2 = 0 ; 14320 PyObject * obj0 = 0 ; 14321 PyObject * obj1 = 0 ; 14322 char *result = 0 ; 14323 14324 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_typebounds_t_parent_name",&obj0,&obj1)) SWIG_fail; 14325 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_typebounds, 0 | 0 ); 14326 if (!SWIG_IsOK(res1)) { 14327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_typebounds_t_parent_name" "', argument " "1"" of type '" "struct qpol_typebounds *""'"); 14328 } 14329 arg1 = (struct qpol_typebounds *)(argp1); 14330 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 14331 if (!SWIG_IsOK(res2)) { 14332 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_typebounds_t_parent_name" "', argument " "2"" of type '" "qpol_policy_t *""'"); 14333 } 14334 arg2 = (qpol_policy_t *)(argp2); 14335 result = (char *)qpol_typebounds_parent_name(arg1,arg2); 14336 resultobj = SWIG_FromCharPtr((const char *)result); 14337 return resultobj; 14338 fail: 14339 return NULL; 14340 } 14341 14342 14343 SWIGINTERN PyObject *_wrap_qpol_typebounds_t_child_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 14344 PyObject *resultobj = 0; 14345 struct qpol_typebounds *arg1 = (struct qpol_typebounds *) 0 ; 14346 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 14347 void *argp1 = 0 ; 14348 int res1 = 0 ; 14349 void *argp2 = 0 ; 14350 int res2 = 0 ; 14351 PyObject * obj0 = 0 ; 14352 PyObject * obj1 = 0 ; 14353 char *result = 0 ; 14354 14355 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_typebounds_t_child_name",&obj0,&obj1)) SWIG_fail; 14356 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_typebounds, 0 | 0 ); 14357 if (!SWIG_IsOK(res1)) { 14358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_typebounds_t_child_name" "', argument " "1"" of type '" "struct qpol_typebounds *""'"); 14359 } 14360 arg1 = (struct qpol_typebounds *)(argp1); 14361 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 14362 if (!SWIG_IsOK(res2)) { 14363 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_typebounds_t_child_name" "', argument " "2"" of type '" "qpol_policy_t *""'"); 14364 } 14365 arg2 = (qpol_policy_t *)(argp2); 14366 result = (char *)qpol_typebounds_child_name(arg1,arg2); 14367 resultobj = SWIG_FromCharPtr((const char *)result); 14368 return resultobj; 14369 fail: 14370 return NULL; 14371 } 14372 14373 14374 SWIGINTERN PyObject *qpol_typebounds_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 14375 PyObject *obj; 14376 if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; 14377 SWIG_TypeNewClientData(SWIGTYPE_p_qpol_typebounds, SWIG_NewClientData(obj)); 14378 return SWIG_Py_Void(); 14379 } 14380 14381 SWIGINTERN PyObject *_wrap_qpol_typebounds_from_void(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 14382 PyObject *resultobj = 0; 14383 void *arg1 = (void *) 0 ; 14384 int res1 ; 14385 PyObject * obj0 = 0 ; 14386 qpol_typebounds_t *result = 0 ; 14387 14388 if (!PyArg_ParseTuple(args,(char *)"O:qpol_typebounds_from_void",&obj0)) SWIG_fail; 14389 res1 = SWIG_ConvertPtr(obj0,SWIG_as_voidptrptr(&arg1), 0, 0); 14390 if (!SWIG_IsOK(res1)) { 14391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_typebounds_from_void" "', argument " "1"" of type '" "void *""'"); 14392 } 14393 result = (qpol_typebounds_t *)qpol_typebounds_from_void(arg1); 14394 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_typebounds, 0 | 0 ); 14395 return resultobj; 14396 fail: 14397 return NULL; 14398 } 14399 14400 14401 SWIGINTERN PyObject *_wrap_new_qpol_rolebounds_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 14402 PyObject *resultobj = 0; 14403 struct qpol_rolebounds *result = 0 ; 14404 14405 if (!PyArg_ParseTuple(args,(char *)":new_qpol_rolebounds_t")) SWIG_fail; 14406 result = (struct qpol_rolebounds *)new_qpol_rolebounds(); 14407 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_rolebounds, SWIG_POINTER_NEW | 0 ); 14408 return resultobj; 14409 fail: 14410 return NULL; 14411 } 14412 14413 14414 SWIGINTERN PyObject *_wrap_delete_qpol_rolebounds_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 14415 PyObject *resultobj = 0; 14416 struct qpol_rolebounds *arg1 = (struct qpol_rolebounds *) 0 ; 14417 void *argp1 = 0 ; 14418 int res1 = 0 ; 14419 PyObject * obj0 = 0 ; 14420 14421 if (!PyArg_ParseTuple(args,(char *)"O:delete_qpol_rolebounds_t",&obj0)) SWIG_fail; 14422 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_rolebounds, SWIG_POINTER_DISOWN | 0 ); 14423 if (!SWIG_IsOK(res1)) { 14424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_qpol_rolebounds_t" "', argument " "1"" of type '" "struct qpol_rolebounds *""'"); 14425 } 14426 arg1 = (struct qpol_rolebounds *)(argp1); 14427 delete_qpol_rolebounds(arg1); 14428 resultobj = SWIG_Py_Void(); 14429 return resultobj; 14430 fail: 14431 return NULL; 14432 } 14433 14434 14435 SWIGINTERN PyObject *_wrap_qpol_rolebounds_t_parent_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 14436 PyObject *resultobj = 0; 14437 struct qpol_rolebounds *arg1 = (struct qpol_rolebounds *) 0 ; 14438 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 14439 void *argp1 = 0 ; 14440 int res1 = 0 ; 14441 void *argp2 = 0 ; 14442 int res2 = 0 ; 14443 PyObject * obj0 = 0 ; 14444 PyObject * obj1 = 0 ; 14445 char *result = 0 ; 14446 14447 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_rolebounds_t_parent_name",&obj0,&obj1)) SWIG_fail; 14448 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_rolebounds, 0 | 0 ); 14449 if (!SWIG_IsOK(res1)) { 14450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_rolebounds_t_parent_name" "', argument " "1"" of type '" "struct qpol_rolebounds *""'"); 14451 } 14452 arg1 = (struct qpol_rolebounds *)(argp1); 14453 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 14454 if (!SWIG_IsOK(res2)) { 14455 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_rolebounds_t_parent_name" "', argument " "2"" of type '" "qpol_policy_t *""'"); 14456 } 14457 arg2 = (qpol_policy_t *)(argp2); 14458 result = (char *)qpol_rolebounds_parent_name(arg1,arg2); 14459 resultobj = SWIG_FromCharPtr((const char *)result); 14460 return resultobj; 14461 fail: 14462 return NULL; 14463 } 14464 14465 14466 SWIGINTERN PyObject *_wrap_qpol_rolebounds_t_child_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 14467 PyObject *resultobj = 0; 14468 struct qpol_rolebounds *arg1 = (struct qpol_rolebounds *) 0 ; 14469 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 14470 void *argp1 = 0 ; 14471 int res1 = 0 ; 14472 void *argp2 = 0 ; 14473 int res2 = 0 ; 14474 PyObject * obj0 = 0 ; 14475 PyObject * obj1 = 0 ; 14476 char *result = 0 ; 14477 14478 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_rolebounds_t_child_name",&obj0,&obj1)) SWIG_fail; 14479 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_rolebounds, 0 | 0 ); 14480 if (!SWIG_IsOK(res1)) { 14481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_rolebounds_t_child_name" "', argument " "1"" of type '" "struct qpol_rolebounds *""'"); 14482 } 14483 arg1 = (struct qpol_rolebounds *)(argp1); 14484 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 14485 if (!SWIG_IsOK(res2)) { 14486 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_rolebounds_t_child_name" "', argument " "2"" of type '" "qpol_policy_t *""'"); 14487 } 14488 arg2 = (qpol_policy_t *)(argp2); 14489 result = (char *)qpol_rolebounds_child_name(arg1,arg2); 14490 resultobj = SWIG_FromCharPtr((const char *)result); 14491 return resultobj; 14492 fail: 14493 return NULL; 14494 } 14495 14496 14497 SWIGINTERN PyObject *qpol_rolebounds_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 14498 PyObject *obj; 14499 if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; 14500 SWIG_TypeNewClientData(SWIGTYPE_p_qpol_rolebounds, SWIG_NewClientData(obj)); 14501 return SWIG_Py_Void(); 14502 } 14503 14504 SWIGINTERN PyObject *_wrap_qpol_rolebounds_from_void(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 14505 PyObject *resultobj = 0; 14506 void *arg1 = (void *) 0 ; 14507 int res1 ; 14508 PyObject * obj0 = 0 ; 14509 qpol_rolebounds_t *result = 0 ; 14510 14511 if (!PyArg_ParseTuple(args,(char *)"O:qpol_rolebounds_from_void",&obj0)) SWIG_fail; 14512 res1 = SWIG_ConvertPtr(obj0,SWIG_as_voidptrptr(&arg1), 0, 0); 14513 if (!SWIG_IsOK(res1)) { 14514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_rolebounds_from_void" "', argument " "1"" of type '" "void *""'"); 14515 } 14516 result = (qpol_rolebounds_t *)qpol_rolebounds_from_void(arg1); 14517 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_rolebounds, 0 | 0 ); 14518 return resultobj; 14519 fail: 14520 return NULL; 14521 } 14522 14523 14524 SWIGINTERN PyObject *_wrap_new_qpol_userbounds_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 14525 PyObject *resultobj = 0; 14526 struct qpol_userbounds *result = 0 ; 14527 14528 if (!PyArg_ParseTuple(args,(char *)":new_qpol_userbounds_t")) SWIG_fail; 14529 result = (struct qpol_userbounds *)new_qpol_userbounds(); 14530 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_userbounds, SWIG_POINTER_NEW | 0 ); 14531 return resultobj; 14532 fail: 14533 return NULL; 14534 } 14535 14536 14537 SWIGINTERN PyObject *_wrap_delete_qpol_userbounds_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 14538 PyObject *resultobj = 0; 14539 struct qpol_userbounds *arg1 = (struct qpol_userbounds *) 0 ; 14540 void *argp1 = 0 ; 14541 int res1 = 0 ; 14542 PyObject * obj0 = 0 ; 14543 14544 if (!PyArg_ParseTuple(args,(char *)"O:delete_qpol_userbounds_t",&obj0)) SWIG_fail; 14545 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_userbounds, SWIG_POINTER_DISOWN | 0 ); 14546 if (!SWIG_IsOK(res1)) { 14547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_qpol_userbounds_t" "', argument " "1"" of type '" "struct qpol_userbounds *""'"); 14548 } 14549 arg1 = (struct qpol_userbounds *)(argp1); 14550 delete_qpol_userbounds(arg1); 14551 resultobj = SWIG_Py_Void(); 14552 return resultobj; 14553 fail: 14554 return NULL; 14555 } 14556 14557 14558 SWIGINTERN PyObject *_wrap_qpol_userbounds_t_parent_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 14559 PyObject *resultobj = 0; 14560 struct qpol_userbounds *arg1 = (struct qpol_userbounds *) 0 ; 14561 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 14562 void *argp1 = 0 ; 14563 int res1 = 0 ; 14564 void *argp2 = 0 ; 14565 int res2 = 0 ; 14566 PyObject * obj0 = 0 ; 14567 PyObject * obj1 = 0 ; 14568 char *result = 0 ; 14569 14570 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_userbounds_t_parent_name",&obj0,&obj1)) SWIG_fail; 14571 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_userbounds, 0 | 0 ); 14572 if (!SWIG_IsOK(res1)) { 14573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_userbounds_t_parent_name" "', argument " "1"" of type '" "struct qpol_userbounds *""'"); 14574 } 14575 arg1 = (struct qpol_userbounds *)(argp1); 14576 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 14577 if (!SWIG_IsOK(res2)) { 14578 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_userbounds_t_parent_name" "', argument " "2"" of type '" "qpol_policy_t *""'"); 14579 } 14580 arg2 = (qpol_policy_t *)(argp2); 14581 result = (char *)qpol_userbounds_parent_name(arg1,arg2); 14582 resultobj = SWIG_FromCharPtr((const char *)result); 14583 return resultobj; 14584 fail: 14585 return NULL; 14586 } 14587 14588 14589 SWIGINTERN PyObject *_wrap_qpol_userbounds_t_child_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 14590 PyObject *resultobj = 0; 14591 struct qpol_userbounds *arg1 = (struct qpol_userbounds *) 0 ; 14592 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 14593 void *argp1 = 0 ; 14594 int res1 = 0 ; 14595 void *argp2 = 0 ; 14596 int res2 = 0 ; 14597 PyObject * obj0 = 0 ; 14598 PyObject * obj1 = 0 ; 14599 char *result = 0 ; 14600 14601 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_userbounds_t_child_name",&obj0,&obj1)) SWIG_fail; 14602 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_userbounds, 0 | 0 ); 14603 if (!SWIG_IsOK(res1)) { 14604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_userbounds_t_child_name" "', argument " "1"" of type '" "struct qpol_userbounds *""'"); 14605 } 14606 arg1 = (struct qpol_userbounds *)(argp1); 14607 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 14608 if (!SWIG_IsOK(res2)) { 14609 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_userbounds_t_child_name" "', argument " "2"" of type '" "qpol_policy_t *""'"); 14610 } 14611 arg2 = (qpol_policy_t *)(argp2); 14612 result = (char *)qpol_userbounds_child_name(arg1,arg2); 14613 resultobj = SWIG_FromCharPtr((const char *)result); 14614 return resultobj; 14615 fail: 14616 return NULL; 14617 } 14618 14619 14620 SWIGINTERN PyObject *qpol_userbounds_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 14621 PyObject *obj; 14622 if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; 14623 SWIG_TypeNewClientData(SWIGTYPE_p_qpol_userbounds, SWIG_NewClientData(obj)); 14624 return SWIG_Py_Void(); 14625 } 14626 14627 SWIGINTERN PyObject *_wrap_qpol_userbounds_from_void(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 14628 PyObject *resultobj = 0; 14629 void *arg1 = (void *) 0 ; 14630 int res1 ; 14631 PyObject * obj0 = 0 ; 14632 qpol_userbounds_t *result = 0 ; 14633 14634 if (!PyArg_ParseTuple(args,(char *)"O:qpol_userbounds_from_void",&obj0)) SWIG_fail; 14635 res1 = SWIG_ConvertPtr(obj0,SWIG_as_voidptrptr(&arg1), 0, 0); 14636 if (!SWIG_IsOK(res1)) { 14637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_userbounds_from_void" "', argument " "1"" of type '" "void *""'"); 14638 } 14639 result = (qpol_userbounds_t *)qpol_userbounds_from_void(arg1); 14640 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_userbounds, 0 | 0 ); 14641 return resultobj; 14642 fail: 14643 return NULL; 14644 } 14645 14646 14647 SWIGINTERN PyObject *_wrap_new_qpol_default_object_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 14648 PyObject *resultobj = 0; 14649 struct qpol_default_object *result = 0 ; 14650 14651 if (!PyArg_ParseTuple(args,(char *)":new_qpol_default_object_t")) SWIG_fail; 14652 result = (struct qpol_default_object *)new_qpol_default_object(); 14653 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_default_object, SWIG_POINTER_NEW | 0 ); 14654 return resultobj; 14655 fail: 14656 return NULL; 14657 } 14658 14659 14660 SWIGINTERN PyObject *_wrap_delete_qpol_default_object_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 14661 PyObject *resultobj = 0; 14662 struct qpol_default_object *arg1 = (struct qpol_default_object *) 0 ; 14663 void *argp1 = 0 ; 14664 int res1 = 0 ; 14665 PyObject * obj0 = 0 ; 14666 14667 if (!PyArg_ParseTuple(args,(char *)"O:delete_qpol_default_object_t",&obj0)) SWIG_fail; 14668 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_default_object, SWIG_POINTER_DISOWN | 0 ); 14669 if (!SWIG_IsOK(res1)) { 14670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_qpol_default_object_t" "', argument " "1"" of type '" "struct qpol_default_object *""'"); 14671 } 14672 arg1 = (struct qpol_default_object *)(argp1); 14673 delete_qpol_default_object(arg1); 14674 resultobj = SWIG_Py_Void(); 14675 return resultobj; 14676 fail: 14677 return NULL; 14678 } 14679 14680 14681 SWIGINTERN PyObject *_wrap_qpol_default_object_t_object_class(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 14682 PyObject *resultobj = 0; 14683 struct qpol_default_object *arg1 = (struct qpol_default_object *) 0 ; 14684 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 14685 void *argp1 = 0 ; 14686 int res1 = 0 ; 14687 void *argp2 = 0 ; 14688 int res2 = 0 ; 14689 PyObject * obj0 = 0 ; 14690 PyObject * obj1 = 0 ; 14691 qpol_class_t *result = 0 ; 14692 14693 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_default_object_t_object_class",&obj0,&obj1)) SWIG_fail; 14694 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_default_object, 0 | 0 ); 14695 if (!SWIG_IsOK(res1)) { 14696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_default_object_t_object_class" "', argument " "1"" of type '" "struct qpol_default_object *""'"); 14697 } 14698 arg1 = (struct qpol_default_object *)(argp1); 14699 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 14700 if (!SWIG_IsOK(res2)) { 14701 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_default_object_t_object_class" "', argument " "2"" of type '" "qpol_policy_t *""'"); 14702 } 14703 arg2 = (qpol_policy_t *)(argp2); 14704 result = (qpol_class_t *)qpol_default_object_object_class(arg1,arg2); 14705 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_class, 0 | 0 ); 14706 return resultobj; 14707 fail: 14708 return NULL; 14709 } 14710 14711 14712 SWIGINTERN PyObject *_wrap_qpol_default_object_t_user_default(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 14713 PyObject *resultobj = 0; 14714 struct qpol_default_object *arg1 = (struct qpol_default_object *) 0 ; 14715 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 14716 void *argp1 = 0 ; 14717 int res1 = 0 ; 14718 void *argp2 = 0 ; 14719 int res2 = 0 ; 14720 PyObject * obj0 = 0 ; 14721 PyObject * obj1 = 0 ; 14722 char *result = 0 ; 14723 14724 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_default_object_t_user_default",&obj0,&obj1)) SWIG_fail; 14725 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_default_object, 0 | 0 ); 14726 if (!SWIG_IsOK(res1)) { 14727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_default_object_t_user_default" "', argument " "1"" of type '" "struct qpol_default_object *""'"); 14728 } 14729 arg1 = (struct qpol_default_object *)(argp1); 14730 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 14731 if (!SWIG_IsOK(res2)) { 14732 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_default_object_t_user_default" "', argument " "2"" of type '" "qpol_policy_t *""'"); 14733 } 14734 arg2 = (qpol_policy_t *)(argp2); 14735 result = (char *)qpol_default_object_user_default(arg1,arg2); 14736 resultobj = SWIG_FromCharPtr((const char *)result); 14737 return resultobj; 14738 fail: 14739 return NULL; 14740 } 14741 14742 14743 SWIGINTERN PyObject *_wrap_qpol_default_object_t_role_default(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 14744 PyObject *resultobj = 0; 14745 struct qpol_default_object *arg1 = (struct qpol_default_object *) 0 ; 14746 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 14747 void *argp1 = 0 ; 14748 int res1 = 0 ; 14749 void *argp2 = 0 ; 14750 int res2 = 0 ; 14751 PyObject * obj0 = 0 ; 14752 PyObject * obj1 = 0 ; 14753 char *result = 0 ; 14754 14755 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_default_object_t_role_default",&obj0,&obj1)) SWIG_fail; 14756 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_default_object, 0 | 0 ); 14757 if (!SWIG_IsOK(res1)) { 14758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_default_object_t_role_default" "', argument " "1"" of type '" "struct qpol_default_object *""'"); 14759 } 14760 arg1 = (struct qpol_default_object *)(argp1); 14761 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 14762 if (!SWIG_IsOK(res2)) { 14763 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_default_object_t_role_default" "', argument " "2"" of type '" "qpol_policy_t *""'"); 14764 } 14765 arg2 = (qpol_policy_t *)(argp2); 14766 result = (char *)qpol_default_object_role_default(arg1,arg2); 14767 resultobj = SWIG_FromCharPtr((const char *)result); 14768 return resultobj; 14769 fail: 14770 return NULL; 14771 } 14772 14773 14774 SWIGINTERN PyObject *_wrap_qpol_default_object_t_type_default(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 14775 PyObject *resultobj = 0; 14776 struct qpol_default_object *arg1 = (struct qpol_default_object *) 0 ; 14777 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 14778 void *argp1 = 0 ; 14779 int res1 = 0 ; 14780 void *argp2 = 0 ; 14781 int res2 = 0 ; 14782 PyObject * obj0 = 0 ; 14783 PyObject * obj1 = 0 ; 14784 char *result = 0 ; 14785 14786 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_default_object_t_type_default",&obj0,&obj1)) SWIG_fail; 14787 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_default_object, 0 | 0 ); 14788 if (!SWIG_IsOK(res1)) { 14789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_default_object_t_type_default" "', argument " "1"" of type '" "struct qpol_default_object *""'"); 14790 } 14791 arg1 = (struct qpol_default_object *)(argp1); 14792 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 14793 if (!SWIG_IsOK(res2)) { 14794 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_default_object_t_type_default" "', argument " "2"" of type '" "qpol_policy_t *""'"); 14795 } 14796 arg2 = (qpol_policy_t *)(argp2); 14797 result = (char *)qpol_default_object_type_default(arg1,arg2); 14798 resultobj = SWIG_FromCharPtr((const char *)result); 14799 return resultobj; 14800 fail: 14801 return NULL; 14802 } 14803 14804 14805 SWIGINTERN PyObject *_wrap_qpol_default_object_t_range_default(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 14806 PyObject *resultobj = 0; 14807 struct qpol_default_object *arg1 = (struct qpol_default_object *) 0 ; 14808 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 14809 void *argp1 = 0 ; 14810 int res1 = 0 ; 14811 void *argp2 = 0 ; 14812 int res2 = 0 ; 14813 PyObject * obj0 = 0 ; 14814 PyObject * obj1 = 0 ; 14815 char *result = 0 ; 14816 14817 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_default_object_t_range_default",&obj0,&obj1)) SWIG_fail; 14818 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_default_object, 0 | 0 ); 14819 if (!SWIG_IsOK(res1)) { 14820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_default_object_t_range_default" "', argument " "1"" of type '" "struct qpol_default_object *""'"); 14821 } 14822 arg1 = (struct qpol_default_object *)(argp1); 14823 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 14824 if (!SWIG_IsOK(res2)) { 14825 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_default_object_t_range_default" "', argument " "2"" of type '" "qpol_policy_t *""'"); 14826 } 14827 arg2 = (qpol_policy_t *)(argp2); 14828 result = (char *)qpol_default_object_range_default(arg1,arg2); 14829 resultobj = SWIG_FromCharPtr((const char *)result); 14830 return resultobj; 14831 fail: 14832 return NULL; 14833 } 14834 14835 14836 SWIGINTERN PyObject *qpol_default_object_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 14837 PyObject *obj; 14838 if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; 14839 SWIG_TypeNewClientData(SWIGTYPE_p_qpol_default_object, SWIG_NewClientData(obj)); 14840 return SWIG_Py_Void(); 14841 } 14842 14843 SWIGINTERN PyObject *_wrap_qpol_default_object_from_void(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 14844 PyObject *resultobj = 0; 14845 void *arg1 = (void *) 0 ; 14846 int res1 ; 14847 PyObject * obj0 = 0 ; 14848 qpol_default_object_t *result = 0 ; 14849 14850 if (!PyArg_ParseTuple(args,(char *)"O:qpol_default_object_from_void",&obj0)) SWIG_fail; 14851 res1 = SWIG_ConvertPtr(obj0,SWIG_as_voidptrptr(&arg1), 0, 0); 14852 if (!SWIG_IsOK(res1)) { 14853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_default_object_from_void" "', argument " "1"" of type '" "void *""'"); 14854 } 14855 result = (qpol_default_object_t *)qpol_default_object_from_void(arg1); 14856 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_default_object, 0 | 0 ); 14857 return resultobj; 14858 fail: 14859 return NULL; 14860 } 14861 14862 14863 SWIGINTERN PyObject *_wrap_new_qpol_iomemcon_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 14864 PyObject *resultobj = 0; 14865 qpol_policy_t *arg1 = (qpol_policy_t *) 0 ; 14866 uint64_t arg2 ; 14867 uint64_t arg3 ; 14868 void *argp1 = 0 ; 14869 int res1 = 0 ; 14870 unsigned long long val2 ; 14871 int ecode2 = 0 ; 14872 unsigned long long val3 ; 14873 int ecode3 = 0 ; 14874 PyObject * obj0 = 0 ; 14875 PyObject * obj1 = 0 ; 14876 PyObject * obj2 = 0 ; 14877 struct qpol_iomemcon *result = 0 ; 14878 14879 if (!PyArg_ParseTuple(args,(char *)"OOO:new_qpol_iomemcon_t",&obj0,&obj1,&obj2)) SWIG_fail; 14880 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_policy, 0 | 0 ); 14881 if (!SWIG_IsOK(res1)) { 14882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_qpol_iomemcon_t" "', argument " "1"" of type '" "qpol_policy_t *""'"); 14883 } 14884 arg1 = (qpol_policy_t *)(argp1); 14885 ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2); 14886 if (!SWIG_IsOK(ecode2)) { 14887 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_qpol_iomemcon_t" "', argument " "2"" of type '" "uint64_t""'"); 14888 } 14889 arg2 = (uint64_t)(val2); 14890 ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(obj2, &val3); 14891 if (!SWIG_IsOK(ecode3)) { 14892 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_qpol_iomemcon_t" "', argument " "3"" of type '" "uint64_t""'"); 14893 } 14894 arg3 = (uint64_t)(val3); 14895 result = (struct qpol_iomemcon *)new_qpol_iomemcon(arg1,arg2,arg3); 14896 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_iomemcon, SWIG_POINTER_NEW | 0 ); 14897 return resultobj; 14898 fail: 14899 return NULL; 14900 } 14901 14902 14903 SWIGINTERN PyObject *_wrap_delete_qpol_iomemcon_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 14904 PyObject *resultobj = 0; 14905 struct qpol_iomemcon *arg1 = (struct qpol_iomemcon *) 0 ; 14906 void *argp1 = 0 ; 14907 int res1 = 0 ; 14908 PyObject * obj0 = 0 ; 14909 14910 if (!PyArg_ParseTuple(args,(char *)"O:delete_qpol_iomemcon_t",&obj0)) SWIG_fail; 14911 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_iomemcon, SWIG_POINTER_DISOWN | 0 ); 14912 if (!SWIG_IsOK(res1)) { 14913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_qpol_iomemcon_t" "', argument " "1"" of type '" "struct qpol_iomemcon *""'"); 14914 } 14915 arg1 = (struct qpol_iomemcon *)(argp1); 14916 delete_qpol_iomemcon(arg1); 14917 resultobj = SWIG_Py_Void(); 14918 return resultobj; 14919 fail: 14920 return NULL; 14921 } 14922 14923 14924 SWIGINTERN PyObject *_wrap_qpol_iomemcon_t_low_addr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 14925 PyObject *resultobj = 0; 14926 struct qpol_iomemcon *arg1 = (struct qpol_iomemcon *) 0 ; 14927 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 14928 void *argp1 = 0 ; 14929 int res1 = 0 ; 14930 void *argp2 = 0 ; 14931 int res2 = 0 ; 14932 PyObject * obj0 = 0 ; 14933 PyObject * obj1 = 0 ; 14934 uint64_t result; 14935 14936 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_iomemcon_t_low_addr",&obj0,&obj1)) SWIG_fail; 14937 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_iomemcon, 0 | 0 ); 14938 if (!SWIG_IsOK(res1)) { 14939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_iomemcon_t_low_addr" "', argument " "1"" of type '" "struct qpol_iomemcon *""'"); 14940 } 14941 arg1 = (struct qpol_iomemcon *)(argp1); 14942 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 14943 if (!SWIG_IsOK(res2)) { 14944 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_iomemcon_t_low_addr" "', argument " "2"" of type '" "qpol_policy_t *""'"); 14945 } 14946 arg2 = (qpol_policy_t *)(argp2); 14947 result = (uint64_t)qpol_iomemcon_low_addr(arg1,arg2); 14948 resultobj = SWIG_From_unsigned_SS_long_SS_long((unsigned long long)(result)); 14949 return resultobj; 14950 fail: 14951 return NULL; 14952 } 14953 14954 14955 SWIGINTERN PyObject *_wrap_qpol_iomemcon_t_high_addr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 14956 PyObject *resultobj = 0; 14957 struct qpol_iomemcon *arg1 = (struct qpol_iomemcon *) 0 ; 14958 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 14959 void *argp1 = 0 ; 14960 int res1 = 0 ; 14961 void *argp2 = 0 ; 14962 int res2 = 0 ; 14963 PyObject * obj0 = 0 ; 14964 PyObject * obj1 = 0 ; 14965 uint64_t result; 14966 14967 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_iomemcon_t_high_addr",&obj0,&obj1)) SWIG_fail; 14968 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_iomemcon, 0 | 0 ); 14969 if (!SWIG_IsOK(res1)) { 14970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_iomemcon_t_high_addr" "', argument " "1"" of type '" "struct qpol_iomemcon *""'"); 14971 } 14972 arg1 = (struct qpol_iomemcon *)(argp1); 14973 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 14974 if (!SWIG_IsOK(res2)) { 14975 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_iomemcon_t_high_addr" "', argument " "2"" of type '" "qpol_policy_t *""'"); 14976 } 14977 arg2 = (qpol_policy_t *)(argp2); 14978 result = (uint64_t)qpol_iomemcon_high_addr(arg1,arg2); 14979 resultobj = SWIG_From_unsigned_SS_long_SS_long((unsigned long long)(result)); 14980 return resultobj; 14981 fail: 14982 return NULL; 14983 } 14984 14985 14986 SWIGINTERN PyObject *_wrap_qpol_iomemcon_t_context(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 14987 PyObject *resultobj = 0; 14988 struct qpol_iomemcon *arg1 = (struct qpol_iomemcon *) 0 ; 14989 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 14990 void *argp1 = 0 ; 14991 int res1 = 0 ; 14992 void *argp2 = 0 ; 14993 int res2 = 0 ; 14994 PyObject * obj0 = 0 ; 14995 PyObject * obj1 = 0 ; 14996 qpol_context_t *result = 0 ; 14997 14998 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_iomemcon_t_context",&obj0,&obj1)) SWIG_fail; 14999 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_iomemcon, 0 | 0 ); 15000 if (!SWIG_IsOK(res1)) { 15001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_iomemcon_t_context" "', argument " "1"" of type '" "struct qpol_iomemcon *""'"); 15002 } 15003 arg1 = (struct qpol_iomemcon *)(argp1); 15004 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 15005 if (!SWIG_IsOK(res2)) { 15006 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_iomemcon_t_context" "', argument " "2"" of type '" "qpol_policy_t *""'"); 15007 } 15008 arg2 = (qpol_policy_t *)(argp2); 15009 result = (qpol_context_t *)qpol_iomemcon_context(arg1,arg2); 15010 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_context, 0 | 0 ); 15011 return resultobj; 15012 fail: 15013 return NULL; 15014 } 15015 15016 15017 SWIGINTERN PyObject *qpol_iomemcon_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 15018 PyObject *obj; 15019 if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; 15020 SWIG_TypeNewClientData(SWIGTYPE_p_qpol_iomemcon, SWIG_NewClientData(obj)); 15021 return SWIG_Py_Void(); 15022 } 15023 15024 SWIGINTERN PyObject *_wrap_qpol_iomemcon_from_void(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 15025 PyObject *resultobj = 0; 15026 void *arg1 = (void *) 0 ; 15027 int res1 ; 15028 PyObject * obj0 = 0 ; 15029 qpol_iomemcon_t *result = 0 ; 15030 15031 if (!PyArg_ParseTuple(args,(char *)"O:qpol_iomemcon_from_void",&obj0)) SWIG_fail; 15032 res1 = SWIG_ConvertPtr(obj0,SWIG_as_voidptrptr(&arg1), 0, 0); 15033 if (!SWIG_IsOK(res1)) { 15034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_iomemcon_from_void" "', argument " "1"" of type '" "void *""'"); 15035 } 15036 result = (qpol_iomemcon_t *)qpol_iomemcon_from_void(arg1); 15037 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_iomemcon, 0 | 0 ); 15038 return resultobj; 15039 fail: 15040 return NULL; 15041 } 15042 15043 15044 SWIGINTERN PyObject *_wrap_new_qpol_ioportcon_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 15045 PyObject *resultobj = 0; 15046 qpol_policy_t *arg1 = (qpol_policy_t *) 0 ; 15047 uint32_t arg2 ; 15048 uint32_t arg3 ; 15049 void *argp1 = 0 ; 15050 int res1 = 0 ; 15051 unsigned int val2 ; 15052 int ecode2 = 0 ; 15053 unsigned int val3 ; 15054 int ecode3 = 0 ; 15055 PyObject * obj0 = 0 ; 15056 PyObject * obj1 = 0 ; 15057 PyObject * obj2 = 0 ; 15058 struct qpol_ioportcon *result = 0 ; 15059 15060 if (!PyArg_ParseTuple(args,(char *)"OOO:new_qpol_ioportcon_t",&obj0,&obj1,&obj2)) SWIG_fail; 15061 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_policy, 0 | 0 ); 15062 if (!SWIG_IsOK(res1)) { 15063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_qpol_ioportcon_t" "', argument " "1"" of type '" "qpol_policy_t *""'"); 15064 } 15065 arg1 = (qpol_policy_t *)(argp1); 15066 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2); 15067 if (!SWIG_IsOK(ecode2)) { 15068 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_qpol_ioportcon_t" "', argument " "2"" of type '" "uint32_t""'"); 15069 } 15070 arg2 = (uint32_t)(val2); 15071 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3); 15072 if (!SWIG_IsOK(ecode3)) { 15073 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_qpol_ioportcon_t" "', argument " "3"" of type '" "uint32_t""'"); 15074 } 15075 arg3 = (uint32_t)(val3); 15076 result = (struct qpol_ioportcon *)new_qpol_ioportcon(arg1,arg2,arg3); 15077 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_ioportcon, SWIG_POINTER_NEW | 0 ); 15078 return resultobj; 15079 fail: 15080 return NULL; 15081 } 15082 15083 15084 SWIGINTERN PyObject *_wrap_delete_qpol_ioportcon_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 15085 PyObject *resultobj = 0; 15086 struct qpol_ioportcon *arg1 = (struct qpol_ioportcon *) 0 ; 15087 void *argp1 = 0 ; 15088 int res1 = 0 ; 15089 PyObject * obj0 = 0 ; 15090 15091 if (!PyArg_ParseTuple(args,(char *)"O:delete_qpol_ioportcon_t",&obj0)) SWIG_fail; 15092 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_ioportcon, SWIG_POINTER_DISOWN | 0 ); 15093 if (!SWIG_IsOK(res1)) { 15094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_qpol_ioportcon_t" "', argument " "1"" of type '" "struct qpol_ioportcon *""'"); 15095 } 15096 arg1 = (struct qpol_ioportcon *)(argp1); 15097 delete_qpol_ioportcon(arg1); 15098 resultobj = SWIG_Py_Void(); 15099 return resultobj; 15100 fail: 15101 return NULL; 15102 } 15103 15104 15105 SWIGINTERN PyObject *_wrap_qpol_ioportcon_t_low_port(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 15106 PyObject *resultobj = 0; 15107 struct qpol_ioportcon *arg1 = (struct qpol_ioportcon *) 0 ; 15108 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 15109 void *argp1 = 0 ; 15110 int res1 = 0 ; 15111 void *argp2 = 0 ; 15112 int res2 = 0 ; 15113 PyObject * obj0 = 0 ; 15114 PyObject * obj1 = 0 ; 15115 uint32_t result; 15116 15117 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_ioportcon_t_low_port",&obj0,&obj1)) SWIG_fail; 15118 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_ioportcon, 0 | 0 ); 15119 if (!SWIG_IsOK(res1)) { 15120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_ioportcon_t_low_port" "', argument " "1"" of type '" "struct qpol_ioportcon *""'"); 15121 } 15122 arg1 = (struct qpol_ioportcon *)(argp1); 15123 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 15124 if (!SWIG_IsOK(res2)) { 15125 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_ioportcon_t_low_port" "', argument " "2"" of type '" "qpol_policy_t *""'"); 15126 } 15127 arg2 = (qpol_policy_t *)(argp2); 15128 result = (uint32_t)qpol_ioportcon_low_port(arg1,arg2); 15129 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); 15130 return resultobj; 15131 fail: 15132 return NULL; 15133 } 15134 15135 15136 SWIGINTERN PyObject *_wrap_qpol_ioportcon_t_high_port(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 15137 PyObject *resultobj = 0; 15138 struct qpol_ioportcon *arg1 = (struct qpol_ioportcon *) 0 ; 15139 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 15140 void *argp1 = 0 ; 15141 int res1 = 0 ; 15142 void *argp2 = 0 ; 15143 int res2 = 0 ; 15144 PyObject * obj0 = 0 ; 15145 PyObject * obj1 = 0 ; 15146 uint32_t result; 15147 15148 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_ioportcon_t_high_port",&obj0,&obj1)) SWIG_fail; 15149 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_ioportcon, 0 | 0 ); 15150 if (!SWIG_IsOK(res1)) { 15151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_ioportcon_t_high_port" "', argument " "1"" of type '" "struct qpol_ioportcon *""'"); 15152 } 15153 arg1 = (struct qpol_ioportcon *)(argp1); 15154 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 15155 if (!SWIG_IsOK(res2)) { 15156 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_ioportcon_t_high_port" "', argument " "2"" of type '" "qpol_policy_t *""'"); 15157 } 15158 arg2 = (qpol_policy_t *)(argp2); 15159 result = (uint32_t)qpol_ioportcon_high_port(arg1,arg2); 15160 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); 15161 return resultobj; 15162 fail: 15163 return NULL; 15164 } 15165 15166 15167 SWIGINTERN PyObject *_wrap_qpol_ioportcon_t_context(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 15168 PyObject *resultobj = 0; 15169 struct qpol_ioportcon *arg1 = (struct qpol_ioportcon *) 0 ; 15170 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 15171 void *argp1 = 0 ; 15172 int res1 = 0 ; 15173 void *argp2 = 0 ; 15174 int res2 = 0 ; 15175 PyObject * obj0 = 0 ; 15176 PyObject * obj1 = 0 ; 15177 qpol_context_t *result = 0 ; 15178 15179 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_ioportcon_t_context",&obj0,&obj1)) SWIG_fail; 15180 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_ioportcon, 0 | 0 ); 15181 if (!SWIG_IsOK(res1)) { 15182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_ioportcon_t_context" "', argument " "1"" of type '" "struct qpol_ioportcon *""'"); 15183 } 15184 arg1 = (struct qpol_ioportcon *)(argp1); 15185 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 15186 if (!SWIG_IsOK(res2)) { 15187 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_ioportcon_t_context" "', argument " "2"" of type '" "qpol_policy_t *""'"); 15188 } 15189 arg2 = (qpol_policy_t *)(argp2); 15190 result = (qpol_context_t *)qpol_ioportcon_context(arg1,arg2); 15191 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_context, 0 | 0 ); 15192 return resultobj; 15193 fail: 15194 return NULL; 15195 } 15196 15197 15198 SWIGINTERN PyObject *qpol_ioportcon_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 15199 PyObject *obj; 15200 if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; 15201 SWIG_TypeNewClientData(SWIGTYPE_p_qpol_ioportcon, SWIG_NewClientData(obj)); 15202 return SWIG_Py_Void(); 15203 } 15204 15205 SWIGINTERN PyObject *_wrap_qpol_ioportcon_from_void(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 15206 PyObject *resultobj = 0; 15207 void *arg1 = (void *) 0 ; 15208 int res1 ; 15209 PyObject * obj0 = 0 ; 15210 qpol_ioportcon_t *result = 0 ; 15211 15212 if (!PyArg_ParseTuple(args,(char *)"O:qpol_ioportcon_from_void",&obj0)) SWIG_fail; 15213 res1 = SWIG_ConvertPtr(obj0,SWIG_as_voidptrptr(&arg1), 0, 0); 15214 if (!SWIG_IsOK(res1)) { 15215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_ioportcon_from_void" "', argument " "1"" of type '" "void *""'"); 15216 } 15217 result = (qpol_ioportcon_t *)qpol_ioportcon_from_void(arg1); 15218 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_ioportcon, 0 | 0 ); 15219 return resultobj; 15220 fail: 15221 return NULL; 15222 } 15223 15224 15225 SWIGINTERN PyObject *_wrap_new_qpol_pcidevicecon_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 15226 PyObject *resultobj = 0; 15227 struct qpol_pcidevicecon *result = 0 ; 15228 15229 if (!PyArg_ParseTuple(args,(char *)":new_qpol_pcidevicecon_t")) SWIG_fail; 15230 result = (struct qpol_pcidevicecon *)new_qpol_pcidevicecon(); 15231 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_pcidevicecon, SWIG_POINTER_NEW | 0 ); 15232 return resultobj; 15233 fail: 15234 return NULL; 15235 } 15236 15237 15238 SWIGINTERN PyObject *_wrap_delete_qpol_pcidevicecon_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 15239 PyObject *resultobj = 0; 15240 struct qpol_pcidevicecon *arg1 = (struct qpol_pcidevicecon *) 0 ; 15241 void *argp1 = 0 ; 15242 int res1 = 0 ; 15243 PyObject * obj0 = 0 ; 15244 15245 if (!PyArg_ParseTuple(args,(char *)"O:delete_qpol_pcidevicecon_t",&obj0)) SWIG_fail; 15246 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_pcidevicecon, SWIG_POINTER_DISOWN | 0 ); 15247 if (!SWIG_IsOK(res1)) { 15248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_qpol_pcidevicecon_t" "', argument " "1"" of type '" "struct qpol_pcidevicecon *""'"); 15249 } 15250 arg1 = (struct qpol_pcidevicecon *)(argp1); 15251 delete_qpol_pcidevicecon(arg1); 15252 resultobj = SWIG_Py_Void(); 15253 return resultobj; 15254 fail: 15255 return NULL; 15256 } 15257 15258 15259 SWIGINTERN PyObject *_wrap_qpol_pcidevicecon_t_device(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 15260 PyObject *resultobj = 0; 15261 struct qpol_pcidevicecon *arg1 = (struct qpol_pcidevicecon *) 0 ; 15262 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 15263 void *argp1 = 0 ; 15264 int res1 = 0 ; 15265 void *argp2 = 0 ; 15266 int res2 = 0 ; 15267 PyObject * obj0 = 0 ; 15268 PyObject * obj1 = 0 ; 15269 uint32_t result; 15270 15271 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_pcidevicecon_t_device",&obj0,&obj1)) SWIG_fail; 15272 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_pcidevicecon, 0 | 0 ); 15273 if (!SWIG_IsOK(res1)) { 15274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_pcidevicecon_t_device" "', argument " "1"" of type '" "struct qpol_pcidevicecon *""'"); 15275 } 15276 arg1 = (struct qpol_pcidevicecon *)(argp1); 15277 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 15278 if (!SWIG_IsOK(res2)) { 15279 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_pcidevicecon_t_device" "', argument " "2"" of type '" "qpol_policy_t *""'"); 15280 } 15281 arg2 = (qpol_policy_t *)(argp2); 15282 result = (uint32_t)qpol_pcidevicecon_device(arg1,arg2); 15283 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); 15284 return resultobj; 15285 fail: 15286 return NULL; 15287 } 15288 15289 15290 SWIGINTERN PyObject *_wrap_qpol_pcidevicecon_t_context(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 15291 PyObject *resultobj = 0; 15292 struct qpol_pcidevicecon *arg1 = (struct qpol_pcidevicecon *) 0 ; 15293 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 15294 void *argp1 = 0 ; 15295 int res1 = 0 ; 15296 void *argp2 = 0 ; 15297 int res2 = 0 ; 15298 PyObject * obj0 = 0 ; 15299 PyObject * obj1 = 0 ; 15300 qpol_context_t *result = 0 ; 15301 15302 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_pcidevicecon_t_context",&obj0,&obj1)) SWIG_fail; 15303 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_pcidevicecon, 0 | 0 ); 15304 if (!SWIG_IsOK(res1)) { 15305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_pcidevicecon_t_context" "', argument " "1"" of type '" "struct qpol_pcidevicecon *""'"); 15306 } 15307 arg1 = (struct qpol_pcidevicecon *)(argp1); 15308 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 15309 if (!SWIG_IsOK(res2)) { 15310 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_pcidevicecon_t_context" "', argument " "2"" of type '" "qpol_policy_t *""'"); 15311 } 15312 arg2 = (qpol_policy_t *)(argp2); 15313 result = (qpol_context_t *)qpol_pcidevicecon_context(arg1,arg2); 15314 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_context, 0 | 0 ); 15315 return resultobj; 15316 fail: 15317 return NULL; 15318 } 15319 15320 15321 SWIGINTERN PyObject *qpol_pcidevicecon_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 15322 PyObject *obj; 15323 if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; 15324 SWIG_TypeNewClientData(SWIGTYPE_p_qpol_pcidevicecon, SWIG_NewClientData(obj)); 15325 return SWIG_Py_Void(); 15326 } 15327 15328 SWIGINTERN PyObject *_wrap_qpol_pcidevicecon_from_void(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 15329 PyObject *resultobj = 0; 15330 void *arg1 = (void *) 0 ; 15331 int res1 ; 15332 PyObject * obj0 = 0 ; 15333 qpol_pcidevicecon_t *result = 0 ; 15334 15335 if (!PyArg_ParseTuple(args,(char *)"O:qpol_pcidevicecon_from_void",&obj0)) SWIG_fail; 15336 res1 = SWIG_ConvertPtr(obj0,SWIG_as_voidptrptr(&arg1), 0, 0); 15337 if (!SWIG_IsOK(res1)) { 15338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_pcidevicecon_from_void" "', argument " "1"" of type '" "void *""'"); 15339 } 15340 result = (qpol_pcidevicecon_t *)qpol_pcidevicecon_from_void(arg1); 15341 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_pcidevicecon, 0 | 0 ); 15342 return resultobj; 15343 fail: 15344 return NULL; 15345 } 15346 15347 15348 SWIGINTERN PyObject *_wrap_new_qpol_pirqcon_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 15349 PyObject *resultobj = 0; 15350 struct qpol_pirqcon *result = 0 ; 15351 15352 if (!PyArg_ParseTuple(args,(char *)":new_qpol_pirqcon_t")) SWIG_fail; 15353 result = (struct qpol_pirqcon *)new_qpol_pirqcon(); 15354 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_pirqcon, SWIG_POINTER_NEW | 0 ); 15355 return resultobj; 15356 fail: 15357 return NULL; 15358 } 15359 15360 15361 SWIGINTERN PyObject *_wrap_delete_qpol_pirqcon_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 15362 PyObject *resultobj = 0; 15363 struct qpol_pirqcon *arg1 = (struct qpol_pirqcon *) 0 ; 15364 void *argp1 = 0 ; 15365 int res1 = 0 ; 15366 PyObject * obj0 = 0 ; 15367 15368 if (!PyArg_ParseTuple(args,(char *)"O:delete_qpol_pirqcon_t",&obj0)) SWIG_fail; 15369 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_pirqcon, SWIG_POINTER_DISOWN | 0 ); 15370 if (!SWIG_IsOK(res1)) { 15371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_qpol_pirqcon_t" "', argument " "1"" of type '" "struct qpol_pirqcon *""'"); 15372 } 15373 arg1 = (struct qpol_pirqcon *)(argp1); 15374 delete_qpol_pirqcon(arg1); 15375 resultobj = SWIG_Py_Void(); 15376 return resultobj; 15377 fail: 15378 return NULL; 15379 } 15380 15381 15382 SWIGINTERN PyObject *_wrap_qpol_pirqcon_t_irq(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 15383 PyObject *resultobj = 0; 15384 struct qpol_pirqcon *arg1 = (struct qpol_pirqcon *) 0 ; 15385 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 15386 void *argp1 = 0 ; 15387 int res1 = 0 ; 15388 void *argp2 = 0 ; 15389 int res2 = 0 ; 15390 PyObject * obj0 = 0 ; 15391 PyObject * obj1 = 0 ; 15392 uint32_t result; 15393 15394 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_pirqcon_t_irq",&obj0,&obj1)) SWIG_fail; 15395 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_pirqcon, 0 | 0 ); 15396 if (!SWIG_IsOK(res1)) { 15397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_pirqcon_t_irq" "', argument " "1"" of type '" "struct qpol_pirqcon *""'"); 15398 } 15399 arg1 = (struct qpol_pirqcon *)(argp1); 15400 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 15401 if (!SWIG_IsOK(res2)) { 15402 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_pirqcon_t_irq" "', argument " "2"" of type '" "qpol_policy_t *""'"); 15403 } 15404 arg2 = (qpol_policy_t *)(argp2); 15405 result = (uint32_t)qpol_pirqcon_irq(arg1,arg2); 15406 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); 15407 return resultobj; 15408 fail: 15409 return NULL; 15410 } 15411 15412 15413 SWIGINTERN PyObject *_wrap_qpol_pirqcon_t_context(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 15414 PyObject *resultobj = 0; 15415 struct qpol_pirqcon *arg1 = (struct qpol_pirqcon *) 0 ; 15416 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 15417 void *argp1 = 0 ; 15418 int res1 = 0 ; 15419 void *argp2 = 0 ; 15420 int res2 = 0 ; 15421 PyObject * obj0 = 0 ; 15422 PyObject * obj1 = 0 ; 15423 qpol_context_t *result = 0 ; 15424 15425 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_pirqcon_t_context",&obj0,&obj1)) SWIG_fail; 15426 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_pirqcon, 0 | 0 ); 15427 if (!SWIG_IsOK(res1)) { 15428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_pirqcon_t_context" "', argument " "1"" of type '" "struct qpol_pirqcon *""'"); 15429 } 15430 arg1 = (struct qpol_pirqcon *)(argp1); 15431 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 15432 if (!SWIG_IsOK(res2)) { 15433 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_pirqcon_t_context" "', argument " "2"" of type '" "qpol_policy_t *""'"); 15434 } 15435 arg2 = (qpol_policy_t *)(argp2); 15436 result = (qpol_context_t *)qpol_pirqcon_context(arg1,arg2); 15437 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_context, 0 | 0 ); 15438 return resultobj; 15439 fail: 15440 return NULL; 15441 } 15442 15443 15444 SWIGINTERN PyObject *qpol_pirqcon_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 15445 PyObject *obj; 15446 if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; 15447 SWIG_TypeNewClientData(SWIGTYPE_p_qpol_pirqcon, SWIG_NewClientData(obj)); 15448 return SWIG_Py_Void(); 15449 } 15450 15451 SWIGINTERN PyObject *_wrap_qpol_pirqcon_from_void(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 15452 PyObject *resultobj = 0; 15453 void *arg1 = (void *) 0 ; 15454 int res1 ; 15455 PyObject * obj0 = 0 ; 15456 qpol_pirqcon_t *result = 0 ; 15457 15458 if (!PyArg_ParseTuple(args,(char *)"O:qpol_pirqcon_from_void",&obj0)) SWIG_fail; 15459 res1 = SWIG_ConvertPtr(obj0,SWIG_as_voidptrptr(&arg1), 0, 0); 15460 if (!SWIG_IsOK(res1)) { 15461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_pirqcon_from_void" "', argument " "1"" of type '" "void *""'"); 15462 } 15463 result = (qpol_pirqcon_t *)qpol_pirqcon_from_void(arg1); 15464 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_pirqcon, 0 | 0 ); 15465 return resultobj; 15466 fail: 15467 return NULL; 15468 } 15469 15470 15471 SWIGINTERN PyObject *_wrap_new_qpol_devicetreecon_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 15472 PyObject *resultobj = 0; 15473 struct qpol_devicetreecon *result = 0 ; 15474 15475 if (!PyArg_ParseTuple(args,(char *)":new_qpol_devicetreecon_t")) SWIG_fail; 15476 result = (struct qpol_devicetreecon *)new_qpol_devicetreecon(); 15477 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_devicetreecon, SWIG_POINTER_NEW | 0 ); 15478 return resultobj; 15479 fail: 15480 return NULL; 15481 } 15482 15483 15484 SWIGINTERN PyObject *_wrap_qpol_devicetreecon_t_path(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 15485 PyObject *resultobj = 0; 15486 struct qpol_devicetreecon *arg1 = (struct qpol_devicetreecon *) 0 ; 15487 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 15488 void *argp1 = 0 ; 15489 int res1 = 0 ; 15490 void *argp2 = 0 ; 15491 int res2 = 0 ; 15492 PyObject * obj0 = 0 ; 15493 PyObject * obj1 = 0 ; 15494 char *result = 0 ; 15495 15496 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_devicetreecon_t_path",&obj0,&obj1)) SWIG_fail; 15497 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_devicetreecon, 0 | 0 ); 15498 if (!SWIG_IsOK(res1)) { 15499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_devicetreecon_t_path" "', argument " "1"" of type '" "struct qpol_devicetreecon *""'"); 15500 } 15501 arg1 = (struct qpol_devicetreecon *)(argp1); 15502 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 15503 if (!SWIG_IsOK(res2)) { 15504 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_devicetreecon_t_path" "', argument " "2"" of type '" "qpol_policy_t *""'"); 15505 } 15506 arg2 = (qpol_policy_t *)(argp2); 15507 result = (char *)qpol_devicetreecon_path(arg1,arg2); 15508 resultobj = SWIG_FromCharPtr((const char *)result); 15509 return resultobj; 15510 fail: 15511 return NULL; 15512 } 15513 15514 15515 SWIGINTERN PyObject *_wrap_qpol_devicetreecon_t_context(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 15516 PyObject *resultobj = 0; 15517 struct qpol_devicetreecon *arg1 = (struct qpol_devicetreecon *) 0 ; 15518 qpol_policy_t *arg2 = (qpol_policy_t *) 0 ; 15519 void *argp1 = 0 ; 15520 int res1 = 0 ; 15521 void *argp2 = 0 ; 15522 int res2 = 0 ; 15523 PyObject * obj0 = 0 ; 15524 PyObject * obj1 = 0 ; 15525 qpol_context_t *result = 0 ; 15526 15527 if (!PyArg_ParseTuple(args,(char *)"OO:qpol_devicetreecon_t_context",&obj0,&obj1)) SWIG_fail; 15528 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_devicetreecon, 0 | 0 ); 15529 if (!SWIG_IsOK(res1)) { 15530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_devicetreecon_t_context" "', argument " "1"" of type '" "struct qpol_devicetreecon *""'"); 15531 } 15532 arg1 = (struct qpol_devicetreecon *)(argp1); 15533 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_qpol_policy, 0 | 0 ); 15534 if (!SWIG_IsOK(res2)) { 15535 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "qpol_devicetreecon_t_context" "', argument " "2"" of type '" "qpol_policy_t *""'"); 15536 } 15537 arg2 = (qpol_policy_t *)(argp2); 15538 result = (qpol_context_t *)qpol_devicetreecon_context(arg1,arg2); 15539 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_context, 0 | 0 ); 15540 return resultobj; 15541 fail: 15542 return NULL; 15543 } 15544 15545 15546 SWIGINTERN PyObject *_wrap_delete_qpol_devicetreecon_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 15547 PyObject *resultobj = 0; 15548 struct qpol_devicetreecon *arg1 = (struct qpol_devicetreecon *) 0 ; 15549 void *argp1 = 0 ; 15550 int res1 = 0 ; 15551 PyObject * obj0 = 0 ; 15552 15553 if (!PyArg_ParseTuple(args,(char *)"O:delete_qpol_devicetreecon_t",&obj0)) SWIG_fail; 15554 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_qpol_devicetreecon, SWIG_POINTER_DISOWN | 0 ); 15555 if (!SWIG_IsOK(res1)) { 15556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_qpol_devicetreecon_t" "', argument " "1"" of type '" "struct qpol_devicetreecon *""'"); 15557 } 15558 arg1 = (struct qpol_devicetreecon *)(argp1); 15559 free((char *) arg1); 15560 resultobj = SWIG_Py_Void(); 15561 return resultobj; 15562 fail: 15563 return NULL; 15564 } 15565 15566 15567 SWIGINTERN PyObject *qpol_devicetreecon_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 15568 PyObject *obj; 15569 if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; 15570 SWIG_TypeNewClientData(SWIGTYPE_p_qpol_devicetreecon, SWIG_NewClientData(obj)); 15571 return SWIG_Py_Void(); 15572 } 15573 15574 SWIGINTERN PyObject *_wrap_qpol_devicetreecon_from_void(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { 15575 PyObject *resultobj = 0; 15576 void *arg1 = (void *) 0 ; 15577 int res1 ; 15578 PyObject * obj0 = 0 ; 15579 qpol_devicetreecon_t *result = 0 ; 15580 15581 if (!PyArg_ParseTuple(args,(char *)"O:qpol_devicetreecon_from_void",&obj0)) SWIG_fail; 15582 res1 = SWIG_ConvertPtr(obj0,SWIG_as_voidptrptr(&arg1), 0, 0); 15583 if (!SWIG_IsOK(res1)) { 15584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "qpol_devicetreecon_from_void" "', argument " "1"" of type '" "void *""'"); 15585 } 15586 result = (qpol_devicetreecon_t *)qpol_devicetreecon_from_void(arg1); 15587 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_qpol_devicetreecon, 0 | 0 ); 15588 return resultobj; 15589 fail: 15590 return NULL; 15591 } 15592 15593 15594 static PyMethodDef SwigMethods[] = { 15595 { (char *)"SWIG_PyInstanceMethod_New", (PyCFunction)SWIG_PyInstanceMethod_New, METH_O, NULL}, 15596 { (char *)"to_str", _wrap_to_str, METH_VARARGS, NULL}, 15597 { (char *)"to_int_with_free", _wrap_to_int_with_free, METH_VARARGS, NULL}, 15598 { (char *)"new_qpol_policy_t", _wrap_new_qpol_policy_t, METH_VARARGS, NULL}, 15599 { (char *)"delete_qpol_policy_t", _wrap_delete_qpol_policy_t, METH_VARARGS, NULL}, 15600 { (char *)"qpol_policy_t_version", _wrap_qpol_policy_t_version, METH_VARARGS, NULL}, 15601 { (char *)"qpol_policy_t_handle_unknown", _wrap_qpol_policy_t_handle_unknown, METH_VARARGS, NULL}, 15602 { (char *)"qpol_policy_t_target_platform", _wrap_qpol_policy_t_target_platform, METH_VARARGS, NULL}, 15603 { (char *)"qpol_policy_t_capability", _wrap_qpol_policy_t_capability, METH_VARARGS, NULL}, 15604 { (char *)"qpol_policy_t_type_iter", _wrap_qpol_policy_t_type_iter, METH_VARARGS, NULL}, 15605 { (char *)"qpol_policy_t_type_count", _wrap_qpol_policy_t_type_count, METH_VARARGS, NULL}, 15606 { (char *)"qpol_policy_t_role_iter", _wrap_qpol_policy_t_role_iter, METH_VARARGS, NULL}, 15607 { (char *)"qpol_policy_t_role_count", _wrap_qpol_policy_t_role_count, METH_VARARGS, NULL}, 15608 { (char *)"qpol_policy_t_level_iter", _wrap_qpol_policy_t_level_iter, METH_VARARGS, NULL}, 15609 { (char *)"qpol_policy_t_level_count", _wrap_qpol_policy_t_level_count, METH_VARARGS, NULL}, 15610 { (char *)"qpol_policy_t_cat_iter", _wrap_qpol_policy_t_cat_iter, METH_VARARGS, NULL}, 15611 { (char *)"qpol_policy_t_cat_count", _wrap_qpol_policy_t_cat_count, METH_VARARGS, NULL}, 15612 { (char *)"qpol_policy_t_user_iter", _wrap_qpol_policy_t_user_iter, METH_VARARGS, NULL}, 15613 { (char *)"qpol_policy_t_user_count", _wrap_qpol_policy_t_user_count, METH_VARARGS, NULL}, 15614 { (char *)"qpol_policy_t_bool_iter", _wrap_qpol_policy_t_bool_iter, METH_VARARGS, NULL}, 15615 { (char *)"qpol_policy_t_bool_count", _wrap_qpol_policy_t_bool_count, METH_VARARGS, NULL}, 15616 { (char *)"qpol_policy_t_class_iter", _wrap_qpol_policy_t_class_iter, METH_VARARGS, NULL}, 15617 { (char *)"qpol_policy_t_class_count", _wrap_qpol_policy_t_class_count, METH_VARARGS, NULL}, 15618 { (char *)"qpol_policy_t_common_iter", _wrap_qpol_policy_t_common_iter, METH_VARARGS, NULL}, 15619 { (char *)"qpol_policy_t_common_count", _wrap_qpol_policy_t_common_count, METH_VARARGS, NULL}, 15620 { (char *)"qpol_policy_t_fs_use_iter", _wrap_qpol_policy_t_fs_use_iter, METH_VARARGS, NULL}, 15621 { (char *)"qpol_policy_t_fs_use_count", _wrap_qpol_policy_t_fs_use_count, METH_VARARGS, NULL}, 15622 { (char *)"qpol_policy_t_genfscon_iter", _wrap_qpol_policy_t_genfscon_iter, METH_VARARGS, NULL}, 15623 { (char *)"qpol_policy_t_genfscon_count", _wrap_qpol_policy_t_genfscon_count, METH_VARARGS, NULL}, 15624 { (char *)"qpol_policy_t_isid_iter", _wrap_qpol_policy_t_isid_iter, METH_VARARGS, NULL}, 15625 { (char *)"qpol_policy_t_isid_count", _wrap_qpol_policy_t_isid_count, METH_VARARGS, NULL}, 15626 { (char *)"qpol_policy_t_netifcon_iter", _wrap_qpol_policy_t_netifcon_iter, METH_VARARGS, NULL}, 15627 { (char *)"qpol_policy_t_netifcon_count", _wrap_qpol_policy_t_netifcon_count, METH_VARARGS, NULL}, 15628 { (char *)"qpol_policy_t_nodecon_iter", _wrap_qpol_policy_t_nodecon_iter, METH_VARARGS, NULL}, 15629 { (char *)"qpol_policy_t_nodecon_count", _wrap_qpol_policy_t_nodecon_count, METH_VARARGS, NULL}, 15630 { (char *)"qpol_policy_t_portcon_iter", _wrap_qpol_policy_t_portcon_iter, METH_VARARGS, NULL}, 15631 { (char *)"qpol_policy_t_portcon_count", _wrap_qpol_policy_t_portcon_count, METH_VARARGS, NULL}, 15632 { (char *)"qpol_policy_t_constraint_iter", _wrap_qpol_policy_t_constraint_iter, METH_VARARGS, NULL}, 15633 { (char *)"qpol_policy_t_constraint_count", _wrap_qpol_policy_t_constraint_count, METH_VARARGS, NULL}, 15634 { (char *)"qpol_policy_t_validatetrans_iter", _wrap_qpol_policy_t_validatetrans_iter, METH_VARARGS, NULL}, 15635 { (char *)"qpol_policy_t_validatetrans_count", _wrap_qpol_policy_t_validatetrans_count, METH_VARARGS, NULL}, 15636 { (char *)"qpol_policy_t_role_allow_iter", _wrap_qpol_policy_t_role_allow_iter, METH_VARARGS, NULL}, 15637 { (char *)"qpol_policy_t_role_allow_count", _wrap_qpol_policy_t_role_allow_count, METH_VARARGS, NULL}, 15638 { (char *)"qpol_policy_t_role_trans_iter", _wrap_qpol_policy_t_role_trans_iter, METH_VARARGS, NULL}, 15639 { (char *)"qpol_policy_t_role_trans_count", _wrap_qpol_policy_t_role_trans_count, METH_VARARGS, NULL}, 15640 { (char *)"qpol_policy_t_range_trans_iter", _wrap_qpol_policy_t_range_trans_iter, METH_VARARGS, NULL}, 15641 { (char *)"qpol_policy_t_range_trans_count", _wrap_qpol_policy_t_range_trans_count, METH_VARARGS, NULL}, 15642 { (char *)"qpol_policy_t_avrule_iter", _wrap_qpol_policy_t_avrule_iter, METH_VARARGS, NULL}, 15643 { (char *)"qpol_policy_t_avrule_allow_count", _wrap_qpol_policy_t_avrule_allow_count, METH_VARARGS, NULL}, 15644 { (char *)"qpol_policy_t_avrule_auditallow_count", _wrap_qpol_policy_t_avrule_auditallow_count, METH_VARARGS, NULL}, 15645 { (char *)"qpol_policy_t_avrule_neverallow_count", _wrap_qpol_policy_t_avrule_neverallow_count, METH_VARARGS, NULL}, 15646 { (char *)"qpol_policy_t_avrule_dontaudit_count", _wrap_qpol_policy_t_avrule_dontaudit_count, METH_VARARGS, NULL}, 15647 { (char *)"qpol_policy_t_avrulex_iter", _wrap_qpol_policy_t_avrulex_iter, METH_VARARGS, NULL}, 15648 { (char *)"qpol_policy_t_avrule_allowx_count", _wrap_qpol_policy_t_avrule_allowx_count, METH_VARARGS, NULL}, 15649 { (char *)"qpol_policy_t_avrule_auditallowx_count", _wrap_qpol_policy_t_avrule_auditallowx_count, METH_VARARGS, NULL}, 15650 { (char *)"qpol_policy_t_avrule_neverallowx_count", _wrap_qpol_policy_t_avrule_neverallowx_count, METH_VARARGS, NULL}, 15651 { (char *)"qpol_policy_t_avrule_dontauditx_count", _wrap_qpol_policy_t_avrule_dontauditx_count, METH_VARARGS, NULL}, 15652 { (char *)"qpol_policy_t_terule_iter", _wrap_qpol_policy_t_terule_iter, METH_VARARGS, NULL}, 15653 { (char *)"qpol_policy_t_terule_trans_count", _wrap_qpol_policy_t_terule_trans_count, METH_VARARGS, NULL}, 15654 { (char *)"qpol_policy_t_terule_change_count", _wrap_qpol_policy_t_terule_change_count, METH_VARARGS, NULL}, 15655 { (char *)"qpol_policy_t_terule_member_count", _wrap_qpol_policy_t_terule_member_count, METH_VARARGS, NULL}, 15656 { (char *)"qpol_policy_t_cond_iter", _wrap_qpol_policy_t_cond_iter, METH_VARARGS, NULL}, 15657 { (char *)"qpol_policy_t_cond_count", _wrap_qpol_policy_t_cond_count, METH_VARARGS, NULL}, 15658 { (char *)"qpol_policy_t_filename_trans_iter", _wrap_qpol_policy_t_filename_trans_iter, METH_VARARGS, NULL}, 15659 { (char *)"qpol_policy_t_filename_trans_count", _wrap_qpol_policy_t_filename_trans_count, METH_VARARGS, NULL}, 15660 { (char *)"qpol_policy_t_permissive_iter", _wrap_qpol_policy_t_permissive_iter, METH_VARARGS, NULL}, 15661 { (char *)"qpol_policy_t_permissive_count", _wrap_qpol_policy_t_permissive_count, METH_VARARGS, NULL}, 15662 { (char *)"qpol_policy_t_typebounds_iter", _wrap_qpol_policy_t_typebounds_iter, METH_VARARGS, NULL}, 15663 { (char *)"qpol_policy_t_polcap_iter", _wrap_qpol_policy_t_polcap_iter, METH_VARARGS, NULL}, 15664 { (char *)"qpol_policy_t_polcap_count", _wrap_qpol_policy_t_polcap_count, METH_VARARGS, NULL}, 15665 { (char *)"qpol_policy_t_default_iter", _wrap_qpol_policy_t_default_iter, METH_VARARGS, NULL}, 15666 { (char *)"qpol_policy_t_iomemcon_iter", _wrap_qpol_policy_t_iomemcon_iter, METH_VARARGS, NULL}, 15667 { (char *)"qpol_policy_t_iomemcon_count", _wrap_qpol_policy_t_iomemcon_count, METH_VARARGS, NULL}, 15668 { (char *)"qpol_policy_t_ioportcon_iter", _wrap_qpol_policy_t_ioportcon_iter, METH_VARARGS, NULL}, 15669 { (char *)"qpol_policy_t_ioportcon_count", _wrap_qpol_policy_t_ioportcon_count, METH_VARARGS, NULL}, 15670 { (char *)"qpol_policy_t_pcidevicecon_iter", _wrap_qpol_policy_t_pcidevicecon_iter, METH_VARARGS, NULL}, 15671 { (char *)"qpol_policy_t_pcidevicecon_count", _wrap_qpol_policy_t_pcidevicecon_count, METH_VARARGS, NULL}, 15672 { (char *)"qpol_policy_t_pirqcon_iter", _wrap_qpol_policy_t_pirqcon_iter, METH_VARARGS, NULL}, 15673 { (char *)"qpol_policy_t_pirqcon_count", _wrap_qpol_policy_t_pirqcon_count, METH_VARARGS, NULL}, 15674 { (char *)"qpol_policy_t_devicetreecon_iter", _wrap_qpol_policy_t_devicetreecon_iter, METH_VARARGS, NULL}, 15675 { (char *)"qpol_policy_t_devicetreecon_count", _wrap_qpol_policy_t_devicetreecon_count, METH_VARARGS, NULL}, 15676 { (char *)"qpol_policy_t_swigregister", qpol_policy_t_swigregister, METH_VARARGS, NULL}, 15677 { (char *)"new_qpol_iterator_t", _wrap_new_qpol_iterator_t, METH_VARARGS, NULL}, 15678 { (char *)"delete_qpol_iterator_t", _wrap_delete_qpol_iterator_t, METH_VARARGS, NULL}, 15679 { (char *)"qpol_iterator_t_item", _wrap_qpol_iterator_t_item, METH_VARARGS, NULL}, 15680 { (char *)"qpol_iterator_t_next_", _wrap_qpol_iterator_t_next_, METH_VARARGS, NULL}, 15681 { (char *)"qpol_iterator_t_isend", _wrap_qpol_iterator_t_isend, METH_VARARGS, NULL}, 15682 { (char *)"qpol_iterator_t_size", _wrap_qpol_iterator_t_size, METH_VARARGS, NULL}, 15683 { (char *)"qpol_iterator_t_swigregister", qpol_iterator_t_swigregister, METH_VARARGS, NULL}, 15684 { (char *)"new_qpol_type_t", _wrap_new_qpol_type_t, METH_VARARGS, NULL}, 15685 { (char *)"delete_qpol_type_t", _wrap_delete_qpol_type_t, METH_VARARGS, NULL}, 15686 { (char *)"qpol_type_t_name", _wrap_qpol_type_t_name, METH_VARARGS, NULL}, 15687 { (char *)"qpol_type_t_value", _wrap_qpol_type_t_value, METH_VARARGS, NULL}, 15688 { (char *)"qpol_type_t_isalias", _wrap_qpol_type_t_isalias, METH_VARARGS, NULL}, 15689 { (char *)"qpol_type_t_isattr", _wrap_qpol_type_t_isattr, METH_VARARGS, NULL}, 15690 { (char *)"qpol_type_t_ispermissive", _wrap_qpol_type_t_ispermissive, METH_VARARGS, NULL}, 15691 { (char *)"qpol_type_t_type_iter", _wrap_qpol_type_t_type_iter, METH_VARARGS, NULL}, 15692 { (char *)"qpol_type_t_attr_iter", _wrap_qpol_type_t_attr_iter, METH_VARARGS, NULL}, 15693 { (char *)"qpol_type_t_alias_iter", _wrap_qpol_type_t_alias_iter, METH_VARARGS, NULL}, 15694 { (char *)"qpol_type_t_swigregister", qpol_type_t_swigregister, METH_VARARGS, NULL}, 15695 { (char *)"qpol_type_from_void", _wrap_qpol_type_from_void, METH_VARARGS, NULL}, 15696 { (char *)"new_qpol_role_t", _wrap_new_qpol_role_t, METH_VARARGS, NULL}, 15697 { (char *)"delete_qpol_role_t", _wrap_delete_qpol_role_t, METH_VARARGS, NULL}, 15698 { (char *)"qpol_role_t_value", _wrap_qpol_role_t_value, METH_VARARGS, NULL}, 15699 { (char *)"qpol_role_t_name", _wrap_qpol_role_t_name, METH_VARARGS, NULL}, 15700 { (char *)"qpol_role_t_type_iter", _wrap_qpol_role_t_type_iter, METH_VARARGS, NULL}, 15701 { (char *)"qpol_role_t_dominate_iter", _wrap_qpol_role_t_dominate_iter, METH_VARARGS, NULL}, 15702 { (char *)"qpol_role_t_swigregister", qpol_role_t_swigregister, METH_VARARGS, NULL}, 15703 { (char *)"qpol_role_from_void", _wrap_qpol_role_from_void, METH_VARARGS, NULL}, 15704 { (char *)"new_qpol_level_t", _wrap_new_qpol_level_t, METH_VARARGS, NULL}, 15705 { (char *)"delete_qpol_level_t", _wrap_delete_qpol_level_t, METH_VARARGS, NULL}, 15706 { (char *)"qpol_level_t_isalias", _wrap_qpol_level_t_isalias, METH_VARARGS, NULL}, 15707 { (char *)"qpol_level_t_value", _wrap_qpol_level_t_value, METH_VARARGS, NULL}, 15708 { (char *)"qpol_level_t_name", _wrap_qpol_level_t_name, METH_VARARGS, NULL}, 15709 { (char *)"qpol_level_t_cat_iter", _wrap_qpol_level_t_cat_iter, METH_VARARGS, NULL}, 15710 { (char *)"qpol_level_t_alias_iter", _wrap_qpol_level_t_alias_iter, METH_VARARGS, NULL}, 15711 { (char *)"qpol_level_t_swigregister", qpol_level_t_swigregister, METH_VARARGS, NULL}, 15712 { (char *)"qpol_level_from_void", _wrap_qpol_level_from_void, METH_VARARGS, NULL}, 15713 { (char *)"new_qpol_cat_t", _wrap_new_qpol_cat_t, METH_VARARGS, NULL}, 15714 { (char *)"delete_qpol_cat_t", _wrap_delete_qpol_cat_t, METH_VARARGS, NULL}, 15715 { (char *)"qpol_cat_t_isalias", _wrap_qpol_cat_t_isalias, METH_VARARGS, NULL}, 15716 { (char *)"qpol_cat_t_value", _wrap_qpol_cat_t_value, METH_VARARGS, NULL}, 15717 { (char *)"qpol_cat_t_name", _wrap_qpol_cat_t_name, METH_VARARGS, NULL}, 15718 { (char *)"qpol_cat_t_alias_iter", _wrap_qpol_cat_t_alias_iter, METH_VARARGS, NULL}, 15719 { (char *)"qpol_cat_t_swigregister", qpol_cat_t_swigregister, METH_VARARGS, NULL}, 15720 { (char *)"qpol_cat_from_void", _wrap_qpol_cat_from_void, METH_VARARGS, NULL}, 15721 { (char *)"new_qpol_mls_range_t", _wrap_new_qpol_mls_range_t, METH_VARARGS, NULL}, 15722 { (char *)"delete_qpol_mls_range_t", _wrap_delete_qpol_mls_range_t, METH_VARARGS, NULL}, 15723 { (char *)"qpol_mls_range_t_high_level", _wrap_qpol_mls_range_t_high_level, METH_VARARGS, NULL}, 15724 { (char *)"qpol_mls_range_t_low_level", _wrap_qpol_mls_range_t_low_level, METH_VARARGS, NULL}, 15725 { (char *)"qpol_mls_range_t_swigregister", qpol_mls_range_t_swigregister, METH_VARARGS, NULL}, 15726 { (char *)"qpol_mls_range_from_void", _wrap_qpol_mls_range_from_void, METH_VARARGS, NULL}, 15727 { (char *)"new_qpol_semantic_level_t", _wrap_new_qpol_semantic_level_t, METH_VARARGS, NULL}, 15728 { (char *)"delete_qpol_semantic_level_t", _wrap_delete_qpol_semantic_level_t, METH_VARARGS, NULL}, 15729 { (char *)"qpol_semantic_level_t_add_cats", _wrap_qpol_semantic_level_t_add_cats, METH_VARARGS, NULL}, 15730 { (char *)"qpol_semantic_level_t_swigregister", qpol_semantic_level_t_swigregister, METH_VARARGS, NULL}, 15731 { (char *)"new_qpol_mls_level_t", _wrap_new_qpol_mls_level_t, METH_VARARGS, NULL}, 15732 { (char *)"delete_qpol_mls_level_t", _wrap_delete_qpol_mls_level_t, METH_VARARGS, NULL}, 15733 { (char *)"qpol_mls_level_t_sens_name", _wrap_qpol_mls_level_t_sens_name, METH_VARARGS, NULL}, 15734 { (char *)"qpol_mls_level_t_cat_iter", _wrap_qpol_mls_level_t_cat_iter, METH_VARARGS, NULL}, 15735 { (char *)"qpol_mls_level_t_swigregister", qpol_mls_level_t_swigregister, METH_VARARGS, NULL}, 15736 { (char *)"qpol_mls_level_from_void", _wrap_qpol_mls_level_from_void, METH_VARARGS, NULL}, 15737 { (char *)"new_qpol_user_t", _wrap_new_qpol_user_t, METH_VARARGS, NULL}, 15738 { (char *)"delete_qpol_user_t", _wrap_delete_qpol_user_t, METH_VARARGS, NULL}, 15739 { (char *)"qpol_user_t_value", _wrap_qpol_user_t_value, METH_VARARGS, NULL}, 15740 { (char *)"qpol_user_t_role_iter", _wrap_qpol_user_t_role_iter, METH_VARARGS, NULL}, 15741 { (char *)"qpol_user_t_range", _wrap_qpol_user_t_range, METH_VARARGS, NULL}, 15742 { (char *)"qpol_user_t_name", _wrap_qpol_user_t_name, METH_VARARGS, NULL}, 15743 { (char *)"qpol_user_t_dfltlevel", _wrap_qpol_user_t_dfltlevel, METH_VARARGS, NULL}, 15744 { (char *)"qpol_user_t_swigregister", qpol_user_t_swigregister, METH_VARARGS, NULL}, 15745 { (char *)"qpol_user_from_void", _wrap_qpol_user_from_void, METH_VARARGS, NULL}, 15746 { (char *)"new_qpol_bool_t", _wrap_new_qpol_bool_t, METH_VARARGS, NULL}, 15747 { (char *)"delete_qpol_bool_t", _wrap_delete_qpol_bool_t, METH_VARARGS, NULL}, 15748 { (char *)"qpol_bool_t_value", _wrap_qpol_bool_t_value, METH_VARARGS, NULL}, 15749 { (char *)"qpol_bool_t_state", _wrap_qpol_bool_t_state, METH_VARARGS, NULL}, 15750 { (char *)"qpol_bool_t_name", _wrap_qpol_bool_t_name, METH_VARARGS, NULL}, 15751 { (char *)"qpol_bool_t_swigregister", qpol_bool_t_swigregister, METH_VARARGS, NULL}, 15752 { (char *)"qpol_bool_from_void", _wrap_qpol_bool_from_void, METH_VARARGS, NULL}, 15753 { (char *)"new_qpol_context_t", _wrap_new_qpol_context_t, METH_VARARGS, NULL}, 15754 { (char *)"delete_qpol_context_t", _wrap_delete_qpol_context_t, METH_VARARGS, NULL}, 15755 { (char *)"qpol_context_t_user", _wrap_qpol_context_t_user, METH_VARARGS, NULL}, 15756 { (char *)"qpol_context_t_role", _wrap_qpol_context_t_role, METH_VARARGS, NULL}, 15757 { (char *)"qpol_context_t_type_", _wrap_qpol_context_t_type_, METH_VARARGS, NULL}, 15758 { (char *)"qpol_context_t_range", _wrap_qpol_context_t_range, METH_VARARGS, NULL}, 15759 { (char *)"qpol_context_t_swigregister", qpol_context_t_swigregister, METH_VARARGS, NULL}, 15760 { (char *)"qpol_context_from_void", _wrap_qpol_context_from_void, METH_VARARGS, NULL}, 15761 { (char *)"new_qpol_class_t", _wrap_new_qpol_class_t, METH_VARARGS, NULL}, 15762 { (char *)"delete_qpol_class_t", _wrap_delete_qpol_class_t, METH_VARARGS, NULL}, 15763 { (char *)"qpol_class_t_value", _wrap_qpol_class_t_value, METH_VARARGS, NULL}, 15764 { (char *)"qpol_class_t_common", _wrap_qpol_class_t_common, METH_VARARGS, NULL}, 15765 { (char *)"qpol_class_t_perm_iter", _wrap_qpol_class_t_perm_iter, METH_VARARGS, NULL}, 15766 { (char *)"qpol_class_t_constraint_iter", _wrap_qpol_class_t_constraint_iter, METH_VARARGS, NULL}, 15767 { (char *)"qpol_class_t_validatetrans_iter", _wrap_qpol_class_t_validatetrans_iter, METH_VARARGS, NULL}, 15768 { (char *)"qpol_class_t_name", _wrap_qpol_class_t_name, METH_VARARGS, NULL}, 15769 { (char *)"qpol_class_t_swigregister", qpol_class_t_swigregister, METH_VARARGS, NULL}, 15770 { (char *)"qpol_class_from_void", _wrap_qpol_class_from_void, METH_VARARGS, NULL}, 15771 { (char *)"new_qpol_common_t", _wrap_new_qpol_common_t, METH_VARARGS, NULL}, 15772 { (char *)"delete_qpol_common_t", _wrap_delete_qpol_common_t, METH_VARARGS, NULL}, 15773 { (char *)"qpol_common_t_value", _wrap_qpol_common_t_value, METH_VARARGS, NULL}, 15774 { (char *)"qpol_common_t_perm_iter", _wrap_qpol_common_t_perm_iter, METH_VARARGS, NULL}, 15775 { (char *)"qpol_common_t_name", _wrap_qpol_common_t_name, METH_VARARGS, NULL}, 15776 { (char *)"qpol_common_t_swigregister", qpol_common_t_swigregister, METH_VARARGS, NULL}, 15777 { (char *)"qpol_common_from_void", _wrap_qpol_common_from_void, METH_VARARGS, NULL}, 15778 { (char *)"new_qpol_fs_use_t", _wrap_new_qpol_fs_use_t, METH_VARARGS, NULL}, 15779 { (char *)"delete_qpol_fs_use_t", _wrap_delete_qpol_fs_use_t, METH_VARARGS, NULL}, 15780 { (char *)"qpol_fs_use_t_name", _wrap_qpol_fs_use_t_name, METH_VARARGS, NULL}, 15781 { (char *)"qpol_fs_use_t_behavior", _wrap_qpol_fs_use_t_behavior, METH_VARARGS, NULL}, 15782 { (char *)"qpol_fs_use_t_context", _wrap_qpol_fs_use_t_context, METH_VARARGS, NULL}, 15783 { (char *)"qpol_fs_use_t_swigregister", qpol_fs_use_t_swigregister, METH_VARARGS, NULL}, 15784 { (char *)"qpol_fs_use_from_void", _wrap_qpol_fs_use_from_void, METH_VARARGS, NULL}, 15785 { (char *)"new_qpol_genfscon_t", _wrap_new_qpol_genfscon_t, METH_VARARGS, NULL}, 15786 { (char *)"delete_qpol_genfscon_t", _wrap_delete_qpol_genfscon_t, METH_VARARGS, NULL}, 15787 { (char *)"qpol_genfscon_t_name", _wrap_qpol_genfscon_t_name, METH_VARARGS, NULL}, 15788 { (char *)"qpol_genfscon_t_path", _wrap_qpol_genfscon_t_path, METH_VARARGS, NULL}, 15789 { (char *)"qpol_genfscon_t_object_class", _wrap_qpol_genfscon_t_object_class, METH_VARARGS, NULL}, 15790 { (char *)"qpol_genfscon_t_context", _wrap_qpol_genfscon_t_context, METH_VARARGS, NULL}, 15791 { (char *)"qpol_genfscon_t_swigregister", qpol_genfscon_t_swigregister, METH_VARARGS, NULL}, 15792 { (char *)"qpol_genfscon_from_void", _wrap_qpol_genfscon_from_void, METH_VARARGS, NULL}, 15793 { (char *)"new_qpol_isid_t", _wrap_new_qpol_isid_t, METH_VARARGS, NULL}, 15794 { (char *)"delete_qpol_isid_t", _wrap_delete_qpol_isid_t, METH_VARARGS, NULL}, 15795 { (char *)"qpol_isid_t_name", _wrap_qpol_isid_t_name, METH_VARARGS, NULL}, 15796 { (char *)"qpol_isid_t_context", _wrap_qpol_isid_t_context, METH_VARARGS, NULL}, 15797 { (char *)"qpol_isid_t_swigregister", qpol_isid_t_swigregister, METH_VARARGS, NULL}, 15798 { (char *)"qpol_isid_from_void", _wrap_qpol_isid_from_void, METH_VARARGS, NULL}, 15799 { (char *)"new_qpol_netifcon_t", _wrap_new_qpol_netifcon_t, METH_VARARGS, NULL}, 15800 { (char *)"delete_qpol_netifcon_t", _wrap_delete_qpol_netifcon_t, METH_VARARGS, NULL}, 15801 { (char *)"qpol_netifcon_t_name", _wrap_qpol_netifcon_t_name, METH_VARARGS, NULL}, 15802 { (char *)"qpol_netifcon_t_msg_con", _wrap_qpol_netifcon_t_msg_con, METH_VARARGS, NULL}, 15803 { (char *)"qpol_netifcon_t_if_con", _wrap_qpol_netifcon_t_if_con, METH_VARARGS, NULL}, 15804 { (char *)"qpol_netifcon_t_swigregister", qpol_netifcon_t_swigregister, METH_VARARGS, NULL}, 15805 { (char *)"qpol_netifcon_from_void", _wrap_qpol_netifcon_from_void, METH_VARARGS, NULL}, 15806 { (char *)"new_qpol_nodecon_t", _wrap_new_qpol_nodecon_t, METH_VARARGS, NULL}, 15807 { (char *)"delete_qpol_nodecon_t", _wrap_delete_qpol_nodecon_t, METH_VARARGS, NULL}, 15808 { (char *)"qpol_nodecon_t_addr", _wrap_qpol_nodecon_t_addr, METH_VARARGS, NULL}, 15809 { (char *)"qpol_nodecon_t_mask", _wrap_qpol_nodecon_t_mask, METH_VARARGS, NULL}, 15810 { (char *)"qpol_nodecon_t_protocol", _wrap_qpol_nodecon_t_protocol, METH_VARARGS, NULL}, 15811 { (char *)"qpol_nodecon_t_context", _wrap_qpol_nodecon_t_context, METH_VARARGS, NULL}, 15812 { (char *)"qpol_nodecon_t_swigregister", qpol_nodecon_t_swigregister, METH_VARARGS, NULL}, 15813 { (char *)"qpol_nodecon_from_void", _wrap_qpol_nodecon_from_void, METH_VARARGS, NULL}, 15814 { (char *)"new_qpol_portcon_t", _wrap_new_qpol_portcon_t, METH_VARARGS, NULL}, 15815 { (char *)"delete_qpol_portcon_t", _wrap_delete_qpol_portcon_t, METH_VARARGS, NULL}, 15816 { (char *)"qpol_portcon_t_low_port", _wrap_qpol_portcon_t_low_port, METH_VARARGS, NULL}, 15817 { (char *)"qpol_portcon_t_high_port", _wrap_qpol_portcon_t_high_port, METH_VARARGS, NULL}, 15818 { (char *)"qpol_portcon_t_protocol", _wrap_qpol_portcon_t_protocol, METH_VARARGS, NULL}, 15819 { (char *)"qpol_portcon_t_context", _wrap_qpol_portcon_t_context, METH_VARARGS, NULL}, 15820 { (char *)"qpol_portcon_t_swigregister", qpol_portcon_t_swigregister, METH_VARARGS, NULL}, 15821 { (char *)"qpol_portcon_from_void", _wrap_qpol_portcon_from_void, METH_VARARGS, NULL}, 15822 { (char *)"new_qpol_constraint_t", _wrap_new_qpol_constraint_t, METH_VARARGS, NULL}, 15823 { (char *)"delete_qpol_constraint_t", _wrap_delete_qpol_constraint_t, METH_VARARGS, NULL}, 15824 { (char *)"qpol_constraint_t_object_class", _wrap_qpol_constraint_t_object_class, METH_VARARGS, NULL}, 15825 { (char *)"qpol_constraint_t_perm_iter", _wrap_qpol_constraint_t_perm_iter, METH_VARARGS, NULL}, 15826 { (char *)"qpol_constraint_t_expr_iter", _wrap_qpol_constraint_t_expr_iter, METH_VARARGS, NULL}, 15827 { (char *)"qpol_constraint_t_swigregister", qpol_constraint_t_swigregister, METH_VARARGS, NULL}, 15828 { (char *)"qpol_constraint_from_void", _wrap_qpol_constraint_from_void, METH_VARARGS, NULL}, 15829 { (char *)"new_qpol_validatetrans_t", _wrap_new_qpol_validatetrans_t, METH_VARARGS, NULL}, 15830 { (char *)"delete_qpol_validatetrans_t", _wrap_delete_qpol_validatetrans_t, METH_VARARGS, NULL}, 15831 { (char *)"qpol_validatetrans_t_object_class", _wrap_qpol_validatetrans_t_object_class, METH_VARARGS, NULL}, 15832 { (char *)"qpol_validatetrans_t_expr_iter", _wrap_qpol_validatetrans_t_expr_iter, METH_VARARGS, NULL}, 15833 { (char *)"qpol_validatetrans_t_swigregister", qpol_validatetrans_t_swigregister, METH_VARARGS, NULL}, 15834 { (char *)"qpol_validatetrans_from_void", _wrap_qpol_validatetrans_from_void, METH_VARARGS, NULL}, 15835 { (char *)"new_qpol_constraint_expr_node_t", _wrap_new_qpol_constraint_expr_node_t, METH_VARARGS, NULL}, 15836 { (char *)"delete_qpol_constraint_expr_node_t", _wrap_delete_qpol_constraint_expr_node_t, METH_VARARGS, NULL}, 15837 { (char *)"qpol_constraint_expr_node_t_expr_type", _wrap_qpol_constraint_expr_node_t_expr_type, METH_VARARGS, NULL}, 15838 { (char *)"qpol_constraint_expr_node_t_sym_type", _wrap_qpol_constraint_expr_node_t_sym_type, METH_VARARGS, NULL}, 15839 { (char *)"qpol_constraint_expr_node_t_op", _wrap_qpol_constraint_expr_node_t_op, METH_VARARGS, NULL}, 15840 { (char *)"qpol_constraint_expr_node_t_names_iter", _wrap_qpol_constraint_expr_node_t_names_iter, METH_VARARGS, NULL}, 15841 { (char *)"qpol_constraint_expr_node_t_swigregister", qpol_constraint_expr_node_t_swigregister, METH_VARARGS, NULL}, 15842 { (char *)"qpol_constraint_expr_node_from_void", _wrap_qpol_constraint_expr_node_from_void, METH_VARARGS, NULL}, 15843 { (char *)"new_qpol_role_allow_t", _wrap_new_qpol_role_allow_t, METH_VARARGS, NULL}, 15844 { (char *)"delete_qpol_role_allow_t", _wrap_delete_qpol_role_allow_t, METH_VARARGS, NULL}, 15845 { (char *)"qpol_role_allow_t_source_role", _wrap_qpol_role_allow_t_source_role, METH_VARARGS, NULL}, 15846 { (char *)"qpol_role_allow_t_target_role", _wrap_qpol_role_allow_t_target_role, METH_VARARGS, NULL}, 15847 { (char *)"qpol_role_allow_t_swigregister", qpol_role_allow_t_swigregister, METH_VARARGS, NULL}, 15848 { (char *)"qpol_role_allow_from_void", _wrap_qpol_role_allow_from_void, METH_VARARGS, NULL}, 15849 { (char *)"new_qpol_role_trans_t", _wrap_new_qpol_role_trans_t, METH_VARARGS, NULL}, 15850 { (char *)"delete_qpol_role_trans_t", _wrap_delete_qpol_role_trans_t, METH_VARARGS, NULL}, 15851 { (char *)"qpol_role_trans_t_source_role", _wrap_qpol_role_trans_t_source_role, METH_VARARGS, NULL}, 15852 { (char *)"qpol_role_trans_t_target_type", _wrap_qpol_role_trans_t_target_type, METH_VARARGS, NULL}, 15853 { (char *)"qpol_role_trans_t_object_class", _wrap_qpol_role_trans_t_object_class, METH_VARARGS, NULL}, 15854 { (char *)"qpol_role_trans_t_default_role", _wrap_qpol_role_trans_t_default_role, METH_VARARGS, NULL}, 15855 { (char *)"qpol_role_trans_t_swigregister", qpol_role_trans_t_swigregister, METH_VARARGS, NULL}, 15856 { (char *)"qpol_role_trans_from_void", _wrap_qpol_role_trans_from_void, METH_VARARGS, NULL}, 15857 { (char *)"new_qpol_range_trans_t", _wrap_new_qpol_range_trans_t, METH_VARARGS, NULL}, 15858 { (char *)"delete_qpol_range_trans_t", _wrap_delete_qpol_range_trans_t, METH_VARARGS, NULL}, 15859 { (char *)"qpol_range_trans_t_source_type", _wrap_qpol_range_trans_t_source_type, METH_VARARGS, NULL}, 15860 { (char *)"qpol_range_trans_t_target_type", _wrap_qpol_range_trans_t_target_type, METH_VARARGS, NULL}, 15861 { (char *)"qpol_range_trans_t_object_class", _wrap_qpol_range_trans_t_object_class, METH_VARARGS, NULL}, 15862 { (char *)"qpol_range_trans_t_range", _wrap_qpol_range_trans_t_range, METH_VARARGS, NULL}, 15863 { (char *)"qpol_range_trans_t_swigregister", qpol_range_trans_t_swigregister, METH_VARARGS, NULL}, 15864 { (char *)"qpol_range_trans_from_void", _wrap_qpol_range_trans_from_void, METH_VARARGS, NULL}, 15865 { (char *)"new_qpol_avrule_t", _wrap_new_qpol_avrule_t, METH_VARARGS, NULL}, 15866 { (char *)"delete_qpol_avrule_t", _wrap_delete_qpol_avrule_t, METH_VARARGS, NULL}, 15867 { (char *)"qpol_avrule_t_rule_type", _wrap_qpol_avrule_t_rule_type, METH_VARARGS, NULL}, 15868 { (char *)"qpol_avrule_t_source_type", _wrap_qpol_avrule_t_source_type, METH_VARARGS, NULL}, 15869 { (char *)"qpol_avrule_t_target_type", _wrap_qpol_avrule_t_target_type, METH_VARARGS, NULL}, 15870 { (char *)"qpol_avrule_t_object_class", _wrap_qpol_avrule_t_object_class, METH_VARARGS, NULL}, 15871 { (char *)"qpol_avrule_t_perm_iter", _wrap_qpol_avrule_t_perm_iter, METH_VARARGS, NULL}, 15872 { (char *)"qpol_avrule_t_xperm_iter", _wrap_qpol_avrule_t_xperm_iter, METH_VARARGS, NULL}, 15873 { (char *)"qpol_avrule_t_is_extended", _wrap_qpol_avrule_t_is_extended, METH_VARARGS, NULL}, 15874 { (char *)"qpol_avrule_t_xperm_type", _wrap_qpol_avrule_t_xperm_type, METH_VARARGS, NULL}, 15875 { (char *)"qpol_avrule_t_cond", _wrap_qpol_avrule_t_cond, METH_VARARGS, NULL}, 15876 { (char *)"qpol_avrule_t_is_enabled", _wrap_qpol_avrule_t_is_enabled, METH_VARARGS, NULL}, 15877 { (char *)"qpol_avrule_t_which_list", _wrap_qpol_avrule_t_which_list, METH_VARARGS, NULL}, 15878 { (char *)"qpol_avrule_t_syn_avrule_iter", _wrap_qpol_avrule_t_syn_avrule_iter, METH_VARARGS, NULL}, 15879 { (char *)"qpol_avrule_t_swigregister", qpol_avrule_t_swigregister, METH_VARARGS, NULL}, 15880 { (char *)"qpol_avrule_from_void", _wrap_qpol_avrule_from_void, METH_VARARGS, NULL}, 15881 { (char *)"new_qpol_terule_t", _wrap_new_qpol_terule_t, METH_VARARGS, NULL}, 15882 { (char *)"delete_qpol_terule_t", _wrap_delete_qpol_terule_t, METH_VARARGS, NULL}, 15883 { (char *)"qpol_terule_t_rule_type", _wrap_qpol_terule_t_rule_type, METH_VARARGS, NULL}, 15884 { (char *)"qpol_terule_t_source_type", _wrap_qpol_terule_t_source_type, METH_VARARGS, NULL}, 15885 { (char *)"qpol_terule_t_target_type", _wrap_qpol_terule_t_target_type, METH_VARARGS, NULL}, 15886 { (char *)"qpol_terule_t_object_class", _wrap_qpol_terule_t_object_class, METH_VARARGS, NULL}, 15887 { (char *)"qpol_terule_t_default_type", _wrap_qpol_terule_t_default_type, METH_VARARGS, NULL}, 15888 { (char *)"qpol_terule_t_cond", _wrap_qpol_terule_t_cond, METH_VARARGS, NULL}, 15889 { (char *)"qpol_terule_t_is_enabled", _wrap_qpol_terule_t_is_enabled, METH_VARARGS, NULL}, 15890 { (char *)"qpol_terule_t_which_list", _wrap_qpol_terule_t_which_list, METH_VARARGS, NULL}, 15891 { (char *)"qpol_terule_t_syn_terule_iter", _wrap_qpol_terule_t_syn_terule_iter, METH_VARARGS, NULL}, 15892 { (char *)"qpol_terule_t_swigregister", qpol_terule_t_swigregister, METH_VARARGS, NULL}, 15893 { (char *)"qpol_terule_from_void", _wrap_qpol_terule_from_void, METH_VARARGS, NULL}, 15894 { (char *)"new_qpol_cond_t", _wrap_new_qpol_cond_t, METH_VARARGS, NULL}, 15895 { (char *)"delete_qpol_cond_t", _wrap_delete_qpol_cond_t, METH_VARARGS, NULL}, 15896 { (char *)"qpol_cond_t_expr_node_iter", _wrap_qpol_cond_t_expr_node_iter, METH_VARARGS, NULL}, 15897 { (char *)"qpol_cond_t_av_true_iter", _wrap_qpol_cond_t_av_true_iter, METH_VARARGS, NULL}, 15898 { (char *)"qpol_cond_t_av_false_iter", _wrap_qpol_cond_t_av_false_iter, METH_VARARGS, NULL}, 15899 { (char *)"qpol_cond_t_te_true_iter", _wrap_qpol_cond_t_te_true_iter, METH_VARARGS, NULL}, 15900 { (char *)"qpol_cond_t_te_false_iter", _wrap_qpol_cond_t_te_false_iter, METH_VARARGS, NULL}, 15901 { (char *)"qpol_cond_t_evaluate", _wrap_qpol_cond_t_evaluate, METH_VARARGS, NULL}, 15902 { (char *)"qpol_cond_t_swigregister", qpol_cond_t_swigregister, METH_VARARGS, NULL}, 15903 { (char *)"qpol_cond_from_void", _wrap_qpol_cond_from_void, METH_VARARGS, NULL}, 15904 { (char *)"new_qpol_cond_expr_node_t", _wrap_new_qpol_cond_expr_node_t, METH_VARARGS, NULL}, 15905 { (char *)"delete_qpol_cond_expr_node_t", _wrap_delete_qpol_cond_expr_node_t, METH_VARARGS, NULL}, 15906 { (char *)"qpol_cond_expr_node_t_expr_type", _wrap_qpol_cond_expr_node_t_expr_type, METH_VARARGS, NULL}, 15907 { (char *)"qpol_cond_expr_node_t_get_boolean", _wrap_qpol_cond_expr_node_t_get_boolean, METH_VARARGS, NULL}, 15908 { (char *)"qpol_cond_expr_node_t_swigregister", qpol_cond_expr_node_t_swigregister, METH_VARARGS, NULL}, 15909 { (char *)"qpol_cond_expr_node_from_void", _wrap_qpol_cond_expr_node_from_void, METH_VARARGS, NULL}, 15910 { (char *)"new_qpol_filename_trans_t", _wrap_new_qpol_filename_trans_t, METH_VARARGS, NULL}, 15911 { (char *)"delete_qpol_filename_trans_t", _wrap_delete_qpol_filename_trans_t, METH_VARARGS, NULL}, 15912 { (char *)"qpol_filename_trans_t_source_type", _wrap_qpol_filename_trans_t_source_type, METH_VARARGS, NULL}, 15913 { (char *)"qpol_filename_trans_t_target_type", _wrap_qpol_filename_trans_t_target_type, METH_VARARGS, NULL}, 15914 { (char *)"qpol_filename_trans_t_object_class", _wrap_qpol_filename_trans_t_object_class, METH_VARARGS, NULL}, 15915 { (char *)"qpol_filename_trans_t_default_type", _wrap_qpol_filename_trans_t_default_type, METH_VARARGS, NULL}, 15916 { (char *)"qpol_filename_trans_t_filename", _wrap_qpol_filename_trans_t_filename, METH_VARARGS, NULL}, 15917 { (char *)"qpol_filename_trans_t_swigregister", qpol_filename_trans_t_swigregister, METH_VARARGS, NULL}, 15918 { (char *)"qpol_filename_trans_from_void", _wrap_qpol_filename_trans_from_void, METH_VARARGS, NULL}, 15919 { (char *)"new_qpol_polcap_t", _wrap_new_qpol_polcap_t, METH_VARARGS, NULL}, 15920 { (char *)"delete_qpol_polcap_t", _wrap_delete_qpol_polcap_t, METH_VARARGS, NULL}, 15921 { (char *)"qpol_polcap_t_name", _wrap_qpol_polcap_t_name, METH_VARARGS, NULL}, 15922 { (char *)"qpol_polcap_t_swigregister", qpol_polcap_t_swigregister, METH_VARARGS, NULL}, 15923 { (char *)"qpol_polcap_from_void", _wrap_qpol_polcap_from_void, METH_VARARGS, NULL}, 15924 { (char *)"new_qpol_typebounds_t", _wrap_new_qpol_typebounds_t, METH_VARARGS, NULL}, 15925 { (char *)"delete_qpol_typebounds_t", _wrap_delete_qpol_typebounds_t, METH_VARARGS, NULL}, 15926 { (char *)"qpol_typebounds_t_parent_name", _wrap_qpol_typebounds_t_parent_name, METH_VARARGS, NULL}, 15927 { (char *)"qpol_typebounds_t_child_name", _wrap_qpol_typebounds_t_child_name, METH_VARARGS, NULL}, 15928 { (char *)"qpol_typebounds_t_swigregister", qpol_typebounds_t_swigregister, METH_VARARGS, NULL}, 15929 { (char *)"qpol_typebounds_from_void", _wrap_qpol_typebounds_from_void, METH_VARARGS, NULL}, 15930 { (char *)"new_qpol_rolebounds_t", _wrap_new_qpol_rolebounds_t, METH_VARARGS, NULL}, 15931 { (char *)"delete_qpol_rolebounds_t", _wrap_delete_qpol_rolebounds_t, METH_VARARGS, NULL}, 15932 { (char *)"qpol_rolebounds_t_parent_name", _wrap_qpol_rolebounds_t_parent_name, METH_VARARGS, NULL}, 15933 { (char *)"qpol_rolebounds_t_child_name", _wrap_qpol_rolebounds_t_child_name, METH_VARARGS, NULL}, 15934 { (char *)"qpol_rolebounds_t_swigregister", qpol_rolebounds_t_swigregister, METH_VARARGS, NULL}, 15935 { (char *)"qpol_rolebounds_from_void", _wrap_qpol_rolebounds_from_void, METH_VARARGS, NULL}, 15936 { (char *)"new_qpol_userbounds_t", _wrap_new_qpol_userbounds_t, METH_VARARGS, NULL}, 15937 { (char *)"delete_qpol_userbounds_t", _wrap_delete_qpol_userbounds_t, METH_VARARGS, NULL}, 15938 { (char *)"qpol_userbounds_t_parent_name", _wrap_qpol_userbounds_t_parent_name, METH_VARARGS, NULL}, 15939 { (char *)"qpol_userbounds_t_child_name", _wrap_qpol_userbounds_t_child_name, METH_VARARGS, NULL}, 15940 { (char *)"qpol_userbounds_t_swigregister", qpol_userbounds_t_swigregister, METH_VARARGS, NULL}, 15941 { (char *)"qpol_userbounds_from_void", _wrap_qpol_userbounds_from_void, METH_VARARGS, NULL}, 15942 { (char *)"new_qpol_default_object_t", _wrap_new_qpol_default_object_t, METH_VARARGS, NULL}, 15943 { (char *)"delete_qpol_default_object_t", _wrap_delete_qpol_default_object_t, METH_VARARGS, NULL}, 15944 { (char *)"qpol_default_object_t_object_class", _wrap_qpol_default_object_t_object_class, METH_VARARGS, NULL}, 15945 { (char *)"qpol_default_object_t_user_default", _wrap_qpol_default_object_t_user_default, METH_VARARGS, NULL}, 15946 { (char *)"qpol_default_object_t_role_default", _wrap_qpol_default_object_t_role_default, METH_VARARGS, NULL}, 15947 { (char *)"qpol_default_object_t_type_default", _wrap_qpol_default_object_t_type_default, METH_VARARGS, NULL}, 15948 { (char *)"qpol_default_object_t_range_default", _wrap_qpol_default_object_t_range_default, METH_VARARGS, NULL}, 15949 { (char *)"qpol_default_object_t_swigregister", qpol_default_object_t_swigregister, METH_VARARGS, NULL}, 15950 { (char *)"qpol_default_object_from_void", _wrap_qpol_default_object_from_void, METH_VARARGS, NULL}, 15951 { (char *)"new_qpol_iomemcon_t", _wrap_new_qpol_iomemcon_t, METH_VARARGS, NULL}, 15952 { (char *)"delete_qpol_iomemcon_t", _wrap_delete_qpol_iomemcon_t, METH_VARARGS, NULL}, 15953 { (char *)"qpol_iomemcon_t_low_addr", _wrap_qpol_iomemcon_t_low_addr, METH_VARARGS, NULL}, 15954 { (char *)"qpol_iomemcon_t_high_addr", _wrap_qpol_iomemcon_t_high_addr, METH_VARARGS, NULL}, 15955 { (char *)"qpol_iomemcon_t_context", _wrap_qpol_iomemcon_t_context, METH_VARARGS, NULL}, 15956 { (char *)"qpol_iomemcon_t_swigregister", qpol_iomemcon_t_swigregister, METH_VARARGS, NULL}, 15957 { (char *)"qpol_iomemcon_from_void", _wrap_qpol_iomemcon_from_void, METH_VARARGS, NULL}, 15958 { (char *)"new_qpol_ioportcon_t", _wrap_new_qpol_ioportcon_t, METH_VARARGS, NULL}, 15959 { (char *)"delete_qpol_ioportcon_t", _wrap_delete_qpol_ioportcon_t, METH_VARARGS, NULL}, 15960 { (char *)"qpol_ioportcon_t_low_port", _wrap_qpol_ioportcon_t_low_port, METH_VARARGS, NULL}, 15961 { (char *)"qpol_ioportcon_t_high_port", _wrap_qpol_ioportcon_t_high_port, METH_VARARGS, NULL}, 15962 { (char *)"qpol_ioportcon_t_context", _wrap_qpol_ioportcon_t_context, METH_VARARGS, NULL}, 15963 { (char *)"qpol_ioportcon_t_swigregister", qpol_ioportcon_t_swigregister, METH_VARARGS, NULL}, 15964 { (char *)"qpol_ioportcon_from_void", _wrap_qpol_ioportcon_from_void, METH_VARARGS, NULL}, 15965 { (char *)"new_qpol_pcidevicecon_t", _wrap_new_qpol_pcidevicecon_t, METH_VARARGS, NULL}, 15966 { (char *)"delete_qpol_pcidevicecon_t", _wrap_delete_qpol_pcidevicecon_t, METH_VARARGS, NULL}, 15967 { (char *)"qpol_pcidevicecon_t_device", _wrap_qpol_pcidevicecon_t_device, METH_VARARGS, NULL}, 15968 { (char *)"qpol_pcidevicecon_t_context", _wrap_qpol_pcidevicecon_t_context, METH_VARARGS, NULL}, 15969 { (char *)"qpol_pcidevicecon_t_swigregister", qpol_pcidevicecon_t_swigregister, METH_VARARGS, NULL}, 15970 { (char *)"qpol_pcidevicecon_from_void", _wrap_qpol_pcidevicecon_from_void, METH_VARARGS, NULL}, 15971 { (char *)"new_qpol_pirqcon_t", _wrap_new_qpol_pirqcon_t, METH_VARARGS, NULL}, 15972 { (char *)"delete_qpol_pirqcon_t", _wrap_delete_qpol_pirqcon_t, METH_VARARGS, NULL}, 15973 { (char *)"qpol_pirqcon_t_irq", _wrap_qpol_pirqcon_t_irq, METH_VARARGS, NULL}, 15974 { (char *)"qpol_pirqcon_t_context", _wrap_qpol_pirqcon_t_context, METH_VARARGS, NULL}, 15975 { (char *)"qpol_pirqcon_t_swigregister", qpol_pirqcon_t_swigregister, METH_VARARGS, NULL}, 15976 { (char *)"qpol_pirqcon_from_void", _wrap_qpol_pirqcon_from_void, METH_VARARGS, NULL}, 15977 { (char *)"new_qpol_devicetreecon_t", _wrap_new_qpol_devicetreecon_t, METH_VARARGS, NULL}, 15978 { (char *)"qpol_devicetreecon_t_path", _wrap_qpol_devicetreecon_t_path, METH_VARARGS, NULL}, 15979 { (char *)"qpol_devicetreecon_t_context", _wrap_qpol_devicetreecon_t_context, METH_VARARGS, NULL}, 15980 { (char *)"delete_qpol_devicetreecon_t", _wrap_delete_qpol_devicetreecon_t, METH_VARARGS, NULL}, 15981 { (char *)"qpol_devicetreecon_t_swigregister", qpol_devicetreecon_t_swigregister, METH_VARARGS, NULL}, 15982 { (char *)"qpol_devicetreecon_from_void", _wrap_qpol_devicetreecon_from_void, METH_VARARGS, NULL}, 15983 { NULL, NULL, 0, NULL } 15984 }; 15985 15986 15987 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */ 15988 15989 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0}; 15990 static swig_type_info _swigt__p_int = {"_p_int", "intptr_t *|int *|int_least32_t *|int_fast32_t *|int32_t *|int_fast16_t *", 0, 0, (void*)0, 0}; 15991 static swig_type_info _swigt__p_long_long = {"_p_long_long", "int_least64_t *|int_fast64_t *|int64_t *|long long *|intmax_t *", 0, 0, (void*)0, 0}; 15992 static swig_type_info _swigt__p_qpol_avrule = {"_p_qpol_avrule", "qpol_avrule_t *|struct qpol_avrule *|qpol_avrule *", 0, 0, (void*)0, 0}; 15993 static swig_type_info _swigt__p_qpol_bool = {"_p_qpol_bool", "struct qpol_bool *|qpol_bool *|qpol_bool_t *", 0, 0, (void*)0, 0}; 15994 static swig_type_info _swigt__p_qpol_capability = {"_p_qpol_capability", "qpol_capability_e *|enum qpol_capability *", 0, 0, (void*)0, 0}; 15995 static swig_type_info _swigt__p_qpol_cat = {"_p_qpol_cat", "qpol_cat_t *|struct qpol_cat *|qpol_cat *", 0, 0, (void*)0, 0}; 15996 static swig_type_info _swigt__p_qpol_class = {"_p_qpol_class", "qpol_class_t *|struct qpol_class *|qpol_class *", 0, 0, (void*)0, 0}; 15997 static swig_type_info _swigt__p_qpol_common = {"_p_qpol_common", "qpol_common_t *|struct qpol_common *|qpol_common *", 0, 0, (void*)0, 0}; 15998 static swig_type_info _swigt__p_qpol_cond = {"_p_qpol_cond", "qpol_cond_t *|struct qpol_cond *|qpol_cond *", 0, 0, (void*)0, 0}; 15999 static swig_type_info _swigt__p_qpol_cond_expr_node = {"_p_qpol_cond_expr_node", "struct qpol_cond_expr_node *|qpol_cond_expr_node_t *|qpol_cond_expr_node *", 0, 0, (void*)0, 0}; 16000 static swig_type_info _swigt__p_qpol_constraint = {"_p_qpol_constraint", "qpol_constraint_t *|struct qpol_constraint *|qpol_constraint *", 0, 0, (void*)0, 0}; 16001 static swig_type_info _swigt__p_qpol_constraint_expr_node = {"_p_qpol_constraint_expr_node", "struct qpol_constraint_expr_node *|qpol_constraint_expr_node_t *|qpol_constraint_expr_node *", 0, 0, (void*)0, 0}; 16002 static swig_type_info _swigt__p_qpol_context = {"_p_qpol_context", "struct qpol_context *|qpol_context *|qpol_context_t *", 0, 0, (void*)0, 0}; 16003 static swig_type_info _swigt__p_qpol_default_object = {"_p_qpol_default_object", "qpol_default_object_t *|struct qpol_default_object *|qpol_default_object *", 0, 0, (void*)0, 0}; 16004 static swig_type_info _swigt__p_qpol_devicetreecon = {"_p_qpol_devicetreecon", "qpol_devicetreecon_t *|struct qpol_devicetreecon *|qpol_devicetreecon *", 0, 0, (void*)0, 0}; 16005 static swig_type_info _swigt__p_qpol_filename_trans = {"_p_qpol_filename_trans", "struct qpol_filename_trans *|qpol_filename_trans *|qpol_filename_trans_t *", 0, 0, (void*)0, 0}; 16006 static swig_type_info _swigt__p_qpol_fs_use = {"_p_qpol_fs_use", "struct qpol_fs_use *|qpol_fs_use *|qpol_fs_use_t *", 0, 0, (void*)0, 0}; 16007 static swig_type_info _swigt__p_qpol_genfscon = {"_p_qpol_genfscon", "qpol_genfscon_t *|struct qpol_genfscon *|qpol_genfscon *", 0, 0, (void*)0, 0}; 16008 static swig_type_info _swigt__p_qpol_iomemcon = {"_p_qpol_iomemcon", "qpol_iomemcon_t *|struct qpol_iomemcon *|qpol_iomemcon *", 0, 0, (void*)0, 0}; 16009 static swig_type_info _swigt__p_qpol_ioportcon = {"_p_qpol_ioportcon", "struct qpol_ioportcon *|qpol_ioportcon *|qpol_ioportcon_t *", 0, 0, (void*)0, 0}; 16010 static swig_type_info _swigt__p_qpol_isid = {"_p_qpol_isid", "struct qpol_isid *|qpol_isid *|qpol_isid_t *", 0, 0, (void*)0, 0}; 16011 static swig_type_info _swigt__p_qpol_iterator = {"_p_qpol_iterator", "struct qpol_iterator *|qpol_iterator *|qpol_iterator_t *", 0, 0, (void*)0, 0}; 16012 static swig_type_info _swigt__p_qpol_level = {"_p_qpol_level", "qpol_level_t *|struct qpol_level *|qpol_level *", 0, 0, (void*)0, 0}; 16013 static swig_type_info _swigt__p_qpol_mls_level = {"_p_qpol_mls_level", "qpol_mls_level_t *|struct qpol_mls_level *|qpol_mls_level *", 0, 0, (void*)0, 0}; 16014 static swig_type_info _swigt__p_qpol_mls_range = {"_p_qpol_mls_range", "struct qpol_mls_range *|qpol_mls_range *|qpol_mls_range_t *", 0, 0, (void*)0, 0}; 16015 static swig_type_info _swigt__p_qpol_netifcon = {"_p_qpol_netifcon", "qpol_netifcon_t *|struct qpol_netifcon *|qpol_netifcon *", 0, 0, (void*)0, 0}; 16016 static swig_type_info _swigt__p_qpol_nodecon = {"_p_qpol_nodecon", "qpol_nodecon_t *|struct qpol_nodecon *|qpol_nodecon *", 0, 0, (void*)0, 0}; 16017 static swig_type_info _swigt__p_qpol_pcidevicecon = {"_p_qpol_pcidevicecon", "qpol_pcidevicecon_t *|struct qpol_pcidevicecon *|qpol_pcidevicecon *", 0, 0, (void*)0, 0}; 16018 static swig_type_info _swigt__p_qpol_pirqcon = {"_p_qpol_pirqcon", "struct qpol_pirqcon *|qpol_pirqcon *|qpol_pirqcon_t *", 0, 0, (void*)0, 0}; 16019 static swig_type_info _swigt__p_qpol_polcap = {"_p_qpol_polcap", "struct qpol_polcap *|qpol_polcap *|qpol_polcap_t *", 0, 0, (void*)0, 0}; 16020 static swig_type_info _swigt__p_qpol_policy = {"_p_qpol_policy", "qpol_policy_t *|struct qpol_policy *|qpol_policy *", 0, 0, (void*)0, 0}; 16021 static swig_type_info _swigt__p_qpol_portcon = {"_p_qpol_portcon", "struct qpol_portcon *|qpol_portcon *|qpol_portcon_t *", 0, 0, (void*)0, 0}; 16022 static swig_type_info _swigt__p_qpol_range_trans = {"_p_qpol_range_trans", "struct qpol_range_trans *|qpol_range_trans *|qpol_range_trans_t *", 0, 0, (void*)0, 0}; 16023 static swig_type_info _swigt__p_qpol_role = {"_p_qpol_role", "struct qpol_role *|qpol_role_t *|qpol_role *", 0, 0, (void*)0, 0}; 16024 static swig_type_info _swigt__p_qpol_role_allow = {"_p_qpol_role_allow", "struct qpol_role_allow *|qpol_role_allow *|qpol_role_allow_t *", 0, 0, (void*)0, 0}; 16025 static swig_type_info _swigt__p_qpol_role_trans = {"_p_qpol_role_trans", "struct qpol_role_trans *|qpol_role_trans *|qpol_role_trans_t *", 0, 0, (void*)0, 0}; 16026 static swig_type_info _swigt__p_qpol_rolebounds = {"_p_qpol_rolebounds", "qpol_rolebounds_t *|struct qpol_rolebounds *|qpol_rolebounds *", 0, 0, (void*)0, 0}; 16027 static swig_type_info _swigt__p_qpol_semantic_level = {"_p_qpol_semantic_level", "qpol_semantic_level_t *|struct qpol_semantic_level *|qpol_semantic_level *", 0, 0, (void*)0, 0}; 16028 static swig_type_info _swigt__p_qpol_terule = {"_p_qpol_terule", "qpol_terule_t *|struct qpol_terule *|qpol_terule *", 0, 0, (void*)0, 0}; 16029 static swig_type_info _swigt__p_qpol_type = {"_p_qpol_type", "struct qpol_type *|qpol_type *|qpol_type_t *", 0, 0, (void*)0, 0}; 16030 static swig_type_info _swigt__p_qpol_typebounds = {"_p_qpol_typebounds", "qpol_typebounds_t *|struct qpol_typebounds *|qpol_typebounds *", 0, 0, (void*)0, 0}; 16031 static swig_type_info _swigt__p_qpol_user = {"_p_qpol_user", "struct qpol_user *|qpol_user *|qpol_user_t *", 0, 0, (void*)0, 0}; 16032 static swig_type_info _swigt__p_qpol_userbounds = {"_p_qpol_userbounds", "qpol_userbounds_t *|struct qpol_userbounds *|qpol_userbounds *", 0, 0, (void*)0, 0}; 16033 static swig_type_info _swigt__p_qpol_validatetrans = {"_p_qpol_validatetrans", "struct qpol_validatetrans *|qpol_validatetrans *|qpol_validatetrans_t *", 0, 0, (void*)0, 0}; 16034 static swig_type_info _swigt__p_short = {"_p_short", "short *|int_least16_t *|int16_t *", 0, 0, (void*)0, 0}; 16035 static swig_type_info _swigt__p_signed_char = {"_p_signed_char", "signed char *|int_least8_t *|int_fast8_t *|int8_t *", 0, 0, (void*)0, 0}; 16036 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|uint_least8_t *|uint_fast8_t *|uint8_t *", 0, 0, (void*)0, 0}; 16037 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "uintptr_t *|uint_least32_t *|uint_fast32_t *|uint32_t *|size_t *|unsigned int *|uint_fast16_t *", 0, 0, (void*)0, 0}; 16038 static swig_type_info _swigt__p_unsigned_long_long = {"_p_unsigned_long_long", "uint_least64_t *|uint_fast64_t *|uint64_t *|unsigned long long *|uintmax_t *", 0, 0, (void*)0, 0}; 16039 static swig_type_info _swigt__p_unsigned_short = {"_p_unsigned_short", "unsigned short *|uint_least16_t *|uint16_t *", 0, 0, (void*)0, 0}; 16040 static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0}; 16041 16042 static swig_type_info *swig_type_initial[] = { 16043 &_swigt__p_char, 16044 &_swigt__p_int, 16045 &_swigt__p_long_long, 16046 &_swigt__p_qpol_avrule, 16047 &_swigt__p_qpol_bool, 16048 &_swigt__p_qpol_capability, 16049 &_swigt__p_qpol_cat, 16050 &_swigt__p_qpol_class, 16051 &_swigt__p_qpol_common, 16052 &_swigt__p_qpol_cond, 16053 &_swigt__p_qpol_cond_expr_node, 16054 &_swigt__p_qpol_constraint, 16055 &_swigt__p_qpol_constraint_expr_node, 16056 &_swigt__p_qpol_context, 16057 &_swigt__p_qpol_default_object, 16058 &_swigt__p_qpol_devicetreecon, 16059 &_swigt__p_qpol_filename_trans, 16060 &_swigt__p_qpol_fs_use, 16061 &_swigt__p_qpol_genfscon, 16062 &_swigt__p_qpol_iomemcon, 16063 &_swigt__p_qpol_ioportcon, 16064 &_swigt__p_qpol_isid, 16065 &_swigt__p_qpol_iterator, 16066 &_swigt__p_qpol_level, 16067 &_swigt__p_qpol_mls_level, 16068 &_swigt__p_qpol_mls_range, 16069 &_swigt__p_qpol_netifcon, 16070 &_swigt__p_qpol_nodecon, 16071 &_swigt__p_qpol_pcidevicecon, 16072 &_swigt__p_qpol_pirqcon, 16073 &_swigt__p_qpol_polcap, 16074 &_swigt__p_qpol_policy, 16075 &_swigt__p_qpol_portcon, 16076 &_swigt__p_qpol_range_trans, 16077 &_swigt__p_qpol_role, 16078 &_swigt__p_qpol_role_allow, 16079 &_swigt__p_qpol_role_trans, 16080 &_swigt__p_qpol_rolebounds, 16081 &_swigt__p_qpol_semantic_level, 16082 &_swigt__p_qpol_terule, 16083 &_swigt__p_qpol_type, 16084 &_swigt__p_qpol_typebounds, 16085 &_swigt__p_qpol_user, 16086 &_swigt__p_qpol_userbounds, 16087 &_swigt__p_qpol_validatetrans, 16088 &_swigt__p_short, 16089 &_swigt__p_signed_char, 16090 &_swigt__p_unsigned_char, 16091 &_swigt__p_unsigned_int, 16092 &_swigt__p_unsigned_long_long, 16093 &_swigt__p_unsigned_short, 16094 &_swigt__p_void, 16095 }; 16096 16097 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}}; 16098 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}}; 16099 static swig_cast_info _swigc__p_long_long[] = { {&_swigt__p_long_long, 0, 0, 0},{0, 0, 0, 0}}; 16100 static swig_cast_info _swigc__p_qpol_avrule[] = { {&_swigt__p_qpol_avrule, 0, 0, 0},{0, 0, 0, 0}}; 16101 static swig_cast_info _swigc__p_qpol_bool[] = { {&_swigt__p_qpol_bool, 0, 0, 0},{0, 0, 0, 0}}; 16102 static swig_cast_info _swigc__p_qpol_capability[] = { {&_swigt__p_qpol_capability, 0, 0, 0},{0, 0, 0, 0}}; 16103 static swig_cast_info _swigc__p_qpol_cat[] = { {&_swigt__p_qpol_cat, 0, 0, 0},{0, 0, 0, 0}}; 16104 static swig_cast_info _swigc__p_qpol_class[] = { {&_swigt__p_qpol_class, 0, 0, 0},{0, 0, 0, 0}}; 16105 static swig_cast_info _swigc__p_qpol_common[] = { {&_swigt__p_qpol_common, 0, 0, 0},{0, 0, 0, 0}}; 16106 static swig_cast_info _swigc__p_qpol_cond[] = { {&_swigt__p_qpol_cond, 0, 0, 0},{0, 0, 0, 0}}; 16107 static swig_cast_info _swigc__p_qpol_cond_expr_node[] = { {&_swigt__p_qpol_cond_expr_node, 0, 0, 0},{0, 0, 0, 0}}; 16108 static swig_cast_info _swigc__p_qpol_constraint[] = { {&_swigt__p_qpol_constraint, 0, 0, 0},{0, 0, 0, 0}}; 16109 static swig_cast_info _swigc__p_qpol_constraint_expr_node[] = { {&_swigt__p_qpol_constraint_expr_node, 0, 0, 0},{0, 0, 0, 0}}; 16110 static swig_cast_info _swigc__p_qpol_context[] = { {&_swigt__p_qpol_context, 0, 0, 0},{0, 0, 0, 0}}; 16111 static swig_cast_info _swigc__p_qpol_default_object[] = { {&_swigt__p_qpol_default_object, 0, 0, 0},{0, 0, 0, 0}}; 16112 static swig_cast_info _swigc__p_qpol_devicetreecon[] = { {&_swigt__p_qpol_devicetreecon, 0, 0, 0},{0, 0, 0, 0}}; 16113 static swig_cast_info _swigc__p_qpol_filename_trans[] = { {&_swigt__p_qpol_filename_trans, 0, 0, 0},{0, 0, 0, 0}}; 16114 static swig_cast_info _swigc__p_qpol_fs_use[] = { {&_swigt__p_qpol_fs_use, 0, 0, 0},{0, 0, 0, 0}}; 16115 static swig_cast_info _swigc__p_qpol_genfscon[] = { {&_swigt__p_qpol_genfscon, 0, 0, 0},{0, 0, 0, 0}}; 16116 static swig_cast_info _swigc__p_qpol_iomemcon[] = { {&_swigt__p_qpol_iomemcon, 0, 0, 0},{0, 0, 0, 0}}; 16117 static swig_cast_info _swigc__p_qpol_ioportcon[] = { {&_swigt__p_qpol_ioportcon, 0, 0, 0},{0, 0, 0, 0}}; 16118 static swig_cast_info _swigc__p_qpol_isid[] = { {&_swigt__p_qpol_isid, 0, 0, 0},{0, 0, 0, 0}}; 16119 static swig_cast_info _swigc__p_qpol_iterator[] = { {&_swigt__p_qpol_iterator, 0, 0, 0},{0, 0, 0, 0}}; 16120 static swig_cast_info _swigc__p_qpol_level[] = { {&_swigt__p_qpol_level, 0, 0, 0},{0, 0, 0, 0}}; 16121 static swig_cast_info _swigc__p_qpol_mls_level[] = { {&_swigt__p_qpol_mls_level, 0, 0, 0},{0, 0, 0, 0}}; 16122 static swig_cast_info _swigc__p_qpol_mls_range[] = { {&_swigt__p_qpol_mls_range, 0, 0, 0},{0, 0, 0, 0}}; 16123 static swig_cast_info _swigc__p_qpol_netifcon[] = { {&_swigt__p_qpol_netifcon, 0, 0, 0},{0, 0, 0, 0}}; 16124 static swig_cast_info _swigc__p_qpol_nodecon[] = { {&_swigt__p_qpol_nodecon, 0, 0, 0},{0, 0, 0, 0}}; 16125 static swig_cast_info _swigc__p_qpol_pcidevicecon[] = { {&_swigt__p_qpol_pcidevicecon, 0, 0, 0},{0, 0, 0, 0}}; 16126 static swig_cast_info _swigc__p_qpol_pirqcon[] = { {&_swigt__p_qpol_pirqcon, 0, 0, 0},{0, 0, 0, 0}}; 16127 static swig_cast_info _swigc__p_qpol_polcap[] = { {&_swigt__p_qpol_polcap, 0, 0, 0},{0, 0, 0, 0}}; 16128 static swig_cast_info _swigc__p_qpol_policy[] = { {&_swigt__p_qpol_policy, 0, 0, 0},{0, 0, 0, 0}}; 16129 static swig_cast_info _swigc__p_qpol_portcon[] = { {&_swigt__p_qpol_portcon, 0, 0, 0},{0, 0, 0, 0}}; 16130 static swig_cast_info _swigc__p_qpol_range_trans[] = { {&_swigt__p_qpol_range_trans, 0, 0, 0},{0, 0, 0, 0}}; 16131 static swig_cast_info _swigc__p_qpol_role[] = { {&_swigt__p_qpol_role, 0, 0, 0},{0, 0, 0, 0}}; 16132 static swig_cast_info _swigc__p_qpol_role_allow[] = { {&_swigt__p_qpol_role_allow, 0, 0, 0},{0, 0, 0, 0}}; 16133 static swig_cast_info _swigc__p_qpol_role_trans[] = { {&_swigt__p_qpol_role_trans, 0, 0, 0},{0, 0, 0, 0}}; 16134 static swig_cast_info _swigc__p_qpol_rolebounds[] = { {&_swigt__p_qpol_rolebounds, 0, 0, 0},{0, 0, 0, 0}}; 16135 static swig_cast_info _swigc__p_qpol_semantic_level[] = { {&_swigt__p_qpol_semantic_level, 0, 0, 0},{0, 0, 0, 0}}; 16136 static swig_cast_info _swigc__p_qpol_terule[] = { {&_swigt__p_qpol_terule, 0, 0, 0},{0, 0, 0, 0}}; 16137 static swig_cast_info _swigc__p_qpol_type[] = { {&_swigt__p_qpol_type, 0, 0, 0},{0, 0, 0, 0}}; 16138 static swig_cast_info _swigc__p_qpol_typebounds[] = { {&_swigt__p_qpol_typebounds, 0, 0, 0},{0, 0, 0, 0}}; 16139 static swig_cast_info _swigc__p_qpol_user[] = { {&_swigt__p_qpol_user, 0, 0, 0},{0, 0, 0, 0}}; 16140 static swig_cast_info _swigc__p_qpol_userbounds[] = { {&_swigt__p_qpol_userbounds, 0, 0, 0},{0, 0, 0, 0}}; 16141 static swig_cast_info _swigc__p_qpol_validatetrans[] = { {&_swigt__p_qpol_validatetrans, 0, 0, 0},{0, 0, 0, 0}}; 16142 static swig_cast_info _swigc__p_short[] = { {&_swigt__p_short, 0, 0, 0},{0, 0, 0, 0}}; 16143 static swig_cast_info _swigc__p_signed_char[] = { {&_swigt__p_signed_char, 0, 0, 0},{0, 0, 0, 0}}; 16144 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}}; 16145 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}}; 16146 static swig_cast_info _swigc__p_unsigned_long_long[] = { {&_swigt__p_unsigned_long_long, 0, 0, 0},{0, 0, 0, 0}}; 16147 static swig_cast_info _swigc__p_unsigned_short[] = { {&_swigt__p_unsigned_short, 0, 0, 0},{0, 0, 0, 0}}; 16148 static swig_cast_info _swigc__p_void[] = { {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}}; 16149 16150 static swig_cast_info *swig_cast_initial[] = { 16151 _swigc__p_char, 16152 _swigc__p_int, 16153 _swigc__p_long_long, 16154 _swigc__p_qpol_avrule, 16155 _swigc__p_qpol_bool, 16156 _swigc__p_qpol_capability, 16157 _swigc__p_qpol_cat, 16158 _swigc__p_qpol_class, 16159 _swigc__p_qpol_common, 16160 _swigc__p_qpol_cond, 16161 _swigc__p_qpol_cond_expr_node, 16162 _swigc__p_qpol_constraint, 16163 _swigc__p_qpol_constraint_expr_node, 16164 _swigc__p_qpol_context, 16165 _swigc__p_qpol_default_object, 16166 _swigc__p_qpol_devicetreecon, 16167 _swigc__p_qpol_filename_trans, 16168 _swigc__p_qpol_fs_use, 16169 _swigc__p_qpol_genfscon, 16170 _swigc__p_qpol_iomemcon, 16171 _swigc__p_qpol_ioportcon, 16172 _swigc__p_qpol_isid, 16173 _swigc__p_qpol_iterator, 16174 _swigc__p_qpol_level, 16175 _swigc__p_qpol_mls_level, 16176 _swigc__p_qpol_mls_range, 16177 _swigc__p_qpol_netifcon, 16178 _swigc__p_qpol_nodecon, 16179 _swigc__p_qpol_pcidevicecon, 16180 _swigc__p_qpol_pirqcon, 16181 _swigc__p_qpol_polcap, 16182 _swigc__p_qpol_policy, 16183 _swigc__p_qpol_portcon, 16184 _swigc__p_qpol_range_trans, 16185 _swigc__p_qpol_role, 16186 _swigc__p_qpol_role_allow, 16187 _swigc__p_qpol_role_trans, 16188 _swigc__p_qpol_rolebounds, 16189 _swigc__p_qpol_semantic_level, 16190 _swigc__p_qpol_terule, 16191 _swigc__p_qpol_type, 16192 _swigc__p_qpol_typebounds, 16193 _swigc__p_qpol_user, 16194 _swigc__p_qpol_userbounds, 16195 _swigc__p_qpol_validatetrans, 16196 _swigc__p_short, 16197 _swigc__p_signed_char, 16198 _swigc__p_unsigned_char, 16199 _swigc__p_unsigned_int, 16200 _swigc__p_unsigned_long_long, 16201 _swigc__p_unsigned_short, 16202 _swigc__p_void, 16203 }; 16204 16205 16206 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */ 16207 16208 static swig_const_info swig_const_table[] = { 16209 {0, 0, 0, 0.0, 0, 0}}; 16210 16211 #ifdef __cplusplus 16212 } 16213 #endif 16214 /* ----------------------------------------------------------------------------- 16215 * Type initialization: 16216 * This problem is tough by the requirement that no dynamic 16217 * memory is used. Also, since swig_type_info structures store pointers to 16218 * swig_cast_info structures and swig_cast_info structures store pointers back 16219 * to swig_type_info structures, we need some lookup code at initialization. 16220 * The idea is that swig generates all the structures that are needed. 16221 * The runtime then collects these partially filled structures. 16222 * The SWIG_InitializeModule function takes these initial arrays out of 16223 * swig_module, and does all the lookup, filling in the swig_module.types 16224 * array with the correct data and linking the correct swig_cast_info 16225 * structures together. 16226 * 16227 * The generated swig_type_info structures are assigned staticly to an initial 16228 * array. We just loop through that array, and handle each type individually. 16229 * First we lookup if this type has been already loaded, and if so, use the 16230 * loaded structure instead of the generated one. Then we have to fill in the 16231 * cast linked list. The cast data is initially stored in something like a 16232 * two-dimensional array. Each row corresponds to a type (there are the same 16233 * number of rows as there are in the swig_type_initial array). Each entry in 16234 * a column is one of the swig_cast_info structures for that type. 16235 * The cast_initial array is actually an array of arrays, because each row has 16236 * a variable number of columns. So to actually build the cast linked list, 16237 * we find the array of casts associated with the type, and loop through it 16238 * adding the casts to the list. The one last trick we need to do is making 16239 * sure the type pointer in the swig_cast_info struct is correct. 16240 * 16241 * First off, we lookup the cast->type name to see if it is already loaded. 16242 * There are three cases to handle: 16243 * 1) If the cast->type has already been loaded AND the type we are adding 16244 * casting info to has not been loaded (it is in this module), THEN we 16245 * replace the cast->type pointer with the type pointer that has already 16246 * been loaded. 16247 * 2) If BOTH types (the one we are adding casting info to, and the 16248 * cast->type) are loaded, THEN the cast info has already been loaded by 16249 * the previous module so we just ignore it. 16250 * 3) Finally, if cast->type has not already been loaded, then we add that 16251 * swig_cast_info to the linked list (because the cast->type) pointer will 16252 * be correct. 16253 * ----------------------------------------------------------------------------- */ 16254 16255 #ifdef __cplusplus 16256 extern "C" { 16257 #if 0 16258 } /* c-mode */ 16259 #endif 16260 #endif 16261 16262 #if 0 16263 #define SWIGRUNTIME_DEBUG 16264 #endif 16265 16266 16267 SWIGRUNTIME void 16268 SWIG_InitializeModule(void *clientdata) { 16269 size_t i; 16270 swig_module_info *module_head, *iter; 16271 int found, init; 16272 16273 /* check to see if the circular list has been setup, if not, set it up */ 16274 if (swig_module.next==0) { 16275 /* Initialize the swig_module */ 16276 swig_module.type_initial = swig_type_initial; 16277 swig_module.cast_initial = swig_cast_initial; 16278 swig_module.next = &swig_module; 16279 init = 1; 16280 } else { 16281 init = 0; 16282 } 16283 16284 /* Try and load any already created modules */ 16285 module_head = SWIG_GetModule(clientdata); 16286 if (!module_head) { 16287 /* This is the first module loaded for this interpreter */ 16288 /* so set the swig module into the interpreter */ 16289 SWIG_SetModule(clientdata, &swig_module); 16290 module_head = &swig_module; 16291 } else { 16292 /* the interpreter has loaded a SWIG module, but has it loaded this one? */ 16293 found=0; 16294 iter=module_head; 16295 do { 16296 if (iter==&swig_module) { 16297 found=1; 16298 break; 16299 } 16300 iter=iter->next; 16301 } while (iter!= module_head); 16302 16303 /* if the is found in the list, then all is done and we may leave */ 16304 if (found) return; 16305 /* otherwise we must add out module into the list */ 16306 swig_module.next = module_head->next; 16307 module_head->next = &swig_module; 16308 } 16309 16310 /* When multiple interpreters are used, a module could have already been initialized in 16311 a different interpreter, but not yet have a pointer in this interpreter. 16312 In this case, we do not want to continue adding types... everything should be 16313 set up already */ 16314 if (init == 0) return; 16315 16316 /* Now work on filling in swig_module.types */ 16317 #ifdef SWIGRUNTIME_DEBUG 16318 printf("SWIG_InitializeModule: size %d\n", swig_module.size); 16319 #endif 16320 for (i = 0; i < swig_module.size; ++i) { 16321 swig_type_info *type = 0; 16322 swig_type_info *ret; 16323 swig_cast_info *cast; 16324 16325 #ifdef SWIGRUNTIME_DEBUG 16326 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name); 16327 #endif 16328 16329 /* if there is another module already loaded */ 16330 if (swig_module.next != &swig_module) { 16331 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name); 16332 } 16333 if (type) { 16334 /* Overwrite clientdata field */ 16335 #ifdef SWIGRUNTIME_DEBUG 16336 printf("SWIG_InitializeModule: found type %s\n", type->name); 16337 #endif 16338 if (swig_module.type_initial[i]->clientdata) { 16339 type->clientdata = swig_module.type_initial[i]->clientdata; 16340 #ifdef SWIGRUNTIME_DEBUG 16341 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name); 16342 #endif 16343 } 16344 } else { 16345 type = swig_module.type_initial[i]; 16346 } 16347 16348 /* Insert casting types */ 16349 cast = swig_module.cast_initial[i]; 16350 while (cast->type) { 16351 /* Don't need to add information already in the list */ 16352 ret = 0; 16353 #ifdef SWIGRUNTIME_DEBUG 16354 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name); 16355 #endif 16356 if (swig_module.next != &swig_module) { 16357 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name); 16358 #ifdef SWIGRUNTIME_DEBUG 16359 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name); 16360 #endif 16361 } 16362 if (ret) { 16363 if (type == swig_module.type_initial[i]) { 16364 #ifdef SWIGRUNTIME_DEBUG 16365 printf("SWIG_InitializeModule: skip old type %s\n", ret->name); 16366 #endif 16367 cast->type = ret; 16368 ret = 0; 16369 } else { 16370 /* Check for casting already in the list */ 16371 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type); 16372 #ifdef SWIGRUNTIME_DEBUG 16373 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name); 16374 #endif 16375 if (!ocast) ret = 0; 16376 } 16377 } 16378 16379 if (!ret) { 16380 #ifdef SWIGRUNTIME_DEBUG 16381 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name); 16382 #endif 16383 if (type->cast) { 16384 type->cast->prev = cast; 16385 cast->next = type->cast; 16386 } 16387 type->cast = cast; 16388 } 16389 cast++; 16390 } 16391 /* Set entry in modules->types array equal to the type */ 16392 swig_module.types[i] = type; 16393 } 16394 swig_module.types[i] = 0; 16395 16396 #ifdef SWIGRUNTIME_DEBUG 16397 printf("**** SWIG_InitializeModule: Cast List ******\n"); 16398 for (i = 0; i < swig_module.size; ++i) { 16399 int j = 0; 16400 swig_cast_info *cast = swig_module.cast_initial[i]; 16401 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name); 16402 while (cast->type) { 16403 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name); 16404 cast++; 16405 ++j; 16406 } 16407 printf("---- Total casts: %d\n",j); 16408 } 16409 printf("**** SWIG_InitializeModule: Cast List ******\n"); 16410 #endif 16411 } 16412 16413 /* This function will propagate the clientdata field of type to 16414 * any new swig_type_info structures that have been added into the list 16415 * of equivalent types. It is like calling 16416 * SWIG_TypeClientData(type, clientdata) a second time. 16417 */ 16418 SWIGRUNTIME void 16419 SWIG_PropagateClientData(void) { 16420 size_t i; 16421 swig_cast_info *equiv; 16422 static int init_run = 0; 16423 16424 if (init_run) return; 16425 init_run = 1; 16426 16427 for (i = 0; i < swig_module.size; i++) { 16428 if (swig_module.types[i]->clientdata) { 16429 equiv = swig_module.types[i]->cast; 16430 while (equiv) { 16431 if (!equiv->converter) { 16432 if (equiv->type && !equiv->type->clientdata) 16433 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata); 16434 } 16435 equiv = equiv->next; 16436 } 16437 } 16438 } 16439 } 16440 16441 #ifdef __cplusplus 16442 #if 0 16443 { 16444 /* c-mode */ 16445 #endif 16446 } 16447 #endif 16448 16449 16450 16451 #ifdef __cplusplus 16452 extern "C" { 16453 #endif 16454 16455 /* Python-specific SWIG API */ 16456 #define SWIG_newvarlink() SWIG_Python_newvarlink() 16457 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr) 16458 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants) 16459 16460 /* ----------------------------------------------------------------------------- 16461 * global variable support code. 16462 * ----------------------------------------------------------------------------- */ 16463 16464 typedef struct swig_globalvar { 16465 char *name; /* Name of global variable */ 16466 PyObject *(*get_attr)(void); /* Return the current value */ 16467 int (*set_attr)(PyObject *); /* Set the value */ 16468 struct swig_globalvar *next; 16469 } swig_globalvar; 16470 16471 typedef struct swig_varlinkobject { 16472 PyObject_HEAD 16473 swig_globalvar *vars; 16474 } swig_varlinkobject; 16475 16476 SWIGINTERN PyObject * 16477 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) { 16478 #if PY_VERSION_HEX >= 0x03000000 16479 return PyUnicode_InternFromString("<Swig global variables>"); 16480 #else 16481 return PyString_FromString("<Swig global variables>"); 16482 #endif 16483 } 16484 16485 SWIGINTERN PyObject * 16486 swig_varlink_str(swig_varlinkobject *v) { 16487 #if PY_VERSION_HEX >= 0x03000000 16488 PyObject *str = PyUnicode_InternFromString("("); 16489 PyObject *tail; 16490 PyObject *joined; 16491 swig_globalvar *var; 16492 for (var = v->vars; var; var=var->next) { 16493 tail = PyUnicode_FromString(var->name); 16494 joined = PyUnicode_Concat(str, tail); 16495 Py_DecRef(str); 16496 Py_DecRef(tail); 16497 str = joined; 16498 if (var->next) { 16499 tail = PyUnicode_InternFromString(", "); 16500 joined = PyUnicode_Concat(str, tail); 16501 Py_DecRef(str); 16502 Py_DecRef(tail); 16503 str = joined; 16504 } 16505 } 16506 tail = PyUnicode_InternFromString(")"); 16507 joined = PyUnicode_Concat(str, tail); 16508 Py_DecRef(str); 16509 Py_DecRef(tail); 16510 str = joined; 16511 #else 16512 PyObject *str = PyString_FromString("("); 16513 swig_globalvar *var; 16514 for (var = v->vars; var; var=var->next) { 16515 PyString_ConcatAndDel(&str,PyString_FromString(var->name)); 16516 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", ")); 16517 } 16518 PyString_ConcatAndDel(&str,PyString_FromString(")")); 16519 #endif 16520 return str; 16521 } 16522 16523 SWIGINTERN int 16524 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) { 16525 char *tmp; 16526 PyObject *str = swig_varlink_str(v); 16527 fprintf(fp,"Swig global variables "); 16528 fprintf(fp,"%s\n", tmp = SWIG_Python_str_AsChar(str)); 16529 SWIG_Python_str_DelForPy3(tmp); 16530 Py_DECREF(str); 16531 return 0; 16532 } 16533 16534 SWIGINTERN void 16535 swig_varlink_dealloc(swig_varlinkobject *v) { 16536 swig_globalvar *var = v->vars; 16537 while (var) { 16538 swig_globalvar *n = var->next; 16539 free(var->name); 16540 free(var); 16541 var = n; 16542 } 16543 } 16544 16545 SWIGINTERN PyObject * 16546 swig_varlink_getattr(swig_varlinkobject *v, char *n) { 16547 PyObject *res = NULL; 16548 swig_globalvar *var = v->vars; 16549 while (var) { 16550 if (strcmp(var->name,n) == 0) { 16551 res = (*var->get_attr)(); 16552 break; 16553 } 16554 var = var->next; 16555 } 16556 if (res == NULL && !PyErr_Occurred()) { 16557 PyErr_SetString(PyExc_NameError,"Unknown C global variable"); 16558 } 16559 return res; 16560 } 16561 16562 SWIGINTERN int 16563 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) { 16564 int res = 1; 16565 swig_globalvar *var = v->vars; 16566 while (var) { 16567 if (strcmp(var->name,n) == 0) { 16568 res = (*var->set_attr)(p); 16569 break; 16570 } 16571 var = var->next; 16572 } 16573 if (res == 1 && !PyErr_Occurred()) { 16574 PyErr_SetString(PyExc_NameError,"Unknown C global variable"); 16575 } 16576 return res; 16577 } 16578 16579 SWIGINTERN PyTypeObject* 16580 swig_varlink_type(void) { 16581 static char varlink__doc__[] = "Swig var link object"; 16582 static PyTypeObject varlink_type; 16583 static int type_init = 0; 16584 if (!type_init) { 16585 const PyTypeObject tmp = { 16586 /* PyObject header changed in Python 3 */ 16587 #if PY_VERSION_HEX >= 0x03000000 16588 PyVarObject_HEAD_INIT(NULL, 0) 16589 #else 16590 PyObject_HEAD_INIT(NULL) 16591 0, /* ob_size */ 16592 #endif 16593 (char *)"swigvarlink", /* tp_name */ 16594 sizeof(swig_varlinkobject), /* tp_basicsize */ 16595 0, /* tp_itemsize */ 16596 (destructor) swig_varlink_dealloc, /* tp_dealloc */ 16597 (printfunc) swig_varlink_print, /* tp_print */ 16598 (getattrfunc) swig_varlink_getattr, /* tp_getattr */ 16599 (setattrfunc) swig_varlink_setattr, /* tp_setattr */ 16600 0, /* tp_compare */ 16601 (reprfunc) swig_varlink_repr, /* tp_repr */ 16602 0, /* tp_as_number */ 16603 0, /* tp_as_sequence */ 16604 0, /* tp_as_mapping */ 16605 0, /* tp_hash */ 16606 0, /* tp_call */ 16607 (reprfunc) swig_varlink_str, /* tp_str */ 16608 0, /* tp_getattro */ 16609 0, /* tp_setattro */ 16610 0, /* tp_as_buffer */ 16611 0, /* tp_flags */ 16612 varlink__doc__, /* tp_doc */ 16613 0, /* tp_traverse */ 16614 0, /* tp_clear */ 16615 0, /* tp_richcompare */ 16616 0, /* tp_weaklistoffset */ 16617 #if PY_VERSION_HEX >= 0x02020000 16618 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */ 16619 #endif 16620 #if PY_VERSION_HEX >= 0x02030000 16621 0, /* tp_del */ 16622 #endif 16623 #if PY_VERSION_HEX >= 0x02060000 16624 0, /* tp_version */ 16625 #endif 16626 #ifdef COUNT_ALLOCS 16627 0,0,0,0 /* tp_alloc -> tp_next */ 16628 #endif 16629 }; 16630 varlink_type = tmp; 16631 type_init = 1; 16632 #if PY_VERSION_HEX < 0x02020000 16633 varlink_type.ob_type = &PyType_Type; 16634 #else 16635 if (PyType_Ready(&varlink_type) < 0) 16636 return NULL; 16637 #endif 16638 } 16639 return &varlink_type; 16640 } 16641 16642 /* Create a variable linking object for use later */ 16643 SWIGINTERN PyObject * 16644 SWIG_Python_newvarlink(void) { 16645 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type()); 16646 if (result) { 16647 result->vars = 0; 16648 } 16649 return ((PyObject*) result); 16650 } 16651 16652 SWIGINTERN void 16653 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) { 16654 swig_varlinkobject *v = (swig_varlinkobject *) p; 16655 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar)); 16656 if (gv) { 16657 size_t size = strlen(name)+1; 16658 gv->name = (char *)malloc(size); 16659 if (gv->name) { 16660 strncpy(gv->name,name,size); 16661 gv->get_attr = get_attr; 16662 gv->set_attr = set_attr; 16663 gv->next = v->vars; 16664 } 16665 } 16666 v->vars = gv; 16667 } 16668 16669 SWIGINTERN PyObject * 16670 SWIG_globals(void) { 16671 static PyObject *_SWIG_globals = 0; 16672 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink(); 16673 return _SWIG_globals; 16674 } 16675 16676 /* ----------------------------------------------------------------------------- 16677 * constants/methods manipulation 16678 * ----------------------------------------------------------------------------- */ 16679 16680 /* Install Constants */ 16681 SWIGINTERN void 16682 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) { 16683 PyObject *obj = 0; 16684 size_t i; 16685 for (i = 0; constants[i].type; ++i) { 16686 switch(constants[i].type) { 16687 case SWIG_PY_POINTER: 16688 obj = SWIG_InternalNewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0); 16689 break; 16690 case SWIG_PY_BINARY: 16691 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype)); 16692 break; 16693 default: 16694 obj = 0; 16695 break; 16696 } 16697 if (obj) { 16698 PyDict_SetItemString(d, constants[i].name, obj); 16699 Py_DECREF(obj); 16700 } 16701 } 16702 } 16703 16704 /* -----------------------------------------------------------------------------*/ 16705 /* Fix SwigMethods to carry the callback ptrs when needed */ 16706 /* -----------------------------------------------------------------------------*/ 16707 16708 SWIGINTERN void 16709 SWIG_Python_FixMethods(PyMethodDef *methods, 16710 swig_const_info *const_table, 16711 swig_type_info **types, 16712 swig_type_info **types_initial) { 16713 size_t i; 16714 for (i = 0; methods[i].ml_name; ++i) { 16715 const char *c = methods[i].ml_doc; 16716 if (c && (c = strstr(c, "swig_ptr: "))) { 16717 int j; 16718 swig_const_info *ci = 0; 16719 const char *name = c + 10; 16720 for (j = 0; const_table[j].type; ++j) { 16721 if (strncmp(const_table[j].name, name, 16722 strlen(const_table[j].name)) == 0) { 16723 ci = &(const_table[j]); 16724 break; 16725 } 16726 } 16727 if (ci) { 16728 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0; 16729 if (ptr) { 16730 size_t shift = (ci->ptype) - types; 16731 swig_type_info *ty = types_initial[shift]; 16732 size_t ldoc = (c - methods[i].ml_doc); 16733 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2; 16734 char *ndoc = (char*)malloc(ldoc + lptr + 10); 16735 if (ndoc) { 16736 char *buff = ndoc; 16737 strncpy(buff, methods[i].ml_doc, ldoc); 16738 buff += ldoc; 16739 strncpy(buff, "swig_ptr: ", 10); 16740 buff += 10; 16741 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr); 16742 methods[i].ml_doc = ndoc; 16743 } 16744 } 16745 } 16746 } 16747 } 16748 } 16749 16750 #ifdef __cplusplus 16751 } 16752 #endif 16753 16754 /* -----------------------------------------------------------------------------* 16755 * Partial Init method 16756 * -----------------------------------------------------------------------------*/ 16757 16758 #ifdef __cplusplus 16759 extern "C" 16760 #endif 16761 16762 SWIGEXPORT 16763 #if PY_VERSION_HEX >= 0x03000000 16764 PyObject* 16765 #else 16766 void 16767 #endif 16768 SWIG_init(void) { 16769 PyObject *m, *d, *md; 16770 #if PY_VERSION_HEX >= 0x03000000 16771 static struct PyModuleDef SWIG_module = { 16772 # if PY_VERSION_HEX >= 0x03020000 16773 PyModuleDef_HEAD_INIT, 16774 # else 16775 { 16776 PyObject_HEAD_INIT(NULL) 16777 NULL, /* m_init */ 16778 0, /* m_index */ 16779 NULL, /* m_copy */ 16780 }, 16781 # endif 16782 (char *) SWIG_name, 16783 NULL, 16784 -1, 16785 SwigMethods, 16786 NULL, 16787 NULL, 16788 NULL, 16789 NULL 16790 }; 16791 #endif 16792 16793 #if defined(SWIGPYTHON_BUILTIN) 16794 static SwigPyClientData SwigPyObject_clientdata = { 16795 0, 0, 0, 0, 0, 0, 0 16796 }; 16797 static PyGetSetDef this_getset_def = { 16798 (char *)"this", &SwigPyBuiltin_ThisClosure, NULL, NULL, NULL 16799 }; 16800 static SwigPyGetSet thisown_getset_closure = { 16801 (PyCFunction) SwigPyObject_own, 16802 (PyCFunction) SwigPyObject_own 16803 }; 16804 static PyGetSetDef thisown_getset_def = { 16805 (char *)"thisown", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, NULL, &thisown_getset_closure 16806 }; 16807 PyObject *metatype_args; 16808 PyTypeObject *builtin_pytype; 16809 int builtin_base_count; 16810 swig_type_info *builtin_basetype; 16811 PyObject *tuple; 16812 PyGetSetDescrObject *static_getset; 16813 PyTypeObject *metatype; 16814 SwigPyClientData *cd; 16815 PyObject *public_interface, *public_symbol; 16816 PyObject *this_descr; 16817 PyObject *thisown_descr; 16818 int i; 16819 16820 (void)builtin_pytype; 16821 (void)builtin_base_count; 16822 (void)builtin_basetype; 16823 (void)tuple; 16824 (void)static_getset; 16825 16826 /* metatype is used to implement static member variables. */ 16827 metatype_args = Py_BuildValue("(s(O){})", "SwigPyObjectType", &PyType_Type); 16828 assert(metatype_args); 16829 metatype = (PyTypeObject *) PyType_Type.tp_call((PyObject *) &PyType_Type, metatype_args, NULL); 16830 assert(metatype); 16831 Py_DECREF(metatype_args); 16832 metatype->tp_setattro = (setattrofunc) &SwigPyObjectType_setattro; 16833 assert(PyType_Ready(metatype) >= 0); 16834 #endif 16835 16836 /* Fix SwigMethods to carry the callback ptrs when needed */ 16837 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial); 16838 16839 #if PY_VERSION_HEX >= 0x03000000 16840 m = PyModule_Create(&SWIG_module); 16841 #else 16842 m = Py_InitModule((char *) SWIG_name, SwigMethods); 16843 #endif 16844 md = d = PyModule_GetDict(m); 16845 (void)md; 16846 16847 SWIG_InitializeModule(0); 16848 16849 #ifdef SWIGPYTHON_BUILTIN 16850 SwigPyObject_stype = SWIG_MangledTypeQuery("_p_SwigPyObject"); 16851 assert(SwigPyObject_stype); 16852 cd = (SwigPyClientData*) SwigPyObject_stype->clientdata; 16853 if (!cd) { 16854 SwigPyObject_stype->clientdata = &SwigPyObject_clientdata; 16855 SwigPyObject_clientdata.pytype = SwigPyObject_TypeOnce(); 16856 } else if (SwigPyObject_TypeOnce()->tp_basicsize != cd->pytype->tp_basicsize) { 16857 PyErr_SetString(PyExc_RuntimeError, "Import error: attempted to load two incompatible swig-generated modules."); 16858 # if PY_VERSION_HEX >= 0x03000000 16859 return NULL; 16860 # else 16861 return; 16862 # endif 16863 } 16864 16865 /* All objects have a 'this' attribute */ 16866 this_descr = PyDescr_NewGetSet(SwigPyObject_type(), &this_getset_def); 16867 (void)this_descr; 16868 16869 /* All objects have a 'thisown' attribute */ 16870 thisown_descr = PyDescr_NewGetSet(SwigPyObject_type(), &thisown_getset_def); 16871 (void)thisown_descr; 16872 16873 public_interface = PyList_New(0); 16874 public_symbol = 0; 16875 (void)public_symbol; 16876 16877 PyDict_SetItemString(md, "__all__", public_interface); 16878 Py_DECREF(public_interface); 16879 for (i = 0; SwigMethods[i].ml_name != NULL; ++i) 16880 SwigPyBuiltin_AddPublicSymbol(public_interface, SwigMethods[i].ml_name); 16881 for (i = 0; swig_const_table[i].name != 0; ++i) 16882 SwigPyBuiltin_AddPublicSymbol(public_interface, swig_const_table[i].name); 16883 #endif 16884 16885 SWIG_InstallConstants(d,swig_const_table); 16886 16887 SWIG_Python_SetConstant(d, "QPOL_POLICY_OPTION_NO_NEVERALLOWS",SWIG_From_int((int)(0x00000001))); 16888 SWIG_Python_SetConstant(d, "QPOL_POLICY_OPTION_NO_RULES",SWIG_From_int((int)(0x00000002))); 16889 SWIG_Python_SetConstant(d, "QPOL_POLICY_OPTION_MATCH_SYSTEM",SWIG_From_int((int)(0x00000004))); 16890 SWIG_Python_SetConstant(d, "QPOL_POLICY_MAX_VERSION",SWIG_From_int((int)(POLICYDB_VERSION_MAX))); 16891 SWIG_Python_SetConstant(d, "QPOL_POLICY_MIN_VERSION",SWIG_From_int((int)(POLICYDB_VERSION_MIN))); 16892 SWIG_Python_SetConstant(d, "QPOL_CAP_ATTRIB_NAMES",SWIG_From_int((int)(QPOL_CAP_ATTRIB_NAMES))); 16893 SWIG_Python_SetConstant(d, "QPOL_CAP_SYN_RULES",SWIG_From_int((int)(QPOL_CAP_SYN_RULES))); 16894 SWIG_Python_SetConstant(d, "QPOL_CAP_LINE_NUMBERS",SWIG_From_int((int)(QPOL_CAP_LINE_NUMBERS))); 16895 SWIG_Python_SetConstant(d, "QPOL_CAP_CONDITIONALS",SWIG_From_int((int)(QPOL_CAP_CONDITIONALS))); 16896 SWIG_Python_SetConstant(d, "QPOL_CAP_MLS",SWIG_From_int((int)(QPOL_CAP_MLS))); 16897 SWIG_Python_SetConstant(d, "QPOL_CAP_MODULES",SWIG_From_int((int)(QPOL_CAP_MODULES))); 16898 SWIG_Python_SetConstant(d, "QPOL_CAP_RULES_LOADED",SWIG_From_int((int)(QPOL_CAP_RULES_LOADED))); 16899 SWIG_Python_SetConstant(d, "QPOL_CAP_SOURCE",SWIG_From_int((int)(QPOL_CAP_SOURCE))); 16900 SWIG_Python_SetConstant(d, "QPOL_CAP_NEVERALLOW",SWIG_From_int((int)(QPOL_CAP_NEVERALLOW))); 16901 SWIG_Python_SetConstant(d, "QPOL_CAP_POLCAPS",SWIG_From_int((int)(QPOL_CAP_POLCAPS))); 16902 SWIG_Python_SetConstant(d, "QPOL_CAP_BOUNDS",SWIG_From_int((int)(QPOL_CAP_BOUNDS))); 16903 SWIG_Python_SetConstant(d, "QPOL_CAP_DEFAULT_OBJECTS",SWIG_From_int((int)(QPOL_CAP_DEFAULT_OBJECTS))); 16904 SWIG_Python_SetConstant(d, "QPOL_CAP_DEFAULT_TYPE",SWIG_From_int((int)(QPOL_CAP_DEFAULT_TYPE))); 16905 SWIG_Python_SetConstant(d, "QPOL_CAP_PERMISSIVE",SWIG_From_int((int)(QPOL_CAP_PERMISSIVE))); 16906 SWIG_Python_SetConstant(d, "QPOL_CAP_FILENAME_TRANS",SWIG_From_int((int)(QPOL_CAP_FILENAME_TRANS))); 16907 SWIG_Python_SetConstant(d, "QPOL_CAP_ROLETRANS",SWIG_From_int((int)(QPOL_CAP_ROLETRANS))); 16908 SWIG_Python_SetConstant(d, "QPOL_CAP_XPERM_IOCTL",SWIG_From_int((int)(QPOL_CAP_XPERM_IOCTL))); 16909 SWIG_Python_SetConstant(d, "QPOL_FS_USE_XATTR",SWIG_From_unsigned_SS_int((unsigned int)(1U))); 16910 SWIG_Python_SetConstant(d, "QPOL_FS_USE_TRANS",SWIG_From_unsigned_SS_int((unsigned int)(2U))); 16911 SWIG_Python_SetConstant(d, "QPOL_FS_USE_TASK",SWIG_From_unsigned_SS_int((unsigned int)(3U))); 16912 SWIG_Python_SetConstant(d, "QPOL_FS_USE_GENFS",SWIG_From_unsigned_SS_int((unsigned int)(4U))); 16913 SWIG_Python_SetConstant(d, "QPOL_FS_USE_NONE",SWIG_From_unsigned_SS_int((unsigned int)(5U))); 16914 SWIG_Python_SetConstant(d, "QPOL_FS_USE_PSID",SWIG_From_unsigned_SS_int((unsigned int)(6U))); 16915 SWIG_Python_SetConstant(d, "QPOL_CLASS_ALL",SWIG_From_unsigned_SS_int((unsigned int)(0U))); 16916 SWIG_Python_SetConstant(d, "QPOL_CLASS_BLK_FILE",SWIG_From_unsigned_SS_int((unsigned int)(11U))); 16917 SWIG_Python_SetConstant(d, "QPOL_CLASS_CHR_FILE",SWIG_From_unsigned_SS_int((unsigned int)(10U))); 16918 SWIG_Python_SetConstant(d, "QPOL_CLASS_DIR",SWIG_From_unsigned_SS_int((unsigned int)(7U))); 16919 SWIG_Python_SetConstant(d, "QPOL_CLASS_FIFO_FILE",SWIG_From_unsigned_SS_int((unsigned int)(13U))); 16920 SWIG_Python_SetConstant(d, "QPOL_CLASS_FILE",SWIG_From_unsigned_SS_int((unsigned int)(6U))); 16921 SWIG_Python_SetConstant(d, "QPOL_CLASS_LNK_FILE",SWIG_From_unsigned_SS_int((unsigned int)(9U))); 16922 SWIG_Python_SetConstant(d, "QPOL_CLASS_SOCK_FILE",SWIG_From_unsigned_SS_int((unsigned int)(12U))); 16923 SWIG_Python_SetConstant(d, "QPOL_IPV4",SWIG_From_int((int)(0))); 16924 SWIG_Python_SetConstant(d, "QPOL_IPV6",SWIG_From_int((int)(1))); 16925 SWIG_Python_SetConstant(d, "IPPROTO_TCP",SWIG_From_int((int)(6))); 16926 SWIG_Python_SetConstant(d, "IPPROTO_UDP",SWIG_From_int((int)(17))); 16927 SWIG_Python_SetConstant(d, "QPOL_CEXPR_TYPE_NOT",SWIG_From_int((int)(1))); 16928 SWIG_Python_SetConstant(d, "QPOL_CEXPR_TYPE_AND",SWIG_From_int((int)(2))); 16929 SWIG_Python_SetConstant(d, "QPOL_CEXPR_TYPE_OR",SWIG_From_int((int)(3))); 16930 SWIG_Python_SetConstant(d, "QPOL_CEXPR_TYPE_ATTR",SWIG_From_int((int)(4))); 16931 SWIG_Python_SetConstant(d, "QPOL_CEXPR_TYPE_NAMES",SWIG_From_int((int)(5))); 16932 SWIG_Python_SetConstant(d, "QPOL_CEXPR_SYM_USER",SWIG_From_int((int)(1))); 16933 SWIG_Python_SetConstant(d, "QPOL_CEXPR_SYM_ROLE",SWIG_From_int((int)(2))); 16934 SWIG_Python_SetConstant(d, "QPOL_CEXPR_SYM_TYPE",SWIG_From_int((int)(4))); 16935 SWIG_Python_SetConstant(d, "QPOL_CEXPR_SYM_TARGET",SWIG_From_int((int)(8))); 16936 SWIG_Python_SetConstant(d, "QPOL_CEXPR_SYM_XTARGET",SWIG_From_int((int)(16))); 16937 SWIG_Python_SetConstant(d, "QPOL_CEXPR_SYM_L1L2",SWIG_From_int((int)(32))); 16938 SWIG_Python_SetConstant(d, "QPOL_CEXPR_SYM_L1H2",SWIG_From_int((int)(64))); 16939 SWIG_Python_SetConstant(d, "QPOL_CEXPR_SYM_H1L2",SWIG_From_int((int)(128))); 16940 SWIG_Python_SetConstant(d, "QPOL_CEXPR_SYM_H1H2",SWIG_From_int((int)(256))); 16941 SWIG_Python_SetConstant(d, "QPOL_CEXPR_SYM_L1H1",SWIG_From_int((int)(512))); 16942 SWIG_Python_SetConstant(d, "QPOL_CEXPR_SYM_L2H2",SWIG_From_int((int)(1024))); 16943 SWIG_Python_SetConstant(d, "QPOL_CEXPR_OP_EQ",SWIG_From_int((int)(1))); 16944 SWIG_Python_SetConstant(d, "QPOL_CEXPR_OP_NEQ",SWIG_From_int((int)(2))); 16945 SWIG_Python_SetConstant(d, "QPOL_CEXPR_OP_DOM",SWIG_From_int((int)(3))); 16946 SWIG_Python_SetConstant(d, "QPOL_CEXPR_OP_DOMBY",SWIG_From_int((int)(4))); 16947 SWIG_Python_SetConstant(d, "QPOL_CEXPR_OP_INCOMP",SWIG_From_int((int)(5))); 16948 SWIG_Python_SetConstant(d, "QPOL_RULE_ALLOW",SWIG_From_int((int)(0x0001))); 16949 SWIG_Python_SetConstant(d, "QPOL_RULE_NEVERALLOW",SWIG_From_int((int)(0x0080))); 16950 SWIG_Python_SetConstant(d, "QPOL_RULE_AUDITALLOW",SWIG_From_int((int)(0x0002))); 16951 SWIG_Python_SetConstant(d, "QPOL_RULE_DONTAUDIT",SWIG_From_int((int)(0x0004))); 16952 SWIG_Python_SetConstant(d, "QPOL_RULE_XPERMS_ALLOW",SWIG_From_int((int)(0x0100))); 16953 SWIG_Python_SetConstant(d, "QPOL_RULE_XPERMS_AUDITALLOW",SWIG_From_int((int)(0x0200))); 16954 SWIG_Python_SetConstant(d, "QPOL_RULE_XPERMS_DONTAUDIT",SWIG_From_int((int)(0x0400))); 16955 SWIG_Python_SetConstant(d, "QPOL_RULE_XPERMS_NEVERALLOW",SWIG_From_int((int)(0x0800))); 16956 SWIG_Python_SetConstant(d, "QPOL_RULE_TYPE_TRANS",SWIG_From_int((int)(16))); 16957 SWIG_Python_SetConstant(d, "QPOL_RULE_TYPE_CHANGE",SWIG_From_int((int)(64))); 16958 SWIG_Python_SetConstant(d, "QPOL_RULE_TYPE_MEMBER",SWIG_From_int((int)(32))); 16959 SWIG_Python_SetConstant(d, "QPOL_COND_EXPR_BOOL",SWIG_From_int((int)(1))); 16960 SWIG_Python_SetConstant(d, "QPOL_COND_EXPR_NOT",SWIG_From_int((int)(2))); 16961 SWIG_Python_SetConstant(d, "QPOL_COND_EXPR_OR",SWIG_From_int((int)(3))); 16962 SWIG_Python_SetConstant(d, "QPOL_COND_EXPR_AND",SWIG_From_int((int)(4))); 16963 SWIG_Python_SetConstant(d, "QPOL_COND_EXPR_XOR",SWIG_From_int((int)(5))); 16964 SWIG_Python_SetConstant(d, "QPOL_COND_EXPR_EQ",SWIG_From_int((int)(6))); 16965 SWIG_Python_SetConstant(d, "QPOL_COND_EXPR_NEQ",SWIG_From_int((int)(7))); 16966 #if PY_VERSION_HEX >= 0x03000000 16967 return m; 16968 #else 16969 return; 16970 #endif 16971 } 16972 16973
