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 19xcb_extension_t xcb_selinux_id = { "SELinux", 0 }; 20 21xcb_selinux_query_version_cookie_t 22xcb_selinux_query_version (xcb_connection_t *c, 23 uint8_t client_major, 24 uint8_t client_minor) 25{ 26 static const xcb_protocol_request_t xcb_req = { 27 .count = 2, 28 .ext = &xcb_selinux_id, 29 .opcode = XCB_SELINUX_QUERY_VERSION, 30 .isvoid = 0 31 }; 32 33 struct iovec xcb_parts[4]; 34 xcb_selinux_query_version_cookie_t xcb_ret; 35 xcb_selinux_query_version_request_t xcb_out; 36 37 xcb_out.client_major = client_major; 38 xcb_out.client_minor = client_minor; 39 40 xcb_parts[2].iov_base = (char *) &xcb_out; 41 xcb_parts[2].iov_len = sizeof(xcb_out); 42 xcb_parts[3].iov_base = 0; 43 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 44 45 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 46 return xcb_ret; 47} 48 49xcb_selinux_query_version_cookie_t 50xcb_selinux_query_version_unchecked (xcb_connection_t *c, 51 uint8_t client_major, 52 uint8_t client_minor) 53{ 54 static const xcb_protocol_request_t xcb_req = { 55 .count = 2, 56 .ext = &xcb_selinux_id, 57 .opcode = XCB_SELINUX_QUERY_VERSION, 58 .isvoid = 0 59 }; 60 61 struct iovec xcb_parts[4]; 62 xcb_selinux_query_version_cookie_t xcb_ret; 63 xcb_selinux_query_version_request_t xcb_out; 64 65 xcb_out.client_major = client_major; 66 xcb_out.client_minor = client_minor; 67 68 xcb_parts[2].iov_base = (char *) &xcb_out; 69 xcb_parts[2].iov_len = sizeof(xcb_out); 70 xcb_parts[3].iov_base = 0; 71 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 72 73 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 74 return xcb_ret; 75} 76 77xcb_selinux_query_version_reply_t * 78xcb_selinux_query_version_reply (xcb_connection_t *c, 79 xcb_selinux_query_version_cookie_t cookie /**< */, 80 xcb_generic_error_t **e) 81{ 82 return (xcb_selinux_query_version_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 83} 84 85int 86xcb_selinux_set_device_create_context_sizeof (const void *_buffer) 87{ 88 char *xcb_tmp = (char *)_buffer; 89 const xcb_selinux_set_device_create_context_request_t *_aux = (xcb_selinux_set_device_create_context_request_t *)_buffer; 90 unsigned int xcb_buffer_len = 0; 91 unsigned int xcb_block_len = 0; 92 unsigned int xcb_pad = 0; 93 unsigned int xcb_align_to = 0; 94 95 96 xcb_block_len += sizeof(xcb_selinux_set_device_create_context_request_t); 97 xcb_tmp += xcb_block_len; 98 xcb_buffer_len += xcb_block_len; 99 xcb_block_len = 0; 100 /* context */ 101 xcb_block_len += _aux->context_len * sizeof(char); 102 xcb_tmp += xcb_block_len; 103 xcb_align_to = ALIGNOF(char); 104 /* insert padding */ 105 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 106 xcb_buffer_len += xcb_block_len + xcb_pad; 107 if (0 != xcb_pad) { 108 xcb_tmp += xcb_pad; 109 xcb_pad = 0; 110 } 111 xcb_block_len = 0; 112 113 return xcb_buffer_len; 114} 115 116xcb_void_cookie_t 117xcb_selinux_set_device_create_context_checked (xcb_connection_t *c, 118 uint32_t context_len, 119 const char *context) 120{ 121 static const xcb_protocol_request_t xcb_req = { 122 .count = 4, 123 .ext = &xcb_selinux_id, 124 .opcode = XCB_SELINUX_SET_DEVICE_CREATE_CONTEXT, 125 .isvoid = 1 126 }; 127 128 struct iovec xcb_parts[6]; 129 xcb_void_cookie_t xcb_ret; 130 xcb_selinux_set_device_create_context_request_t xcb_out; 131 132 xcb_out.context_len = context_len; 133 134 xcb_parts[2].iov_base = (char *) &xcb_out; 135 xcb_parts[2].iov_len = sizeof(xcb_out); 136 xcb_parts[3].iov_base = 0; 137 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 138 /* char context */ 139 xcb_parts[4].iov_base = (char *) context; 140 xcb_parts[4].iov_len = context_len * sizeof(char); 141 xcb_parts[5].iov_base = 0; 142 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 143 144 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 145 return xcb_ret; 146} 147 148xcb_void_cookie_t 149xcb_selinux_set_device_create_context (xcb_connection_t *c, 150 uint32_t context_len, 151 const char *context) 152{ 153 static const xcb_protocol_request_t xcb_req = { 154 .count = 4, 155 .ext = &xcb_selinux_id, 156 .opcode = XCB_SELINUX_SET_DEVICE_CREATE_CONTEXT, 157 .isvoid = 1 158 }; 159 160 struct iovec xcb_parts[6]; 161 xcb_void_cookie_t xcb_ret; 162 xcb_selinux_set_device_create_context_request_t xcb_out; 163 164 xcb_out.context_len = context_len; 165 166 xcb_parts[2].iov_base = (char *) &xcb_out; 167 xcb_parts[2].iov_len = sizeof(xcb_out); 168 xcb_parts[3].iov_base = 0; 169 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 170 /* char context */ 171 xcb_parts[4].iov_base = (char *) context; 172 xcb_parts[4].iov_len = context_len * sizeof(char); 173 xcb_parts[5].iov_base = 0; 174 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 175 176 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 177 return xcb_ret; 178} 179 180char * 181xcb_selinux_set_device_create_context_context (const xcb_selinux_set_device_create_context_request_t *R) 182{ 183 return (char *) (R + 1); 184} 185 186int 187xcb_selinux_set_device_create_context_context_length (const xcb_selinux_set_device_create_context_request_t *R) 188{ 189 return R->context_len; 190} 191 192xcb_generic_iterator_t 193xcb_selinux_set_device_create_context_context_end (const xcb_selinux_set_device_create_context_request_t *R) 194{ 195 xcb_generic_iterator_t i; 196 i.data = ((char *) (R + 1)) + (R->context_len); 197 i.rem = 0; 198 i.index = (char *) i.data - (char *) R; 199 return i; 200} 201 202int 203xcb_selinux_get_device_create_context_sizeof (const void *_buffer) 204{ 205 char *xcb_tmp = (char *)_buffer; 206 const xcb_selinux_get_device_create_context_reply_t *_aux = (xcb_selinux_get_device_create_context_reply_t *)_buffer; 207 unsigned int xcb_buffer_len = 0; 208 unsigned int xcb_block_len = 0; 209 unsigned int xcb_pad = 0; 210 unsigned int xcb_align_to = 0; 211 212 213 xcb_block_len += sizeof(xcb_selinux_get_device_create_context_reply_t); 214 xcb_tmp += xcb_block_len; 215 xcb_buffer_len += xcb_block_len; 216 xcb_block_len = 0; 217 /* context */ 218 xcb_block_len += _aux->context_len * sizeof(char); 219 xcb_tmp += xcb_block_len; 220 xcb_align_to = ALIGNOF(char); 221 /* insert padding */ 222 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 223 xcb_buffer_len += xcb_block_len + xcb_pad; 224 if (0 != xcb_pad) { 225 xcb_tmp += xcb_pad; 226 xcb_pad = 0; 227 } 228 xcb_block_len = 0; 229 230 return xcb_buffer_len; 231} 232 233xcb_selinux_get_device_create_context_cookie_t 234xcb_selinux_get_device_create_context (xcb_connection_t *c) 235{ 236 static const xcb_protocol_request_t xcb_req = { 237 .count = 2, 238 .ext = &xcb_selinux_id, 239 .opcode = XCB_SELINUX_GET_DEVICE_CREATE_CONTEXT, 240 .isvoid = 0 241 }; 242 243 struct iovec xcb_parts[4]; 244 xcb_selinux_get_device_create_context_cookie_t xcb_ret; 245 xcb_selinux_get_device_create_context_request_t xcb_out; 246 247 248 xcb_parts[2].iov_base = (char *) &xcb_out; 249 xcb_parts[2].iov_len = sizeof(xcb_out); 250 xcb_parts[3].iov_base = 0; 251 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 252 253 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 254 return xcb_ret; 255} 256 257xcb_selinux_get_device_create_context_cookie_t 258xcb_selinux_get_device_create_context_unchecked (xcb_connection_t *c) 259{ 260 static const xcb_protocol_request_t xcb_req = { 261 .count = 2, 262 .ext = &xcb_selinux_id, 263 .opcode = XCB_SELINUX_GET_DEVICE_CREATE_CONTEXT, 264 .isvoid = 0 265 }; 266 267 struct iovec xcb_parts[4]; 268 xcb_selinux_get_device_create_context_cookie_t xcb_ret; 269 xcb_selinux_get_device_create_context_request_t xcb_out; 270 271 272 xcb_parts[2].iov_base = (char *) &xcb_out; 273 xcb_parts[2].iov_len = sizeof(xcb_out); 274 xcb_parts[3].iov_base = 0; 275 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 276 277 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 278 return xcb_ret; 279} 280 281char * 282xcb_selinux_get_device_create_context_context (const xcb_selinux_get_device_create_context_reply_t *R) 283{ 284 return (char *) (R + 1); 285} 286 287int 288xcb_selinux_get_device_create_context_context_length (const xcb_selinux_get_device_create_context_reply_t *R) 289{ 290 return R->context_len; 291} 292 293xcb_generic_iterator_t 294xcb_selinux_get_device_create_context_context_end (const xcb_selinux_get_device_create_context_reply_t *R) 295{ 296 xcb_generic_iterator_t i; 297 i.data = ((char *) (R + 1)) + (R->context_len); 298 i.rem = 0; 299 i.index = (char *) i.data - (char *) R; 300 return i; 301} 302 303xcb_selinux_get_device_create_context_reply_t * 304xcb_selinux_get_device_create_context_reply (xcb_connection_t *c, 305 xcb_selinux_get_device_create_context_cookie_t cookie /**< */, 306 xcb_generic_error_t **e) 307{ 308 return (xcb_selinux_get_device_create_context_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 309} 310 311int 312xcb_selinux_set_device_context_sizeof (const void *_buffer) 313{ 314 char *xcb_tmp = (char *)_buffer; 315 const xcb_selinux_set_device_context_request_t *_aux = (xcb_selinux_set_device_context_request_t *)_buffer; 316 unsigned int xcb_buffer_len = 0; 317 unsigned int xcb_block_len = 0; 318 unsigned int xcb_pad = 0; 319 unsigned int xcb_align_to = 0; 320 321 322 xcb_block_len += sizeof(xcb_selinux_set_device_context_request_t); 323 xcb_tmp += xcb_block_len; 324 xcb_buffer_len += xcb_block_len; 325 xcb_block_len = 0; 326 /* context */ 327 xcb_block_len += _aux->context_len * sizeof(char); 328 xcb_tmp += xcb_block_len; 329 xcb_align_to = ALIGNOF(char); 330 /* insert padding */ 331 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 332 xcb_buffer_len += xcb_block_len + xcb_pad; 333 if (0 != xcb_pad) { 334 xcb_tmp += xcb_pad; 335 xcb_pad = 0; 336 } 337 xcb_block_len = 0; 338 339 return xcb_buffer_len; 340} 341 342xcb_void_cookie_t 343xcb_selinux_set_device_context_checked (xcb_connection_t *c, 344 uint32_t device, 345 uint32_t context_len, 346 const char *context) 347{ 348 static const xcb_protocol_request_t xcb_req = { 349 .count = 4, 350 .ext = &xcb_selinux_id, 351 .opcode = XCB_SELINUX_SET_DEVICE_CONTEXT, 352 .isvoid = 1 353 }; 354 355 struct iovec xcb_parts[6]; 356 xcb_void_cookie_t xcb_ret; 357 xcb_selinux_set_device_context_request_t xcb_out; 358 359 xcb_out.device = device; 360 xcb_out.context_len = context_len; 361 362 xcb_parts[2].iov_base = (char *) &xcb_out; 363 xcb_parts[2].iov_len = sizeof(xcb_out); 364 xcb_parts[3].iov_base = 0; 365 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 366 /* char context */ 367 xcb_parts[4].iov_base = (char *) context; 368 xcb_parts[4].iov_len = context_len * sizeof(char); 369 xcb_parts[5].iov_base = 0; 370 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 371 372 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 373 return xcb_ret; 374} 375 376xcb_void_cookie_t 377xcb_selinux_set_device_context (xcb_connection_t *c, 378 uint32_t device, 379 uint32_t context_len, 380 const char *context) 381{ 382 static const xcb_protocol_request_t xcb_req = { 383 .count = 4, 384 .ext = &xcb_selinux_id, 385 .opcode = XCB_SELINUX_SET_DEVICE_CONTEXT, 386 .isvoid = 1 387 }; 388 389 struct iovec xcb_parts[6]; 390 xcb_void_cookie_t xcb_ret; 391 xcb_selinux_set_device_context_request_t xcb_out; 392 393 xcb_out.device = device; 394 xcb_out.context_len = context_len; 395 396 xcb_parts[2].iov_base = (char *) &xcb_out; 397 xcb_parts[2].iov_len = sizeof(xcb_out); 398 xcb_parts[3].iov_base = 0; 399 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 400 /* char context */ 401 xcb_parts[4].iov_base = (char *) context; 402 xcb_parts[4].iov_len = context_len * sizeof(char); 403 xcb_parts[5].iov_base = 0; 404 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 405 406 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 407 return xcb_ret; 408} 409 410char * 411xcb_selinux_set_device_context_context (const xcb_selinux_set_device_context_request_t *R) 412{ 413 return (char *) (R + 1); 414} 415 416int 417xcb_selinux_set_device_context_context_length (const xcb_selinux_set_device_context_request_t *R) 418{ 419 return R->context_len; 420} 421 422xcb_generic_iterator_t 423xcb_selinux_set_device_context_context_end (const xcb_selinux_set_device_context_request_t *R) 424{ 425 xcb_generic_iterator_t i; 426 i.data = ((char *) (R + 1)) + (R->context_len); 427 i.rem = 0; 428 i.index = (char *) i.data - (char *) R; 429 return i; 430} 431 432int 433xcb_selinux_get_device_context_sizeof (const void *_buffer) 434{ 435 char *xcb_tmp = (char *)_buffer; 436 const xcb_selinux_get_device_context_reply_t *_aux = (xcb_selinux_get_device_context_reply_t *)_buffer; 437 unsigned int xcb_buffer_len = 0; 438 unsigned int xcb_block_len = 0; 439 unsigned int xcb_pad = 0; 440 unsigned int xcb_align_to = 0; 441 442 443 xcb_block_len += sizeof(xcb_selinux_get_device_context_reply_t); 444 xcb_tmp += xcb_block_len; 445 xcb_buffer_len += xcb_block_len; 446 xcb_block_len = 0; 447 /* context */ 448 xcb_block_len += _aux->context_len * sizeof(char); 449 xcb_tmp += xcb_block_len; 450 xcb_align_to = ALIGNOF(char); 451 /* insert padding */ 452 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 453 xcb_buffer_len += xcb_block_len + xcb_pad; 454 if (0 != xcb_pad) { 455 xcb_tmp += xcb_pad; 456 xcb_pad = 0; 457 } 458 xcb_block_len = 0; 459 460 return xcb_buffer_len; 461} 462 463xcb_selinux_get_device_context_cookie_t 464xcb_selinux_get_device_context (xcb_connection_t *c, 465 uint32_t device) 466{ 467 static const xcb_protocol_request_t xcb_req = { 468 .count = 2, 469 .ext = &xcb_selinux_id, 470 .opcode = XCB_SELINUX_GET_DEVICE_CONTEXT, 471 .isvoid = 0 472 }; 473 474 struct iovec xcb_parts[4]; 475 xcb_selinux_get_device_context_cookie_t xcb_ret; 476 xcb_selinux_get_device_context_request_t xcb_out; 477 478 xcb_out.device = device; 479 480 xcb_parts[2].iov_base = (char *) &xcb_out; 481 xcb_parts[2].iov_len = sizeof(xcb_out); 482 xcb_parts[3].iov_base = 0; 483 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 484 485 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 486 return xcb_ret; 487} 488 489xcb_selinux_get_device_context_cookie_t 490xcb_selinux_get_device_context_unchecked (xcb_connection_t *c, 491 uint32_t device) 492{ 493 static const xcb_protocol_request_t xcb_req = { 494 .count = 2, 495 .ext = &xcb_selinux_id, 496 .opcode = XCB_SELINUX_GET_DEVICE_CONTEXT, 497 .isvoid = 0 498 }; 499 500 struct iovec xcb_parts[4]; 501 xcb_selinux_get_device_context_cookie_t xcb_ret; 502 xcb_selinux_get_device_context_request_t xcb_out; 503 504 xcb_out.device = device; 505 506 xcb_parts[2].iov_base = (char *) &xcb_out; 507 xcb_parts[2].iov_len = sizeof(xcb_out); 508 xcb_parts[3].iov_base = 0; 509 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 510 511 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 512 return xcb_ret; 513} 514 515char * 516xcb_selinux_get_device_context_context (const xcb_selinux_get_device_context_reply_t *R) 517{ 518 return (char *) (R + 1); 519} 520 521int 522xcb_selinux_get_device_context_context_length (const xcb_selinux_get_device_context_reply_t *R) 523{ 524 return R->context_len; 525} 526 527xcb_generic_iterator_t 528xcb_selinux_get_device_context_context_end (const xcb_selinux_get_device_context_reply_t *R) 529{ 530 xcb_generic_iterator_t i; 531 i.data = ((char *) (R + 1)) + (R->context_len); 532 i.rem = 0; 533 i.index = (char *) i.data - (char *) R; 534 return i; 535} 536 537xcb_selinux_get_device_context_reply_t * 538xcb_selinux_get_device_context_reply (xcb_connection_t *c, 539 xcb_selinux_get_device_context_cookie_t cookie /**< */, 540 xcb_generic_error_t **e) 541{ 542 return (xcb_selinux_get_device_context_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 543} 544 545int 546xcb_selinux_set_window_create_context_sizeof (const void *_buffer) 547{ 548 char *xcb_tmp = (char *)_buffer; 549 const xcb_selinux_set_window_create_context_request_t *_aux = (xcb_selinux_set_window_create_context_request_t *)_buffer; 550 unsigned int xcb_buffer_len = 0; 551 unsigned int xcb_block_len = 0; 552 unsigned int xcb_pad = 0; 553 unsigned int xcb_align_to = 0; 554 555 556 xcb_block_len += sizeof(xcb_selinux_set_window_create_context_request_t); 557 xcb_tmp += xcb_block_len; 558 xcb_buffer_len += xcb_block_len; 559 xcb_block_len = 0; 560 /* context */ 561 xcb_block_len += _aux->context_len * sizeof(char); 562 xcb_tmp += xcb_block_len; 563 xcb_align_to = ALIGNOF(char); 564 /* insert padding */ 565 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 566 xcb_buffer_len += xcb_block_len + xcb_pad; 567 if (0 != xcb_pad) { 568 xcb_tmp += xcb_pad; 569 xcb_pad = 0; 570 } 571 xcb_block_len = 0; 572 573 return xcb_buffer_len; 574} 575 576xcb_void_cookie_t 577xcb_selinux_set_window_create_context_checked (xcb_connection_t *c, 578 uint32_t context_len, 579 const char *context) 580{ 581 static const xcb_protocol_request_t xcb_req = { 582 .count = 4, 583 .ext = &xcb_selinux_id, 584 .opcode = XCB_SELINUX_SET_WINDOW_CREATE_CONTEXT, 585 .isvoid = 1 586 }; 587 588 struct iovec xcb_parts[6]; 589 xcb_void_cookie_t xcb_ret; 590 xcb_selinux_set_window_create_context_request_t xcb_out; 591 592 xcb_out.context_len = context_len; 593 594 xcb_parts[2].iov_base = (char *) &xcb_out; 595 xcb_parts[2].iov_len = sizeof(xcb_out); 596 xcb_parts[3].iov_base = 0; 597 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 598 /* char context */ 599 xcb_parts[4].iov_base = (char *) context; 600 xcb_parts[4].iov_len = context_len * sizeof(char); 601 xcb_parts[5].iov_base = 0; 602 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 603 604 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 605 return xcb_ret; 606} 607 608xcb_void_cookie_t 609xcb_selinux_set_window_create_context (xcb_connection_t *c, 610 uint32_t context_len, 611 const char *context) 612{ 613 static const xcb_protocol_request_t xcb_req = { 614 .count = 4, 615 .ext = &xcb_selinux_id, 616 .opcode = XCB_SELINUX_SET_WINDOW_CREATE_CONTEXT, 617 .isvoid = 1 618 }; 619 620 struct iovec xcb_parts[6]; 621 xcb_void_cookie_t xcb_ret; 622 xcb_selinux_set_window_create_context_request_t xcb_out; 623 624 xcb_out.context_len = context_len; 625 626 xcb_parts[2].iov_base = (char *) &xcb_out; 627 xcb_parts[2].iov_len = sizeof(xcb_out); 628 xcb_parts[3].iov_base = 0; 629 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 630 /* char context */ 631 xcb_parts[4].iov_base = (char *) context; 632 xcb_parts[4].iov_len = context_len * sizeof(char); 633 xcb_parts[5].iov_base = 0; 634 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 635 636 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 637 return xcb_ret; 638} 639 640char * 641xcb_selinux_set_window_create_context_context (const xcb_selinux_set_window_create_context_request_t *R) 642{ 643 return (char *) (R + 1); 644} 645 646int 647xcb_selinux_set_window_create_context_context_length (const xcb_selinux_set_window_create_context_request_t *R) 648{ 649 return R->context_len; 650} 651 652xcb_generic_iterator_t 653xcb_selinux_set_window_create_context_context_end (const xcb_selinux_set_window_create_context_request_t *R) 654{ 655 xcb_generic_iterator_t i; 656 i.data = ((char *) (R + 1)) + (R->context_len); 657 i.rem = 0; 658 i.index = (char *) i.data - (char *) R; 659 return i; 660} 661 662int 663xcb_selinux_get_window_create_context_sizeof (const void *_buffer) 664{ 665 char *xcb_tmp = (char *)_buffer; 666 const xcb_selinux_get_window_create_context_reply_t *_aux = (xcb_selinux_get_window_create_context_reply_t *)_buffer; 667 unsigned int xcb_buffer_len = 0; 668 unsigned int xcb_block_len = 0; 669 unsigned int xcb_pad = 0; 670 unsigned int xcb_align_to = 0; 671 672 673 xcb_block_len += sizeof(xcb_selinux_get_window_create_context_reply_t); 674 xcb_tmp += xcb_block_len; 675 xcb_buffer_len += xcb_block_len; 676 xcb_block_len = 0; 677 /* context */ 678 xcb_block_len += _aux->context_len * sizeof(char); 679 xcb_tmp += xcb_block_len; 680 xcb_align_to = ALIGNOF(char); 681 /* insert padding */ 682 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 683 xcb_buffer_len += xcb_block_len + xcb_pad; 684 if (0 != xcb_pad) { 685 xcb_tmp += xcb_pad; 686 xcb_pad = 0; 687 } 688 xcb_block_len = 0; 689 690 return xcb_buffer_len; 691} 692 693xcb_selinux_get_window_create_context_cookie_t 694xcb_selinux_get_window_create_context (xcb_connection_t *c) 695{ 696 static const xcb_protocol_request_t xcb_req = { 697 .count = 2, 698 .ext = &xcb_selinux_id, 699 .opcode = XCB_SELINUX_GET_WINDOW_CREATE_CONTEXT, 700 .isvoid = 0 701 }; 702 703 struct iovec xcb_parts[4]; 704 xcb_selinux_get_window_create_context_cookie_t xcb_ret; 705 xcb_selinux_get_window_create_context_request_t xcb_out; 706 707 708 xcb_parts[2].iov_base = (char *) &xcb_out; 709 xcb_parts[2].iov_len = sizeof(xcb_out); 710 xcb_parts[3].iov_base = 0; 711 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 712 713 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 714 return xcb_ret; 715} 716 717xcb_selinux_get_window_create_context_cookie_t 718xcb_selinux_get_window_create_context_unchecked (xcb_connection_t *c) 719{ 720 static const xcb_protocol_request_t xcb_req = { 721 .count = 2, 722 .ext = &xcb_selinux_id, 723 .opcode = XCB_SELINUX_GET_WINDOW_CREATE_CONTEXT, 724 .isvoid = 0 725 }; 726 727 struct iovec xcb_parts[4]; 728 xcb_selinux_get_window_create_context_cookie_t xcb_ret; 729 xcb_selinux_get_window_create_context_request_t xcb_out; 730 731 732 xcb_parts[2].iov_base = (char *) &xcb_out; 733 xcb_parts[2].iov_len = sizeof(xcb_out); 734 xcb_parts[3].iov_base = 0; 735 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 736 737 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 738 return xcb_ret; 739} 740 741char * 742xcb_selinux_get_window_create_context_context (const xcb_selinux_get_window_create_context_reply_t *R) 743{ 744 return (char *) (R + 1); 745} 746 747int 748xcb_selinux_get_window_create_context_context_length (const xcb_selinux_get_window_create_context_reply_t *R) 749{ 750 return R->context_len; 751} 752 753xcb_generic_iterator_t 754xcb_selinux_get_window_create_context_context_end (const xcb_selinux_get_window_create_context_reply_t *R) 755{ 756 xcb_generic_iterator_t i; 757 i.data = ((char *) (R + 1)) + (R->context_len); 758 i.rem = 0; 759 i.index = (char *) i.data - (char *) R; 760 return i; 761} 762 763xcb_selinux_get_window_create_context_reply_t * 764xcb_selinux_get_window_create_context_reply (xcb_connection_t *c, 765 xcb_selinux_get_window_create_context_cookie_t cookie /**< */, 766 xcb_generic_error_t **e) 767{ 768 return (xcb_selinux_get_window_create_context_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 769} 770 771int 772xcb_selinux_get_window_context_sizeof (const void *_buffer) 773{ 774 char *xcb_tmp = (char *)_buffer; 775 const xcb_selinux_get_window_context_reply_t *_aux = (xcb_selinux_get_window_context_reply_t *)_buffer; 776 unsigned int xcb_buffer_len = 0; 777 unsigned int xcb_block_len = 0; 778 unsigned int xcb_pad = 0; 779 unsigned int xcb_align_to = 0; 780 781 782 xcb_block_len += sizeof(xcb_selinux_get_window_context_reply_t); 783 xcb_tmp += xcb_block_len; 784 xcb_buffer_len += xcb_block_len; 785 xcb_block_len = 0; 786 /* context */ 787 xcb_block_len += _aux->context_len * sizeof(char); 788 xcb_tmp += xcb_block_len; 789 xcb_align_to = ALIGNOF(char); 790 /* insert padding */ 791 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 792 xcb_buffer_len += xcb_block_len + xcb_pad; 793 if (0 != xcb_pad) { 794 xcb_tmp += xcb_pad; 795 xcb_pad = 0; 796 } 797 xcb_block_len = 0; 798 799 return xcb_buffer_len; 800} 801 802xcb_selinux_get_window_context_cookie_t 803xcb_selinux_get_window_context (xcb_connection_t *c, 804 xcb_window_t window) 805{ 806 static const xcb_protocol_request_t xcb_req = { 807 .count = 2, 808 .ext = &xcb_selinux_id, 809 .opcode = XCB_SELINUX_GET_WINDOW_CONTEXT, 810 .isvoid = 0 811 }; 812 813 struct iovec xcb_parts[4]; 814 xcb_selinux_get_window_context_cookie_t xcb_ret; 815 xcb_selinux_get_window_context_request_t xcb_out; 816 817 xcb_out.window = window; 818 819 xcb_parts[2].iov_base = (char *) &xcb_out; 820 xcb_parts[2].iov_len = sizeof(xcb_out); 821 xcb_parts[3].iov_base = 0; 822 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 823 824 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 825 return xcb_ret; 826} 827 828xcb_selinux_get_window_context_cookie_t 829xcb_selinux_get_window_context_unchecked (xcb_connection_t *c, 830 xcb_window_t window) 831{ 832 static const xcb_protocol_request_t xcb_req = { 833 .count = 2, 834 .ext = &xcb_selinux_id, 835 .opcode = XCB_SELINUX_GET_WINDOW_CONTEXT, 836 .isvoid = 0 837 }; 838 839 struct iovec xcb_parts[4]; 840 xcb_selinux_get_window_context_cookie_t xcb_ret; 841 xcb_selinux_get_window_context_request_t xcb_out; 842 843 xcb_out.window = window; 844 845 xcb_parts[2].iov_base = (char *) &xcb_out; 846 xcb_parts[2].iov_len = sizeof(xcb_out); 847 xcb_parts[3].iov_base = 0; 848 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 849 850 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 851 return xcb_ret; 852} 853 854char * 855xcb_selinux_get_window_context_context (const xcb_selinux_get_window_context_reply_t *R) 856{ 857 return (char *) (R + 1); 858} 859 860int 861xcb_selinux_get_window_context_context_length (const xcb_selinux_get_window_context_reply_t *R) 862{ 863 return R->context_len; 864} 865 866xcb_generic_iterator_t 867xcb_selinux_get_window_context_context_end (const xcb_selinux_get_window_context_reply_t *R) 868{ 869 xcb_generic_iterator_t i; 870 i.data = ((char *) (R + 1)) + (R->context_len); 871 i.rem = 0; 872 i.index = (char *) i.data - (char *) R; 873 return i; 874} 875 876xcb_selinux_get_window_context_reply_t * 877xcb_selinux_get_window_context_reply (xcb_connection_t *c, 878 xcb_selinux_get_window_context_cookie_t cookie /**< */, 879 xcb_generic_error_t **e) 880{ 881 return (xcb_selinux_get_window_context_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 882} 883 884int 885xcb_selinux_list_item_sizeof (const void *_buffer) 886{ 887 char *xcb_tmp = (char *)_buffer; 888 const xcb_selinux_list_item_t *_aux = (xcb_selinux_list_item_t *)_buffer; 889 unsigned int xcb_buffer_len = 0; 890 unsigned int xcb_block_len = 0; 891 unsigned int xcb_pad = 0; 892 unsigned int xcb_align_to = 0; 893 894 895 xcb_block_len += sizeof(xcb_selinux_list_item_t); 896 xcb_tmp += xcb_block_len; 897 xcb_buffer_len += xcb_block_len; 898 xcb_block_len = 0; 899 /* object_context */ 900 xcb_block_len += _aux->object_context_len * sizeof(char); 901 xcb_tmp += xcb_block_len; 902 xcb_align_to = ALIGNOF(char); 903 xcb_align_to = 4; 904 /* insert padding */ 905 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 906 xcb_buffer_len += xcb_block_len + xcb_pad; 907 if (0 != xcb_pad) { 908 xcb_tmp += xcb_pad; 909 xcb_pad = 0; 910 } 911 xcb_block_len = 0; 912 /* insert padding */ 913 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 914 xcb_buffer_len += xcb_block_len + xcb_pad; 915 if (0 != xcb_pad) { 916 xcb_tmp += xcb_pad; 917 xcb_pad = 0; 918 } 919 xcb_block_len = 0; 920 /* data_context */ 921 xcb_block_len += _aux->data_context_len * sizeof(char); 922 xcb_tmp += xcb_block_len; 923 xcb_align_to = ALIGNOF(char); 924 xcb_align_to = 4; 925 /* insert padding */ 926 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 927 xcb_buffer_len += xcb_block_len + xcb_pad; 928 if (0 != xcb_pad) { 929 xcb_tmp += xcb_pad; 930 xcb_pad = 0; 931 } 932 xcb_block_len = 0; 933 /* insert padding */ 934 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 935 xcb_buffer_len += xcb_block_len + xcb_pad; 936 if (0 != xcb_pad) { 937 xcb_tmp += xcb_pad; 938 xcb_pad = 0; 939 } 940 xcb_block_len = 0; 941 942 return xcb_buffer_len; 943} 944 945char * 946xcb_selinux_list_item_object_context (const xcb_selinux_list_item_t *R) 947{ 948 return (char *) (R + 1); 949} 950 951int 952xcb_selinux_list_item_object_context_length (const xcb_selinux_list_item_t *R) 953{ 954 return R->object_context_len; 955} 956 957xcb_generic_iterator_t 958xcb_selinux_list_item_object_context_end (const xcb_selinux_list_item_t *R) 959{ 960 xcb_generic_iterator_t i; 961 i.data = ((char *) (R + 1)) + (R->object_context_len); 962 i.rem = 0; 963 i.index = (char *) i.data - (char *) R; 964 return i; 965} 966 967char * 968xcb_selinux_list_item_data_context (const xcb_selinux_list_item_t *R) 969{ 970 xcb_generic_iterator_t prev = xcb_selinux_list_item_object_context_end(R); 971 return (char *) ((char *) prev.data + ((-prev.index) & (4 - 1)) + 0); 972} 973 974int 975xcb_selinux_list_item_data_context_length (const xcb_selinux_list_item_t *R) 976{ 977 return R->data_context_len; 978} 979 980xcb_generic_iterator_t 981xcb_selinux_list_item_data_context_end (const xcb_selinux_list_item_t *R) 982{ 983 xcb_generic_iterator_t i; 984 xcb_generic_iterator_t prev = xcb_selinux_list_item_object_context_end(R); 985 i.data = ((char *) ((char*) prev.data + ((-prev.index) & (4 - 1)))) + (R->data_context_len); 986 i.rem = 0; 987 i.index = (char *) i.data - (char *) R; 988 return i; 989} 990 991void 992xcb_selinux_list_item_next (xcb_selinux_list_item_iterator_t *i) 993{ 994 xcb_selinux_list_item_t *R = i->data; 995 xcb_generic_iterator_t child; 996 child.data = (xcb_selinux_list_item_t *)(((char *)R) + xcb_selinux_list_item_sizeof(R)); 997 i->index = (char *) child.data - (char *) i->data; 998 --i->rem; 999 i->data = (xcb_selinux_list_item_t *) child.data; 1000} 1001 1002xcb_generic_iterator_t 1003xcb_selinux_list_item_end (xcb_selinux_list_item_iterator_t i) 1004{ 1005 xcb_generic_iterator_t ret; 1006 while(i.rem > 0) 1007 xcb_selinux_list_item_next(&i); 1008 ret.data = i.data; 1009 ret.rem = i.rem; 1010 ret.index = i.index; 1011 return ret; 1012} 1013 1014int 1015xcb_selinux_set_property_create_context_sizeof (const void *_buffer) 1016{ 1017 char *xcb_tmp = (char *)_buffer; 1018 const xcb_selinux_set_property_create_context_request_t *_aux = (xcb_selinux_set_property_create_context_request_t *)_buffer; 1019 unsigned int xcb_buffer_len = 0; 1020 unsigned int xcb_block_len = 0; 1021 unsigned int xcb_pad = 0; 1022 unsigned int xcb_align_to = 0; 1023 1024 1025 xcb_block_len += sizeof(xcb_selinux_set_property_create_context_request_t); 1026 xcb_tmp += xcb_block_len; 1027 xcb_buffer_len += xcb_block_len; 1028 xcb_block_len = 0; 1029 /* context */ 1030 xcb_block_len += _aux->context_len * sizeof(char); 1031 xcb_tmp += xcb_block_len; 1032 xcb_align_to = ALIGNOF(char); 1033 /* insert padding */ 1034 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 1035 xcb_buffer_len += xcb_block_len + xcb_pad; 1036 if (0 != xcb_pad) { 1037 xcb_tmp += xcb_pad; 1038 xcb_pad = 0; 1039 } 1040 xcb_block_len = 0; 1041 1042 return xcb_buffer_len; 1043} 1044 1045xcb_void_cookie_t 1046xcb_selinux_set_property_create_context_checked (xcb_connection_t *c, 1047 uint32_t context_len, 1048 const char *context) 1049{ 1050 static const xcb_protocol_request_t xcb_req = { 1051 .count = 4, 1052 .ext = &xcb_selinux_id, 1053 .opcode = XCB_SELINUX_SET_PROPERTY_CREATE_CONTEXT, 1054 .isvoid = 1 1055 }; 1056 1057 struct iovec xcb_parts[6]; 1058 xcb_void_cookie_t xcb_ret; 1059 xcb_selinux_set_property_create_context_request_t xcb_out; 1060 1061 xcb_out.context_len = context_len; 1062 1063 xcb_parts[2].iov_base = (char *) &xcb_out; 1064 xcb_parts[2].iov_len = sizeof(xcb_out); 1065 xcb_parts[3].iov_base = 0; 1066 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1067 /* char context */ 1068 xcb_parts[4].iov_base = (char *) context; 1069 xcb_parts[4].iov_len = context_len * sizeof(char); 1070 xcb_parts[5].iov_base = 0; 1071 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 1072 1073 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 1074 return xcb_ret; 1075} 1076 1077xcb_void_cookie_t 1078xcb_selinux_set_property_create_context (xcb_connection_t *c, 1079 uint32_t context_len, 1080 const char *context) 1081{ 1082 static const xcb_protocol_request_t xcb_req = { 1083 .count = 4, 1084 .ext = &xcb_selinux_id, 1085 .opcode = XCB_SELINUX_SET_PROPERTY_CREATE_CONTEXT, 1086 .isvoid = 1 1087 }; 1088 1089 struct iovec xcb_parts[6]; 1090 xcb_void_cookie_t xcb_ret; 1091 xcb_selinux_set_property_create_context_request_t xcb_out; 1092 1093 xcb_out.context_len = context_len; 1094 1095 xcb_parts[2].iov_base = (char *) &xcb_out; 1096 xcb_parts[2].iov_len = sizeof(xcb_out); 1097 xcb_parts[3].iov_base = 0; 1098 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1099 /* char context */ 1100 xcb_parts[4].iov_base = (char *) context; 1101 xcb_parts[4].iov_len = context_len * sizeof(char); 1102 xcb_parts[5].iov_base = 0; 1103 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 1104 1105 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 1106 return xcb_ret; 1107} 1108 1109char * 1110xcb_selinux_set_property_create_context_context (const xcb_selinux_set_property_create_context_request_t *R) 1111{ 1112 return (char *) (R + 1); 1113} 1114 1115int 1116xcb_selinux_set_property_create_context_context_length (const xcb_selinux_set_property_create_context_request_t *R) 1117{ 1118 return R->context_len; 1119} 1120 1121xcb_generic_iterator_t 1122xcb_selinux_set_property_create_context_context_end (const xcb_selinux_set_property_create_context_request_t *R) 1123{ 1124 xcb_generic_iterator_t i; 1125 i.data = ((char *) (R + 1)) + (R->context_len); 1126 i.rem = 0; 1127 i.index = (char *) i.data - (char *) R; 1128 return i; 1129} 1130 1131int 1132xcb_selinux_get_property_create_context_sizeof (const void *_buffer) 1133{ 1134 char *xcb_tmp = (char *)_buffer; 1135 const xcb_selinux_get_property_create_context_reply_t *_aux = (xcb_selinux_get_property_create_context_reply_t *)_buffer; 1136 unsigned int xcb_buffer_len = 0; 1137 unsigned int xcb_block_len = 0; 1138 unsigned int xcb_pad = 0; 1139 unsigned int xcb_align_to = 0; 1140 1141 1142 xcb_block_len += sizeof(xcb_selinux_get_property_create_context_reply_t); 1143 xcb_tmp += xcb_block_len; 1144 xcb_buffer_len += xcb_block_len; 1145 xcb_block_len = 0; 1146 /* context */ 1147 xcb_block_len += _aux->context_len * sizeof(char); 1148 xcb_tmp += xcb_block_len; 1149 xcb_align_to = ALIGNOF(char); 1150 /* insert padding */ 1151 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 1152 xcb_buffer_len += xcb_block_len + xcb_pad; 1153 if (0 != xcb_pad) { 1154 xcb_tmp += xcb_pad; 1155 xcb_pad = 0; 1156 } 1157 xcb_block_len = 0; 1158 1159 return xcb_buffer_len; 1160} 1161 1162xcb_selinux_get_property_create_context_cookie_t 1163xcb_selinux_get_property_create_context (xcb_connection_t *c) 1164{ 1165 static const xcb_protocol_request_t xcb_req = { 1166 .count = 2, 1167 .ext = &xcb_selinux_id, 1168 .opcode = XCB_SELINUX_GET_PROPERTY_CREATE_CONTEXT, 1169 .isvoid = 0 1170 }; 1171 1172 struct iovec xcb_parts[4]; 1173 xcb_selinux_get_property_create_context_cookie_t xcb_ret; 1174 xcb_selinux_get_property_create_context_request_t xcb_out; 1175 1176 1177 xcb_parts[2].iov_base = (char *) &xcb_out; 1178 xcb_parts[2].iov_len = sizeof(xcb_out); 1179 xcb_parts[3].iov_base = 0; 1180 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1181 1182 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 1183 return xcb_ret; 1184} 1185 1186xcb_selinux_get_property_create_context_cookie_t 1187xcb_selinux_get_property_create_context_unchecked (xcb_connection_t *c) 1188{ 1189 static const xcb_protocol_request_t xcb_req = { 1190 .count = 2, 1191 .ext = &xcb_selinux_id, 1192 .opcode = XCB_SELINUX_GET_PROPERTY_CREATE_CONTEXT, 1193 .isvoid = 0 1194 }; 1195 1196 struct iovec xcb_parts[4]; 1197 xcb_selinux_get_property_create_context_cookie_t xcb_ret; 1198 xcb_selinux_get_property_create_context_request_t xcb_out; 1199 1200 1201 xcb_parts[2].iov_base = (char *) &xcb_out; 1202 xcb_parts[2].iov_len = sizeof(xcb_out); 1203 xcb_parts[3].iov_base = 0; 1204 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1205 1206 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 1207 return xcb_ret; 1208} 1209 1210char * 1211xcb_selinux_get_property_create_context_context (const xcb_selinux_get_property_create_context_reply_t *R) 1212{ 1213 return (char *) (R + 1); 1214} 1215 1216int 1217xcb_selinux_get_property_create_context_context_length (const xcb_selinux_get_property_create_context_reply_t *R) 1218{ 1219 return R->context_len; 1220} 1221 1222xcb_generic_iterator_t 1223xcb_selinux_get_property_create_context_context_end (const xcb_selinux_get_property_create_context_reply_t *R) 1224{ 1225 xcb_generic_iterator_t i; 1226 i.data = ((char *) (R + 1)) + (R->context_len); 1227 i.rem = 0; 1228 i.index = (char *) i.data - (char *) R; 1229 return i; 1230} 1231 1232xcb_selinux_get_property_create_context_reply_t * 1233xcb_selinux_get_property_create_context_reply (xcb_connection_t *c, 1234 xcb_selinux_get_property_create_context_cookie_t cookie /**< */, 1235 xcb_generic_error_t **e) 1236{ 1237 return (xcb_selinux_get_property_create_context_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 1238} 1239 1240int 1241xcb_selinux_set_property_use_context_sizeof (const void *_buffer) 1242{ 1243 char *xcb_tmp = (char *)_buffer; 1244 const xcb_selinux_set_property_use_context_request_t *_aux = (xcb_selinux_set_property_use_context_request_t *)_buffer; 1245 unsigned int xcb_buffer_len = 0; 1246 unsigned int xcb_block_len = 0; 1247 unsigned int xcb_pad = 0; 1248 unsigned int xcb_align_to = 0; 1249 1250 1251 xcb_block_len += sizeof(xcb_selinux_set_property_use_context_request_t); 1252 xcb_tmp += xcb_block_len; 1253 xcb_buffer_len += xcb_block_len; 1254 xcb_block_len = 0; 1255 /* context */ 1256 xcb_block_len += _aux->context_len * sizeof(char); 1257 xcb_tmp += xcb_block_len; 1258 xcb_align_to = ALIGNOF(char); 1259 /* insert padding */ 1260 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 1261 xcb_buffer_len += xcb_block_len + xcb_pad; 1262 if (0 != xcb_pad) { 1263 xcb_tmp += xcb_pad; 1264 xcb_pad = 0; 1265 } 1266 xcb_block_len = 0; 1267 1268 return xcb_buffer_len; 1269} 1270 1271xcb_void_cookie_t 1272xcb_selinux_set_property_use_context_checked (xcb_connection_t *c, 1273 uint32_t context_len, 1274 const char *context) 1275{ 1276 static const xcb_protocol_request_t xcb_req = { 1277 .count = 4, 1278 .ext = &xcb_selinux_id, 1279 .opcode = XCB_SELINUX_SET_PROPERTY_USE_CONTEXT, 1280 .isvoid = 1 1281 }; 1282 1283 struct iovec xcb_parts[6]; 1284 xcb_void_cookie_t xcb_ret; 1285 xcb_selinux_set_property_use_context_request_t xcb_out; 1286 1287 xcb_out.context_len = context_len; 1288 1289 xcb_parts[2].iov_base = (char *) &xcb_out; 1290 xcb_parts[2].iov_len = sizeof(xcb_out); 1291 xcb_parts[3].iov_base = 0; 1292 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1293 /* char context */ 1294 xcb_parts[4].iov_base = (char *) context; 1295 xcb_parts[4].iov_len = context_len * sizeof(char); 1296 xcb_parts[5].iov_base = 0; 1297 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 1298 1299 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 1300 return xcb_ret; 1301} 1302 1303xcb_void_cookie_t 1304xcb_selinux_set_property_use_context (xcb_connection_t *c, 1305 uint32_t context_len, 1306 const char *context) 1307{ 1308 static const xcb_protocol_request_t xcb_req = { 1309 .count = 4, 1310 .ext = &xcb_selinux_id, 1311 .opcode = XCB_SELINUX_SET_PROPERTY_USE_CONTEXT, 1312 .isvoid = 1 1313 }; 1314 1315 struct iovec xcb_parts[6]; 1316 xcb_void_cookie_t xcb_ret; 1317 xcb_selinux_set_property_use_context_request_t xcb_out; 1318 1319 xcb_out.context_len = context_len; 1320 1321 xcb_parts[2].iov_base = (char *) &xcb_out; 1322 xcb_parts[2].iov_len = sizeof(xcb_out); 1323 xcb_parts[3].iov_base = 0; 1324 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1325 /* char context */ 1326 xcb_parts[4].iov_base = (char *) context; 1327 xcb_parts[4].iov_len = context_len * sizeof(char); 1328 xcb_parts[5].iov_base = 0; 1329 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 1330 1331 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 1332 return xcb_ret; 1333} 1334 1335char * 1336xcb_selinux_set_property_use_context_context (const xcb_selinux_set_property_use_context_request_t *R) 1337{ 1338 return (char *) (R + 1); 1339} 1340 1341int 1342xcb_selinux_set_property_use_context_context_length (const xcb_selinux_set_property_use_context_request_t *R) 1343{ 1344 return R->context_len; 1345} 1346 1347xcb_generic_iterator_t 1348xcb_selinux_set_property_use_context_context_end (const xcb_selinux_set_property_use_context_request_t *R) 1349{ 1350 xcb_generic_iterator_t i; 1351 i.data = ((char *) (R + 1)) + (R->context_len); 1352 i.rem = 0; 1353 i.index = (char *) i.data - (char *) R; 1354 return i; 1355} 1356 1357int 1358xcb_selinux_get_property_use_context_sizeof (const void *_buffer) 1359{ 1360 char *xcb_tmp = (char *)_buffer; 1361 const xcb_selinux_get_property_use_context_reply_t *_aux = (xcb_selinux_get_property_use_context_reply_t *)_buffer; 1362 unsigned int xcb_buffer_len = 0; 1363 unsigned int xcb_block_len = 0; 1364 unsigned int xcb_pad = 0; 1365 unsigned int xcb_align_to = 0; 1366 1367 1368 xcb_block_len += sizeof(xcb_selinux_get_property_use_context_reply_t); 1369 xcb_tmp += xcb_block_len; 1370 xcb_buffer_len += xcb_block_len; 1371 xcb_block_len = 0; 1372 /* context */ 1373 xcb_block_len += _aux->context_len * sizeof(char); 1374 xcb_tmp += xcb_block_len; 1375 xcb_align_to = ALIGNOF(char); 1376 /* insert padding */ 1377 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 1378 xcb_buffer_len += xcb_block_len + xcb_pad; 1379 if (0 != xcb_pad) { 1380 xcb_tmp += xcb_pad; 1381 xcb_pad = 0; 1382 } 1383 xcb_block_len = 0; 1384 1385 return xcb_buffer_len; 1386} 1387 1388xcb_selinux_get_property_use_context_cookie_t 1389xcb_selinux_get_property_use_context (xcb_connection_t *c) 1390{ 1391 static const xcb_protocol_request_t xcb_req = { 1392 .count = 2, 1393 .ext = &xcb_selinux_id, 1394 .opcode = XCB_SELINUX_GET_PROPERTY_USE_CONTEXT, 1395 .isvoid = 0 1396 }; 1397 1398 struct iovec xcb_parts[4]; 1399 xcb_selinux_get_property_use_context_cookie_t xcb_ret; 1400 xcb_selinux_get_property_use_context_request_t xcb_out; 1401 1402 1403 xcb_parts[2].iov_base = (char *) &xcb_out; 1404 xcb_parts[2].iov_len = sizeof(xcb_out); 1405 xcb_parts[3].iov_base = 0; 1406 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1407 1408 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 1409 return xcb_ret; 1410} 1411 1412xcb_selinux_get_property_use_context_cookie_t 1413xcb_selinux_get_property_use_context_unchecked (xcb_connection_t *c) 1414{ 1415 static const xcb_protocol_request_t xcb_req = { 1416 .count = 2, 1417 .ext = &xcb_selinux_id, 1418 .opcode = XCB_SELINUX_GET_PROPERTY_USE_CONTEXT, 1419 .isvoid = 0 1420 }; 1421 1422 struct iovec xcb_parts[4]; 1423 xcb_selinux_get_property_use_context_cookie_t xcb_ret; 1424 xcb_selinux_get_property_use_context_request_t xcb_out; 1425 1426 1427 xcb_parts[2].iov_base = (char *) &xcb_out; 1428 xcb_parts[2].iov_len = sizeof(xcb_out); 1429 xcb_parts[3].iov_base = 0; 1430 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1431 1432 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 1433 return xcb_ret; 1434} 1435 1436char * 1437xcb_selinux_get_property_use_context_context (const xcb_selinux_get_property_use_context_reply_t *R) 1438{ 1439 return (char *) (R + 1); 1440} 1441 1442int 1443xcb_selinux_get_property_use_context_context_length (const xcb_selinux_get_property_use_context_reply_t *R) 1444{ 1445 return R->context_len; 1446} 1447 1448xcb_generic_iterator_t 1449xcb_selinux_get_property_use_context_context_end (const xcb_selinux_get_property_use_context_reply_t *R) 1450{ 1451 xcb_generic_iterator_t i; 1452 i.data = ((char *) (R + 1)) + (R->context_len); 1453 i.rem = 0; 1454 i.index = (char *) i.data - (char *) R; 1455 return i; 1456} 1457 1458xcb_selinux_get_property_use_context_reply_t * 1459xcb_selinux_get_property_use_context_reply (xcb_connection_t *c, 1460 xcb_selinux_get_property_use_context_cookie_t cookie /**< */, 1461 xcb_generic_error_t **e) 1462{ 1463 return (xcb_selinux_get_property_use_context_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 1464} 1465 1466int 1467xcb_selinux_get_property_context_sizeof (const void *_buffer) 1468{ 1469 char *xcb_tmp = (char *)_buffer; 1470 const xcb_selinux_get_property_context_reply_t *_aux = (xcb_selinux_get_property_context_reply_t *)_buffer; 1471 unsigned int xcb_buffer_len = 0; 1472 unsigned int xcb_block_len = 0; 1473 unsigned int xcb_pad = 0; 1474 unsigned int xcb_align_to = 0; 1475 1476 1477 xcb_block_len += sizeof(xcb_selinux_get_property_context_reply_t); 1478 xcb_tmp += xcb_block_len; 1479 xcb_buffer_len += xcb_block_len; 1480 xcb_block_len = 0; 1481 /* context */ 1482 xcb_block_len += _aux->context_len * sizeof(char); 1483 xcb_tmp += xcb_block_len; 1484 xcb_align_to = ALIGNOF(char); 1485 /* insert padding */ 1486 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 1487 xcb_buffer_len += xcb_block_len + xcb_pad; 1488 if (0 != xcb_pad) { 1489 xcb_tmp += xcb_pad; 1490 xcb_pad = 0; 1491 } 1492 xcb_block_len = 0; 1493 1494 return xcb_buffer_len; 1495} 1496 1497xcb_selinux_get_property_context_cookie_t 1498xcb_selinux_get_property_context (xcb_connection_t *c, 1499 xcb_window_t window, 1500 xcb_atom_t property) 1501{ 1502 static const xcb_protocol_request_t xcb_req = { 1503 .count = 2, 1504 .ext = &xcb_selinux_id, 1505 .opcode = XCB_SELINUX_GET_PROPERTY_CONTEXT, 1506 .isvoid = 0 1507 }; 1508 1509 struct iovec xcb_parts[4]; 1510 xcb_selinux_get_property_context_cookie_t xcb_ret; 1511 xcb_selinux_get_property_context_request_t xcb_out; 1512 1513 xcb_out.window = window; 1514 xcb_out.property = property; 1515 1516 xcb_parts[2].iov_base = (char *) &xcb_out; 1517 xcb_parts[2].iov_len = sizeof(xcb_out); 1518 xcb_parts[3].iov_base = 0; 1519 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1520 1521 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 1522 return xcb_ret; 1523} 1524 1525xcb_selinux_get_property_context_cookie_t 1526xcb_selinux_get_property_context_unchecked (xcb_connection_t *c, 1527 xcb_window_t window, 1528 xcb_atom_t property) 1529{ 1530 static const xcb_protocol_request_t xcb_req = { 1531 .count = 2, 1532 .ext = &xcb_selinux_id, 1533 .opcode = XCB_SELINUX_GET_PROPERTY_CONTEXT, 1534 .isvoid = 0 1535 }; 1536 1537 struct iovec xcb_parts[4]; 1538 xcb_selinux_get_property_context_cookie_t xcb_ret; 1539 xcb_selinux_get_property_context_request_t xcb_out; 1540 1541 xcb_out.window = window; 1542 xcb_out.property = property; 1543 1544 xcb_parts[2].iov_base = (char *) &xcb_out; 1545 xcb_parts[2].iov_len = sizeof(xcb_out); 1546 xcb_parts[3].iov_base = 0; 1547 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1548 1549 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 1550 return xcb_ret; 1551} 1552 1553char * 1554xcb_selinux_get_property_context_context (const xcb_selinux_get_property_context_reply_t *R) 1555{ 1556 return (char *) (R + 1); 1557} 1558 1559int 1560xcb_selinux_get_property_context_context_length (const xcb_selinux_get_property_context_reply_t *R) 1561{ 1562 return R->context_len; 1563} 1564 1565xcb_generic_iterator_t 1566xcb_selinux_get_property_context_context_end (const xcb_selinux_get_property_context_reply_t *R) 1567{ 1568 xcb_generic_iterator_t i; 1569 i.data = ((char *) (R + 1)) + (R->context_len); 1570 i.rem = 0; 1571 i.index = (char *) i.data - (char *) R; 1572 return i; 1573} 1574 1575xcb_selinux_get_property_context_reply_t * 1576xcb_selinux_get_property_context_reply (xcb_connection_t *c, 1577 xcb_selinux_get_property_context_cookie_t cookie /**< */, 1578 xcb_generic_error_t **e) 1579{ 1580 return (xcb_selinux_get_property_context_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 1581} 1582 1583int 1584xcb_selinux_get_property_data_context_sizeof (const void *_buffer) 1585{ 1586 char *xcb_tmp = (char *)_buffer; 1587 const xcb_selinux_get_property_data_context_reply_t *_aux = (xcb_selinux_get_property_data_context_reply_t *)_buffer; 1588 unsigned int xcb_buffer_len = 0; 1589 unsigned int xcb_block_len = 0; 1590 unsigned int xcb_pad = 0; 1591 unsigned int xcb_align_to = 0; 1592 1593 1594 xcb_block_len += sizeof(xcb_selinux_get_property_data_context_reply_t); 1595 xcb_tmp += xcb_block_len; 1596 xcb_buffer_len += xcb_block_len; 1597 xcb_block_len = 0; 1598 /* context */ 1599 xcb_block_len += _aux->context_len * sizeof(char); 1600 xcb_tmp += xcb_block_len; 1601 xcb_align_to = ALIGNOF(char); 1602 /* insert padding */ 1603 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 1604 xcb_buffer_len += xcb_block_len + xcb_pad; 1605 if (0 != xcb_pad) { 1606 xcb_tmp += xcb_pad; 1607 xcb_pad = 0; 1608 } 1609 xcb_block_len = 0; 1610 1611 return xcb_buffer_len; 1612} 1613 1614xcb_selinux_get_property_data_context_cookie_t 1615xcb_selinux_get_property_data_context (xcb_connection_t *c, 1616 xcb_window_t window, 1617 xcb_atom_t property) 1618{ 1619 static const xcb_protocol_request_t xcb_req = { 1620 .count = 2, 1621 .ext = &xcb_selinux_id, 1622 .opcode = XCB_SELINUX_GET_PROPERTY_DATA_CONTEXT, 1623 .isvoid = 0 1624 }; 1625 1626 struct iovec xcb_parts[4]; 1627 xcb_selinux_get_property_data_context_cookie_t xcb_ret; 1628 xcb_selinux_get_property_data_context_request_t xcb_out; 1629 1630 xcb_out.window = window; 1631 xcb_out.property = property; 1632 1633 xcb_parts[2].iov_base = (char *) &xcb_out; 1634 xcb_parts[2].iov_len = sizeof(xcb_out); 1635 xcb_parts[3].iov_base = 0; 1636 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1637 1638 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 1639 return xcb_ret; 1640} 1641 1642xcb_selinux_get_property_data_context_cookie_t 1643xcb_selinux_get_property_data_context_unchecked (xcb_connection_t *c, 1644 xcb_window_t window, 1645 xcb_atom_t property) 1646{ 1647 static const xcb_protocol_request_t xcb_req = { 1648 .count = 2, 1649 .ext = &xcb_selinux_id, 1650 .opcode = XCB_SELINUX_GET_PROPERTY_DATA_CONTEXT, 1651 .isvoid = 0 1652 }; 1653 1654 struct iovec xcb_parts[4]; 1655 xcb_selinux_get_property_data_context_cookie_t xcb_ret; 1656 xcb_selinux_get_property_data_context_request_t xcb_out; 1657 1658 xcb_out.window = window; 1659 xcb_out.property = property; 1660 1661 xcb_parts[2].iov_base = (char *) &xcb_out; 1662 xcb_parts[2].iov_len = sizeof(xcb_out); 1663 xcb_parts[3].iov_base = 0; 1664 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1665 1666 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 1667 return xcb_ret; 1668} 1669 1670char * 1671xcb_selinux_get_property_data_context_context (const xcb_selinux_get_property_data_context_reply_t *R) 1672{ 1673 return (char *) (R + 1); 1674} 1675 1676int 1677xcb_selinux_get_property_data_context_context_length (const xcb_selinux_get_property_data_context_reply_t *R) 1678{ 1679 return R->context_len; 1680} 1681 1682xcb_generic_iterator_t 1683xcb_selinux_get_property_data_context_context_end (const xcb_selinux_get_property_data_context_reply_t *R) 1684{ 1685 xcb_generic_iterator_t i; 1686 i.data = ((char *) (R + 1)) + (R->context_len); 1687 i.rem = 0; 1688 i.index = (char *) i.data - (char *) R; 1689 return i; 1690} 1691 1692xcb_selinux_get_property_data_context_reply_t * 1693xcb_selinux_get_property_data_context_reply (xcb_connection_t *c, 1694 xcb_selinux_get_property_data_context_cookie_t cookie /**< */, 1695 xcb_generic_error_t **e) 1696{ 1697 return (xcb_selinux_get_property_data_context_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 1698} 1699 1700int 1701xcb_selinux_list_properties_sizeof (const void *_buffer) 1702{ 1703 char *xcb_tmp = (char *)_buffer; 1704 const xcb_selinux_list_properties_reply_t *_aux = (xcb_selinux_list_properties_reply_t *)_buffer; 1705 unsigned int xcb_buffer_len = 0; 1706 unsigned int xcb_block_len = 0; 1707 unsigned int xcb_pad = 0; 1708 unsigned int xcb_align_to = 0; 1709 1710 unsigned int i; 1711 unsigned int xcb_tmp_len; 1712 1713 xcb_block_len += sizeof(xcb_selinux_list_properties_reply_t); 1714 xcb_tmp += xcb_block_len; 1715 xcb_buffer_len += xcb_block_len; 1716 xcb_block_len = 0; 1717 /* properties */ 1718 for(i=0; i<_aux->properties_len; i++) { 1719 xcb_tmp_len = xcb_selinux_list_item_sizeof(xcb_tmp); 1720 xcb_block_len += xcb_tmp_len; 1721 xcb_tmp += xcb_tmp_len; 1722 } 1723 xcb_align_to = ALIGNOF(xcb_selinux_list_item_t); 1724 /* insert padding */ 1725 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 1726 xcb_buffer_len += xcb_block_len + xcb_pad; 1727 if (0 != xcb_pad) { 1728 xcb_tmp += xcb_pad; 1729 xcb_pad = 0; 1730 } 1731 xcb_block_len = 0; 1732 1733 return xcb_buffer_len; 1734} 1735 1736xcb_selinux_list_properties_cookie_t 1737xcb_selinux_list_properties (xcb_connection_t *c, 1738 xcb_window_t window) 1739{ 1740 static const xcb_protocol_request_t xcb_req = { 1741 .count = 2, 1742 .ext = &xcb_selinux_id, 1743 .opcode = XCB_SELINUX_LIST_PROPERTIES, 1744 .isvoid = 0 1745 }; 1746 1747 struct iovec xcb_parts[4]; 1748 xcb_selinux_list_properties_cookie_t xcb_ret; 1749 xcb_selinux_list_properties_request_t xcb_out; 1750 1751 xcb_out.window = window; 1752 1753 xcb_parts[2].iov_base = (char *) &xcb_out; 1754 xcb_parts[2].iov_len = sizeof(xcb_out); 1755 xcb_parts[3].iov_base = 0; 1756 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1757 1758 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 1759 return xcb_ret; 1760} 1761 1762xcb_selinux_list_properties_cookie_t 1763xcb_selinux_list_properties_unchecked (xcb_connection_t *c, 1764 xcb_window_t window) 1765{ 1766 static const xcb_protocol_request_t xcb_req = { 1767 .count = 2, 1768 .ext = &xcb_selinux_id, 1769 .opcode = XCB_SELINUX_LIST_PROPERTIES, 1770 .isvoid = 0 1771 }; 1772 1773 struct iovec xcb_parts[4]; 1774 xcb_selinux_list_properties_cookie_t xcb_ret; 1775 xcb_selinux_list_properties_request_t xcb_out; 1776 1777 xcb_out.window = window; 1778 1779 xcb_parts[2].iov_base = (char *) &xcb_out; 1780 xcb_parts[2].iov_len = sizeof(xcb_out); 1781 xcb_parts[3].iov_base = 0; 1782 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1783 1784 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 1785 return xcb_ret; 1786} 1787 1788int 1789xcb_selinux_list_properties_properties_length (const xcb_selinux_list_properties_reply_t *R) 1790{ 1791 return R->properties_len; 1792} 1793 1794xcb_selinux_list_item_iterator_t 1795xcb_selinux_list_properties_properties_iterator (const xcb_selinux_list_properties_reply_t *R) 1796{ 1797 xcb_selinux_list_item_iterator_t i; 1798 i.data = (xcb_selinux_list_item_t *) (R + 1); 1799 i.rem = R->properties_len; 1800 i.index = (char *) i.data - (char *) R; 1801 return i; 1802} 1803 1804xcb_selinux_list_properties_reply_t * 1805xcb_selinux_list_properties_reply (xcb_connection_t *c, 1806 xcb_selinux_list_properties_cookie_t cookie /**< */, 1807 xcb_generic_error_t **e) 1808{ 1809 return (xcb_selinux_list_properties_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 1810} 1811 1812int 1813xcb_selinux_set_selection_create_context_sizeof (const void *_buffer) 1814{ 1815 char *xcb_tmp = (char *)_buffer; 1816 const xcb_selinux_set_selection_create_context_request_t *_aux = (xcb_selinux_set_selection_create_context_request_t *)_buffer; 1817 unsigned int xcb_buffer_len = 0; 1818 unsigned int xcb_block_len = 0; 1819 unsigned int xcb_pad = 0; 1820 unsigned int xcb_align_to = 0; 1821 1822 1823 xcb_block_len += sizeof(xcb_selinux_set_selection_create_context_request_t); 1824 xcb_tmp += xcb_block_len; 1825 xcb_buffer_len += xcb_block_len; 1826 xcb_block_len = 0; 1827 /* context */ 1828 xcb_block_len += _aux->context_len * sizeof(char); 1829 xcb_tmp += xcb_block_len; 1830 xcb_align_to = ALIGNOF(char); 1831 /* insert padding */ 1832 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 1833 xcb_buffer_len += xcb_block_len + xcb_pad; 1834 if (0 != xcb_pad) { 1835 xcb_tmp += xcb_pad; 1836 xcb_pad = 0; 1837 } 1838 xcb_block_len = 0; 1839 1840 return xcb_buffer_len; 1841} 1842 1843xcb_void_cookie_t 1844xcb_selinux_set_selection_create_context_checked (xcb_connection_t *c, 1845 uint32_t context_len, 1846 const char *context) 1847{ 1848 static const xcb_protocol_request_t xcb_req = { 1849 .count = 4, 1850 .ext = &xcb_selinux_id, 1851 .opcode = XCB_SELINUX_SET_SELECTION_CREATE_CONTEXT, 1852 .isvoid = 1 1853 }; 1854 1855 struct iovec xcb_parts[6]; 1856 xcb_void_cookie_t xcb_ret; 1857 xcb_selinux_set_selection_create_context_request_t xcb_out; 1858 1859 xcb_out.context_len = context_len; 1860 1861 xcb_parts[2].iov_base = (char *) &xcb_out; 1862 xcb_parts[2].iov_len = sizeof(xcb_out); 1863 xcb_parts[3].iov_base = 0; 1864 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1865 /* char context */ 1866 xcb_parts[4].iov_base = (char *) context; 1867 xcb_parts[4].iov_len = context_len * sizeof(char); 1868 xcb_parts[5].iov_base = 0; 1869 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 1870 1871 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 1872 return xcb_ret; 1873} 1874 1875xcb_void_cookie_t 1876xcb_selinux_set_selection_create_context (xcb_connection_t *c, 1877 uint32_t context_len, 1878 const char *context) 1879{ 1880 static const xcb_protocol_request_t xcb_req = { 1881 .count = 4, 1882 .ext = &xcb_selinux_id, 1883 .opcode = XCB_SELINUX_SET_SELECTION_CREATE_CONTEXT, 1884 .isvoid = 1 1885 }; 1886 1887 struct iovec xcb_parts[6]; 1888 xcb_void_cookie_t xcb_ret; 1889 xcb_selinux_set_selection_create_context_request_t xcb_out; 1890 1891 xcb_out.context_len = context_len; 1892 1893 xcb_parts[2].iov_base = (char *) &xcb_out; 1894 xcb_parts[2].iov_len = sizeof(xcb_out); 1895 xcb_parts[3].iov_base = 0; 1896 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1897 /* char context */ 1898 xcb_parts[4].iov_base = (char *) context; 1899 xcb_parts[4].iov_len = context_len * sizeof(char); 1900 xcb_parts[5].iov_base = 0; 1901 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 1902 1903 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 1904 return xcb_ret; 1905} 1906 1907char * 1908xcb_selinux_set_selection_create_context_context (const xcb_selinux_set_selection_create_context_request_t *R) 1909{ 1910 return (char *) (R + 1); 1911} 1912 1913int 1914xcb_selinux_set_selection_create_context_context_length (const xcb_selinux_set_selection_create_context_request_t *R) 1915{ 1916 return R->context_len; 1917} 1918 1919xcb_generic_iterator_t 1920xcb_selinux_set_selection_create_context_context_end (const xcb_selinux_set_selection_create_context_request_t *R) 1921{ 1922 xcb_generic_iterator_t i; 1923 i.data = ((char *) (R + 1)) + (R->context_len); 1924 i.rem = 0; 1925 i.index = (char *) i.data - (char *) R; 1926 return i; 1927} 1928 1929int 1930xcb_selinux_get_selection_create_context_sizeof (const void *_buffer) 1931{ 1932 char *xcb_tmp = (char *)_buffer; 1933 const xcb_selinux_get_selection_create_context_reply_t *_aux = (xcb_selinux_get_selection_create_context_reply_t *)_buffer; 1934 unsigned int xcb_buffer_len = 0; 1935 unsigned int xcb_block_len = 0; 1936 unsigned int xcb_pad = 0; 1937 unsigned int xcb_align_to = 0; 1938 1939 1940 xcb_block_len += sizeof(xcb_selinux_get_selection_create_context_reply_t); 1941 xcb_tmp += xcb_block_len; 1942 xcb_buffer_len += xcb_block_len; 1943 xcb_block_len = 0; 1944 /* context */ 1945 xcb_block_len += _aux->context_len * sizeof(char); 1946 xcb_tmp += xcb_block_len; 1947 xcb_align_to = ALIGNOF(char); 1948 /* insert padding */ 1949 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 1950 xcb_buffer_len += xcb_block_len + xcb_pad; 1951 if (0 != xcb_pad) { 1952 xcb_tmp += xcb_pad; 1953 xcb_pad = 0; 1954 } 1955 xcb_block_len = 0; 1956 1957 return xcb_buffer_len; 1958} 1959 1960xcb_selinux_get_selection_create_context_cookie_t 1961xcb_selinux_get_selection_create_context (xcb_connection_t *c) 1962{ 1963 static const xcb_protocol_request_t xcb_req = { 1964 .count = 2, 1965 .ext = &xcb_selinux_id, 1966 .opcode = XCB_SELINUX_GET_SELECTION_CREATE_CONTEXT, 1967 .isvoid = 0 1968 }; 1969 1970 struct iovec xcb_parts[4]; 1971 xcb_selinux_get_selection_create_context_cookie_t xcb_ret; 1972 xcb_selinux_get_selection_create_context_request_t xcb_out; 1973 1974 1975 xcb_parts[2].iov_base = (char *) &xcb_out; 1976 xcb_parts[2].iov_len = sizeof(xcb_out); 1977 xcb_parts[3].iov_base = 0; 1978 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1979 1980 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 1981 return xcb_ret; 1982} 1983 1984xcb_selinux_get_selection_create_context_cookie_t 1985xcb_selinux_get_selection_create_context_unchecked (xcb_connection_t *c) 1986{ 1987 static const xcb_protocol_request_t xcb_req = { 1988 .count = 2, 1989 .ext = &xcb_selinux_id, 1990 .opcode = XCB_SELINUX_GET_SELECTION_CREATE_CONTEXT, 1991 .isvoid = 0 1992 }; 1993 1994 struct iovec xcb_parts[4]; 1995 xcb_selinux_get_selection_create_context_cookie_t xcb_ret; 1996 xcb_selinux_get_selection_create_context_request_t xcb_out; 1997 1998 1999 xcb_parts[2].iov_base = (char *) &xcb_out; 2000 xcb_parts[2].iov_len = sizeof(xcb_out); 2001 xcb_parts[3].iov_base = 0; 2002 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2003 2004 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 2005 return xcb_ret; 2006} 2007 2008char * 2009xcb_selinux_get_selection_create_context_context (const xcb_selinux_get_selection_create_context_reply_t *R) 2010{ 2011 return (char *) (R + 1); 2012} 2013 2014int 2015xcb_selinux_get_selection_create_context_context_length (const xcb_selinux_get_selection_create_context_reply_t *R) 2016{ 2017 return R->context_len; 2018} 2019 2020xcb_generic_iterator_t 2021xcb_selinux_get_selection_create_context_context_end (const xcb_selinux_get_selection_create_context_reply_t *R) 2022{ 2023 xcb_generic_iterator_t i; 2024 i.data = ((char *) (R + 1)) + (R->context_len); 2025 i.rem = 0; 2026 i.index = (char *) i.data - (char *) R; 2027 return i; 2028} 2029 2030xcb_selinux_get_selection_create_context_reply_t * 2031xcb_selinux_get_selection_create_context_reply (xcb_connection_t *c, 2032 xcb_selinux_get_selection_create_context_cookie_t cookie /**< */, 2033 xcb_generic_error_t **e) 2034{ 2035 return (xcb_selinux_get_selection_create_context_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 2036} 2037 2038int 2039xcb_selinux_set_selection_use_context_sizeof (const void *_buffer) 2040{ 2041 char *xcb_tmp = (char *)_buffer; 2042 const xcb_selinux_set_selection_use_context_request_t *_aux = (xcb_selinux_set_selection_use_context_request_t *)_buffer; 2043 unsigned int xcb_buffer_len = 0; 2044 unsigned int xcb_block_len = 0; 2045 unsigned int xcb_pad = 0; 2046 unsigned int xcb_align_to = 0; 2047 2048 2049 xcb_block_len += sizeof(xcb_selinux_set_selection_use_context_request_t); 2050 xcb_tmp += xcb_block_len; 2051 xcb_buffer_len += xcb_block_len; 2052 xcb_block_len = 0; 2053 /* context */ 2054 xcb_block_len += _aux->context_len * sizeof(char); 2055 xcb_tmp += xcb_block_len; 2056 xcb_align_to = ALIGNOF(char); 2057 /* insert padding */ 2058 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 2059 xcb_buffer_len += xcb_block_len + xcb_pad; 2060 if (0 != xcb_pad) { 2061 xcb_tmp += xcb_pad; 2062 xcb_pad = 0; 2063 } 2064 xcb_block_len = 0; 2065 2066 return xcb_buffer_len; 2067} 2068 2069xcb_void_cookie_t 2070xcb_selinux_set_selection_use_context_checked (xcb_connection_t *c, 2071 uint32_t context_len, 2072 const char *context) 2073{ 2074 static const xcb_protocol_request_t xcb_req = { 2075 .count = 4, 2076 .ext = &xcb_selinux_id, 2077 .opcode = XCB_SELINUX_SET_SELECTION_USE_CONTEXT, 2078 .isvoid = 1 2079 }; 2080 2081 struct iovec xcb_parts[6]; 2082 xcb_void_cookie_t xcb_ret; 2083 xcb_selinux_set_selection_use_context_request_t xcb_out; 2084 2085 xcb_out.context_len = context_len; 2086 2087 xcb_parts[2].iov_base = (char *) &xcb_out; 2088 xcb_parts[2].iov_len = sizeof(xcb_out); 2089 xcb_parts[3].iov_base = 0; 2090 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2091 /* char context */ 2092 xcb_parts[4].iov_base = (char *) context; 2093 xcb_parts[4].iov_len = context_len * sizeof(char); 2094 xcb_parts[5].iov_base = 0; 2095 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 2096 2097 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 2098 return xcb_ret; 2099} 2100 2101xcb_void_cookie_t 2102xcb_selinux_set_selection_use_context (xcb_connection_t *c, 2103 uint32_t context_len, 2104 const char *context) 2105{ 2106 static const xcb_protocol_request_t xcb_req = { 2107 .count = 4, 2108 .ext = &xcb_selinux_id, 2109 .opcode = XCB_SELINUX_SET_SELECTION_USE_CONTEXT, 2110 .isvoid = 1 2111 }; 2112 2113 struct iovec xcb_parts[6]; 2114 xcb_void_cookie_t xcb_ret; 2115 xcb_selinux_set_selection_use_context_request_t xcb_out; 2116 2117 xcb_out.context_len = context_len; 2118 2119 xcb_parts[2].iov_base = (char *) &xcb_out; 2120 xcb_parts[2].iov_len = sizeof(xcb_out); 2121 xcb_parts[3].iov_base = 0; 2122 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2123 /* char context */ 2124 xcb_parts[4].iov_base = (char *) context; 2125 xcb_parts[4].iov_len = context_len * sizeof(char); 2126 xcb_parts[5].iov_base = 0; 2127 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 2128 2129 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 2130 return xcb_ret; 2131} 2132 2133char * 2134xcb_selinux_set_selection_use_context_context (const xcb_selinux_set_selection_use_context_request_t *R) 2135{ 2136 return (char *) (R + 1); 2137} 2138 2139int 2140xcb_selinux_set_selection_use_context_context_length (const xcb_selinux_set_selection_use_context_request_t *R) 2141{ 2142 return R->context_len; 2143} 2144 2145xcb_generic_iterator_t 2146xcb_selinux_set_selection_use_context_context_end (const xcb_selinux_set_selection_use_context_request_t *R) 2147{ 2148 xcb_generic_iterator_t i; 2149 i.data = ((char *) (R + 1)) + (R->context_len); 2150 i.rem = 0; 2151 i.index = (char *) i.data - (char *) R; 2152 return i; 2153} 2154 2155int 2156xcb_selinux_get_selection_use_context_sizeof (const void *_buffer) 2157{ 2158 char *xcb_tmp = (char *)_buffer; 2159 const xcb_selinux_get_selection_use_context_reply_t *_aux = (xcb_selinux_get_selection_use_context_reply_t *)_buffer; 2160 unsigned int xcb_buffer_len = 0; 2161 unsigned int xcb_block_len = 0; 2162 unsigned int xcb_pad = 0; 2163 unsigned int xcb_align_to = 0; 2164 2165 2166 xcb_block_len += sizeof(xcb_selinux_get_selection_use_context_reply_t); 2167 xcb_tmp += xcb_block_len; 2168 xcb_buffer_len += xcb_block_len; 2169 xcb_block_len = 0; 2170 /* context */ 2171 xcb_block_len += _aux->context_len * sizeof(char); 2172 xcb_tmp += xcb_block_len; 2173 xcb_align_to = ALIGNOF(char); 2174 /* insert padding */ 2175 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 2176 xcb_buffer_len += xcb_block_len + xcb_pad; 2177 if (0 != xcb_pad) { 2178 xcb_tmp += xcb_pad; 2179 xcb_pad = 0; 2180 } 2181 xcb_block_len = 0; 2182 2183 return xcb_buffer_len; 2184} 2185 2186xcb_selinux_get_selection_use_context_cookie_t 2187xcb_selinux_get_selection_use_context (xcb_connection_t *c) 2188{ 2189 static const xcb_protocol_request_t xcb_req = { 2190 .count = 2, 2191 .ext = &xcb_selinux_id, 2192 .opcode = XCB_SELINUX_GET_SELECTION_USE_CONTEXT, 2193 .isvoid = 0 2194 }; 2195 2196 struct iovec xcb_parts[4]; 2197 xcb_selinux_get_selection_use_context_cookie_t xcb_ret; 2198 xcb_selinux_get_selection_use_context_request_t xcb_out; 2199 2200 2201 xcb_parts[2].iov_base = (char *) &xcb_out; 2202 xcb_parts[2].iov_len = sizeof(xcb_out); 2203 xcb_parts[3].iov_base = 0; 2204 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2205 2206 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 2207 return xcb_ret; 2208} 2209 2210xcb_selinux_get_selection_use_context_cookie_t 2211xcb_selinux_get_selection_use_context_unchecked (xcb_connection_t *c) 2212{ 2213 static const xcb_protocol_request_t xcb_req = { 2214 .count = 2, 2215 .ext = &xcb_selinux_id, 2216 .opcode = XCB_SELINUX_GET_SELECTION_USE_CONTEXT, 2217 .isvoid = 0 2218 }; 2219 2220 struct iovec xcb_parts[4]; 2221 xcb_selinux_get_selection_use_context_cookie_t xcb_ret; 2222 xcb_selinux_get_selection_use_context_request_t xcb_out; 2223 2224 2225 xcb_parts[2].iov_base = (char *) &xcb_out; 2226 xcb_parts[2].iov_len = sizeof(xcb_out); 2227 xcb_parts[3].iov_base = 0; 2228 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2229 2230 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 2231 return xcb_ret; 2232} 2233 2234char * 2235xcb_selinux_get_selection_use_context_context (const xcb_selinux_get_selection_use_context_reply_t *R) 2236{ 2237 return (char *) (R + 1); 2238} 2239 2240int 2241xcb_selinux_get_selection_use_context_context_length (const xcb_selinux_get_selection_use_context_reply_t *R) 2242{ 2243 return R->context_len; 2244} 2245 2246xcb_generic_iterator_t 2247xcb_selinux_get_selection_use_context_context_end (const xcb_selinux_get_selection_use_context_reply_t *R) 2248{ 2249 xcb_generic_iterator_t i; 2250 i.data = ((char *) (R + 1)) + (R->context_len); 2251 i.rem = 0; 2252 i.index = (char *) i.data - (char *) R; 2253 return i; 2254} 2255 2256xcb_selinux_get_selection_use_context_reply_t * 2257xcb_selinux_get_selection_use_context_reply (xcb_connection_t *c, 2258 xcb_selinux_get_selection_use_context_cookie_t cookie /**< */, 2259 xcb_generic_error_t **e) 2260{ 2261 return (xcb_selinux_get_selection_use_context_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 2262} 2263 2264int 2265xcb_selinux_get_selection_context_sizeof (const void *_buffer) 2266{ 2267 char *xcb_tmp = (char *)_buffer; 2268 const xcb_selinux_get_selection_context_reply_t *_aux = (xcb_selinux_get_selection_context_reply_t *)_buffer; 2269 unsigned int xcb_buffer_len = 0; 2270 unsigned int xcb_block_len = 0; 2271 unsigned int xcb_pad = 0; 2272 unsigned int xcb_align_to = 0; 2273 2274 2275 xcb_block_len += sizeof(xcb_selinux_get_selection_context_reply_t); 2276 xcb_tmp += xcb_block_len; 2277 xcb_buffer_len += xcb_block_len; 2278 xcb_block_len = 0; 2279 /* context */ 2280 xcb_block_len += _aux->context_len * sizeof(char); 2281 xcb_tmp += xcb_block_len; 2282 xcb_align_to = ALIGNOF(char); 2283 /* insert padding */ 2284 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 2285 xcb_buffer_len += xcb_block_len + xcb_pad; 2286 if (0 != xcb_pad) { 2287 xcb_tmp += xcb_pad; 2288 xcb_pad = 0; 2289 } 2290 xcb_block_len = 0; 2291 2292 return xcb_buffer_len; 2293} 2294 2295xcb_selinux_get_selection_context_cookie_t 2296xcb_selinux_get_selection_context (xcb_connection_t *c, 2297 xcb_atom_t selection) 2298{ 2299 static const xcb_protocol_request_t xcb_req = { 2300 .count = 2, 2301 .ext = &xcb_selinux_id, 2302 .opcode = XCB_SELINUX_GET_SELECTION_CONTEXT, 2303 .isvoid = 0 2304 }; 2305 2306 struct iovec xcb_parts[4]; 2307 xcb_selinux_get_selection_context_cookie_t xcb_ret; 2308 xcb_selinux_get_selection_context_request_t xcb_out; 2309 2310 xcb_out.selection = selection; 2311 2312 xcb_parts[2].iov_base = (char *) &xcb_out; 2313 xcb_parts[2].iov_len = sizeof(xcb_out); 2314 xcb_parts[3].iov_base = 0; 2315 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2316 2317 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 2318 return xcb_ret; 2319} 2320 2321xcb_selinux_get_selection_context_cookie_t 2322xcb_selinux_get_selection_context_unchecked (xcb_connection_t *c, 2323 xcb_atom_t selection) 2324{ 2325 static const xcb_protocol_request_t xcb_req = { 2326 .count = 2, 2327 .ext = &xcb_selinux_id, 2328 .opcode = XCB_SELINUX_GET_SELECTION_CONTEXT, 2329 .isvoid = 0 2330 }; 2331 2332 struct iovec xcb_parts[4]; 2333 xcb_selinux_get_selection_context_cookie_t xcb_ret; 2334 xcb_selinux_get_selection_context_request_t xcb_out; 2335 2336 xcb_out.selection = selection; 2337 2338 xcb_parts[2].iov_base = (char *) &xcb_out; 2339 xcb_parts[2].iov_len = sizeof(xcb_out); 2340 xcb_parts[3].iov_base = 0; 2341 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2342 2343 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 2344 return xcb_ret; 2345} 2346 2347char * 2348xcb_selinux_get_selection_context_context (const xcb_selinux_get_selection_context_reply_t *R) 2349{ 2350 return (char *) (R + 1); 2351} 2352 2353int 2354xcb_selinux_get_selection_context_context_length (const xcb_selinux_get_selection_context_reply_t *R) 2355{ 2356 return R->context_len; 2357} 2358 2359xcb_generic_iterator_t 2360xcb_selinux_get_selection_context_context_end (const xcb_selinux_get_selection_context_reply_t *R) 2361{ 2362 xcb_generic_iterator_t i; 2363 i.data = ((char *) (R + 1)) + (R->context_len); 2364 i.rem = 0; 2365 i.index = (char *) i.data - (char *) R; 2366 return i; 2367} 2368 2369xcb_selinux_get_selection_context_reply_t * 2370xcb_selinux_get_selection_context_reply (xcb_connection_t *c, 2371 xcb_selinux_get_selection_context_cookie_t cookie /**< */, 2372 xcb_generic_error_t **e) 2373{ 2374 return (xcb_selinux_get_selection_context_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 2375} 2376 2377int 2378xcb_selinux_get_selection_data_context_sizeof (const void *_buffer) 2379{ 2380 char *xcb_tmp = (char *)_buffer; 2381 const xcb_selinux_get_selection_data_context_reply_t *_aux = (xcb_selinux_get_selection_data_context_reply_t *)_buffer; 2382 unsigned int xcb_buffer_len = 0; 2383 unsigned int xcb_block_len = 0; 2384 unsigned int xcb_pad = 0; 2385 unsigned int xcb_align_to = 0; 2386 2387 2388 xcb_block_len += sizeof(xcb_selinux_get_selection_data_context_reply_t); 2389 xcb_tmp += xcb_block_len; 2390 xcb_buffer_len += xcb_block_len; 2391 xcb_block_len = 0; 2392 /* context */ 2393 xcb_block_len += _aux->context_len * sizeof(char); 2394 xcb_tmp += xcb_block_len; 2395 xcb_align_to = ALIGNOF(char); 2396 /* insert padding */ 2397 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 2398 xcb_buffer_len += xcb_block_len + xcb_pad; 2399 if (0 != xcb_pad) { 2400 xcb_tmp += xcb_pad; 2401 xcb_pad = 0; 2402 } 2403 xcb_block_len = 0; 2404 2405 return xcb_buffer_len; 2406} 2407 2408xcb_selinux_get_selection_data_context_cookie_t 2409xcb_selinux_get_selection_data_context (xcb_connection_t *c, 2410 xcb_atom_t selection) 2411{ 2412 static const xcb_protocol_request_t xcb_req = { 2413 .count = 2, 2414 .ext = &xcb_selinux_id, 2415 .opcode = XCB_SELINUX_GET_SELECTION_DATA_CONTEXT, 2416 .isvoid = 0 2417 }; 2418 2419 struct iovec xcb_parts[4]; 2420 xcb_selinux_get_selection_data_context_cookie_t xcb_ret; 2421 xcb_selinux_get_selection_data_context_request_t xcb_out; 2422 2423 xcb_out.selection = selection; 2424 2425 xcb_parts[2].iov_base = (char *) &xcb_out; 2426 xcb_parts[2].iov_len = sizeof(xcb_out); 2427 xcb_parts[3].iov_base = 0; 2428 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2429 2430 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 2431 return xcb_ret; 2432} 2433 2434xcb_selinux_get_selection_data_context_cookie_t 2435xcb_selinux_get_selection_data_context_unchecked (xcb_connection_t *c, 2436 xcb_atom_t selection) 2437{ 2438 static const xcb_protocol_request_t xcb_req = { 2439 .count = 2, 2440 .ext = &xcb_selinux_id, 2441 .opcode = XCB_SELINUX_GET_SELECTION_DATA_CONTEXT, 2442 .isvoid = 0 2443 }; 2444 2445 struct iovec xcb_parts[4]; 2446 xcb_selinux_get_selection_data_context_cookie_t xcb_ret; 2447 xcb_selinux_get_selection_data_context_request_t xcb_out; 2448 2449 xcb_out.selection = selection; 2450 2451 xcb_parts[2].iov_base = (char *) &xcb_out; 2452 xcb_parts[2].iov_len = sizeof(xcb_out); 2453 xcb_parts[3].iov_base = 0; 2454 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2455 2456 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 2457 return xcb_ret; 2458} 2459 2460char * 2461xcb_selinux_get_selection_data_context_context (const xcb_selinux_get_selection_data_context_reply_t *R) 2462{ 2463 return (char *) (R + 1); 2464} 2465 2466int 2467xcb_selinux_get_selection_data_context_context_length (const xcb_selinux_get_selection_data_context_reply_t *R) 2468{ 2469 return R->context_len; 2470} 2471 2472xcb_generic_iterator_t 2473xcb_selinux_get_selection_data_context_context_end (const xcb_selinux_get_selection_data_context_reply_t *R) 2474{ 2475 xcb_generic_iterator_t i; 2476 i.data = ((char *) (R + 1)) + (R->context_len); 2477 i.rem = 0; 2478 i.index = (char *) i.data - (char *) R; 2479 return i; 2480} 2481 2482xcb_selinux_get_selection_data_context_reply_t * 2483xcb_selinux_get_selection_data_context_reply (xcb_connection_t *c, 2484 xcb_selinux_get_selection_data_context_cookie_t cookie /**< */, 2485 xcb_generic_error_t **e) 2486{ 2487 return (xcb_selinux_get_selection_data_context_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 2488} 2489 2490int 2491xcb_selinux_list_selections_sizeof (const void *_buffer) 2492{ 2493 char *xcb_tmp = (char *)_buffer; 2494 const xcb_selinux_list_selections_reply_t *_aux = (xcb_selinux_list_selections_reply_t *)_buffer; 2495 unsigned int xcb_buffer_len = 0; 2496 unsigned int xcb_block_len = 0; 2497 unsigned int xcb_pad = 0; 2498 unsigned int xcb_align_to = 0; 2499 2500 unsigned int i; 2501 unsigned int xcb_tmp_len; 2502 2503 xcb_block_len += sizeof(xcb_selinux_list_selections_reply_t); 2504 xcb_tmp += xcb_block_len; 2505 xcb_buffer_len += xcb_block_len; 2506 xcb_block_len = 0; 2507 /* selections */ 2508 for(i=0; i<_aux->selections_len; i++) { 2509 xcb_tmp_len = xcb_selinux_list_item_sizeof(xcb_tmp); 2510 xcb_block_len += xcb_tmp_len; 2511 xcb_tmp += xcb_tmp_len; 2512 } 2513 xcb_align_to = ALIGNOF(xcb_selinux_list_item_t); 2514 /* insert padding */ 2515 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 2516 xcb_buffer_len += xcb_block_len + xcb_pad; 2517 if (0 != xcb_pad) { 2518 xcb_tmp += xcb_pad; 2519 xcb_pad = 0; 2520 } 2521 xcb_block_len = 0; 2522 2523 return xcb_buffer_len; 2524} 2525 2526xcb_selinux_list_selections_cookie_t 2527xcb_selinux_list_selections (xcb_connection_t *c) 2528{ 2529 static const xcb_protocol_request_t xcb_req = { 2530 .count = 2, 2531 .ext = &xcb_selinux_id, 2532 .opcode = XCB_SELINUX_LIST_SELECTIONS, 2533 .isvoid = 0 2534 }; 2535 2536 struct iovec xcb_parts[4]; 2537 xcb_selinux_list_selections_cookie_t xcb_ret; 2538 xcb_selinux_list_selections_request_t xcb_out; 2539 2540 2541 xcb_parts[2].iov_base = (char *) &xcb_out; 2542 xcb_parts[2].iov_len = sizeof(xcb_out); 2543 xcb_parts[3].iov_base = 0; 2544 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2545 2546 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 2547 return xcb_ret; 2548} 2549 2550xcb_selinux_list_selections_cookie_t 2551xcb_selinux_list_selections_unchecked (xcb_connection_t *c) 2552{ 2553 static const xcb_protocol_request_t xcb_req = { 2554 .count = 2, 2555 .ext = &xcb_selinux_id, 2556 .opcode = XCB_SELINUX_LIST_SELECTIONS, 2557 .isvoid = 0 2558 }; 2559 2560 struct iovec xcb_parts[4]; 2561 xcb_selinux_list_selections_cookie_t xcb_ret; 2562 xcb_selinux_list_selections_request_t xcb_out; 2563 2564 2565 xcb_parts[2].iov_base = (char *) &xcb_out; 2566 xcb_parts[2].iov_len = sizeof(xcb_out); 2567 xcb_parts[3].iov_base = 0; 2568 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2569 2570 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 2571 return xcb_ret; 2572} 2573 2574int 2575xcb_selinux_list_selections_selections_length (const xcb_selinux_list_selections_reply_t *R) 2576{ 2577 return R->selections_len; 2578} 2579 2580xcb_selinux_list_item_iterator_t 2581xcb_selinux_list_selections_selections_iterator (const xcb_selinux_list_selections_reply_t *R) 2582{ 2583 xcb_selinux_list_item_iterator_t i; 2584 i.data = (xcb_selinux_list_item_t *) (R + 1); 2585 i.rem = R->selections_len; 2586 i.index = (char *) i.data - (char *) R; 2587 return i; 2588} 2589 2590xcb_selinux_list_selections_reply_t * 2591xcb_selinux_list_selections_reply (xcb_connection_t *c, 2592 xcb_selinux_list_selections_cookie_t cookie /**< */, 2593 xcb_generic_error_t **e) 2594{ 2595 return (xcb_selinux_list_selections_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 2596} 2597 2598int 2599xcb_selinux_get_client_context_sizeof (const void *_buffer) 2600{ 2601 char *xcb_tmp = (char *)_buffer; 2602 const xcb_selinux_get_client_context_reply_t *_aux = (xcb_selinux_get_client_context_reply_t *)_buffer; 2603 unsigned int xcb_buffer_len = 0; 2604 unsigned int xcb_block_len = 0; 2605 unsigned int xcb_pad = 0; 2606 unsigned int xcb_align_to = 0; 2607 2608 2609 xcb_block_len += sizeof(xcb_selinux_get_client_context_reply_t); 2610 xcb_tmp += xcb_block_len; 2611 xcb_buffer_len += xcb_block_len; 2612 xcb_block_len = 0; 2613 /* context */ 2614 xcb_block_len += _aux->context_len * sizeof(char); 2615 xcb_tmp += xcb_block_len; 2616 xcb_align_to = ALIGNOF(char); 2617 /* insert padding */ 2618 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 2619 xcb_buffer_len += xcb_block_len + xcb_pad; 2620 if (0 != xcb_pad) { 2621 xcb_tmp += xcb_pad; 2622 xcb_pad = 0; 2623 } 2624 xcb_block_len = 0; 2625 2626 return xcb_buffer_len; 2627} 2628 2629xcb_selinux_get_client_context_cookie_t 2630xcb_selinux_get_client_context (xcb_connection_t *c, 2631 uint32_t resource) 2632{ 2633 static const xcb_protocol_request_t xcb_req = { 2634 .count = 2, 2635 .ext = &xcb_selinux_id, 2636 .opcode = XCB_SELINUX_GET_CLIENT_CONTEXT, 2637 .isvoid = 0 2638 }; 2639 2640 struct iovec xcb_parts[4]; 2641 xcb_selinux_get_client_context_cookie_t xcb_ret; 2642 xcb_selinux_get_client_context_request_t xcb_out; 2643 2644 xcb_out.resource = resource; 2645 2646 xcb_parts[2].iov_base = (char *) &xcb_out; 2647 xcb_parts[2].iov_len = sizeof(xcb_out); 2648 xcb_parts[3].iov_base = 0; 2649 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2650 2651 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 2652 return xcb_ret; 2653} 2654 2655xcb_selinux_get_client_context_cookie_t 2656xcb_selinux_get_client_context_unchecked (xcb_connection_t *c, 2657 uint32_t resource) 2658{ 2659 static const xcb_protocol_request_t xcb_req = { 2660 .count = 2, 2661 .ext = &xcb_selinux_id, 2662 .opcode = XCB_SELINUX_GET_CLIENT_CONTEXT, 2663 .isvoid = 0 2664 }; 2665 2666 struct iovec xcb_parts[4]; 2667 xcb_selinux_get_client_context_cookie_t xcb_ret; 2668 xcb_selinux_get_client_context_request_t xcb_out; 2669 2670 xcb_out.resource = resource; 2671 2672 xcb_parts[2].iov_base = (char *) &xcb_out; 2673 xcb_parts[2].iov_len = sizeof(xcb_out); 2674 xcb_parts[3].iov_base = 0; 2675 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2676 2677 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 2678 return xcb_ret; 2679} 2680 2681char * 2682xcb_selinux_get_client_context_context (const xcb_selinux_get_client_context_reply_t *R) 2683{ 2684 return (char *) (R + 1); 2685} 2686 2687int 2688xcb_selinux_get_client_context_context_length (const xcb_selinux_get_client_context_reply_t *R) 2689{ 2690 return R->context_len; 2691} 2692 2693xcb_generic_iterator_t 2694xcb_selinux_get_client_context_context_end (const xcb_selinux_get_client_context_reply_t *R) 2695{ 2696 xcb_generic_iterator_t i; 2697 i.data = ((char *) (R + 1)) + (R->context_len); 2698 i.rem = 0; 2699 i.index = (char *) i.data - (char *) R; 2700 return i; 2701} 2702 2703xcb_selinux_get_client_context_reply_t * 2704xcb_selinux_get_client_context_reply (xcb_connection_t *c, 2705 xcb_selinux_get_client_context_cookie_t cookie /**< */, 2706 xcb_generic_error_t **e) 2707{ 2708 return (xcb_selinux_get_client_context_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 2709} 2710 2711