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 xcb_selinux_query_version_cookie_t 22 xcb_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 49 xcb_selinux_query_version_cookie_t 50 xcb_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 77 xcb_selinux_query_version_reply_t * 78 xcb_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 85 int 86 xcb_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 116 xcb_void_cookie_t 117 xcb_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 148 xcb_void_cookie_t 149 xcb_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 180 char * 181 xcb_selinux_set_device_create_context_context (const xcb_selinux_set_device_create_context_request_t *R) 182 { 183 return (char *) (R + 1); 184 } 185 186 int 187 xcb_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 192 xcb_generic_iterator_t 193 xcb_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 202 int 203 xcb_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 233 xcb_selinux_get_device_create_context_cookie_t 234 xcb_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 257 xcb_selinux_get_device_create_context_cookie_t 258 xcb_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 281 char * 282 xcb_selinux_get_device_create_context_context (const xcb_selinux_get_device_create_context_reply_t *R) 283 { 284 return (char *) (R + 1); 285 } 286 287 int 288 xcb_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 293 xcb_generic_iterator_t 294 xcb_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 303 xcb_selinux_get_device_create_context_reply_t * 304 xcb_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 311 int 312 xcb_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 342 xcb_void_cookie_t 343 xcb_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 376 xcb_void_cookie_t 377 xcb_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 410 char * 411 xcb_selinux_set_device_context_context (const xcb_selinux_set_device_context_request_t *R) 412 { 413 return (char *) (R + 1); 414 } 415 416 int 417 xcb_selinux_set_device_context_context_length (const xcb_selinux_set_device_context_request_t *R) 418 { 419 return R->context_len; 420 } 421 422 xcb_generic_iterator_t 423 xcb_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 432 int 433 xcb_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 463 xcb_selinux_get_device_context_cookie_t 464 xcb_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 489 xcb_selinux_get_device_context_cookie_t 490 xcb_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 515 char * 516 xcb_selinux_get_device_context_context (const xcb_selinux_get_device_context_reply_t *R) 517 { 518 return (char *) (R + 1); 519 } 520 521 int 522 xcb_selinux_get_device_context_context_length (const xcb_selinux_get_device_context_reply_t *R) 523 { 524 return R->context_len; 525 } 526 527 xcb_generic_iterator_t 528 xcb_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 537 xcb_selinux_get_device_context_reply_t * 538 xcb_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 545 int 546 xcb_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 576 xcb_void_cookie_t 577 xcb_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 608 xcb_void_cookie_t 609 xcb_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 640 char * 641 xcb_selinux_set_window_create_context_context (const xcb_selinux_set_window_create_context_request_t *R) 642 { 643 return (char *) (R + 1); 644 } 645 646 int 647 xcb_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 652 xcb_generic_iterator_t 653 xcb_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 662 int 663 xcb_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 693 xcb_selinux_get_window_create_context_cookie_t 694 xcb_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 717 xcb_selinux_get_window_create_context_cookie_t 718 xcb_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 741 char * 742 xcb_selinux_get_window_create_context_context (const xcb_selinux_get_window_create_context_reply_t *R) 743 { 744 return (char *) (R + 1); 745 } 746 747 int 748 xcb_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 753 xcb_generic_iterator_t 754 xcb_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 763 xcb_selinux_get_window_create_context_reply_t * 764 xcb_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 771 int 772 xcb_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 802 xcb_selinux_get_window_context_cookie_t 803 xcb_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 828 xcb_selinux_get_window_context_cookie_t 829 xcb_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 854 char * 855 xcb_selinux_get_window_context_context (const xcb_selinux_get_window_context_reply_t *R) 856 { 857 return (char *) (R + 1); 858 } 859 860 int 861 xcb_selinux_get_window_context_context_length (const xcb_selinux_get_window_context_reply_t *R) 862 { 863 return R->context_len; 864 } 865 866 xcb_generic_iterator_t 867 xcb_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 876 xcb_selinux_get_window_context_reply_t * 877 xcb_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 884 int 885 xcb_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 945 char * 946 xcb_selinux_list_item_object_context (const xcb_selinux_list_item_t *R) 947 { 948 return (char *) (R + 1); 949 } 950 951 int 952 xcb_selinux_list_item_object_context_length (const xcb_selinux_list_item_t *R) 953 { 954 return R->object_context_len; 955 } 956 957 xcb_generic_iterator_t 958 xcb_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 967 char * 968 xcb_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 974 int 975 xcb_selinux_list_item_data_context_length (const xcb_selinux_list_item_t *R) 976 { 977 return R->data_context_len; 978 } 979 980 xcb_generic_iterator_t 981 xcb_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 991 void 992 xcb_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 1002 xcb_generic_iterator_t 1003 xcb_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 1014 int 1015 xcb_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 1045 xcb_void_cookie_t 1046 xcb_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 1077 xcb_void_cookie_t 1078 xcb_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 1109 char * 1110 xcb_selinux_set_property_create_context_context (const xcb_selinux_set_property_create_context_request_t *R) 1111 { 1112 return (char *) (R + 1); 1113 } 1114 1115 int 1116 xcb_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 1121 xcb_generic_iterator_t 1122 xcb_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 1131 int 1132 xcb_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 1162 xcb_selinux_get_property_create_context_cookie_t 1163 xcb_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 1186 xcb_selinux_get_property_create_context_cookie_t 1187 xcb_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 1210 char * 1211 xcb_selinux_get_property_create_context_context (const xcb_selinux_get_property_create_context_reply_t *R) 1212 { 1213 return (char *) (R + 1); 1214 } 1215 1216 int 1217 xcb_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 1222 xcb_generic_iterator_t 1223 xcb_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 1232 xcb_selinux_get_property_create_context_reply_t * 1233 xcb_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 1240 int 1241 xcb_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 1271 xcb_void_cookie_t 1272 xcb_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 1303 xcb_void_cookie_t 1304 xcb_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 1335 char * 1336 xcb_selinux_set_property_use_context_context (const xcb_selinux_set_property_use_context_request_t *R) 1337 { 1338 return (char *) (R + 1); 1339 } 1340 1341 int 1342 xcb_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 1347 xcb_generic_iterator_t 1348 xcb_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 1357 int 1358 xcb_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 1388 xcb_selinux_get_property_use_context_cookie_t 1389 xcb_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 1412 xcb_selinux_get_property_use_context_cookie_t 1413 xcb_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 1436 char * 1437 xcb_selinux_get_property_use_context_context (const xcb_selinux_get_property_use_context_reply_t *R) 1438 { 1439 return (char *) (R + 1); 1440 } 1441 1442 int 1443 xcb_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 1448 xcb_generic_iterator_t 1449 xcb_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 1458 xcb_selinux_get_property_use_context_reply_t * 1459 xcb_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 1466 int 1467 xcb_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 1497 xcb_selinux_get_property_context_cookie_t 1498 xcb_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 1525 xcb_selinux_get_property_context_cookie_t 1526 xcb_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 1553 char * 1554 xcb_selinux_get_property_context_context (const xcb_selinux_get_property_context_reply_t *R) 1555 { 1556 return (char *) (R + 1); 1557 } 1558 1559 int 1560 xcb_selinux_get_property_context_context_length (const xcb_selinux_get_property_context_reply_t *R) 1561 { 1562 return R->context_len; 1563 } 1564 1565 xcb_generic_iterator_t 1566 xcb_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 1575 xcb_selinux_get_property_context_reply_t * 1576 xcb_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 1583 int 1584 xcb_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 1614 xcb_selinux_get_property_data_context_cookie_t 1615 xcb_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 1642 xcb_selinux_get_property_data_context_cookie_t 1643 xcb_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 1670 char * 1671 xcb_selinux_get_property_data_context_context (const xcb_selinux_get_property_data_context_reply_t *R) 1672 { 1673 return (char *) (R + 1); 1674 } 1675 1676 int 1677 xcb_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 1682 xcb_generic_iterator_t 1683 xcb_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 1692 xcb_selinux_get_property_data_context_reply_t * 1693 xcb_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 1700 int 1701 xcb_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 1736 xcb_selinux_list_properties_cookie_t 1737 xcb_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 1762 xcb_selinux_list_properties_cookie_t 1763 xcb_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 1788 int 1789 xcb_selinux_list_properties_properties_length (const xcb_selinux_list_properties_reply_t *R) 1790 { 1791 return R->properties_len; 1792 } 1793 1794 xcb_selinux_list_item_iterator_t 1795 xcb_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 1804 xcb_selinux_list_properties_reply_t * 1805 xcb_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 1812 int 1813 xcb_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 1843 xcb_void_cookie_t 1844 xcb_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 1875 xcb_void_cookie_t 1876 xcb_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 1907 char * 1908 xcb_selinux_set_selection_create_context_context (const xcb_selinux_set_selection_create_context_request_t *R) 1909 { 1910 return (char *) (R + 1); 1911 } 1912 1913 int 1914 xcb_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 1919 xcb_generic_iterator_t 1920 xcb_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 1929 int 1930 xcb_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 1960 xcb_selinux_get_selection_create_context_cookie_t 1961 xcb_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 1984 xcb_selinux_get_selection_create_context_cookie_t 1985 xcb_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 2008 char * 2009 xcb_selinux_get_selection_create_context_context (const xcb_selinux_get_selection_create_context_reply_t *R) 2010 { 2011 return (char *) (R + 1); 2012 } 2013 2014 int 2015 xcb_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 2020 xcb_generic_iterator_t 2021 xcb_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 2030 xcb_selinux_get_selection_create_context_reply_t * 2031 xcb_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 2038 int 2039 xcb_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 2069 xcb_void_cookie_t 2070 xcb_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 2101 xcb_void_cookie_t 2102 xcb_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 2133 char * 2134 xcb_selinux_set_selection_use_context_context (const xcb_selinux_set_selection_use_context_request_t *R) 2135 { 2136 return (char *) (R + 1); 2137 } 2138 2139 int 2140 xcb_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 2145 xcb_generic_iterator_t 2146 xcb_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 2155 int 2156 xcb_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 2186 xcb_selinux_get_selection_use_context_cookie_t 2187 xcb_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 2210 xcb_selinux_get_selection_use_context_cookie_t 2211 xcb_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 2234 char * 2235 xcb_selinux_get_selection_use_context_context (const xcb_selinux_get_selection_use_context_reply_t *R) 2236 { 2237 return (char *) (R + 1); 2238 } 2239 2240 int 2241 xcb_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 2246 xcb_generic_iterator_t 2247 xcb_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 2256 xcb_selinux_get_selection_use_context_reply_t * 2257 xcb_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 2264 int 2265 xcb_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 2295 xcb_selinux_get_selection_context_cookie_t 2296 xcb_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 2321 xcb_selinux_get_selection_context_cookie_t 2322 xcb_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 2347 char * 2348 xcb_selinux_get_selection_context_context (const xcb_selinux_get_selection_context_reply_t *R) 2349 { 2350 return (char *) (R + 1); 2351 } 2352 2353 int 2354 xcb_selinux_get_selection_context_context_length (const xcb_selinux_get_selection_context_reply_t *R) 2355 { 2356 return R->context_len; 2357 } 2358 2359 xcb_generic_iterator_t 2360 xcb_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 2369 xcb_selinux_get_selection_context_reply_t * 2370 xcb_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 2377 int 2378 xcb_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 2408 xcb_selinux_get_selection_data_context_cookie_t 2409 xcb_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 2434 xcb_selinux_get_selection_data_context_cookie_t 2435 xcb_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 2460 char * 2461 xcb_selinux_get_selection_data_context_context (const xcb_selinux_get_selection_data_context_reply_t *R) 2462 { 2463 return (char *) (R + 1); 2464 } 2465 2466 int 2467 xcb_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 2472 xcb_generic_iterator_t 2473 xcb_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 2482 xcb_selinux_get_selection_data_context_reply_t * 2483 xcb_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 2490 int 2491 xcb_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 2526 xcb_selinux_list_selections_cookie_t 2527 xcb_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 2550 xcb_selinux_list_selections_cookie_t 2551 xcb_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 2574 int 2575 xcb_selinux_list_selections_selections_length (const xcb_selinux_list_selections_reply_t *R) 2576 { 2577 return R->selections_len; 2578 } 2579 2580 xcb_selinux_list_item_iterator_t 2581 xcb_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 2590 xcb_selinux_list_selections_reply_t * 2591 xcb_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 2598 int 2599 xcb_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 2629 xcb_selinux_get_client_context_cookie_t 2630 xcb_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 2655 xcb_selinux_get_client_context_cookie_t 2656 xcb_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 2681 char * 2682 xcb_selinux_get_client_context_context (const xcb_selinux_get_client_context_reply_t *R) 2683 { 2684 return (char *) (R + 1); 2685 } 2686 2687 int 2688 xcb_selinux_get_client_context_context_length (const xcb_selinux_get_client_context_reply_t *R) 2689 { 2690 return R->context_len; 2691 } 2692 2693 xcb_generic_iterator_t 2694 xcb_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 2703 xcb_selinux_get_client_context_reply_t * 2704 xcb_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