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