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