1 /* 2 * This file generated automatically from xselinux.xml by c_client.py. 3 * Edit at your peril. 4 */ 5 6 #ifdef HAVE_CONFIG_H 7 #include "config.h" 8 #endif 9 #include <stdlib.h> 10 #include <string.h> 11 #include <assert.h> 12 #include <stddef.h> /* for offsetof() */ 13 #include "xcbext.h" 14 #include "xselinux.h" 15 16 #define ALIGNOF(type) offsetof(struct { char dummy; type member; }, member) 17 #include "xproto.h" 18 19 xcb_extension_t xcb_selinux_id = { "SELinux", 0 }; 20 21 22 /***************************************************************************** 23 ** 24 ** xcb_selinux_query_version_cookie_t xcb_selinux_query_version 25 ** 26 ** @param xcb_connection_t *c 27 ** @param uint8_t client_major 28 ** @param uint8_t client_minor 29 ** @returns xcb_selinux_query_version_cookie_t 30 ** 31 *****************************************************************************/ 32 33 xcb_selinux_query_version_cookie_t 34 xcb_selinux_query_version (xcb_connection_t *c /**< */, 35 uint8_t client_major /**< */, 36 uint8_t client_minor /**< */) 37 { 38 static const xcb_protocol_request_t xcb_req = { 39 /* count */ 2, 40 /* ext */ &xcb_selinux_id, 41 /* opcode */ XCB_SELINUX_QUERY_VERSION, 42 /* isvoid */ 0 43 }; 44 45 struct iovec xcb_parts[4]; 46 xcb_selinux_query_version_cookie_t xcb_ret; 47 xcb_selinux_query_version_request_t xcb_out; 48 49 xcb_out.client_major = client_major; 50 xcb_out.client_minor = client_minor; 51 52 xcb_parts[2].iov_base = (char *) &xcb_out; 53 xcb_parts[2].iov_len = sizeof(xcb_out); 54 xcb_parts[3].iov_base = 0; 55 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 56 57 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 58 return xcb_ret; 59 } 60 61 62 /***************************************************************************** 63 ** 64 ** xcb_selinux_query_version_cookie_t xcb_selinux_query_version_unchecked 65 ** 66 ** @param xcb_connection_t *c 67 ** @param uint8_t client_major 68 ** @param uint8_t client_minor 69 ** @returns xcb_selinux_query_version_cookie_t 70 ** 71 *****************************************************************************/ 72 73 xcb_selinux_query_version_cookie_t 74 xcb_selinux_query_version_unchecked (xcb_connection_t *c /**< */, 75 uint8_t client_major /**< */, 76 uint8_t client_minor /**< */) 77 { 78 static const xcb_protocol_request_t xcb_req = { 79 /* count */ 2, 80 /* ext */ &xcb_selinux_id, 81 /* opcode */ XCB_SELINUX_QUERY_VERSION, 82 /* isvoid */ 0 83 }; 84 85 struct iovec xcb_parts[4]; 86 xcb_selinux_query_version_cookie_t xcb_ret; 87 xcb_selinux_query_version_request_t xcb_out; 88 89 xcb_out.client_major = client_major; 90 xcb_out.client_minor = client_minor; 91 92 xcb_parts[2].iov_base = (char *) &xcb_out; 93 xcb_parts[2].iov_len = sizeof(xcb_out); 94 xcb_parts[3].iov_base = 0; 95 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 96 97 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 98 return xcb_ret; 99 } 100 101 102 /***************************************************************************** 103 ** 104 ** xcb_selinux_query_version_reply_t * xcb_selinux_query_version_reply 105 ** 106 ** @param xcb_connection_t *c 107 ** @param xcb_selinux_query_version_cookie_t cookie 108 ** @param xcb_generic_error_t **e 109 ** @returns xcb_selinux_query_version_reply_t * 110 ** 111 *****************************************************************************/ 112 113 xcb_selinux_query_version_reply_t * 114 xcb_selinux_query_version_reply (xcb_connection_t *c /**< */, 115 xcb_selinux_query_version_cookie_t cookie /**< */, 116 xcb_generic_error_t **e /**< */) 117 { 118 return (xcb_selinux_query_version_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 119 } 120 121 int 122 xcb_selinux_set_device_create_context_sizeof (const void *_buffer /**< */) 123 { 124 char *xcb_tmp = (char *)_buffer; 125 const xcb_selinux_set_device_create_context_request_t *_aux = (xcb_selinux_set_device_create_context_request_t *)_buffer; 126 unsigned int xcb_buffer_len = 0; 127 unsigned int xcb_block_len = 0; 128 unsigned int xcb_pad = 0; 129 unsigned int xcb_align_to = 0; 130 131 132 xcb_block_len += sizeof(xcb_selinux_set_device_create_context_request_t); 133 xcb_tmp += xcb_block_len; 134 xcb_buffer_len += xcb_block_len; 135 xcb_block_len = 0; 136 /* context */ 137 xcb_block_len += _aux->context_len * sizeof(char); 138 xcb_tmp += xcb_block_len; 139 xcb_align_to = ALIGNOF(char); 140 /* insert padding */ 141 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 142 xcb_buffer_len += xcb_block_len + xcb_pad; 143 if (0 != xcb_pad) { 144 xcb_tmp += xcb_pad; 145 xcb_pad = 0; 146 } 147 xcb_block_len = 0; 148 149 return xcb_buffer_len; 150 } 151 152 153 /***************************************************************************** 154 ** 155 ** xcb_void_cookie_t xcb_selinux_set_device_create_context_checked 156 ** 157 ** @param xcb_connection_t *c 158 ** @param uint32_t context_len 159 ** @param const char *context 160 ** @returns xcb_void_cookie_t 161 ** 162 *****************************************************************************/ 163 164 xcb_void_cookie_t 165 xcb_selinux_set_device_create_context_checked (xcb_connection_t *c /**< */, 166 uint32_t context_len /**< */, 167 const char *context /**< */) 168 { 169 static const xcb_protocol_request_t xcb_req = { 170 /* count */ 4, 171 /* ext */ &xcb_selinux_id, 172 /* opcode */ XCB_SELINUX_SET_DEVICE_CREATE_CONTEXT, 173 /* isvoid */ 1 174 }; 175 176 struct iovec xcb_parts[6]; 177 xcb_void_cookie_t xcb_ret; 178 xcb_selinux_set_device_create_context_request_t xcb_out; 179 180 xcb_out.context_len = context_len; 181 182 xcb_parts[2].iov_base = (char *) &xcb_out; 183 xcb_parts[2].iov_len = sizeof(xcb_out); 184 xcb_parts[3].iov_base = 0; 185 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 186 /* char context */ 187 xcb_parts[4].iov_base = (char *) context; 188 xcb_parts[4].iov_len = context_len * sizeof(char); 189 xcb_parts[5].iov_base = 0; 190 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 191 192 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 193 return xcb_ret; 194 } 195 196 197 /***************************************************************************** 198 ** 199 ** xcb_void_cookie_t xcb_selinux_set_device_create_context 200 ** 201 ** @param xcb_connection_t *c 202 ** @param uint32_t context_len 203 ** @param const char *context 204 ** @returns xcb_void_cookie_t 205 ** 206 *****************************************************************************/ 207 208 xcb_void_cookie_t 209 xcb_selinux_set_device_create_context (xcb_connection_t *c /**< */, 210 uint32_t context_len /**< */, 211 const char *context /**< */) 212 { 213 static const xcb_protocol_request_t xcb_req = { 214 /* count */ 4, 215 /* ext */ &xcb_selinux_id, 216 /* opcode */ XCB_SELINUX_SET_DEVICE_CREATE_CONTEXT, 217 /* isvoid */ 1 218 }; 219 220 struct iovec xcb_parts[6]; 221 xcb_void_cookie_t xcb_ret; 222 xcb_selinux_set_device_create_context_request_t xcb_out; 223 224 xcb_out.context_len = context_len; 225 226 xcb_parts[2].iov_base = (char *) &xcb_out; 227 xcb_parts[2].iov_len = sizeof(xcb_out); 228 xcb_parts[3].iov_base = 0; 229 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 230 /* char context */ 231 xcb_parts[4].iov_base = (char *) context; 232 xcb_parts[4].iov_len = context_len * sizeof(char); 233 xcb_parts[5].iov_base = 0; 234 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 235 236 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 237 return xcb_ret; 238 } 239 240 int 241 xcb_selinux_get_device_create_context_sizeof (const void *_buffer /**< */) 242 { 243 char *xcb_tmp = (char *)_buffer; 244 const xcb_selinux_get_device_create_context_reply_t *_aux = (xcb_selinux_get_device_create_context_reply_t *)_buffer; 245 unsigned int xcb_buffer_len = 0; 246 unsigned int xcb_block_len = 0; 247 unsigned int xcb_pad = 0; 248 unsigned int xcb_align_to = 0; 249 250 251 xcb_block_len += sizeof(xcb_selinux_get_device_create_context_reply_t); 252 xcb_tmp += xcb_block_len; 253 xcb_buffer_len += xcb_block_len; 254 xcb_block_len = 0; 255 /* context */ 256 xcb_block_len += _aux->context_len * sizeof(char); 257 xcb_tmp += xcb_block_len; 258 xcb_align_to = ALIGNOF(char); 259 /* insert padding */ 260 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 261 xcb_buffer_len += xcb_block_len + xcb_pad; 262 if (0 != xcb_pad) { 263 xcb_tmp += xcb_pad; 264 xcb_pad = 0; 265 } 266 xcb_block_len = 0; 267 268 return xcb_buffer_len; 269 } 270 271 272 /***************************************************************************** 273 ** 274 ** xcb_selinux_get_device_create_context_cookie_t xcb_selinux_get_device_create_context 275 ** 276 ** @param xcb_connection_t *c 277 ** @returns xcb_selinux_get_device_create_context_cookie_t 278 ** 279 *****************************************************************************/ 280 281 xcb_selinux_get_device_create_context_cookie_t 282 xcb_selinux_get_device_create_context (xcb_connection_t *c /**< */) 283 { 284 static const xcb_protocol_request_t xcb_req = { 285 /* count */ 2, 286 /* ext */ &xcb_selinux_id, 287 /* opcode */ XCB_SELINUX_GET_DEVICE_CREATE_CONTEXT, 288 /* isvoid */ 0 289 }; 290 291 struct iovec xcb_parts[4]; 292 xcb_selinux_get_device_create_context_cookie_t xcb_ret; 293 xcb_selinux_get_device_create_context_request_t xcb_out; 294 295 296 xcb_parts[2].iov_base = (char *) &xcb_out; 297 xcb_parts[2].iov_len = sizeof(xcb_out); 298 xcb_parts[3].iov_base = 0; 299 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 300 301 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 302 return xcb_ret; 303 } 304 305 306 /***************************************************************************** 307 ** 308 ** xcb_selinux_get_device_create_context_cookie_t xcb_selinux_get_device_create_context_unchecked 309 ** 310 ** @param xcb_connection_t *c 311 ** @returns xcb_selinux_get_device_create_context_cookie_t 312 ** 313 *****************************************************************************/ 314 315 xcb_selinux_get_device_create_context_cookie_t 316 xcb_selinux_get_device_create_context_unchecked (xcb_connection_t *c /**< */) 317 { 318 static const xcb_protocol_request_t xcb_req = { 319 /* count */ 2, 320 /* ext */ &xcb_selinux_id, 321 /* opcode */ XCB_SELINUX_GET_DEVICE_CREATE_CONTEXT, 322 /* isvoid */ 0 323 }; 324 325 struct iovec xcb_parts[4]; 326 xcb_selinux_get_device_create_context_cookie_t xcb_ret; 327 xcb_selinux_get_device_create_context_request_t xcb_out; 328 329 330 xcb_parts[2].iov_base = (char *) &xcb_out; 331 xcb_parts[2].iov_len = sizeof(xcb_out); 332 xcb_parts[3].iov_base = 0; 333 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 334 335 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 336 return xcb_ret; 337 } 338 339 340 /***************************************************************************** 341 ** 342 ** char * xcb_selinux_get_device_create_context_context 343 ** 344 ** @param const xcb_selinux_get_device_create_context_reply_t *R 345 ** @returns char * 346 ** 347 *****************************************************************************/ 348 349 char * 350 xcb_selinux_get_device_create_context_context (const xcb_selinux_get_device_create_context_reply_t *R /**< */) 351 { 352 return (char *) (R + 1); 353 } 354 355 356 /***************************************************************************** 357 ** 358 ** int xcb_selinux_get_device_create_context_context_length 359 ** 360 ** @param const xcb_selinux_get_device_create_context_reply_t *R 361 ** @returns int 362 ** 363 *****************************************************************************/ 364 365 int 366 xcb_selinux_get_device_create_context_context_length (const xcb_selinux_get_device_create_context_reply_t *R /**< */) 367 { 368 return R->context_len; 369 } 370 371 372 /***************************************************************************** 373 ** 374 ** xcb_generic_iterator_t xcb_selinux_get_device_create_context_context_end 375 ** 376 ** @param const xcb_selinux_get_device_create_context_reply_t *R 377 ** @returns xcb_generic_iterator_t 378 ** 379 *****************************************************************************/ 380 381 xcb_generic_iterator_t 382 xcb_selinux_get_device_create_context_context_end (const xcb_selinux_get_device_create_context_reply_t *R /**< */) 383 { 384 xcb_generic_iterator_t i; 385 i.data = ((char *) (R + 1)) + (R->context_len); 386 i.rem = 0; 387 i.index = (char *) i.data - (char *) R; 388 return i; 389 } 390 391 392 /***************************************************************************** 393 ** 394 ** xcb_selinux_get_device_create_context_reply_t * xcb_selinux_get_device_create_context_reply 395 ** 396 ** @param xcb_connection_t *c 397 ** @param xcb_selinux_get_device_create_context_cookie_t cookie 398 ** @param xcb_generic_error_t **e 399 ** @returns xcb_selinux_get_device_create_context_reply_t * 400 ** 401 *****************************************************************************/ 402 403 xcb_selinux_get_device_create_context_reply_t * 404 xcb_selinux_get_device_create_context_reply (xcb_connection_t *c /**< */, 405 xcb_selinux_get_device_create_context_cookie_t cookie /**< */, 406 xcb_generic_error_t **e /**< */) 407 { 408 return (xcb_selinux_get_device_create_context_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 409 } 410 411 int 412 xcb_selinux_set_device_context_sizeof (const void *_buffer /**< */) 413 { 414 char *xcb_tmp = (char *)_buffer; 415 const xcb_selinux_set_device_context_request_t *_aux = (xcb_selinux_set_device_context_request_t *)_buffer; 416 unsigned int xcb_buffer_len = 0; 417 unsigned int xcb_block_len = 0; 418 unsigned int xcb_pad = 0; 419 unsigned int xcb_align_to = 0; 420 421 422 xcb_block_len += sizeof(xcb_selinux_set_device_context_request_t); 423 xcb_tmp += xcb_block_len; 424 xcb_buffer_len += xcb_block_len; 425 xcb_block_len = 0; 426 /* context */ 427 xcb_block_len += _aux->context_len * sizeof(char); 428 xcb_tmp += xcb_block_len; 429 xcb_align_to = ALIGNOF(char); 430 /* insert padding */ 431 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 432 xcb_buffer_len += xcb_block_len + xcb_pad; 433 if (0 != xcb_pad) { 434 xcb_tmp += xcb_pad; 435 xcb_pad = 0; 436 } 437 xcb_block_len = 0; 438 439 return xcb_buffer_len; 440 } 441 442 443 /***************************************************************************** 444 ** 445 ** xcb_void_cookie_t xcb_selinux_set_device_context_checked 446 ** 447 ** @param xcb_connection_t *c 448 ** @param uint32_t device 449 ** @param uint32_t context_len 450 ** @param const char *context 451 ** @returns xcb_void_cookie_t 452 ** 453 *****************************************************************************/ 454 455 xcb_void_cookie_t 456 xcb_selinux_set_device_context_checked (xcb_connection_t *c /**< */, 457 uint32_t device /**< */, 458 uint32_t context_len /**< */, 459 const char *context /**< */) 460 { 461 static const xcb_protocol_request_t xcb_req = { 462 /* count */ 4, 463 /* ext */ &xcb_selinux_id, 464 /* opcode */ XCB_SELINUX_SET_DEVICE_CONTEXT, 465 /* isvoid */ 1 466 }; 467 468 struct iovec xcb_parts[6]; 469 xcb_void_cookie_t xcb_ret; 470 xcb_selinux_set_device_context_request_t xcb_out; 471 472 xcb_out.device = device; 473 xcb_out.context_len = context_len; 474 475 xcb_parts[2].iov_base = (char *) &xcb_out; 476 xcb_parts[2].iov_len = sizeof(xcb_out); 477 xcb_parts[3].iov_base = 0; 478 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 479 /* char context */ 480 xcb_parts[4].iov_base = (char *) context; 481 xcb_parts[4].iov_len = context_len * sizeof(char); 482 xcb_parts[5].iov_base = 0; 483 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 484 485 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 486 return xcb_ret; 487 } 488 489 490 /***************************************************************************** 491 ** 492 ** xcb_void_cookie_t xcb_selinux_set_device_context 493 ** 494 ** @param xcb_connection_t *c 495 ** @param uint32_t device 496 ** @param uint32_t context_len 497 ** @param const char *context 498 ** @returns xcb_void_cookie_t 499 ** 500 *****************************************************************************/ 501 502 xcb_void_cookie_t 503 xcb_selinux_set_device_context (xcb_connection_t *c /**< */, 504 uint32_t device /**< */, 505 uint32_t context_len /**< */, 506 const char *context /**< */) 507 { 508 static const xcb_protocol_request_t xcb_req = { 509 /* count */ 4, 510 /* ext */ &xcb_selinux_id, 511 /* opcode */ XCB_SELINUX_SET_DEVICE_CONTEXT, 512 /* isvoid */ 1 513 }; 514 515 struct iovec xcb_parts[6]; 516 xcb_void_cookie_t xcb_ret; 517 xcb_selinux_set_device_context_request_t xcb_out; 518 519 xcb_out.device = device; 520 xcb_out.context_len = context_len; 521 522 xcb_parts[2].iov_base = (char *) &xcb_out; 523 xcb_parts[2].iov_len = sizeof(xcb_out); 524 xcb_parts[3].iov_base = 0; 525 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 526 /* char context */ 527 xcb_parts[4].iov_base = (char *) context; 528 xcb_parts[4].iov_len = context_len * sizeof(char); 529 xcb_parts[5].iov_base = 0; 530 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 531 532 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 533 return xcb_ret; 534 } 535 536 int 537 xcb_selinux_get_device_context_sizeof (const void *_buffer /**< */) 538 { 539 char *xcb_tmp = (char *)_buffer; 540 const xcb_selinux_get_device_context_reply_t *_aux = (xcb_selinux_get_device_context_reply_t *)_buffer; 541 unsigned int xcb_buffer_len = 0; 542 unsigned int xcb_block_len = 0; 543 unsigned int xcb_pad = 0; 544 unsigned int xcb_align_to = 0; 545 546 547 xcb_block_len += sizeof(xcb_selinux_get_device_context_reply_t); 548 xcb_tmp += xcb_block_len; 549 xcb_buffer_len += xcb_block_len; 550 xcb_block_len = 0; 551 /* context */ 552 xcb_block_len += _aux->context_len * sizeof(char); 553 xcb_tmp += xcb_block_len; 554 xcb_align_to = ALIGNOF(char); 555 /* insert padding */ 556 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 557 xcb_buffer_len += xcb_block_len + xcb_pad; 558 if (0 != xcb_pad) { 559 xcb_tmp += xcb_pad; 560 xcb_pad = 0; 561 } 562 xcb_block_len = 0; 563 564 return xcb_buffer_len; 565 } 566 567 568 /***************************************************************************** 569 ** 570 ** xcb_selinux_get_device_context_cookie_t xcb_selinux_get_device_context 571 ** 572 ** @param xcb_connection_t *c 573 ** @param uint32_t device 574 ** @returns xcb_selinux_get_device_context_cookie_t 575 ** 576 *****************************************************************************/ 577 578 xcb_selinux_get_device_context_cookie_t 579 xcb_selinux_get_device_context (xcb_connection_t *c /**< */, 580 uint32_t device /**< */) 581 { 582 static const xcb_protocol_request_t xcb_req = { 583 /* count */ 2, 584 /* ext */ &xcb_selinux_id, 585 /* opcode */ XCB_SELINUX_GET_DEVICE_CONTEXT, 586 /* isvoid */ 0 587 }; 588 589 struct iovec xcb_parts[4]; 590 xcb_selinux_get_device_context_cookie_t xcb_ret; 591 xcb_selinux_get_device_context_request_t xcb_out; 592 593 xcb_out.device = device; 594 595 xcb_parts[2].iov_base = (char *) &xcb_out; 596 xcb_parts[2].iov_len = sizeof(xcb_out); 597 xcb_parts[3].iov_base = 0; 598 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 599 600 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 601 return xcb_ret; 602 } 603 604 605 /***************************************************************************** 606 ** 607 ** xcb_selinux_get_device_context_cookie_t xcb_selinux_get_device_context_unchecked 608 ** 609 ** @param xcb_connection_t *c 610 ** @param uint32_t device 611 ** @returns xcb_selinux_get_device_context_cookie_t 612 ** 613 *****************************************************************************/ 614 615 xcb_selinux_get_device_context_cookie_t 616 xcb_selinux_get_device_context_unchecked (xcb_connection_t *c /**< */, 617 uint32_t device /**< */) 618 { 619 static const xcb_protocol_request_t xcb_req = { 620 /* count */ 2, 621 /* ext */ &xcb_selinux_id, 622 /* opcode */ XCB_SELINUX_GET_DEVICE_CONTEXT, 623 /* isvoid */ 0 624 }; 625 626 struct iovec xcb_parts[4]; 627 xcb_selinux_get_device_context_cookie_t xcb_ret; 628 xcb_selinux_get_device_context_request_t xcb_out; 629 630 xcb_out.device = device; 631 632 xcb_parts[2].iov_base = (char *) &xcb_out; 633 xcb_parts[2].iov_len = sizeof(xcb_out); 634 xcb_parts[3].iov_base = 0; 635 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 636 637 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 638 return xcb_ret; 639 } 640 641 642 /***************************************************************************** 643 ** 644 ** char * xcb_selinux_get_device_context_context 645 ** 646 ** @param const xcb_selinux_get_device_context_reply_t *R 647 ** @returns char * 648 ** 649 *****************************************************************************/ 650 651 char * 652 xcb_selinux_get_device_context_context (const xcb_selinux_get_device_context_reply_t *R /**< */) 653 { 654 return (char *) (R + 1); 655 } 656 657 658 /***************************************************************************** 659 ** 660 ** int xcb_selinux_get_device_context_context_length 661 ** 662 ** @param const xcb_selinux_get_device_context_reply_t *R 663 ** @returns int 664 ** 665 *****************************************************************************/ 666 667 int 668 xcb_selinux_get_device_context_context_length (const xcb_selinux_get_device_context_reply_t *R /**< */) 669 { 670 return R->context_len; 671 } 672 673 674 /***************************************************************************** 675 ** 676 ** xcb_generic_iterator_t xcb_selinux_get_device_context_context_end 677 ** 678 ** @param const xcb_selinux_get_device_context_reply_t *R 679 ** @returns xcb_generic_iterator_t 680 ** 681 *****************************************************************************/ 682 683 xcb_generic_iterator_t 684 xcb_selinux_get_device_context_context_end (const xcb_selinux_get_device_context_reply_t *R /**< */) 685 { 686 xcb_generic_iterator_t i; 687 i.data = ((char *) (R + 1)) + (R->context_len); 688 i.rem = 0; 689 i.index = (char *) i.data - (char *) R; 690 return i; 691 } 692 693 694 /***************************************************************************** 695 ** 696 ** xcb_selinux_get_device_context_reply_t * xcb_selinux_get_device_context_reply 697 ** 698 ** @param xcb_connection_t *c 699 ** @param xcb_selinux_get_device_context_cookie_t cookie 700 ** @param xcb_generic_error_t **e 701 ** @returns xcb_selinux_get_device_context_reply_t * 702 ** 703 *****************************************************************************/ 704 705 xcb_selinux_get_device_context_reply_t * 706 xcb_selinux_get_device_context_reply (xcb_connection_t *c /**< */, 707 xcb_selinux_get_device_context_cookie_t cookie /**< */, 708 xcb_generic_error_t **e /**< */) 709 { 710 return (xcb_selinux_get_device_context_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 711 } 712 713 int 714 xcb_selinux_set_window_create_context_sizeof (const void *_buffer /**< */) 715 { 716 char *xcb_tmp = (char *)_buffer; 717 const xcb_selinux_set_window_create_context_request_t *_aux = (xcb_selinux_set_window_create_context_request_t *)_buffer; 718 unsigned int xcb_buffer_len = 0; 719 unsigned int xcb_block_len = 0; 720 unsigned int xcb_pad = 0; 721 unsigned int xcb_align_to = 0; 722 723 724 xcb_block_len += sizeof(xcb_selinux_set_window_create_context_request_t); 725 xcb_tmp += xcb_block_len; 726 xcb_buffer_len += xcb_block_len; 727 xcb_block_len = 0; 728 /* context */ 729 xcb_block_len += _aux->context_len * sizeof(char); 730 xcb_tmp += xcb_block_len; 731 xcb_align_to = ALIGNOF(char); 732 /* insert padding */ 733 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 734 xcb_buffer_len += xcb_block_len + xcb_pad; 735 if (0 != xcb_pad) { 736 xcb_tmp += xcb_pad; 737 xcb_pad = 0; 738 } 739 xcb_block_len = 0; 740 741 return xcb_buffer_len; 742 } 743 744 745 /***************************************************************************** 746 ** 747 ** xcb_void_cookie_t xcb_selinux_set_window_create_context_checked 748 ** 749 ** @param xcb_connection_t *c 750 ** @param uint32_t context_len 751 ** @param const char *context 752 ** @returns xcb_void_cookie_t 753 ** 754 *****************************************************************************/ 755 756 xcb_void_cookie_t 757 xcb_selinux_set_window_create_context_checked (xcb_connection_t *c /**< */, 758 uint32_t context_len /**< */, 759 const char *context /**< */) 760 { 761 static const xcb_protocol_request_t xcb_req = { 762 /* count */ 4, 763 /* ext */ &xcb_selinux_id, 764 /* opcode */ XCB_SELINUX_SET_WINDOW_CREATE_CONTEXT, 765 /* isvoid */ 1 766 }; 767 768 struct iovec xcb_parts[6]; 769 xcb_void_cookie_t xcb_ret; 770 xcb_selinux_set_window_create_context_request_t xcb_out; 771 772 xcb_out.context_len = context_len; 773 774 xcb_parts[2].iov_base = (char *) &xcb_out; 775 xcb_parts[2].iov_len = sizeof(xcb_out); 776 xcb_parts[3].iov_base = 0; 777 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 778 /* char context */ 779 xcb_parts[4].iov_base = (char *) context; 780 xcb_parts[4].iov_len = context_len * sizeof(char); 781 xcb_parts[5].iov_base = 0; 782 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 783 784 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 785 return xcb_ret; 786 } 787 788 789 /***************************************************************************** 790 ** 791 ** xcb_void_cookie_t xcb_selinux_set_window_create_context 792 ** 793 ** @param xcb_connection_t *c 794 ** @param uint32_t context_len 795 ** @param const char *context 796 ** @returns xcb_void_cookie_t 797 ** 798 *****************************************************************************/ 799 800 xcb_void_cookie_t 801 xcb_selinux_set_window_create_context (xcb_connection_t *c /**< */, 802 uint32_t context_len /**< */, 803 const char *context /**< */) 804 { 805 static const xcb_protocol_request_t xcb_req = { 806 /* count */ 4, 807 /* ext */ &xcb_selinux_id, 808 /* opcode */ XCB_SELINUX_SET_WINDOW_CREATE_CONTEXT, 809 /* isvoid */ 1 810 }; 811 812 struct iovec xcb_parts[6]; 813 xcb_void_cookie_t xcb_ret; 814 xcb_selinux_set_window_create_context_request_t xcb_out; 815 816 xcb_out.context_len = context_len; 817 818 xcb_parts[2].iov_base = (char *) &xcb_out; 819 xcb_parts[2].iov_len = sizeof(xcb_out); 820 xcb_parts[3].iov_base = 0; 821 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 822 /* char context */ 823 xcb_parts[4].iov_base = (char *) context; 824 xcb_parts[4].iov_len = context_len * sizeof(char); 825 xcb_parts[5].iov_base = 0; 826 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 827 828 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 829 return xcb_ret; 830 } 831 832 int 833 xcb_selinux_get_window_create_context_sizeof (const void *_buffer /**< */) 834 { 835 char *xcb_tmp = (char *)_buffer; 836 const xcb_selinux_get_window_create_context_reply_t *_aux = (xcb_selinux_get_window_create_context_reply_t *)_buffer; 837 unsigned int xcb_buffer_len = 0; 838 unsigned int xcb_block_len = 0; 839 unsigned int xcb_pad = 0; 840 unsigned int xcb_align_to = 0; 841 842 843 xcb_block_len += sizeof(xcb_selinux_get_window_create_context_reply_t); 844 xcb_tmp += xcb_block_len; 845 xcb_buffer_len += xcb_block_len; 846 xcb_block_len = 0; 847 /* context */ 848 xcb_block_len += _aux->context_len * sizeof(char); 849 xcb_tmp += xcb_block_len; 850 xcb_align_to = ALIGNOF(char); 851 /* insert padding */ 852 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 853 xcb_buffer_len += xcb_block_len + xcb_pad; 854 if (0 != xcb_pad) { 855 xcb_tmp += xcb_pad; 856 xcb_pad = 0; 857 } 858 xcb_block_len = 0; 859 860 return xcb_buffer_len; 861 } 862 863 864 /***************************************************************************** 865 ** 866 ** xcb_selinux_get_window_create_context_cookie_t xcb_selinux_get_window_create_context 867 ** 868 ** @param xcb_connection_t *c 869 ** @returns xcb_selinux_get_window_create_context_cookie_t 870 ** 871 *****************************************************************************/ 872 873 xcb_selinux_get_window_create_context_cookie_t 874 xcb_selinux_get_window_create_context (xcb_connection_t *c /**< */) 875 { 876 static const xcb_protocol_request_t xcb_req = { 877 /* count */ 2, 878 /* ext */ &xcb_selinux_id, 879 /* opcode */ XCB_SELINUX_GET_WINDOW_CREATE_CONTEXT, 880 /* isvoid */ 0 881 }; 882 883 struct iovec xcb_parts[4]; 884 xcb_selinux_get_window_create_context_cookie_t xcb_ret; 885 xcb_selinux_get_window_create_context_request_t xcb_out; 886 887 888 xcb_parts[2].iov_base = (char *) &xcb_out; 889 xcb_parts[2].iov_len = sizeof(xcb_out); 890 xcb_parts[3].iov_base = 0; 891 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 892 893 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 894 return xcb_ret; 895 } 896 897 898 /***************************************************************************** 899 ** 900 ** xcb_selinux_get_window_create_context_cookie_t xcb_selinux_get_window_create_context_unchecked 901 ** 902 ** @param xcb_connection_t *c 903 ** @returns xcb_selinux_get_window_create_context_cookie_t 904 ** 905 *****************************************************************************/ 906 907 xcb_selinux_get_window_create_context_cookie_t 908 xcb_selinux_get_window_create_context_unchecked (xcb_connection_t *c /**< */) 909 { 910 static const xcb_protocol_request_t xcb_req = { 911 /* count */ 2, 912 /* ext */ &xcb_selinux_id, 913 /* opcode */ XCB_SELINUX_GET_WINDOW_CREATE_CONTEXT, 914 /* isvoid */ 0 915 }; 916 917 struct iovec xcb_parts[4]; 918 xcb_selinux_get_window_create_context_cookie_t xcb_ret; 919 xcb_selinux_get_window_create_context_request_t xcb_out; 920 921 922 xcb_parts[2].iov_base = (char *) &xcb_out; 923 xcb_parts[2].iov_len = sizeof(xcb_out); 924 xcb_parts[3].iov_base = 0; 925 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 926 927 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 928 return xcb_ret; 929 } 930 931 932 /***************************************************************************** 933 ** 934 ** char * xcb_selinux_get_window_create_context_context 935 ** 936 ** @param const xcb_selinux_get_window_create_context_reply_t *R 937 ** @returns char * 938 ** 939 *****************************************************************************/ 940 941 char * 942 xcb_selinux_get_window_create_context_context (const xcb_selinux_get_window_create_context_reply_t *R /**< */) 943 { 944 return (char *) (R + 1); 945 } 946 947 948 /***************************************************************************** 949 ** 950 ** int xcb_selinux_get_window_create_context_context_length 951 ** 952 ** @param const xcb_selinux_get_window_create_context_reply_t *R 953 ** @returns int 954 ** 955 *****************************************************************************/ 956 957 int 958 xcb_selinux_get_window_create_context_context_length (const xcb_selinux_get_window_create_context_reply_t *R /**< */) 959 { 960 return R->context_len; 961 } 962 963 964 /***************************************************************************** 965 ** 966 ** xcb_generic_iterator_t xcb_selinux_get_window_create_context_context_end 967 ** 968 ** @param const xcb_selinux_get_window_create_context_reply_t *R 969 ** @returns xcb_generic_iterator_t 970 ** 971 *****************************************************************************/ 972 973 xcb_generic_iterator_t 974 xcb_selinux_get_window_create_context_context_end (const xcb_selinux_get_window_create_context_reply_t *R /**< */) 975 { 976 xcb_generic_iterator_t i; 977 i.data = ((char *) (R + 1)) + (R->context_len); 978 i.rem = 0; 979 i.index = (char *) i.data - (char *) R; 980 return i; 981 } 982 983 984 /***************************************************************************** 985 ** 986 ** xcb_selinux_get_window_create_context_reply_t * xcb_selinux_get_window_create_context_reply 987 ** 988 ** @param xcb_connection_t *c 989 ** @param xcb_selinux_get_window_create_context_cookie_t cookie 990 ** @param xcb_generic_error_t **e 991 ** @returns xcb_selinux_get_window_create_context_reply_t * 992 ** 993 *****************************************************************************/ 994 995 xcb_selinux_get_window_create_context_reply_t * 996 xcb_selinux_get_window_create_context_reply (xcb_connection_t *c /**< */, 997 xcb_selinux_get_window_create_context_cookie_t cookie /**< */, 998 xcb_generic_error_t **e /**< */) 999 { 1000 return (xcb_selinux_get_window_create_context_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 1001 } 1002 1003 int 1004 xcb_selinux_get_window_context_sizeof (const void *_buffer /**< */) 1005 { 1006 char *xcb_tmp = (char *)_buffer; 1007 const xcb_selinux_get_window_context_reply_t *_aux = (xcb_selinux_get_window_context_reply_t *)_buffer; 1008 unsigned int xcb_buffer_len = 0; 1009 unsigned int xcb_block_len = 0; 1010 unsigned int xcb_pad = 0; 1011 unsigned int xcb_align_to = 0; 1012 1013 1014 xcb_block_len += sizeof(xcb_selinux_get_window_context_reply_t); 1015 xcb_tmp += xcb_block_len; 1016 xcb_buffer_len += xcb_block_len; 1017 xcb_block_len = 0; 1018 /* context */ 1019 xcb_block_len += _aux->context_len * sizeof(char); 1020 xcb_tmp += xcb_block_len; 1021 xcb_align_to = ALIGNOF(char); 1022 /* insert padding */ 1023 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 1024 xcb_buffer_len += xcb_block_len + xcb_pad; 1025 if (0 != xcb_pad) { 1026 xcb_tmp += xcb_pad; 1027 xcb_pad = 0; 1028 } 1029 xcb_block_len = 0; 1030 1031 return xcb_buffer_len; 1032 } 1033 1034 1035 /***************************************************************************** 1036 ** 1037 ** xcb_selinux_get_window_context_cookie_t xcb_selinux_get_window_context 1038 ** 1039 ** @param xcb_connection_t *c 1040 ** @param xcb_window_t window 1041 ** @returns xcb_selinux_get_window_context_cookie_t 1042 ** 1043 *****************************************************************************/ 1044 1045 xcb_selinux_get_window_context_cookie_t 1046 xcb_selinux_get_window_context (xcb_connection_t *c /**< */, 1047 xcb_window_t window /**< */) 1048 { 1049 static const xcb_protocol_request_t xcb_req = { 1050 /* count */ 2, 1051 /* ext */ &xcb_selinux_id, 1052 /* opcode */ XCB_SELINUX_GET_WINDOW_CONTEXT, 1053 /* isvoid */ 0 1054 }; 1055 1056 struct iovec xcb_parts[4]; 1057 xcb_selinux_get_window_context_cookie_t xcb_ret; 1058 xcb_selinux_get_window_context_request_t xcb_out; 1059 1060 xcb_out.window = window; 1061 1062 xcb_parts[2].iov_base = (char *) &xcb_out; 1063 xcb_parts[2].iov_len = sizeof(xcb_out); 1064 xcb_parts[3].iov_base = 0; 1065 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1066 1067 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 1068 return xcb_ret; 1069 } 1070 1071 1072 /***************************************************************************** 1073 ** 1074 ** xcb_selinux_get_window_context_cookie_t xcb_selinux_get_window_context_unchecked 1075 ** 1076 ** @param xcb_connection_t *c 1077 ** @param xcb_window_t window 1078 ** @returns xcb_selinux_get_window_context_cookie_t 1079 ** 1080 *****************************************************************************/ 1081 1082 xcb_selinux_get_window_context_cookie_t 1083 xcb_selinux_get_window_context_unchecked (xcb_connection_t *c /**< */, 1084 xcb_window_t window /**< */) 1085 { 1086 static const xcb_protocol_request_t xcb_req = { 1087 /* count */ 2, 1088 /* ext */ &xcb_selinux_id, 1089 /* opcode */ XCB_SELINUX_GET_WINDOW_CONTEXT, 1090 /* isvoid */ 0 1091 }; 1092 1093 struct iovec xcb_parts[4]; 1094 xcb_selinux_get_window_context_cookie_t xcb_ret; 1095 xcb_selinux_get_window_context_request_t xcb_out; 1096 1097 xcb_out.window = window; 1098 1099 xcb_parts[2].iov_base = (char *) &xcb_out; 1100 xcb_parts[2].iov_len = sizeof(xcb_out); 1101 xcb_parts[3].iov_base = 0; 1102 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1103 1104 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 1105 return xcb_ret; 1106 } 1107 1108 1109 /***************************************************************************** 1110 ** 1111 ** char * xcb_selinux_get_window_context_context 1112 ** 1113 ** @param const xcb_selinux_get_window_context_reply_t *R 1114 ** @returns char * 1115 ** 1116 *****************************************************************************/ 1117 1118 char * 1119 xcb_selinux_get_window_context_context (const xcb_selinux_get_window_context_reply_t *R /**< */) 1120 { 1121 return (char *) (R + 1); 1122 } 1123 1124 1125 /***************************************************************************** 1126 ** 1127 ** int xcb_selinux_get_window_context_context_length 1128 ** 1129 ** @param const xcb_selinux_get_window_context_reply_t *R 1130 ** @returns int 1131 ** 1132 *****************************************************************************/ 1133 1134 int 1135 xcb_selinux_get_window_context_context_length (const xcb_selinux_get_window_context_reply_t *R /**< */) 1136 { 1137 return R->context_len; 1138 } 1139 1140 1141 /***************************************************************************** 1142 ** 1143 ** xcb_generic_iterator_t xcb_selinux_get_window_context_context_end 1144 ** 1145 ** @param const xcb_selinux_get_window_context_reply_t *R 1146 ** @returns xcb_generic_iterator_t 1147 ** 1148 *****************************************************************************/ 1149 1150 xcb_generic_iterator_t 1151 xcb_selinux_get_window_context_context_end (const xcb_selinux_get_window_context_reply_t *R /**< */) 1152 { 1153 xcb_generic_iterator_t i; 1154 i.data = ((char *) (R + 1)) + (R->context_len); 1155 i.rem = 0; 1156 i.index = (char *) i.data - (char *) R; 1157 return i; 1158 } 1159 1160 1161 /***************************************************************************** 1162 ** 1163 ** xcb_selinux_get_window_context_reply_t * xcb_selinux_get_window_context_reply 1164 ** 1165 ** @param xcb_connection_t *c 1166 ** @param xcb_selinux_get_window_context_cookie_t cookie 1167 ** @param xcb_generic_error_t **e 1168 ** @returns xcb_selinux_get_window_context_reply_t * 1169 ** 1170 *****************************************************************************/ 1171 1172 xcb_selinux_get_window_context_reply_t * 1173 xcb_selinux_get_window_context_reply (xcb_connection_t *c /**< */, 1174 xcb_selinux_get_window_context_cookie_t cookie /**< */, 1175 xcb_generic_error_t **e /**< */) 1176 { 1177 return (xcb_selinux_get_window_context_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 1178 } 1179 1180 int 1181 xcb_selinux_list_item_sizeof (const void *_buffer /**< */) 1182 { 1183 char *xcb_tmp = (char *)_buffer; 1184 const xcb_selinux_list_item_t *_aux = (xcb_selinux_list_item_t *)_buffer; 1185 unsigned int xcb_buffer_len = 0; 1186 unsigned int xcb_block_len = 0; 1187 unsigned int xcb_pad = 0; 1188 unsigned int xcb_align_to = 0; 1189 1190 1191 xcb_block_len += sizeof(xcb_selinux_list_item_t); 1192 xcb_tmp += xcb_block_len; 1193 xcb_buffer_len += xcb_block_len; 1194 xcb_block_len = 0; 1195 /* object_context */ 1196 xcb_block_len += _aux->object_context_len * sizeof(char); 1197 xcb_tmp += xcb_block_len; 1198 xcb_align_to = ALIGNOF(char); 1199 /* insert padding */ 1200 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 1201 xcb_buffer_len += xcb_block_len + xcb_pad; 1202 if (0 != xcb_pad) { 1203 xcb_tmp += xcb_pad; 1204 xcb_pad = 0; 1205 } 1206 xcb_block_len = 0; 1207 /* data_context */ 1208 xcb_block_len += _aux->data_context_len * sizeof(char); 1209 xcb_tmp += xcb_block_len; 1210 xcb_align_to = ALIGNOF(char); 1211 /* insert padding */ 1212 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 1213 xcb_buffer_len += xcb_block_len + xcb_pad; 1214 if (0 != xcb_pad) { 1215 xcb_tmp += xcb_pad; 1216 xcb_pad = 0; 1217 } 1218 xcb_block_len = 0; 1219 1220 return xcb_buffer_len; 1221 } 1222 1223 1224 /***************************************************************************** 1225 ** 1226 ** char * xcb_selinux_list_item_object_context 1227 ** 1228 ** @param const xcb_selinux_list_item_t *R 1229 ** @returns char * 1230 ** 1231 *****************************************************************************/ 1232 1233 char * 1234 xcb_selinux_list_item_object_context (const xcb_selinux_list_item_t *R /**< */) 1235 { 1236 return (char *) (R + 1); 1237 } 1238 1239 1240 /***************************************************************************** 1241 ** 1242 ** int xcb_selinux_list_item_object_context_length 1243 ** 1244 ** @param const xcb_selinux_list_item_t *R 1245 ** @returns int 1246 ** 1247 *****************************************************************************/ 1248 1249 int 1250 xcb_selinux_list_item_object_context_length (const xcb_selinux_list_item_t *R /**< */) 1251 { 1252 return R->object_context_len; 1253 } 1254 1255 1256 /***************************************************************************** 1257 ** 1258 ** xcb_generic_iterator_t xcb_selinux_list_item_object_context_end 1259 ** 1260 ** @param const xcb_selinux_list_item_t *R 1261 ** @returns xcb_generic_iterator_t 1262 ** 1263 *****************************************************************************/ 1264 1265 xcb_generic_iterator_t 1266 xcb_selinux_list_item_object_context_end (const xcb_selinux_list_item_t *R /**< */) 1267 { 1268 xcb_generic_iterator_t i; 1269 i.data = ((char *) (R + 1)) + (R->object_context_len); 1270 i.rem = 0; 1271 i.index = (char *) i.data - (char *) R; 1272 return i; 1273 } 1274 1275 1276 /***************************************************************************** 1277 ** 1278 ** char * xcb_selinux_list_item_data_context 1279 ** 1280 ** @param const xcb_selinux_list_item_t *R 1281 ** @returns char * 1282 ** 1283 *****************************************************************************/ 1284 1285 char * 1286 xcb_selinux_list_item_data_context (const xcb_selinux_list_item_t *R /**< */) 1287 { 1288 xcb_generic_iterator_t prev = xcb_selinux_list_item_object_context_end(R); 1289 return (char *) ((char *) prev.data + XCB_TYPE_PAD(char, prev.index) + 0); 1290 } 1291 1292 1293 /***************************************************************************** 1294 ** 1295 ** int xcb_selinux_list_item_data_context_length 1296 ** 1297 ** @param const xcb_selinux_list_item_t *R 1298 ** @returns int 1299 ** 1300 *****************************************************************************/ 1301 1302 int 1303 xcb_selinux_list_item_data_context_length (const xcb_selinux_list_item_t *R /**< */) 1304 { 1305 return R->data_context_len; 1306 } 1307 1308 1309 /***************************************************************************** 1310 ** 1311 ** xcb_generic_iterator_t xcb_selinux_list_item_data_context_end 1312 ** 1313 ** @param const xcb_selinux_list_item_t *R 1314 ** @returns xcb_generic_iterator_t 1315 ** 1316 *****************************************************************************/ 1317 1318 xcb_generic_iterator_t 1319 xcb_selinux_list_item_data_context_end (const xcb_selinux_list_item_t *R /**< */) 1320 { 1321 xcb_generic_iterator_t i; 1322 xcb_generic_iterator_t child = xcb_selinux_list_item_object_context_end(R); 1323 i.data = ((char *) child.data) + (R->data_context_len); 1324 i.rem = 0; 1325 i.index = (char *) i.data - (char *) R; 1326 return i; 1327 } 1328 1329 1330 /***************************************************************************** 1331 ** 1332 ** void xcb_selinux_list_item_next 1333 ** 1334 ** @param xcb_selinux_list_item_iterator_t *i 1335 ** @returns void 1336 ** 1337 *****************************************************************************/ 1338 1339 void 1340 xcb_selinux_list_item_next (xcb_selinux_list_item_iterator_t *i /**< */) 1341 { 1342 xcb_selinux_list_item_t *R = i->data; 1343 xcb_generic_iterator_t child; 1344 child.data = (xcb_selinux_list_item_t *)(((char *)R) + xcb_selinux_list_item_sizeof(R)); 1345 i->index = (char *) child.data - (char *) i->data; 1346 --i->rem; 1347 i->data = (xcb_selinux_list_item_t *) child.data; 1348 } 1349 1350 1351 /***************************************************************************** 1352 ** 1353 ** xcb_generic_iterator_t xcb_selinux_list_item_end 1354 ** 1355 ** @param xcb_selinux_list_item_iterator_t i 1356 ** @returns xcb_generic_iterator_t 1357 ** 1358 *****************************************************************************/ 1359 1360 xcb_generic_iterator_t 1361 xcb_selinux_list_item_end (xcb_selinux_list_item_iterator_t i /**< */) 1362 { 1363 xcb_generic_iterator_t ret; 1364 while(i.rem > 0) 1365 xcb_selinux_list_item_next(&i); 1366 ret.data = i.data; 1367 ret.rem = i.rem; 1368 ret.index = i.index; 1369 return ret; 1370 } 1371 1372 int 1373 xcb_selinux_set_property_create_context_sizeof (const void *_buffer /**< */) 1374 { 1375 char *xcb_tmp = (char *)_buffer; 1376 const xcb_selinux_set_property_create_context_request_t *_aux = (xcb_selinux_set_property_create_context_request_t *)_buffer; 1377 unsigned int xcb_buffer_len = 0; 1378 unsigned int xcb_block_len = 0; 1379 unsigned int xcb_pad = 0; 1380 unsigned int xcb_align_to = 0; 1381 1382 1383 xcb_block_len += sizeof(xcb_selinux_set_property_create_context_request_t); 1384 xcb_tmp += xcb_block_len; 1385 xcb_buffer_len += xcb_block_len; 1386 xcb_block_len = 0; 1387 /* context */ 1388 xcb_block_len += _aux->context_len * sizeof(char); 1389 xcb_tmp += xcb_block_len; 1390 xcb_align_to = ALIGNOF(char); 1391 /* insert padding */ 1392 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 1393 xcb_buffer_len += xcb_block_len + xcb_pad; 1394 if (0 != xcb_pad) { 1395 xcb_tmp += xcb_pad; 1396 xcb_pad = 0; 1397 } 1398 xcb_block_len = 0; 1399 1400 return xcb_buffer_len; 1401 } 1402 1403 1404 /***************************************************************************** 1405 ** 1406 ** xcb_void_cookie_t xcb_selinux_set_property_create_context_checked 1407 ** 1408 ** @param xcb_connection_t *c 1409 ** @param uint32_t context_len 1410 ** @param const char *context 1411 ** @returns xcb_void_cookie_t 1412 ** 1413 *****************************************************************************/ 1414 1415 xcb_void_cookie_t 1416 xcb_selinux_set_property_create_context_checked (xcb_connection_t *c /**< */, 1417 uint32_t context_len /**< */, 1418 const char *context /**< */) 1419 { 1420 static const xcb_protocol_request_t xcb_req = { 1421 /* count */ 4, 1422 /* ext */ &xcb_selinux_id, 1423 /* opcode */ XCB_SELINUX_SET_PROPERTY_CREATE_CONTEXT, 1424 /* isvoid */ 1 1425 }; 1426 1427 struct iovec xcb_parts[6]; 1428 xcb_void_cookie_t xcb_ret; 1429 xcb_selinux_set_property_create_context_request_t xcb_out; 1430 1431 xcb_out.context_len = context_len; 1432 1433 xcb_parts[2].iov_base = (char *) &xcb_out; 1434 xcb_parts[2].iov_len = sizeof(xcb_out); 1435 xcb_parts[3].iov_base = 0; 1436 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1437 /* char context */ 1438 xcb_parts[4].iov_base = (char *) context; 1439 xcb_parts[4].iov_len = context_len * sizeof(char); 1440 xcb_parts[5].iov_base = 0; 1441 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 1442 1443 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 1444 return xcb_ret; 1445 } 1446 1447 1448 /***************************************************************************** 1449 ** 1450 ** xcb_void_cookie_t xcb_selinux_set_property_create_context 1451 ** 1452 ** @param xcb_connection_t *c 1453 ** @param uint32_t context_len 1454 ** @param const char *context 1455 ** @returns xcb_void_cookie_t 1456 ** 1457 *****************************************************************************/ 1458 1459 xcb_void_cookie_t 1460 xcb_selinux_set_property_create_context (xcb_connection_t *c /**< */, 1461 uint32_t context_len /**< */, 1462 const char *context /**< */) 1463 { 1464 static const xcb_protocol_request_t xcb_req = { 1465 /* count */ 4, 1466 /* ext */ &xcb_selinux_id, 1467 /* opcode */ XCB_SELINUX_SET_PROPERTY_CREATE_CONTEXT, 1468 /* isvoid */ 1 1469 }; 1470 1471 struct iovec xcb_parts[6]; 1472 xcb_void_cookie_t xcb_ret; 1473 xcb_selinux_set_property_create_context_request_t xcb_out; 1474 1475 xcb_out.context_len = context_len; 1476 1477 xcb_parts[2].iov_base = (char *) &xcb_out; 1478 xcb_parts[2].iov_len = sizeof(xcb_out); 1479 xcb_parts[3].iov_base = 0; 1480 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1481 /* char context */ 1482 xcb_parts[4].iov_base = (char *) context; 1483 xcb_parts[4].iov_len = context_len * sizeof(char); 1484 xcb_parts[5].iov_base = 0; 1485 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 1486 1487 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 1488 return xcb_ret; 1489 } 1490 1491 int 1492 xcb_selinux_get_property_create_context_sizeof (const void *_buffer /**< */) 1493 { 1494 char *xcb_tmp = (char *)_buffer; 1495 const xcb_selinux_get_property_create_context_reply_t *_aux = (xcb_selinux_get_property_create_context_reply_t *)_buffer; 1496 unsigned int xcb_buffer_len = 0; 1497 unsigned int xcb_block_len = 0; 1498 unsigned int xcb_pad = 0; 1499 unsigned int xcb_align_to = 0; 1500 1501 1502 xcb_block_len += sizeof(xcb_selinux_get_property_create_context_reply_t); 1503 xcb_tmp += xcb_block_len; 1504 xcb_buffer_len += xcb_block_len; 1505 xcb_block_len = 0; 1506 /* context */ 1507 xcb_block_len += _aux->context_len * sizeof(char); 1508 xcb_tmp += xcb_block_len; 1509 xcb_align_to = ALIGNOF(char); 1510 /* insert padding */ 1511 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 1512 xcb_buffer_len += xcb_block_len + xcb_pad; 1513 if (0 != xcb_pad) { 1514 xcb_tmp += xcb_pad; 1515 xcb_pad = 0; 1516 } 1517 xcb_block_len = 0; 1518 1519 return xcb_buffer_len; 1520 } 1521 1522 1523 /***************************************************************************** 1524 ** 1525 ** xcb_selinux_get_property_create_context_cookie_t xcb_selinux_get_property_create_context 1526 ** 1527 ** @param xcb_connection_t *c 1528 ** @returns xcb_selinux_get_property_create_context_cookie_t 1529 ** 1530 *****************************************************************************/ 1531 1532 xcb_selinux_get_property_create_context_cookie_t 1533 xcb_selinux_get_property_create_context (xcb_connection_t *c /**< */) 1534 { 1535 static const xcb_protocol_request_t xcb_req = { 1536 /* count */ 2, 1537 /* ext */ &xcb_selinux_id, 1538 /* opcode */ XCB_SELINUX_GET_PROPERTY_CREATE_CONTEXT, 1539 /* isvoid */ 0 1540 }; 1541 1542 struct iovec xcb_parts[4]; 1543 xcb_selinux_get_property_create_context_cookie_t xcb_ret; 1544 xcb_selinux_get_property_create_context_request_t xcb_out; 1545 1546 1547 xcb_parts[2].iov_base = (char *) &xcb_out; 1548 xcb_parts[2].iov_len = sizeof(xcb_out); 1549 xcb_parts[3].iov_base = 0; 1550 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1551 1552 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 1553 return xcb_ret; 1554 } 1555 1556 1557 /***************************************************************************** 1558 ** 1559 ** xcb_selinux_get_property_create_context_cookie_t xcb_selinux_get_property_create_context_unchecked 1560 ** 1561 ** @param xcb_connection_t *c 1562 ** @returns xcb_selinux_get_property_create_context_cookie_t 1563 ** 1564 *****************************************************************************/ 1565 1566 xcb_selinux_get_property_create_context_cookie_t 1567 xcb_selinux_get_property_create_context_unchecked (xcb_connection_t *c /**< */) 1568 { 1569 static const xcb_protocol_request_t xcb_req = { 1570 /* count */ 2, 1571 /* ext */ &xcb_selinux_id, 1572 /* opcode */ XCB_SELINUX_GET_PROPERTY_CREATE_CONTEXT, 1573 /* isvoid */ 0 1574 }; 1575 1576 struct iovec xcb_parts[4]; 1577 xcb_selinux_get_property_create_context_cookie_t xcb_ret; 1578 xcb_selinux_get_property_create_context_request_t xcb_out; 1579 1580 1581 xcb_parts[2].iov_base = (char *) &xcb_out; 1582 xcb_parts[2].iov_len = sizeof(xcb_out); 1583 xcb_parts[3].iov_base = 0; 1584 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1585 1586 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 1587 return xcb_ret; 1588 } 1589 1590 1591 /***************************************************************************** 1592 ** 1593 ** char * xcb_selinux_get_property_create_context_context 1594 ** 1595 ** @param const xcb_selinux_get_property_create_context_reply_t *R 1596 ** @returns char * 1597 ** 1598 *****************************************************************************/ 1599 1600 char * 1601 xcb_selinux_get_property_create_context_context (const xcb_selinux_get_property_create_context_reply_t *R /**< */) 1602 { 1603 return (char *) (R + 1); 1604 } 1605 1606 1607 /***************************************************************************** 1608 ** 1609 ** int xcb_selinux_get_property_create_context_context_length 1610 ** 1611 ** @param const xcb_selinux_get_property_create_context_reply_t *R 1612 ** @returns int 1613 ** 1614 *****************************************************************************/ 1615 1616 int 1617 xcb_selinux_get_property_create_context_context_length (const xcb_selinux_get_property_create_context_reply_t *R /**< */) 1618 { 1619 return R->context_len; 1620 } 1621 1622 1623 /***************************************************************************** 1624 ** 1625 ** xcb_generic_iterator_t xcb_selinux_get_property_create_context_context_end 1626 ** 1627 ** @param const xcb_selinux_get_property_create_context_reply_t *R 1628 ** @returns xcb_generic_iterator_t 1629 ** 1630 *****************************************************************************/ 1631 1632 xcb_generic_iterator_t 1633 xcb_selinux_get_property_create_context_context_end (const xcb_selinux_get_property_create_context_reply_t *R /**< */) 1634 { 1635 xcb_generic_iterator_t i; 1636 i.data = ((char *) (R + 1)) + (R->context_len); 1637 i.rem = 0; 1638 i.index = (char *) i.data - (char *) R; 1639 return i; 1640 } 1641 1642 1643 /***************************************************************************** 1644 ** 1645 ** xcb_selinux_get_property_create_context_reply_t * xcb_selinux_get_property_create_context_reply 1646 ** 1647 ** @param xcb_connection_t *c 1648 ** @param xcb_selinux_get_property_create_context_cookie_t cookie 1649 ** @param xcb_generic_error_t **e 1650 ** @returns xcb_selinux_get_property_create_context_reply_t * 1651 ** 1652 *****************************************************************************/ 1653 1654 xcb_selinux_get_property_create_context_reply_t * 1655 xcb_selinux_get_property_create_context_reply (xcb_connection_t *c /**< */, 1656 xcb_selinux_get_property_create_context_cookie_t cookie /**< */, 1657 xcb_generic_error_t **e /**< */) 1658 { 1659 return (xcb_selinux_get_property_create_context_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 1660 } 1661 1662 int 1663 xcb_selinux_set_property_use_context_sizeof (const void *_buffer /**< */) 1664 { 1665 char *xcb_tmp = (char *)_buffer; 1666 const xcb_selinux_set_property_use_context_request_t *_aux = (xcb_selinux_set_property_use_context_request_t *)_buffer; 1667 unsigned int xcb_buffer_len = 0; 1668 unsigned int xcb_block_len = 0; 1669 unsigned int xcb_pad = 0; 1670 unsigned int xcb_align_to = 0; 1671 1672 1673 xcb_block_len += sizeof(xcb_selinux_set_property_use_context_request_t); 1674 xcb_tmp += xcb_block_len; 1675 xcb_buffer_len += xcb_block_len; 1676 xcb_block_len = 0; 1677 /* context */ 1678 xcb_block_len += _aux->context_len * sizeof(char); 1679 xcb_tmp += xcb_block_len; 1680 xcb_align_to = ALIGNOF(char); 1681 /* insert padding */ 1682 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 1683 xcb_buffer_len += xcb_block_len + xcb_pad; 1684 if (0 != xcb_pad) { 1685 xcb_tmp += xcb_pad; 1686 xcb_pad = 0; 1687 } 1688 xcb_block_len = 0; 1689 1690 return xcb_buffer_len; 1691 } 1692 1693 1694 /***************************************************************************** 1695 ** 1696 ** xcb_void_cookie_t xcb_selinux_set_property_use_context_checked 1697 ** 1698 ** @param xcb_connection_t *c 1699 ** @param uint32_t context_len 1700 ** @param const char *context 1701 ** @returns xcb_void_cookie_t 1702 ** 1703 *****************************************************************************/ 1704 1705 xcb_void_cookie_t 1706 xcb_selinux_set_property_use_context_checked (xcb_connection_t *c /**< */, 1707 uint32_t context_len /**< */, 1708 const char *context /**< */) 1709 { 1710 static const xcb_protocol_request_t xcb_req = { 1711 /* count */ 4, 1712 /* ext */ &xcb_selinux_id, 1713 /* opcode */ XCB_SELINUX_SET_PROPERTY_USE_CONTEXT, 1714 /* isvoid */ 1 1715 }; 1716 1717 struct iovec xcb_parts[6]; 1718 xcb_void_cookie_t xcb_ret; 1719 xcb_selinux_set_property_use_context_request_t xcb_out; 1720 1721 xcb_out.context_len = context_len; 1722 1723 xcb_parts[2].iov_base = (char *) &xcb_out; 1724 xcb_parts[2].iov_len = sizeof(xcb_out); 1725 xcb_parts[3].iov_base = 0; 1726 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1727 /* char context */ 1728 xcb_parts[4].iov_base = (char *) context; 1729 xcb_parts[4].iov_len = context_len * sizeof(char); 1730 xcb_parts[5].iov_base = 0; 1731 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 1732 1733 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 1734 return xcb_ret; 1735 } 1736 1737 1738 /***************************************************************************** 1739 ** 1740 ** xcb_void_cookie_t xcb_selinux_set_property_use_context 1741 ** 1742 ** @param xcb_connection_t *c 1743 ** @param uint32_t context_len 1744 ** @param const char *context 1745 ** @returns xcb_void_cookie_t 1746 ** 1747 *****************************************************************************/ 1748 1749 xcb_void_cookie_t 1750 xcb_selinux_set_property_use_context (xcb_connection_t *c /**< */, 1751 uint32_t context_len /**< */, 1752 const char *context /**< */) 1753 { 1754 static const xcb_protocol_request_t xcb_req = { 1755 /* count */ 4, 1756 /* ext */ &xcb_selinux_id, 1757 /* opcode */ XCB_SELINUX_SET_PROPERTY_USE_CONTEXT, 1758 /* isvoid */ 1 1759 }; 1760 1761 struct iovec xcb_parts[6]; 1762 xcb_void_cookie_t xcb_ret; 1763 xcb_selinux_set_property_use_context_request_t xcb_out; 1764 1765 xcb_out.context_len = context_len; 1766 1767 xcb_parts[2].iov_base = (char *) &xcb_out; 1768 xcb_parts[2].iov_len = sizeof(xcb_out); 1769 xcb_parts[3].iov_base = 0; 1770 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1771 /* char context */ 1772 xcb_parts[4].iov_base = (char *) context; 1773 xcb_parts[4].iov_len = context_len * sizeof(char); 1774 xcb_parts[5].iov_base = 0; 1775 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 1776 1777 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 1778 return xcb_ret; 1779 } 1780 1781 int 1782 xcb_selinux_get_property_use_context_sizeof (const void *_buffer /**< */) 1783 { 1784 char *xcb_tmp = (char *)_buffer; 1785 const xcb_selinux_get_property_use_context_reply_t *_aux = (xcb_selinux_get_property_use_context_reply_t *)_buffer; 1786 unsigned int xcb_buffer_len = 0; 1787 unsigned int xcb_block_len = 0; 1788 unsigned int xcb_pad = 0; 1789 unsigned int xcb_align_to = 0; 1790 1791 1792 xcb_block_len += sizeof(xcb_selinux_get_property_use_context_reply_t); 1793 xcb_tmp += xcb_block_len; 1794 xcb_buffer_len += xcb_block_len; 1795 xcb_block_len = 0; 1796 /* context */ 1797 xcb_block_len += _aux->context_len * sizeof(char); 1798 xcb_tmp += xcb_block_len; 1799 xcb_align_to = ALIGNOF(char); 1800 /* insert padding */ 1801 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 1802 xcb_buffer_len += xcb_block_len + xcb_pad; 1803 if (0 != xcb_pad) { 1804 xcb_tmp += xcb_pad; 1805 xcb_pad = 0; 1806 } 1807 xcb_block_len = 0; 1808 1809 return xcb_buffer_len; 1810 } 1811 1812 1813 /***************************************************************************** 1814 ** 1815 ** xcb_selinux_get_property_use_context_cookie_t xcb_selinux_get_property_use_context 1816 ** 1817 ** @param xcb_connection_t *c 1818 ** @returns xcb_selinux_get_property_use_context_cookie_t 1819 ** 1820 *****************************************************************************/ 1821 1822 xcb_selinux_get_property_use_context_cookie_t 1823 xcb_selinux_get_property_use_context (xcb_connection_t *c /**< */) 1824 { 1825 static const xcb_protocol_request_t xcb_req = { 1826 /* count */ 2, 1827 /* ext */ &xcb_selinux_id, 1828 /* opcode */ XCB_SELINUX_GET_PROPERTY_USE_CONTEXT, 1829 /* isvoid */ 0 1830 }; 1831 1832 struct iovec xcb_parts[4]; 1833 xcb_selinux_get_property_use_context_cookie_t xcb_ret; 1834 xcb_selinux_get_property_use_context_request_t xcb_out; 1835 1836 1837 xcb_parts[2].iov_base = (char *) &xcb_out; 1838 xcb_parts[2].iov_len = sizeof(xcb_out); 1839 xcb_parts[3].iov_base = 0; 1840 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1841 1842 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 1843 return xcb_ret; 1844 } 1845 1846 1847 /***************************************************************************** 1848 ** 1849 ** xcb_selinux_get_property_use_context_cookie_t xcb_selinux_get_property_use_context_unchecked 1850 ** 1851 ** @param xcb_connection_t *c 1852 ** @returns xcb_selinux_get_property_use_context_cookie_t 1853 ** 1854 *****************************************************************************/ 1855 1856 xcb_selinux_get_property_use_context_cookie_t 1857 xcb_selinux_get_property_use_context_unchecked (xcb_connection_t *c /**< */) 1858 { 1859 static const xcb_protocol_request_t xcb_req = { 1860 /* count */ 2, 1861 /* ext */ &xcb_selinux_id, 1862 /* opcode */ XCB_SELINUX_GET_PROPERTY_USE_CONTEXT, 1863 /* isvoid */ 0 1864 }; 1865 1866 struct iovec xcb_parts[4]; 1867 xcb_selinux_get_property_use_context_cookie_t xcb_ret; 1868 xcb_selinux_get_property_use_context_request_t xcb_out; 1869 1870 1871 xcb_parts[2].iov_base = (char *) &xcb_out; 1872 xcb_parts[2].iov_len = sizeof(xcb_out); 1873 xcb_parts[3].iov_base = 0; 1874 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1875 1876 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 1877 return xcb_ret; 1878 } 1879 1880 1881 /***************************************************************************** 1882 ** 1883 ** char * xcb_selinux_get_property_use_context_context 1884 ** 1885 ** @param const xcb_selinux_get_property_use_context_reply_t *R 1886 ** @returns char * 1887 ** 1888 *****************************************************************************/ 1889 1890 char * 1891 xcb_selinux_get_property_use_context_context (const xcb_selinux_get_property_use_context_reply_t *R /**< */) 1892 { 1893 return (char *) (R + 1); 1894 } 1895 1896 1897 /***************************************************************************** 1898 ** 1899 ** int xcb_selinux_get_property_use_context_context_length 1900 ** 1901 ** @param const xcb_selinux_get_property_use_context_reply_t *R 1902 ** @returns int 1903 ** 1904 *****************************************************************************/ 1905 1906 int 1907 xcb_selinux_get_property_use_context_context_length (const xcb_selinux_get_property_use_context_reply_t *R /**< */) 1908 { 1909 return R->context_len; 1910 } 1911 1912 1913 /***************************************************************************** 1914 ** 1915 ** xcb_generic_iterator_t xcb_selinux_get_property_use_context_context_end 1916 ** 1917 ** @param const xcb_selinux_get_property_use_context_reply_t *R 1918 ** @returns xcb_generic_iterator_t 1919 ** 1920 *****************************************************************************/ 1921 1922 xcb_generic_iterator_t 1923 xcb_selinux_get_property_use_context_context_end (const xcb_selinux_get_property_use_context_reply_t *R /**< */) 1924 { 1925 xcb_generic_iterator_t i; 1926 i.data = ((char *) (R + 1)) + (R->context_len); 1927 i.rem = 0; 1928 i.index = (char *) i.data - (char *) R; 1929 return i; 1930 } 1931 1932 1933 /***************************************************************************** 1934 ** 1935 ** xcb_selinux_get_property_use_context_reply_t * xcb_selinux_get_property_use_context_reply 1936 ** 1937 ** @param xcb_connection_t *c 1938 ** @param xcb_selinux_get_property_use_context_cookie_t cookie 1939 ** @param xcb_generic_error_t **e 1940 ** @returns xcb_selinux_get_property_use_context_reply_t * 1941 ** 1942 *****************************************************************************/ 1943 1944 xcb_selinux_get_property_use_context_reply_t * 1945 xcb_selinux_get_property_use_context_reply (xcb_connection_t *c /**< */, 1946 xcb_selinux_get_property_use_context_cookie_t cookie /**< */, 1947 xcb_generic_error_t **e /**< */) 1948 { 1949 return (xcb_selinux_get_property_use_context_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 1950 } 1951 1952 int 1953 xcb_selinux_get_property_context_sizeof (const void *_buffer /**< */) 1954 { 1955 char *xcb_tmp = (char *)_buffer; 1956 const xcb_selinux_get_property_context_reply_t *_aux = (xcb_selinux_get_property_context_reply_t *)_buffer; 1957 unsigned int xcb_buffer_len = 0; 1958 unsigned int xcb_block_len = 0; 1959 unsigned int xcb_pad = 0; 1960 unsigned int xcb_align_to = 0; 1961 1962 1963 xcb_block_len += sizeof(xcb_selinux_get_property_context_reply_t); 1964 xcb_tmp += xcb_block_len; 1965 xcb_buffer_len += xcb_block_len; 1966 xcb_block_len = 0; 1967 /* context */ 1968 xcb_block_len += _aux->context_len * sizeof(char); 1969 xcb_tmp += xcb_block_len; 1970 xcb_align_to = ALIGNOF(char); 1971 /* insert padding */ 1972 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 1973 xcb_buffer_len += xcb_block_len + xcb_pad; 1974 if (0 != xcb_pad) { 1975 xcb_tmp += xcb_pad; 1976 xcb_pad = 0; 1977 } 1978 xcb_block_len = 0; 1979 1980 return xcb_buffer_len; 1981 } 1982 1983 1984 /***************************************************************************** 1985 ** 1986 ** xcb_selinux_get_property_context_cookie_t xcb_selinux_get_property_context 1987 ** 1988 ** @param xcb_connection_t *c 1989 ** @param xcb_window_t window 1990 ** @param xcb_atom_t property 1991 ** @returns xcb_selinux_get_property_context_cookie_t 1992 ** 1993 *****************************************************************************/ 1994 1995 xcb_selinux_get_property_context_cookie_t 1996 xcb_selinux_get_property_context (xcb_connection_t *c /**< */, 1997 xcb_window_t window /**< */, 1998 xcb_atom_t property /**< */) 1999 { 2000 static const xcb_protocol_request_t xcb_req = { 2001 /* count */ 2, 2002 /* ext */ &xcb_selinux_id, 2003 /* opcode */ XCB_SELINUX_GET_PROPERTY_CONTEXT, 2004 /* isvoid */ 0 2005 }; 2006 2007 struct iovec xcb_parts[4]; 2008 xcb_selinux_get_property_context_cookie_t xcb_ret; 2009 xcb_selinux_get_property_context_request_t xcb_out; 2010 2011 xcb_out.window = window; 2012 xcb_out.property = property; 2013 2014 xcb_parts[2].iov_base = (char *) &xcb_out; 2015 xcb_parts[2].iov_len = sizeof(xcb_out); 2016 xcb_parts[3].iov_base = 0; 2017 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2018 2019 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 2020 return xcb_ret; 2021 } 2022 2023 2024 /***************************************************************************** 2025 ** 2026 ** xcb_selinux_get_property_context_cookie_t xcb_selinux_get_property_context_unchecked 2027 ** 2028 ** @param xcb_connection_t *c 2029 ** @param xcb_window_t window 2030 ** @param xcb_atom_t property 2031 ** @returns xcb_selinux_get_property_context_cookie_t 2032 ** 2033 *****************************************************************************/ 2034 2035 xcb_selinux_get_property_context_cookie_t 2036 xcb_selinux_get_property_context_unchecked (xcb_connection_t *c /**< */, 2037 xcb_window_t window /**< */, 2038 xcb_atom_t property /**< */) 2039 { 2040 static const xcb_protocol_request_t xcb_req = { 2041 /* count */ 2, 2042 /* ext */ &xcb_selinux_id, 2043 /* opcode */ XCB_SELINUX_GET_PROPERTY_CONTEXT, 2044 /* isvoid */ 0 2045 }; 2046 2047 struct iovec xcb_parts[4]; 2048 xcb_selinux_get_property_context_cookie_t xcb_ret; 2049 xcb_selinux_get_property_context_request_t xcb_out; 2050 2051 xcb_out.window = window; 2052 xcb_out.property = property; 2053 2054 xcb_parts[2].iov_base = (char *) &xcb_out; 2055 xcb_parts[2].iov_len = sizeof(xcb_out); 2056 xcb_parts[3].iov_base = 0; 2057 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2058 2059 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 2060 return xcb_ret; 2061 } 2062 2063 2064 /***************************************************************************** 2065 ** 2066 ** char * xcb_selinux_get_property_context_context 2067 ** 2068 ** @param const xcb_selinux_get_property_context_reply_t *R 2069 ** @returns char * 2070 ** 2071 *****************************************************************************/ 2072 2073 char * 2074 xcb_selinux_get_property_context_context (const xcb_selinux_get_property_context_reply_t *R /**< */) 2075 { 2076 return (char *) (R + 1); 2077 } 2078 2079 2080 /***************************************************************************** 2081 ** 2082 ** int xcb_selinux_get_property_context_context_length 2083 ** 2084 ** @param const xcb_selinux_get_property_context_reply_t *R 2085 ** @returns int 2086 ** 2087 *****************************************************************************/ 2088 2089 int 2090 xcb_selinux_get_property_context_context_length (const xcb_selinux_get_property_context_reply_t *R /**< */) 2091 { 2092 return R->context_len; 2093 } 2094 2095 2096 /***************************************************************************** 2097 ** 2098 ** xcb_generic_iterator_t xcb_selinux_get_property_context_context_end 2099 ** 2100 ** @param const xcb_selinux_get_property_context_reply_t *R 2101 ** @returns xcb_generic_iterator_t 2102 ** 2103 *****************************************************************************/ 2104 2105 xcb_generic_iterator_t 2106 xcb_selinux_get_property_context_context_end (const xcb_selinux_get_property_context_reply_t *R /**< */) 2107 { 2108 xcb_generic_iterator_t i; 2109 i.data = ((char *) (R + 1)) + (R->context_len); 2110 i.rem = 0; 2111 i.index = (char *) i.data - (char *) R; 2112 return i; 2113 } 2114 2115 2116 /***************************************************************************** 2117 ** 2118 ** xcb_selinux_get_property_context_reply_t * xcb_selinux_get_property_context_reply 2119 ** 2120 ** @param xcb_connection_t *c 2121 ** @param xcb_selinux_get_property_context_cookie_t cookie 2122 ** @param xcb_generic_error_t **e 2123 ** @returns xcb_selinux_get_property_context_reply_t * 2124 ** 2125 *****************************************************************************/ 2126 2127 xcb_selinux_get_property_context_reply_t * 2128 xcb_selinux_get_property_context_reply (xcb_connection_t *c /**< */, 2129 xcb_selinux_get_property_context_cookie_t cookie /**< */, 2130 xcb_generic_error_t **e /**< */) 2131 { 2132 return (xcb_selinux_get_property_context_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 2133 } 2134 2135 int 2136 xcb_selinux_get_property_data_context_sizeof (const void *_buffer /**< */) 2137 { 2138 char *xcb_tmp = (char *)_buffer; 2139 const xcb_selinux_get_property_data_context_reply_t *_aux = (xcb_selinux_get_property_data_context_reply_t *)_buffer; 2140 unsigned int xcb_buffer_len = 0; 2141 unsigned int xcb_block_len = 0; 2142 unsigned int xcb_pad = 0; 2143 unsigned int xcb_align_to = 0; 2144 2145 2146 xcb_block_len += sizeof(xcb_selinux_get_property_data_context_reply_t); 2147 xcb_tmp += xcb_block_len; 2148 xcb_buffer_len += xcb_block_len; 2149 xcb_block_len = 0; 2150 /* context */ 2151 xcb_block_len += _aux->context_len * sizeof(char); 2152 xcb_tmp += xcb_block_len; 2153 xcb_align_to = ALIGNOF(char); 2154 /* insert padding */ 2155 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 2156 xcb_buffer_len += xcb_block_len + xcb_pad; 2157 if (0 != xcb_pad) { 2158 xcb_tmp += xcb_pad; 2159 xcb_pad = 0; 2160 } 2161 xcb_block_len = 0; 2162 2163 return xcb_buffer_len; 2164 } 2165 2166 2167 /***************************************************************************** 2168 ** 2169 ** xcb_selinux_get_property_data_context_cookie_t xcb_selinux_get_property_data_context 2170 ** 2171 ** @param xcb_connection_t *c 2172 ** @param xcb_window_t window 2173 ** @param xcb_atom_t property 2174 ** @returns xcb_selinux_get_property_data_context_cookie_t 2175 ** 2176 *****************************************************************************/ 2177 2178 xcb_selinux_get_property_data_context_cookie_t 2179 xcb_selinux_get_property_data_context (xcb_connection_t *c /**< */, 2180 xcb_window_t window /**< */, 2181 xcb_atom_t property /**< */) 2182 { 2183 static const xcb_protocol_request_t xcb_req = { 2184 /* count */ 2, 2185 /* ext */ &xcb_selinux_id, 2186 /* opcode */ XCB_SELINUX_GET_PROPERTY_DATA_CONTEXT, 2187 /* isvoid */ 0 2188 }; 2189 2190 struct iovec xcb_parts[4]; 2191 xcb_selinux_get_property_data_context_cookie_t xcb_ret; 2192 xcb_selinux_get_property_data_context_request_t xcb_out; 2193 2194 xcb_out.window = window; 2195 xcb_out.property = property; 2196 2197 xcb_parts[2].iov_base = (char *) &xcb_out; 2198 xcb_parts[2].iov_len = sizeof(xcb_out); 2199 xcb_parts[3].iov_base = 0; 2200 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2201 2202 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 2203 return xcb_ret; 2204 } 2205 2206 2207 /***************************************************************************** 2208 ** 2209 ** xcb_selinux_get_property_data_context_cookie_t xcb_selinux_get_property_data_context_unchecked 2210 ** 2211 ** @param xcb_connection_t *c 2212 ** @param xcb_window_t window 2213 ** @param xcb_atom_t property 2214 ** @returns xcb_selinux_get_property_data_context_cookie_t 2215 ** 2216 *****************************************************************************/ 2217 2218 xcb_selinux_get_property_data_context_cookie_t 2219 xcb_selinux_get_property_data_context_unchecked (xcb_connection_t *c /**< */, 2220 xcb_window_t window /**< */, 2221 xcb_atom_t property /**< */) 2222 { 2223 static const xcb_protocol_request_t xcb_req = { 2224 /* count */ 2, 2225 /* ext */ &xcb_selinux_id, 2226 /* opcode */ XCB_SELINUX_GET_PROPERTY_DATA_CONTEXT, 2227 /* isvoid */ 0 2228 }; 2229 2230 struct iovec xcb_parts[4]; 2231 xcb_selinux_get_property_data_context_cookie_t xcb_ret; 2232 xcb_selinux_get_property_data_context_request_t xcb_out; 2233 2234 xcb_out.window = window; 2235 xcb_out.property = property; 2236 2237 xcb_parts[2].iov_base = (char *) &xcb_out; 2238 xcb_parts[2].iov_len = sizeof(xcb_out); 2239 xcb_parts[3].iov_base = 0; 2240 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2241 2242 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 2243 return xcb_ret; 2244 } 2245 2246 2247 /***************************************************************************** 2248 ** 2249 ** char * xcb_selinux_get_property_data_context_context 2250 ** 2251 ** @param const xcb_selinux_get_property_data_context_reply_t *R 2252 ** @returns char * 2253 ** 2254 *****************************************************************************/ 2255 2256 char * 2257 xcb_selinux_get_property_data_context_context (const xcb_selinux_get_property_data_context_reply_t *R /**< */) 2258 { 2259 return (char *) (R + 1); 2260 } 2261 2262 2263 /***************************************************************************** 2264 ** 2265 ** int xcb_selinux_get_property_data_context_context_length 2266 ** 2267 ** @param const xcb_selinux_get_property_data_context_reply_t *R 2268 ** @returns int 2269 ** 2270 *****************************************************************************/ 2271 2272 int 2273 xcb_selinux_get_property_data_context_context_length (const xcb_selinux_get_property_data_context_reply_t *R /**< */) 2274 { 2275 return R->context_len; 2276 } 2277 2278 2279 /***************************************************************************** 2280 ** 2281 ** xcb_generic_iterator_t xcb_selinux_get_property_data_context_context_end 2282 ** 2283 ** @param const xcb_selinux_get_property_data_context_reply_t *R 2284 ** @returns xcb_generic_iterator_t 2285 ** 2286 *****************************************************************************/ 2287 2288 xcb_generic_iterator_t 2289 xcb_selinux_get_property_data_context_context_end (const xcb_selinux_get_property_data_context_reply_t *R /**< */) 2290 { 2291 xcb_generic_iterator_t i; 2292 i.data = ((char *) (R + 1)) + (R->context_len); 2293 i.rem = 0; 2294 i.index = (char *) i.data - (char *) R; 2295 return i; 2296 } 2297 2298 2299 /***************************************************************************** 2300 ** 2301 ** xcb_selinux_get_property_data_context_reply_t * xcb_selinux_get_property_data_context_reply 2302 ** 2303 ** @param xcb_connection_t *c 2304 ** @param xcb_selinux_get_property_data_context_cookie_t cookie 2305 ** @param xcb_generic_error_t **e 2306 ** @returns xcb_selinux_get_property_data_context_reply_t * 2307 ** 2308 *****************************************************************************/ 2309 2310 xcb_selinux_get_property_data_context_reply_t * 2311 xcb_selinux_get_property_data_context_reply (xcb_connection_t *c /**< */, 2312 xcb_selinux_get_property_data_context_cookie_t cookie /**< */, 2313 xcb_generic_error_t **e /**< */) 2314 { 2315 return (xcb_selinux_get_property_data_context_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 2316 } 2317 2318 int 2319 xcb_selinux_list_properties_sizeof (const void *_buffer /**< */) 2320 { 2321 char *xcb_tmp = (char *)_buffer; 2322 const xcb_selinux_list_properties_reply_t *_aux = (xcb_selinux_list_properties_reply_t *)_buffer; 2323 unsigned int xcb_buffer_len = 0; 2324 unsigned int xcb_block_len = 0; 2325 unsigned int xcb_pad = 0; 2326 unsigned int xcb_align_to = 0; 2327 2328 unsigned int i; 2329 unsigned int xcb_tmp_len; 2330 2331 xcb_block_len += sizeof(xcb_selinux_list_properties_reply_t); 2332 xcb_tmp += xcb_block_len; 2333 xcb_buffer_len += xcb_block_len; 2334 xcb_block_len = 0; 2335 /* properties */ 2336 for(i=0; i<_aux->properties_len; i++) { 2337 xcb_tmp_len = xcb_selinux_list_item_sizeof(xcb_tmp); 2338 xcb_block_len += xcb_tmp_len; 2339 xcb_tmp += xcb_tmp_len; 2340 } 2341 xcb_align_to = ALIGNOF(xcb_selinux_list_item_t); 2342 /* insert padding */ 2343 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 2344 xcb_buffer_len += xcb_block_len + xcb_pad; 2345 if (0 != xcb_pad) { 2346 xcb_tmp += xcb_pad; 2347 xcb_pad = 0; 2348 } 2349 xcb_block_len = 0; 2350 2351 return xcb_buffer_len; 2352 } 2353 2354 2355 /***************************************************************************** 2356 ** 2357 ** xcb_selinux_list_properties_cookie_t xcb_selinux_list_properties 2358 ** 2359 ** @param xcb_connection_t *c 2360 ** @param xcb_window_t window 2361 ** @returns xcb_selinux_list_properties_cookie_t 2362 ** 2363 *****************************************************************************/ 2364 2365 xcb_selinux_list_properties_cookie_t 2366 xcb_selinux_list_properties (xcb_connection_t *c /**< */, 2367 xcb_window_t window /**< */) 2368 { 2369 static const xcb_protocol_request_t xcb_req = { 2370 /* count */ 2, 2371 /* ext */ &xcb_selinux_id, 2372 /* opcode */ XCB_SELINUX_LIST_PROPERTIES, 2373 /* isvoid */ 0 2374 }; 2375 2376 struct iovec xcb_parts[4]; 2377 xcb_selinux_list_properties_cookie_t xcb_ret; 2378 xcb_selinux_list_properties_request_t xcb_out; 2379 2380 xcb_out.window = window; 2381 2382 xcb_parts[2].iov_base = (char *) &xcb_out; 2383 xcb_parts[2].iov_len = sizeof(xcb_out); 2384 xcb_parts[3].iov_base = 0; 2385 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2386 2387 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 2388 return xcb_ret; 2389 } 2390 2391 2392 /***************************************************************************** 2393 ** 2394 ** xcb_selinux_list_properties_cookie_t xcb_selinux_list_properties_unchecked 2395 ** 2396 ** @param xcb_connection_t *c 2397 ** @param xcb_window_t window 2398 ** @returns xcb_selinux_list_properties_cookie_t 2399 ** 2400 *****************************************************************************/ 2401 2402 xcb_selinux_list_properties_cookie_t 2403 xcb_selinux_list_properties_unchecked (xcb_connection_t *c /**< */, 2404 xcb_window_t window /**< */) 2405 { 2406 static const xcb_protocol_request_t xcb_req = { 2407 /* count */ 2, 2408 /* ext */ &xcb_selinux_id, 2409 /* opcode */ XCB_SELINUX_LIST_PROPERTIES, 2410 /* isvoid */ 0 2411 }; 2412 2413 struct iovec xcb_parts[4]; 2414 xcb_selinux_list_properties_cookie_t xcb_ret; 2415 xcb_selinux_list_properties_request_t xcb_out; 2416 2417 xcb_out.window = window; 2418 2419 xcb_parts[2].iov_base = (char *) &xcb_out; 2420 xcb_parts[2].iov_len = sizeof(xcb_out); 2421 xcb_parts[3].iov_base = 0; 2422 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2423 2424 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 2425 return xcb_ret; 2426 } 2427 2428 2429 /***************************************************************************** 2430 ** 2431 ** int xcb_selinux_list_properties_properties_length 2432 ** 2433 ** @param const xcb_selinux_list_properties_reply_t *R 2434 ** @returns int 2435 ** 2436 *****************************************************************************/ 2437 2438 int 2439 xcb_selinux_list_properties_properties_length (const xcb_selinux_list_properties_reply_t *R /**< */) 2440 { 2441 return R->properties_len; 2442 } 2443 2444 2445 /***************************************************************************** 2446 ** 2447 ** xcb_selinux_list_item_iterator_t xcb_selinux_list_properties_properties_iterator 2448 ** 2449 ** @param const xcb_selinux_list_properties_reply_t *R 2450 ** @returns xcb_selinux_list_item_iterator_t 2451 ** 2452 *****************************************************************************/ 2453 2454 xcb_selinux_list_item_iterator_t 2455 xcb_selinux_list_properties_properties_iterator (const xcb_selinux_list_properties_reply_t *R /**< */) 2456 { 2457 xcb_selinux_list_item_iterator_t i; 2458 i.data = (xcb_selinux_list_item_t *) (R + 1); 2459 i.rem = R->properties_len; 2460 i.index = (char *) i.data - (char *) R; 2461 return i; 2462 } 2463 2464 2465 /***************************************************************************** 2466 ** 2467 ** xcb_selinux_list_properties_reply_t * xcb_selinux_list_properties_reply 2468 ** 2469 ** @param xcb_connection_t *c 2470 ** @param xcb_selinux_list_properties_cookie_t cookie 2471 ** @param xcb_generic_error_t **e 2472 ** @returns xcb_selinux_list_properties_reply_t * 2473 ** 2474 *****************************************************************************/ 2475 2476 xcb_selinux_list_properties_reply_t * 2477 xcb_selinux_list_properties_reply (xcb_connection_t *c /**< */, 2478 xcb_selinux_list_properties_cookie_t cookie /**< */, 2479 xcb_generic_error_t **e /**< */) 2480 { 2481 return (xcb_selinux_list_properties_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 2482 } 2483 2484 int 2485 xcb_selinux_set_selection_create_context_sizeof (const void *_buffer /**< */) 2486 { 2487 char *xcb_tmp = (char *)_buffer; 2488 const xcb_selinux_set_selection_create_context_request_t *_aux = (xcb_selinux_set_selection_create_context_request_t *)_buffer; 2489 unsigned int xcb_buffer_len = 0; 2490 unsigned int xcb_block_len = 0; 2491 unsigned int xcb_pad = 0; 2492 unsigned int xcb_align_to = 0; 2493 2494 2495 xcb_block_len += sizeof(xcb_selinux_set_selection_create_context_request_t); 2496 xcb_tmp += xcb_block_len; 2497 xcb_buffer_len += xcb_block_len; 2498 xcb_block_len = 0; 2499 /* context */ 2500 xcb_block_len += _aux->context_len * sizeof(char); 2501 xcb_tmp += xcb_block_len; 2502 xcb_align_to = ALIGNOF(char); 2503 /* insert padding */ 2504 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 2505 xcb_buffer_len += xcb_block_len + xcb_pad; 2506 if (0 != xcb_pad) { 2507 xcb_tmp += xcb_pad; 2508 xcb_pad = 0; 2509 } 2510 xcb_block_len = 0; 2511 2512 return xcb_buffer_len; 2513 } 2514 2515 2516 /***************************************************************************** 2517 ** 2518 ** xcb_void_cookie_t xcb_selinux_set_selection_create_context_checked 2519 ** 2520 ** @param xcb_connection_t *c 2521 ** @param uint32_t context_len 2522 ** @param const char *context 2523 ** @returns xcb_void_cookie_t 2524 ** 2525 *****************************************************************************/ 2526 2527 xcb_void_cookie_t 2528 xcb_selinux_set_selection_create_context_checked (xcb_connection_t *c /**< */, 2529 uint32_t context_len /**< */, 2530 const char *context /**< */) 2531 { 2532 static const xcb_protocol_request_t xcb_req = { 2533 /* count */ 4, 2534 /* ext */ &xcb_selinux_id, 2535 /* opcode */ XCB_SELINUX_SET_SELECTION_CREATE_CONTEXT, 2536 /* isvoid */ 1 2537 }; 2538 2539 struct iovec xcb_parts[6]; 2540 xcb_void_cookie_t xcb_ret; 2541 xcb_selinux_set_selection_create_context_request_t xcb_out; 2542 2543 xcb_out.context_len = context_len; 2544 2545 xcb_parts[2].iov_base = (char *) &xcb_out; 2546 xcb_parts[2].iov_len = sizeof(xcb_out); 2547 xcb_parts[3].iov_base = 0; 2548 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2549 /* char context */ 2550 xcb_parts[4].iov_base = (char *) context; 2551 xcb_parts[4].iov_len = context_len * sizeof(char); 2552 xcb_parts[5].iov_base = 0; 2553 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 2554 2555 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 2556 return xcb_ret; 2557 } 2558 2559 2560 /***************************************************************************** 2561 ** 2562 ** xcb_void_cookie_t xcb_selinux_set_selection_create_context 2563 ** 2564 ** @param xcb_connection_t *c 2565 ** @param uint32_t context_len 2566 ** @param const char *context 2567 ** @returns xcb_void_cookie_t 2568 ** 2569 *****************************************************************************/ 2570 2571 xcb_void_cookie_t 2572 xcb_selinux_set_selection_create_context (xcb_connection_t *c /**< */, 2573 uint32_t context_len /**< */, 2574 const char *context /**< */) 2575 { 2576 static const xcb_protocol_request_t xcb_req = { 2577 /* count */ 4, 2578 /* ext */ &xcb_selinux_id, 2579 /* opcode */ XCB_SELINUX_SET_SELECTION_CREATE_CONTEXT, 2580 /* isvoid */ 1 2581 }; 2582 2583 struct iovec xcb_parts[6]; 2584 xcb_void_cookie_t xcb_ret; 2585 xcb_selinux_set_selection_create_context_request_t xcb_out; 2586 2587 xcb_out.context_len = context_len; 2588 2589 xcb_parts[2].iov_base = (char *) &xcb_out; 2590 xcb_parts[2].iov_len = sizeof(xcb_out); 2591 xcb_parts[3].iov_base = 0; 2592 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2593 /* char context */ 2594 xcb_parts[4].iov_base = (char *) context; 2595 xcb_parts[4].iov_len = context_len * sizeof(char); 2596 xcb_parts[5].iov_base = 0; 2597 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 2598 2599 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 2600 return xcb_ret; 2601 } 2602 2603 int 2604 xcb_selinux_get_selection_create_context_sizeof (const void *_buffer /**< */) 2605 { 2606 char *xcb_tmp = (char *)_buffer; 2607 const xcb_selinux_get_selection_create_context_reply_t *_aux = (xcb_selinux_get_selection_create_context_reply_t *)_buffer; 2608 unsigned int xcb_buffer_len = 0; 2609 unsigned int xcb_block_len = 0; 2610 unsigned int xcb_pad = 0; 2611 unsigned int xcb_align_to = 0; 2612 2613 2614 xcb_block_len += sizeof(xcb_selinux_get_selection_create_context_reply_t); 2615 xcb_tmp += xcb_block_len; 2616 xcb_buffer_len += xcb_block_len; 2617 xcb_block_len = 0; 2618 /* context */ 2619 xcb_block_len += _aux->context_len * sizeof(char); 2620 xcb_tmp += xcb_block_len; 2621 xcb_align_to = ALIGNOF(char); 2622 /* insert padding */ 2623 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 2624 xcb_buffer_len += xcb_block_len + xcb_pad; 2625 if (0 != xcb_pad) { 2626 xcb_tmp += xcb_pad; 2627 xcb_pad = 0; 2628 } 2629 xcb_block_len = 0; 2630 2631 return xcb_buffer_len; 2632 } 2633 2634 2635 /***************************************************************************** 2636 ** 2637 ** xcb_selinux_get_selection_create_context_cookie_t xcb_selinux_get_selection_create_context 2638 ** 2639 ** @param xcb_connection_t *c 2640 ** @returns xcb_selinux_get_selection_create_context_cookie_t 2641 ** 2642 *****************************************************************************/ 2643 2644 xcb_selinux_get_selection_create_context_cookie_t 2645 xcb_selinux_get_selection_create_context (xcb_connection_t *c /**< */) 2646 { 2647 static const xcb_protocol_request_t xcb_req = { 2648 /* count */ 2, 2649 /* ext */ &xcb_selinux_id, 2650 /* opcode */ XCB_SELINUX_GET_SELECTION_CREATE_CONTEXT, 2651 /* isvoid */ 0 2652 }; 2653 2654 struct iovec xcb_parts[4]; 2655 xcb_selinux_get_selection_create_context_cookie_t xcb_ret; 2656 xcb_selinux_get_selection_create_context_request_t xcb_out; 2657 2658 2659 xcb_parts[2].iov_base = (char *) &xcb_out; 2660 xcb_parts[2].iov_len = sizeof(xcb_out); 2661 xcb_parts[3].iov_base = 0; 2662 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2663 2664 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 2665 return xcb_ret; 2666 } 2667 2668 2669 /***************************************************************************** 2670 ** 2671 ** xcb_selinux_get_selection_create_context_cookie_t xcb_selinux_get_selection_create_context_unchecked 2672 ** 2673 ** @param xcb_connection_t *c 2674 ** @returns xcb_selinux_get_selection_create_context_cookie_t 2675 ** 2676 *****************************************************************************/ 2677 2678 xcb_selinux_get_selection_create_context_cookie_t 2679 xcb_selinux_get_selection_create_context_unchecked (xcb_connection_t *c /**< */) 2680 { 2681 static const xcb_protocol_request_t xcb_req = { 2682 /* count */ 2, 2683 /* ext */ &xcb_selinux_id, 2684 /* opcode */ XCB_SELINUX_GET_SELECTION_CREATE_CONTEXT, 2685 /* isvoid */ 0 2686 }; 2687 2688 struct iovec xcb_parts[4]; 2689 xcb_selinux_get_selection_create_context_cookie_t xcb_ret; 2690 xcb_selinux_get_selection_create_context_request_t xcb_out; 2691 2692 2693 xcb_parts[2].iov_base = (char *) &xcb_out; 2694 xcb_parts[2].iov_len = sizeof(xcb_out); 2695 xcb_parts[3].iov_base = 0; 2696 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2697 2698 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 2699 return xcb_ret; 2700 } 2701 2702 2703 /***************************************************************************** 2704 ** 2705 ** char * xcb_selinux_get_selection_create_context_context 2706 ** 2707 ** @param const xcb_selinux_get_selection_create_context_reply_t *R 2708 ** @returns char * 2709 ** 2710 *****************************************************************************/ 2711 2712 char * 2713 xcb_selinux_get_selection_create_context_context (const xcb_selinux_get_selection_create_context_reply_t *R /**< */) 2714 { 2715 return (char *) (R + 1); 2716 } 2717 2718 2719 /***************************************************************************** 2720 ** 2721 ** int xcb_selinux_get_selection_create_context_context_length 2722 ** 2723 ** @param const xcb_selinux_get_selection_create_context_reply_t *R 2724 ** @returns int 2725 ** 2726 *****************************************************************************/ 2727 2728 int 2729 xcb_selinux_get_selection_create_context_context_length (const xcb_selinux_get_selection_create_context_reply_t *R /**< */) 2730 { 2731 return R->context_len; 2732 } 2733 2734 2735 /***************************************************************************** 2736 ** 2737 ** xcb_generic_iterator_t xcb_selinux_get_selection_create_context_context_end 2738 ** 2739 ** @param const xcb_selinux_get_selection_create_context_reply_t *R 2740 ** @returns xcb_generic_iterator_t 2741 ** 2742 *****************************************************************************/ 2743 2744 xcb_generic_iterator_t 2745 xcb_selinux_get_selection_create_context_context_end (const xcb_selinux_get_selection_create_context_reply_t *R /**< */) 2746 { 2747 xcb_generic_iterator_t i; 2748 i.data = ((char *) (R + 1)) + (R->context_len); 2749 i.rem = 0; 2750 i.index = (char *) i.data - (char *) R; 2751 return i; 2752 } 2753 2754 2755 /***************************************************************************** 2756 ** 2757 ** xcb_selinux_get_selection_create_context_reply_t * xcb_selinux_get_selection_create_context_reply 2758 ** 2759 ** @param xcb_connection_t *c 2760 ** @param xcb_selinux_get_selection_create_context_cookie_t cookie 2761 ** @param xcb_generic_error_t **e 2762 ** @returns xcb_selinux_get_selection_create_context_reply_t * 2763 ** 2764 *****************************************************************************/ 2765 2766 xcb_selinux_get_selection_create_context_reply_t * 2767 xcb_selinux_get_selection_create_context_reply (xcb_connection_t *c /**< */, 2768 xcb_selinux_get_selection_create_context_cookie_t cookie /**< */, 2769 xcb_generic_error_t **e /**< */) 2770 { 2771 return (xcb_selinux_get_selection_create_context_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 2772 } 2773 2774 int 2775 xcb_selinux_set_selection_use_context_sizeof (const void *_buffer /**< */) 2776 { 2777 char *xcb_tmp = (char *)_buffer; 2778 const xcb_selinux_set_selection_use_context_request_t *_aux = (xcb_selinux_set_selection_use_context_request_t *)_buffer; 2779 unsigned int xcb_buffer_len = 0; 2780 unsigned int xcb_block_len = 0; 2781 unsigned int xcb_pad = 0; 2782 unsigned int xcb_align_to = 0; 2783 2784 2785 xcb_block_len += sizeof(xcb_selinux_set_selection_use_context_request_t); 2786 xcb_tmp += xcb_block_len; 2787 xcb_buffer_len += xcb_block_len; 2788 xcb_block_len = 0; 2789 /* context */ 2790 xcb_block_len += _aux->context_len * sizeof(char); 2791 xcb_tmp += xcb_block_len; 2792 xcb_align_to = ALIGNOF(char); 2793 /* insert padding */ 2794 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 2795 xcb_buffer_len += xcb_block_len + xcb_pad; 2796 if (0 != xcb_pad) { 2797 xcb_tmp += xcb_pad; 2798 xcb_pad = 0; 2799 } 2800 xcb_block_len = 0; 2801 2802 return xcb_buffer_len; 2803 } 2804 2805 2806 /***************************************************************************** 2807 ** 2808 ** xcb_void_cookie_t xcb_selinux_set_selection_use_context_checked 2809 ** 2810 ** @param xcb_connection_t *c 2811 ** @param uint32_t context_len 2812 ** @param const char *context 2813 ** @returns xcb_void_cookie_t 2814 ** 2815 *****************************************************************************/ 2816 2817 xcb_void_cookie_t 2818 xcb_selinux_set_selection_use_context_checked (xcb_connection_t *c /**< */, 2819 uint32_t context_len /**< */, 2820 const char *context /**< */) 2821 { 2822 static const xcb_protocol_request_t xcb_req = { 2823 /* count */ 4, 2824 /* ext */ &xcb_selinux_id, 2825 /* opcode */ XCB_SELINUX_SET_SELECTION_USE_CONTEXT, 2826 /* isvoid */ 1 2827 }; 2828 2829 struct iovec xcb_parts[6]; 2830 xcb_void_cookie_t xcb_ret; 2831 xcb_selinux_set_selection_use_context_request_t xcb_out; 2832 2833 xcb_out.context_len = context_len; 2834 2835 xcb_parts[2].iov_base = (char *) &xcb_out; 2836 xcb_parts[2].iov_len = sizeof(xcb_out); 2837 xcb_parts[3].iov_base = 0; 2838 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2839 /* char context */ 2840 xcb_parts[4].iov_base = (char *) context; 2841 xcb_parts[4].iov_len = context_len * sizeof(char); 2842 xcb_parts[5].iov_base = 0; 2843 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 2844 2845 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 2846 return xcb_ret; 2847 } 2848 2849 2850 /***************************************************************************** 2851 ** 2852 ** xcb_void_cookie_t xcb_selinux_set_selection_use_context 2853 ** 2854 ** @param xcb_connection_t *c 2855 ** @param uint32_t context_len 2856 ** @param const char *context 2857 ** @returns xcb_void_cookie_t 2858 ** 2859 *****************************************************************************/ 2860 2861 xcb_void_cookie_t 2862 xcb_selinux_set_selection_use_context (xcb_connection_t *c /**< */, 2863 uint32_t context_len /**< */, 2864 const char *context /**< */) 2865 { 2866 static const xcb_protocol_request_t xcb_req = { 2867 /* count */ 4, 2868 /* ext */ &xcb_selinux_id, 2869 /* opcode */ XCB_SELINUX_SET_SELECTION_USE_CONTEXT, 2870 /* isvoid */ 1 2871 }; 2872 2873 struct iovec xcb_parts[6]; 2874 xcb_void_cookie_t xcb_ret; 2875 xcb_selinux_set_selection_use_context_request_t xcb_out; 2876 2877 xcb_out.context_len = context_len; 2878 2879 xcb_parts[2].iov_base = (char *) &xcb_out; 2880 xcb_parts[2].iov_len = sizeof(xcb_out); 2881 xcb_parts[3].iov_base = 0; 2882 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2883 /* char context */ 2884 xcb_parts[4].iov_base = (char *) context; 2885 xcb_parts[4].iov_len = context_len * sizeof(char); 2886 xcb_parts[5].iov_base = 0; 2887 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 2888 2889 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 2890 return xcb_ret; 2891 } 2892 2893 int 2894 xcb_selinux_get_selection_use_context_sizeof (const void *_buffer /**< */) 2895 { 2896 char *xcb_tmp = (char *)_buffer; 2897 const xcb_selinux_get_selection_use_context_reply_t *_aux = (xcb_selinux_get_selection_use_context_reply_t *)_buffer; 2898 unsigned int xcb_buffer_len = 0; 2899 unsigned int xcb_block_len = 0; 2900 unsigned int xcb_pad = 0; 2901 unsigned int xcb_align_to = 0; 2902 2903 2904 xcb_block_len += sizeof(xcb_selinux_get_selection_use_context_reply_t); 2905 xcb_tmp += xcb_block_len; 2906 xcb_buffer_len += xcb_block_len; 2907 xcb_block_len = 0; 2908 /* context */ 2909 xcb_block_len += _aux->context_len * sizeof(char); 2910 xcb_tmp += xcb_block_len; 2911 xcb_align_to = ALIGNOF(char); 2912 /* insert padding */ 2913 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 2914 xcb_buffer_len += xcb_block_len + xcb_pad; 2915 if (0 != xcb_pad) { 2916 xcb_tmp += xcb_pad; 2917 xcb_pad = 0; 2918 } 2919 xcb_block_len = 0; 2920 2921 return xcb_buffer_len; 2922 } 2923 2924 2925 /***************************************************************************** 2926 ** 2927 ** xcb_selinux_get_selection_use_context_cookie_t xcb_selinux_get_selection_use_context 2928 ** 2929 ** @param xcb_connection_t *c 2930 ** @returns xcb_selinux_get_selection_use_context_cookie_t 2931 ** 2932 *****************************************************************************/ 2933 2934 xcb_selinux_get_selection_use_context_cookie_t 2935 xcb_selinux_get_selection_use_context (xcb_connection_t *c /**< */) 2936 { 2937 static const xcb_protocol_request_t xcb_req = { 2938 /* count */ 2, 2939 /* ext */ &xcb_selinux_id, 2940 /* opcode */ XCB_SELINUX_GET_SELECTION_USE_CONTEXT, 2941 /* isvoid */ 0 2942 }; 2943 2944 struct iovec xcb_parts[4]; 2945 xcb_selinux_get_selection_use_context_cookie_t xcb_ret; 2946 xcb_selinux_get_selection_use_context_request_t xcb_out; 2947 2948 2949 xcb_parts[2].iov_base = (char *) &xcb_out; 2950 xcb_parts[2].iov_len = sizeof(xcb_out); 2951 xcb_parts[3].iov_base = 0; 2952 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2953 2954 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 2955 return xcb_ret; 2956 } 2957 2958 2959 /***************************************************************************** 2960 ** 2961 ** xcb_selinux_get_selection_use_context_cookie_t xcb_selinux_get_selection_use_context_unchecked 2962 ** 2963 ** @param xcb_connection_t *c 2964 ** @returns xcb_selinux_get_selection_use_context_cookie_t 2965 ** 2966 *****************************************************************************/ 2967 2968 xcb_selinux_get_selection_use_context_cookie_t 2969 xcb_selinux_get_selection_use_context_unchecked (xcb_connection_t *c /**< */) 2970 { 2971 static const xcb_protocol_request_t xcb_req = { 2972 /* count */ 2, 2973 /* ext */ &xcb_selinux_id, 2974 /* opcode */ XCB_SELINUX_GET_SELECTION_USE_CONTEXT, 2975 /* isvoid */ 0 2976 }; 2977 2978 struct iovec xcb_parts[4]; 2979 xcb_selinux_get_selection_use_context_cookie_t xcb_ret; 2980 xcb_selinux_get_selection_use_context_request_t xcb_out; 2981 2982 2983 xcb_parts[2].iov_base = (char *) &xcb_out; 2984 xcb_parts[2].iov_len = sizeof(xcb_out); 2985 xcb_parts[3].iov_base = 0; 2986 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2987 2988 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 2989 return xcb_ret; 2990 } 2991 2992 2993 /***************************************************************************** 2994 ** 2995 ** char * xcb_selinux_get_selection_use_context_context 2996 ** 2997 ** @param const xcb_selinux_get_selection_use_context_reply_t *R 2998 ** @returns char * 2999 ** 3000 *****************************************************************************/ 3001 3002 char * 3003 xcb_selinux_get_selection_use_context_context (const xcb_selinux_get_selection_use_context_reply_t *R /**< */) 3004 { 3005 return (char *) (R + 1); 3006 } 3007 3008 3009 /***************************************************************************** 3010 ** 3011 ** int xcb_selinux_get_selection_use_context_context_length 3012 ** 3013 ** @param const xcb_selinux_get_selection_use_context_reply_t *R 3014 ** @returns int 3015 ** 3016 *****************************************************************************/ 3017 3018 int 3019 xcb_selinux_get_selection_use_context_context_length (const xcb_selinux_get_selection_use_context_reply_t *R /**< */) 3020 { 3021 return R->context_len; 3022 } 3023 3024 3025 /***************************************************************************** 3026 ** 3027 ** xcb_generic_iterator_t xcb_selinux_get_selection_use_context_context_end 3028 ** 3029 ** @param const xcb_selinux_get_selection_use_context_reply_t *R 3030 ** @returns xcb_generic_iterator_t 3031 ** 3032 *****************************************************************************/ 3033 3034 xcb_generic_iterator_t 3035 xcb_selinux_get_selection_use_context_context_end (const xcb_selinux_get_selection_use_context_reply_t *R /**< */) 3036 { 3037 xcb_generic_iterator_t i; 3038 i.data = ((char *) (R + 1)) + (R->context_len); 3039 i.rem = 0; 3040 i.index = (char *) i.data - (char *) R; 3041 return i; 3042 } 3043 3044 3045 /***************************************************************************** 3046 ** 3047 ** xcb_selinux_get_selection_use_context_reply_t * xcb_selinux_get_selection_use_context_reply 3048 ** 3049 ** @param xcb_connection_t *c 3050 ** @param xcb_selinux_get_selection_use_context_cookie_t cookie 3051 ** @param xcb_generic_error_t **e 3052 ** @returns xcb_selinux_get_selection_use_context_reply_t * 3053 ** 3054 *****************************************************************************/ 3055 3056 xcb_selinux_get_selection_use_context_reply_t * 3057 xcb_selinux_get_selection_use_context_reply (xcb_connection_t *c /**< */, 3058 xcb_selinux_get_selection_use_context_cookie_t cookie /**< */, 3059 xcb_generic_error_t **e /**< */) 3060 { 3061 return (xcb_selinux_get_selection_use_context_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 3062 } 3063 3064 int 3065 xcb_selinux_get_selection_context_sizeof (const void *_buffer /**< */) 3066 { 3067 char *xcb_tmp = (char *)_buffer; 3068 const xcb_selinux_get_selection_context_reply_t *_aux = (xcb_selinux_get_selection_context_reply_t *)_buffer; 3069 unsigned int xcb_buffer_len = 0; 3070 unsigned int xcb_block_len = 0; 3071 unsigned int xcb_pad = 0; 3072 unsigned int xcb_align_to = 0; 3073 3074 3075 xcb_block_len += sizeof(xcb_selinux_get_selection_context_reply_t); 3076 xcb_tmp += xcb_block_len; 3077 xcb_buffer_len += xcb_block_len; 3078 xcb_block_len = 0; 3079 /* context */ 3080 xcb_block_len += _aux->context_len * sizeof(char); 3081 xcb_tmp += xcb_block_len; 3082 xcb_align_to = ALIGNOF(char); 3083 /* insert padding */ 3084 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 3085 xcb_buffer_len += xcb_block_len + xcb_pad; 3086 if (0 != xcb_pad) { 3087 xcb_tmp += xcb_pad; 3088 xcb_pad = 0; 3089 } 3090 xcb_block_len = 0; 3091 3092 return xcb_buffer_len; 3093 } 3094 3095 3096 /***************************************************************************** 3097 ** 3098 ** xcb_selinux_get_selection_context_cookie_t xcb_selinux_get_selection_context 3099 ** 3100 ** @param xcb_connection_t *c 3101 ** @param xcb_atom_t selection 3102 ** @returns xcb_selinux_get_selection_context_cookie_t 3103 ** 3104 *****************************************************************************/ 3105 3106 xcb_selinux_get_selection_context_cookie_t 3107 xcb_selinux_get_selection_context (xcb_connection_t *c /**< */, 3108 xcb_atom_t selection /**< */) 3109 { 3110 static const xcb_protocol_request_t xcb_req = { 3111 /* count */ 2, 3112 /* ext */ &xcb_selinux_id, 3113 /* opcode */ XCB_SELINUX_GET_SELECTION_CONTEXT, 3114 /* isvoid */ 0 3115 }; 3116 3117 struct iovec xcb_parts[4]; 3118 xcb_selinux_get_selection_context_cookie_t xcb_ret; 3119 xcb_selinux_get_selection_context_request_t xcb_out; 3120 3121 xcb_out.selection = selection; 3122 3123 xcb_parts[2].iov_base = (char *) &xcb_out; 3124 xcb_parts[2].iov_len = sizeof(xcb_out); 3125 xcb_parts[3].iov_base = 0; 3126 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3127 3128 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 3129 return xcb_ret; 3130 } 3131 3132 3133 /***************************************************************************** 3134 ** 3135 ** xcb_selinux_get_selection_context_cookie_t xcb_selinux_get_selection_context_unchecked 3136 ** 3137 ** @param xcb_connection_t *c 3138 ** @param xcb_atom_t selection 3139 ** @returns xcb_selinux_get_selection_context_cookie_t 3140 ** 3141 *****************************************************************************/ 3142 3143 xcb_selinux_get_selection_context_cookie_t 3144 xcb_selinux_get_selection_context_unchecked (xcb_connection_t *c /**< */, 3145 xcb_atom_t selection /**< */) 3146 { 3147 static const xcb_protocol_request_t xcb_req = { 3148 /* count */ 2, 3149 /* ext */ &xcb_selinux_id, 3150 /* opcode */ XCB_SELINUX_GET_SELECTION_CONTEXT, 3151 /* isvoid */ 0 3152 }; 3153 3154 struct iovec xcb_parts[4]; 3155 xcb_selinux_get_selection_context_cookie_t xcb_ret; 3156 xcb_selinux_get_selection_context_request_t xcb_out; 3157 3158 xcb_out.selection = selection; 3159 3160 xcb_parts[2].iov_base = (char *) &xcb_out; 3161 xcb_parts[2].iov_len = sizeof(xcb_out); 3162 xcb_parts[3].iov_base = 0; 3163 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3164 3165 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 3166 return xcb_ret; 3167 } 3168 3169 3170 /***************************************************************************** 3171 ** 3172 ** char * xcb_selinux_get_selection_context_context 3173 ** 3174 ** @param const xcb_selinux_get_selection_context_reply_t *R 3175 ** @returns char * 3176 ** 3177 *****************************************************************************/ 3178 3179 char * 3180 xcb_selinux_get_selection_context_context (const xcb_selinux_get_selection_context_reply_t *R /**< */) 3181 { 3182 return (char *) (R + 1); 3183 } 3184 3185 3186 /***************************************************************************** 3187 ** 3188 ** int xcb_selinux_get_selection_context_context_length 3189 ** 3190 ** @param const xcb_selinux_get_selection_context_reply_t *R 3191 ** @returns int 3192 ** 3193 *****************************************************************************/ 3194 3195 int 3196 xcb_selinux_get_selection_context_context_length (const xcb_selinux_get_selection_context_reply_t *R /**< */) 3197 { 3198 return R->context_len; 3199 } 3200 3201 3202 /***************************************************************************** 3203 ** 3204 ** xcb_generic_iterator_t xcb_selinux_get_selection_context_context_end 3205 ** 3206 ** @param const xcb_selinux_get_selection_context_reply_t *R 3207 ** @returns xcb_generic_iterator_t 3208 ** 3209 *****************************************************************************/ 3210 3211 xcb_generic_iterator_t 3212 xcb_selinux_get_selection_context_context_end (const xcb_selinux_get_selection_context_reply_t *R /**< */) 3213 { 3214 xcb_generic_iterator_t i; 3215 i.data = ((char *) (R + 1)) + (R->context_len); 3216 i.rem = 0; 3217 i.index = (char *) i.data - (char *) R; 3218 return i; 3219 } 3220 3221 3222 /***************************************************************************** 3223 ** 3224 ** xcb_selinux_get_selection_context_reply_t * xcb_selinux_get_selection_context_reply 3225 ** 3226 ** @param xcb_connection_t *c 3227 ** @param xcb_selinux_get_selection_context_cookie_t cookie 3228 ** @param xcb_generic_error_t **e 3229 ** @returns xcb_selinux_get_selection_context_reply_t * 3230 ** 3231 *****************************************************************************/ 3232 3233 xcb_selinux_get_selection_context_reply_t * 3234 xcb_selinux_get_selection_context_reply (xcb_connection_t *c /**< */, 3235 xcb_selinux_get_selection_context_cookie_t cookie /**< */, 3236 xcb_generic_error_t **e /**< */) 3237 { 3238 return (xcb_selinux_get_selection_context_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 3239 } 3240 3241 int 3242 xcb_selinux_get_selection_data_context_sizeof (const void *_buffer /**< */) 3243 { 3244 char *xcb_tmp = (char *)_buffer; 3245 const xcb_selinux_get_selection_data_context_reply_t *_aux = (xcb_selinux_get_selection_data_context_reply_t *)_buffer; 3246 unsigned int xcb_buffer_len = 0; 3247 unsigned int xcb_block_len = 0; 3248 unsigned int xcb_pad = 0; 3249 unsigned int xcb_align_to = 0; 3250 3251 3252 xcb_block_len += sizeof(xcb_selinux_get_selection_data_context_reply_t); 3253 xcb_tmp += xcb_block_len; 3254 xcb_buffer_len += xcb_block_len; 3255 xcb_block_len = 0; 3256 /* context */ 3257 xcb_block_len += _aux->context_len * sizeof(char); 3258 xcb_tmp += xcb_block_len; 3259 xcb_align_to = ALIGNOF(char); 3260 /* insert padding */ 3261 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 3262 xcb_buffer_len += xcb_block_len + xcb_pad; 3263 if (0 != xcb_pad) { 3264 xcb_tmp += xcb_pad; 3265 xcb_pad = 0; 3266 } 3267 xcb_block_len = 0; 3268 3269 return xcb_buffer_len; 3270 } 3271 3272 3273 /***************************************************************************** 3274 ** 3275 ** xcb_selinux_get_selection_data_context_cookie_t xcb_selinux_get_selection_data_context 3276 ** 3277 ** @param xcb_connection_t *c 3278 ** @param xcb_atom_t selection 3279 ** @returns xcb_selinux_get_selection_data_context_cookie_t 3280 ** 3281 *****************************************************************************/ 3282 3283 xcb_selinux_get_selection_data_context_cookie_t 3284 xcb_selinux_get_selection_data_context (xcb_connection_t *c /**< */, 3285 xcb_atom_t selection /**< */) 3286 { 3287 static const xcb_protocol_request_t xcb_req = { 3288 /* count */ 2, 3289 /* ext */ &xcb_selinux_id, 3290 /* opcode */ XCB_SELINUX_GET_SELECTION_DATA_CONTEXT, 3291 /* isvoid */ 0 3292 }; 3293 3294 struct iovec xcb_parts[4]; 3295 xcb_selinux_get_selection_data_context_cookie_t xcb_ret; 3296 xcb_selinux_get_selection_data_context_request_t xcb_out; 3297 3298 xcb_out.selection = selection; 3299 3300 xcb_parts[2].iov_base = (char *) &xcb_out; 3301 xcb_parts[2].iov_len = sizeof(xcb_out); 3302 xcb_parts[3].iov_base = 0; 3303 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3304 3305 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 3306 return xcb_ret; 3307 } 3308 3309 3310 /***************************************************************************** 3311 ** 3312 ** xcb_selinux_get_selection_data_context_cookie_t xcb_selinux_get_selection_data_context_unchecked 3313 ** 3314 ** @param xcb_connection_t *c 3315 ** @param xcb_atom_t selection 3316 ** @returns xcb_selinux_get_selection_data_context_cookie_t 3317 ** 3318 *****************************************************************************/ 3319 3320 xcb_selinux_get_selection_data_context_cookie_t 3321 xcb_selinux_get_selection_data_context_unchecked (xcb_connection_t *c /**< */, 3322 xcb_atom_t selection /**< */) 3323 { 3324 static const xcb_protocol_request_t xcb_req = { 3325 /* count */ 2, 3326 /* ext */ &xcb_selinux_id, 3327 /* opcode */ XCB_SELINUX_GET_SELECTION_DATA_CONTEXT, 3328 /* isvoid */ 0 3329 }; 3330 3331 struct iovec xcb_parts[4]; 3332 xcb_selinux_get_selection_data_context_cookie_t xcb_ret; 3333 xcb_selinux_get_selection_data_context_request_t xcb_out; 3334 3335 xcb_out.selection = selection; 3336 3337 xcb_parts[2].iov_base = (char *) &xcb_out; 3338 xcb_parts[2].iov_len = sizeof(xcb_out); 3339 xcb_parts[3].iov_base = 0; 3340 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3341 3342 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 3343 return xcb_ret; 3344 } 3345 3346 3347 /***************************************************************************** 3348 ** 3349 ** char * xcb_selinux_get_selection_data_context_context 3350 ** 3351 ** @param const xcb_selinux_get_selection_data_context_reply_t *R 3352 ** @returns char * 3353 ** 3354 *****************************************************************************/ 3355 3356 char * 3357 xcb_selinux_get_selection_data_context_context (const xcb_selinux_get_selection_data_context_reply_t *R /**< */) 3358 { 3359 return (char *) (R + 1); 3360 } 3361 3362 3363 /***************************************************************************** 3364 ** 3365 ** int xcb_selinux_get_selection_data_context_context_length 3366 ** 3367 ** @param const xcb_selinux_get_selection_data_context_reply_t *R 3368 ** @returns int 3369 ** 3370 *****************************************************************************/ 3371 3372 int 3373 xcb_selinux_get_selection_data_context_context_length (const xcb_selinux_get_selection_data_context_reply_t *R /**< */) 3374 { 3375 return R->context_len; 3376 } 3377 3378 3379 /***************************************************************************** 3380 ** 3381 ** xcb_generic_iterator_t xcb_selinux_get_selection_data_context_context_end 3382 ** 3383 ** @param const xcb_selinux_get_selection_data_context_reply_t *R 3384 ** @returns xcb_generic_iterator_t 3385 ** 3386 *****************************************************************************/ 3387 3388 xcb_generic_iterator_t 3389 xcb_selinux_get_selection_data_context_context_end (const xcb_selinux_get_selection_data_context_reply_t *R /**< */) 3390 { 3391 xcb_generic_iterator_t i; 3392 i.data = ((char *) (R + 1)) + (R->context_len); 3393 i.rem = 0; 3394 i.index = (char *) i.data - (char *) R; 3395 return i; 3396 } 3397 3398 3399 /***************************************************************************** 3400 ** 3401 ** xcb_selinux_get_selection_data_context_reply_t * xcb_selinux_get_selection_data_context_reply 3402 ** 3403 ** @param xcb_connection_t *c 3404 ** @param xcb_selinux_get_selection_data_context_cookie_t cookie 3405 ** @param xcb_generic_error_t **e 3406 ** @returns xcb_selinux_get_selection_data_context_reply_t * 3407 ** 3408 *****************************************************************************/ 3409 3410 xcb_selinux_get_selection_data_context_reply_t * 3411 xcb_selinux_get_selection_data_context_reply (xcb_connection_t *c /**< */, 3412 xcb_selinux_get_selection_data_context_cookie_t cookie /**< */, 3413 xcb_generic_error_t **e /**< */) 3414 { 3415 return (xcb_selinux_get_selection_data_context_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 3416 } 3417 3418 int 3419 xcb_selinux_list_selections_sizeof (const void *_buffer /**< */) 3420 { 3421 char *xcb_tmp = (char *)_buffer; 3422 const xcb_selinux_list_selections_reply_t *_aux = (xcb_selinux_list_selections_reply_t *)_buffer; 3423 unsigned int xcb_buffer_len = 0; 3424 unsigned int xcb_block_len = 0; 3425 unsigned int xcb_pad = 0; 3426 unsigned int xcb_align_to = 0; 3427 3428 unsigned int i; 3429 unsigned int xcb_tmp_len; 3430 3431 xcb_block_len += sizeof(xcb_selinux_list_selections_reply_t); 3432 xcb_tmp += xcb_block_len; 3433 xcb_buffer_len += xcb_block_len; 3434 xcb_block_len = 0; 3435 /* selections */ 3436 for(i=0; i<_aux->selections_len; i++) { 3437 xcb_tmp_len = xcb_selinux_list_item_sizeof(xcb_tmp); 3438 xcb_block_len += xcb_tmp_len; 3439 xcb_tmp += xcb_tmp_len; 3440 } 3441 xcb_align_to = ALIGNOF(xcb_selinux_list_item_t); 3442 /* insert padding */ 3443 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 3444 xcb_buffer_len += xcb_block_len + xcb_pad; 3445 if (0 != xcb_pad) { 3446 xcb_tmp += xcb_pad; 3447 xcb_pad = 0; 3448 } 3449 xcb_block_len = 0; 3450 3451 return xcb_buffer_len; 3452 } 3453 3454 3455 /***************************************************************************** 3456 ** 3457 ** xcb_selinux_list_selections_cookie_t xcb_selinux_list_selections 3458 ** 3459 ** @param xcb_connection_t *c 3460 ** @returns xcb_selinux_list_selections_cookie_t 3461 ** 3462 *****************************************************************************/ 3463 3464 xcb_selinux_list_selections_cookie_t 3465 xcb_selinux_list_selections (xcb_connection_t *c /**< */) 3466 { 3467 static const xcb_protocol_request_t xcb_req = { 3468 /* count */ 2, 3469 /* ext */ &xcb_selinux_id, 3470 /* opcode */ XCB_SELINUX_LIST_SELECTIONS, 3471 /* isvoid */ 0 3472 }; 3473 3474 struct iovec xcb_parts[4]; 3475 xcb_selinux_list_selections_cookie_t xcb_ret; 3476 xcb_selinux_list_selections_request_t xcb_out; 3477 3478 3479 xcb_parts[2].iov_base = (char *) &xcb_out; 3480 xcb_parts[2].iov_len = sizeof(xcb_out); 3481 xcb_parts[3].iov_base = 0; 3482 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3483 3484 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 3485 return xcb_ret; 3486 } 3487 3488 3489 /***************************************************************************** 3490 ** 3491 ** xcb_selinux_list_selections_cookie_t xcb_selinux_list_selections_unchecked 3492 ** 3493 ** @param xcb_connection_t *c 3494 ** @returns xcb_selinux_list_selections_cookie_t 3495 ** 3496 *****************************************************************************/ 3497 3498 xcb_selinux_list_selections_cookie_t 3499 xcb_selinux_list_selections_unchecked (xcb_connection_t *c /**< */) 3500 { 3501 static const xcb_protocol_request_t xcb_req = { 3502 /* count */ 2, 3503 /* ext */ &xcb_selinux_id, 3504 /* opcode */ XCB_SELINUX_LIST_SELECTIONS, 3505 /* isvoid */ 0 3506 }; 3507 3508 struct iovec xcb_parts[4]; 3509 xcb_selinux_list_selections_cookie_t xcb_ret; 3510 xcb_selinux_list_selections_request_t xcb_out; 3511 3512 3513 xcb_parts[2].iov_base = (char *) &xcb_out; 3514 xcb_parts[2].iov_len = sizeof(xcb_out); 3515 xcb_parts[3].iov_base = 0; 3516 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3517 3518 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 3519 return xcb_ret; 3520 } 3521 3522 3523 /***************************************************************************** 3524 ** 3525 ** int xcb_selinux_list_selections_selections_length 3526 ** 3527 ** @param const xcb_selinux_list_selections_reply_t *R 3528 ** @returns int 3529 ** 3530 *****************************************************************************/ 3531 3532 int 3533 xcb_selinux_list_selections_selections_length (const xcb_selinux_list_selections_reply_t *R /**< */) 3534 { 3535 return R->selections_len; 3536 } 3537 3538 3539 /***************************************************************************** 3540 ** 3541 ** xcb_selinux_list_item_iterator_t xcb_selinux_list_selections_selections_iterator 3542 ** 3543 ** @param const xcb_selinux_list_selections_reply_t *R 3544 ** @returns xcb_selinux_list_item_iterator_t 3545 ** 3546 *****************************************************************************/ 3547 3548 xcb_selinux_list_item_iterator_t 3549 xcb_selinux_list_selections_selections_iterator (const xcb_selinux_list_selections_reply_t *R /**< */) 3550 { 3551 xcb_selinux_list_item_iterator_t i; 3552 i.data = (xcb_selinux_list_item_t *) (R + 1); 3553 i.rem = R->selections_len; 3554 i.index = (char *) i.data - (char *) R; 3555 return i; 3556 } 3557 3558 3559 /***************************************************************************** 3560 ** 3561 ** xcb_selinux_list_selections_reply_t * xcb_selinux_list_selections_reply 3562 ** 3563 ** @param xcb_connection_t *c 3564 ** @param xcb_selinux_list_selections_cookie_t cookie 3565 ** @param xcb_generic_error_t **e 3566 ** @returns xcb_selinux_list_selections_reply_t * 3567 ** 3568 *****************************************************************************/ 3569 3570 xcb_selinux_list_selections_reply_t * 3571 xcb_selinux_list_selections_reply (xcb_connection_t *c /**< */, 3572 xcb_selinux_list_selections_cookie_t cookie /**< */, 3573 xcb_generic_error_t **e /**< */) 3574 { 3575 return (xcb_selinux_list_selections_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 3576 } 3577 3578 int 3579 xcb_selinux_get_client_context_sizeof (const void *_buffer /**< */) 3580 { 3581 char *xcb_tmp = (char *)_buffer; 3582 const xcb_selinux_get_client_context_reply_t *_aux = (xcb_selinux_get_client_context_reply_t *)_buffer; 3583 unsigned int xcb_buffer_len = 0; 3584 unsigned int xcb_block_len = 0; 3585 unsigned int xcb_pad = 0; 3586 unsigned int xcb_align_to = 0; 3587 3588 3589 xcb_block_len += sizeof(xcb_selinux_get_client_context_reply_t); 3590 xcb_tmp += xcb_block_len; 3591 xcb_buffer_len += xcb_block_len; 3592 xcb_block_len = 0; 3593 /* context */ 3594 xcb_block_len += _aux->context_len * sizeof(char); 3595 xcb_tmp += xcb_block_len; 3596 xcb_align_to = ALIGNOF(char); 3597 /* insert padding */ 3598 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 3599 xcb_buffer_len += xcb_block_len + xcb_pad; 3600 if (0 != xcb_pad) { 3601 xcb_tmp += xcb_pad; 3602 xcb_pad = 0; 3603 } 3604 xcb_block_len = 0; 3605 3606 return xcb_buffer_len; 3607 } 3608 3609 3610 /***************************************************************************** 3611 ** 3612 ** xcb_selinux_get_client_context_cookie_t xcb_selinux_get_client_context 3613 ** 3614 ** @param xcb_connection_t *c 3615 ** @param uint32_t resource 3616 ** @returns xcb_selinux_get_client_context_cookie_t 3617 ** 3618 *****************************************************************************/ 3619 3620 xcb_selinux_get_client_context_cookie_t 3621 xcb_selinux_get_client_context (xcb_connection_t *c /**< */, 3622 uint32_t resource /**< */) 3623 { 3624 static const xcb_protocol_request_t xcb_req = { 3625 /* count */ 2, 3626 /* ext */ &xcb_selinux_id, 3627 /* opcode */ XCB_SELINUX_GET_CLIENT_CONTEXT, 3628 /* isvoid */ 0 3629 }; 3630 3631 struct iovec xcb_parts[4]; 3632 xcb_selinux_get_client_context_cookie_t xcb_ret; 3633 xcb_selinux_get_client_context_request_t xcb_out; 3634 3635 xcb_out.resource = resource; 3636 3637 xcb_parts[2].iov_base = (char *) &xcb_out; 3638 xcb_parts[2].iov_len = sizeof(xcb_out); 3639 xcb_parts[3].iov_base = 0; 3640 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3641 3642 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 3643 return xcb_ret; 3644 } 3645 3646 3647 /***************************************************************************** 3648 ** 3649 ** xcb_selinux_get_client_context_cookie_t xcb_selinux_get_client_context_unchecked 3650 ** 3651 ** @param xcb_connection_t *c 3652 ** @param uint32_t resource 3653 ** @returns xcb_selinux_get_client_context_cookie_t 3654 ** 3655 *****************************************************************************/ 3656 3657 xcb_selinux_get_client_context_cookie_t 3658 xcb_selinux_get_client_context_unchecked (xcb_connection_t *c /**< */, 3659 uint32_t resource /**< */) 3660 { 3661 static const xcb_protocol_request_t xcb_req = { 3662 /* count */ 2, 3663 /* ext */ &xcb_selinux_id, 3664 /* opcode */ XCB_SELINUX_GET_CLIENT_CONTEXT, 3665 /* isvoid */ 0 3666 }; 3667 3668 struct iovec xcb_parts[4]; 3669 xcb_selinux_get_client_context_cookie_t xcb_ret; 3670 xcb_selinux_get_client_context_request_t xcb_out; 3671 3672 xcb_out.resource = resource; 3673 3674 xcb_parts[2].iov_base = (char *) &xcb_out; 3675 xcb_parts[2].iov_len = sizeof(xcb_out); 3676 xcb_parts[3].iov_base = 0; 3677 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3678 3679 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 3680 return xcb_ret; 3681 } 3682 3683 3684 /***************************************************************************** 3685 ** 3686 ** char * xcb_selinux_get_client_context_context 3687 ** 3688 ** @param const xcb_selinux_get_client_context_reply_t *R 3689 ** @returns char * 3690 ** 3691 *****************************************************************************/ 3692 3693 char * 3694 xcb_selinux_get_client_context_context (const xcb_selinux_get_client_context_reply_t *R /**< */) 3695 { 3696 return (char *) (R + 1); 3697 } 3698 3699 3700 /***************************************************************************** 3701 ** 3702 ** int xcb_selinux_get_client_context_context_length 3703 ** 3704 ** @param const xcb_selinux_get_client_context_reply_t *R 3705 ** @returns int 3706 ** 3707 *****************************************************************************/ 3708 3709 int 3710 xcb_selinux_get_client_context_context_length (const xcb_selinux_get_client_context_reply_t *R /**< */) 3711 { 3712 return R->context_len; 3713 } 3714 3715 3716 /***************************************************************************** 3717 ** 3718 ** xcb_generic_iterator_t xcb_selinux_get_client_context_context_end 3719 ** 3720 ** @param const xcb_selinux_get_client_context_reply_t *R 3721 ** @returns xcb_generic_iterator_t 3722 ** 3723 *****************************************************************************/ 3724 3725 xcb_generic_iterator_t 3726 xcb_selinux_get_client_context_context_end (const xcb_selinux_get_client_context_reply_t *R /**< */) 3727 { 3728 xcb_generic_iterator_t i; 3729 i.data = ((char *) (R + 1)) + (R->context_len); 3730 i.rem = 0; 3731 i.index = (char *) i.data - (char *) R; 3732 return i; 3733 } 3734 3735 3736 /***************************************************************************** 3737 ** 3738 ** xcb_selinux_get_client_context_reply_t * xcb_selinux_get_client_context_reply 3739 ** 3740 ** @param xcb_connection_t *c 3741 ** @param xcb_selinux_get_client_context_cookie_t cookie 3742 ** @param xcb_generic_error_t **e 3743 ** @returns xcb_selinux_get_client_context_reply_t * 3744 ** 3745 *****************************************************************************/ 3746 3747 xcb_selinux_get_client_context_reply_t * 3748 xcb_selinux_get_client_context_reply (xcb_connection_t *c /**< */, 3749 xcb_selinux_get_client_context_cookie_t cookie /**< */, 3750 xcb_generic_error_t **e /**< */) 3751 { 3752 return (xcb_selinux_get_client_context_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 3753 } 3754 3755