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
xcb_selinux_query_version(xcb_connection_t * c,uint8_t client_major,uint8_t client_minor)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
xcb_selinux_query_version_unchecked(xcb_connection_t * c,uint8_t client_major,uint8_t client_minor)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 *
xcb_selinux_query_version_reply(xcb_connection_t * c,xcb_selinux_query_version_cookie_t cookie,xcb_generic_error_t ** e)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
xcb_selinux_set_device_create_context_sizeof(const void * _buffer)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
xcb_selinux_set_device_create_context_checked(xcb_connection_t * c,uint32_t context_len,const char * context)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
xcb_selinux_set_device_create_context(xcb_connection_t * c,uint32_t context_len,const char * context)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 *
xcb_selinux_set_device_create_context_context(const xcb_selinux_set_device_create_context_request_t * R)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
xcb_selinux_set_device_create_context_context_length(const xcb_selinux_set_device_create_context_request_t * R)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
xcb_selinux_set_device_create_context_context_end(const xcb_selinux_set_device_create_context_request_t * R)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
xcb_selinux_get_device_create_context_sizeof(const void * _buffer)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
xcb_selinux_get_device_create_context(xcb_connection_t * c)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
xcb_selinux_get_device_create_context_unchecked(xcb_connection_t * c)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 *
xcb_selinux_get_device_create_context_context(const xcb_selinux_get_device_create_context_reply_t * R)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
xcb_selinux_get_device_create_context_context_length(const xcb_selinux_get_device_create_context_reply_t * R)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
xcb_selinux_get_device_create_context_context_end(const xcb_selinux_get_device_create_context_reply_t * R)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 *
xcb_selinux_get_device_create_context_reply(xcb_connection_t * c,xcb_selinux_get_device_create_context_cookie_t cookie,xcb_generic_error_t ** e)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
xcb_selinux_set_device_context_sizeof(const void * _buffer)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
xcb_selinux_set_device_context_checked(xcb_connection_t * c,uint32_t device,uint32_t context_len,const char * context)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
xcb_selinux_set_device_context(xcb_connection_t * c,uint32_t device,uint32_t context_len,const char * context)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 *
xcb_selinux_set_device_context_context(const xcb_selinux_set_device_context_request_t * R)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
xcb_selinux_set_device_context_context_length(const xcb_selinux_set_device_context_request_t * R)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
xcb_selinux_set_device_context_context_end(const xcb_selinux_set_device_context_request_t * R)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
xcb_selinux_get_device_context_sizeof(const void * _buffer)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
xcb_selinux_get_device_context(xcb_connection_t * c,uint32_t device)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
xcb_selinux_get_device_context_unchecked(xcb_connection_t * c,uint32_t device)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 *
xcb_selinux_get_device_context_context(const xcb_selinux_get_device_context_reply_t * R)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
xcb_selinux_get_device_context_context_length(const xcb_selinux_get_device_context_reply_t * R)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
xcb_selinux_get_device_context_context_end(const xcb_selinux_get_device_context_reply_t * R)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 *
xcb_selinux_get_device_context_reply(xcb_connection_t * c,xcb_selinux_get_device_context_cookie_t cookie,xcb_generic_error_t ** e)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
xcb_selinux_set_window_create_context_sizeof(const void * _buffer)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
xcb_selinux_set_window_create_context_checked(xcb_connection_t * c,uint32_t context_len,const char * context)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
xcb_selinux_set_window_create_context(xcb_connection_t * c,uint32_t context_len,const char * context)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 *
xcb_selinux_set_window_create_context_context(const xcb_selinux_set_window_create_context_request_t * R)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
xcb_selinux_set_window_create_context_context_length(const xcb_selinux_set_window_create_context_request_t * R)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
xcb_selinux_set_window_create_context_context_end(const xcb_selinux_set_window_create_context_request_t * R)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
xcb_selinux_get_window_create_context_sizeof(const void * _buffer)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
xcb_selinux_get_window_create_context(xcb_connection_t * c)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
xcb_selinux_get_window_create_context_unchecked(xcb_connection_t * c)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 *
xcb_selinux_get_window_create_context_context(const xcb_selinux_get_window_create_context_reply_t * R)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
xcb_selinux_get_window_create_context_context_length(const xcb_selinux_get_window_create_context_reply_t * R)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
xcb_selinux_get_window_create_context_context_end(const xcb_selinux_get_window_create_context_reply_t * R)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 *
xcb_selinux_get_window_create_context_reply(xcb_connection_t * c,xcb_selinux_get_window_create_context_cookie_t cookie,xcb_generic_error_t ** e)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
xcb_selinux_get_window_context_sizeof(const void * _buffer)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
xcb_selinux_get_window_context(xcb_connection_t * c,xcb_window_t window)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
xcb_selinux_get_window_context_unchecked(xcb_connection_t * c,xcb_window_t window)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 *
xcb_selinux_get_window_context_context(const xcb_selinux_get_window_context_reply_t * R)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
xcb_selinux_get_window_context_context_length(const xcb_selinux_get_window_context_reply_t * R)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
xcb_selinux_get_window_context_context_end(const xcb_selinux_get_window_context_reply_t * R)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 *
xcb_selinux_get_window_context_reply(xcb_connection_t * c,xcb_selinux_get_window_context_cookie_t cookie,xcb_generic_error_t ** e)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
xcb_selinux_list_item_sizeof(const void * _buffer)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 *
xcb_selinux_list_item_object_context(const xcb_selinux_list_item_t * R)946 xcb_selinux_list_item_object_context (const xcb_selinux_list_item_t *R)
947 {
948 return (char *) (R + 1);
949 }
950
951 int
xcb_selinux_list_item_object_context_length(const xcb_selinux_list_item_t * R)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
xcb_selinux_list_item_object_context_end(const xcb_selinux_list_item_t * R)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 *
xcb_selinux_list_item_data_context(const xcb_selinux_list_item_t * R)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
xcb_selinux_list_item_data_context_length(const xcb_selinux_list_item_t * R)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
xcb_selinux_list_item_data_context_end(const xcb_selinux_list_item_t * R)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
xcb_selinux_list_item_next(xcb_selinux_list_item_iterator_t * i)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
xcb_selinux_list_item_end(xcb_selinux_list_item_iterator_t i)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
xcb_selinux_set_property_create_context_sizeof(const void * _buffer)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
xcb_selinux_set_property_create_context_checked(xcb_connection_t * c,uint32_t context_len,const char * context)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
xcb_selinux_set_property_create_context(xcb_connection_t * c,uint32_t context_len,const char * context)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 *
xcb_selinux_set_property_create_context_context(const xcb_selinux_set_property_create_context_request_t * R)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
xcb_selinux_set_property_create_context_context_length(const xcb_selinux_set_property_create_context_request_t * R)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
xcb_selinux_set_property_create_context_context_end(const xcb_selinux_set_property_create_context_request_t * R)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
xcb_selinux_get_property_create_context_sizeof(const void * _buffer)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
xcb_selinux_get_property_create_context(xcb_connection_t * c)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
xcb_selinux_get_property_create_context_unchecked(xcb_connection_t * c)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 *
xcb_selinux_get_property_create_context_context(const xcb_selinux_get_property_create_context_reply_t * R)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
xcb_selinux_get_property_create_context_context_length(const xcb_selinux_get_property_create_context_reply_t * R)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
xcb_selinux_get_property_create_context_context_end(const xcb_selinux_get_property_create_context_reply_t * R)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 *
xcb_selinux_get_property_create_context_reply(xcb_connection_t * c,xcb_selinux_get_property_create_context_cookie_t cookie,xcb_generic_error_t ** e)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
xcb_selinux_set_property_use_context_sizeof(const void * _buffer)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
xcb_selinux_set_property_use_context_checked(xcb_connection_t * c,uint32_t context_len,const char * context)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
xcb_selinux_set_property_use_context(xcb_connection_t * c,uint32_t context_len,const char * context)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 *
xcb_selinux_set_property_use_context_context(const xcb_selinux_set_property_use_context_request_t * R)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
xcb_selinux_set_property_use_context_context_length(const xcb_selinux_set_property_use_context_request_t * R)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
xcb_selinux_set_property_use_context_context_end(const xcb_selinux_set_property_use_context_request_t * R)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
xcb_selinux_get_property_use_context_sizeof(const void * _buffer)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
xcb_selinux_get_property_use_context(xcb_connection_t * c)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
xcb_selinux_get_property_use_context_unchecked(xcb_connection_t * c)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 *
xcb_selinux_get_property_use_context_context(const xcb_selinux_get_property_use_context_reply_t * R)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
xcb_selinux_get_property_use_context_context_length(const xcb_selinux_get_property_use_context_reply_t * R)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
xcb_selinux_get_property_use_context_context_end(const xcb_selinux_get_property_use_context_reply_t * R)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 *
xcb_selinux_get_property_use_context_reply(xcb_connection_t * c,xcb_selinux_get_property_use_context_cookie_t cookie,xcb_generic_error_t ** e)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
xcb_selinux_get_property_context_sizeof(const void * _buffer)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
xcb_selinux_get_property_context(xcb_connection_t * c,xcb_window_t window,xcb_atom_t property)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
xcb_selinux_get_property_context_unchecked(xcb_connection_t * c,xcb_window_t window,xcb_atom_t property)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 *
xcb_selinux_get_property_context_context(const xcb_selinux_get_property_context_reply_t * R)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
xcb_selinux_get_property_context_context_length(const xcb_selinux_get_property_context_reply_t * R)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
xcb_selinux_get_property_context_context_end(const xcb_selinux_get_property_context_reply_t * R)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 *
xcb_selinux_get_property_context_reply(xcb_connection_t * c,xcb_selinux_get_property_context_cookie_t cookie,xcb_generic_error_t ** e)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
xcb_selinux_get_property_data_context_sizeof(const void * _buffer)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
xcb_selinux_get_property_data_context(xcb_connection_t * c,xcb_window_t window,xcb_atom_t property)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
xcb_selinux_get_property_data_context_unchecked(xcb_connection_t * c,xcb_window_t window,xcb_atom_t property)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 *
xcb_selinux_get_property_data_context_context(const xcb_selinux_get_property_data_context_reply_t * R)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
xcb_selinux_get_property_data_context_context_length(const xcb_selinux_get_property_data_context_reply_t * R)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
xcb_selinux_get_property_data_context_context_end(const xcb_selinux_get_property_data_context_reply_t * R)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 *
xcb_selinux_get_property_data_context_reply(xcb_connection_t * c,xcb_selinux_get_property_data_context_cookie_t cookie,xcb_generic_error_t ** e)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
xcb_selinux_list_properties_sizeof(const void * _buffer)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
xcb_selinux_list_properties(xcb_connection_t * c,xcb_window_t window)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
xcb_selinux_list_properties_unchecked(xcb_connection_t * c,xcb_window_t window)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
xcb_selinux_list_properties_properties_length(const xcb_selinux_list_properties_reply_t * R)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
xcb_selinux_list_properties_properties_iterator(const xcb_selinux_list_properties_reply_t * R)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 *
xcb_selinux_list_properties_reply(xcb_connection_t * c,xcb_selinux_list_properties_cookie_t cookie,xcb_generic_error_t ** e)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
xcb_selinux_set_selection_create_context_sizeof(const void * _buffer)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
xcb_selinux_set_selection_create_context_checked(xcb_connection_t * c,uint32_t context_len,const char * context)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
xcb_selinux_set_selection_create_context(xcb_connection_t * c,uint32_t context_len,const char * context)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 *
xcb_selinux_set_selection_create_context_context(const xcb_selinux_set_selection_create_context_request_t * R)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
xcb_selinux_set_selection_create_context_context_length(const xcb_selinux_set_selection_create_context_request_t * R)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
xcb_selinux_set_selection_create_context_context_end(const xcb_selinux_set_selection_create_context_request_t * R)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
xcb_selinux_get_selection_create_context_sizeof(const void * _buffer)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
xcb_selinux_get_selection_create_context(xcb_connection_t * c)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
xcb_selinux_get_selection_create_context_unchecked(xcb_connection_t * c)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 *
xcb_selinux_get_selection_create_context_context(const xcb_selinux_get_selection_create_context_reply_t * R)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
xcb_selinux_get_selection_create_context_context_length(const xcb_selinux_get_selection_create_context_reply_t * R)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
xcb_selinux_get_selection_create_context_context_end(const xcb_selinux_get_selection_create_context_reply_t * R)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 *
xcb_selinux_get_selection_create_context_reply(xcb_connection_t * c,xcb_selinux_get_selection_create_context_cookie_t cookie,xcb_generic_error_t ** e)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
xcb_selinux_set_selection_use_context_sizeof(const void * _buffer)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
xcb_selinux_set_selection_use_context_checked(xcb_connection_t * c,uint32_t context_len,const char * context)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
xcb_selinux_set_selection_use_context(xcb_connection_t * c,uint32_t context_len,const char * context)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 *
xcb_selinux_set_selection_use_context_context(const xcb_selinux_set_selection_use_context_request_t * R)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
xcb_selinux_set_selection_use_context_context_length(const xcb_selinux_set_selection_use_context_request_t * R)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
xcb_selinux_set_selection_use_context_context_end(const xcb_selinux_set_selection_use_context_request_t * R)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
xcb_selinux_get_selection_use_context_sizeof(const void * _buffer)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
xcb_selinux_get_selection_use_context(xcb_connection_t * c)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
xcb_selinux_get_selection_use_context_unchecked(xcb_connection_t * c)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 *
xcb_selinux_get_selection_use_context_context(const xcb_selinux_get_selection_use_context_reply_t * R)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
xcb_selinux_get_selection_use_context_context_length(const xcb_selinux_get_selection_use_context_reply_t * R)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
xcb_selinux_get_selection_use_context_context_end(const xcb_selinux_get_selection_use_context_reply_t * R)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 *
xcb_selinux_get_selection_use_context_reply(xcb_connection_t * c,xcb_selinux_get_selection_use_context_cookie_t cookie,xcb_generic_error_t ** e)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
xcb_selinux_get_selection_context_sizeof(const void * _buffer)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
xcb_selinux_get_selection_context(xcb_connection_t * c,xcb_atom_t selection)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
xcb_selinux_get_selection_context_unchecked(xcb_connection_t * c,xcb_atom_t selection)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 *
xcb_selinux_get_selection_context_context(const xcb_selinux_get_selection_context_reply_t * R)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
xcb_selinux_get_selection_context_context_length(const xcb_selinux_get_selection_context_reply_t * R)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
xcb_selinux_get_selection_context_context_end(const xcb_selinux_get_selection_context_reply_t * R)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 *
xcb_selinux_get_selection_context_reply(xcb_connection_t * c,xcb_selinux_get_selection_context_cookie_t cookie,xcb_generic_error_t ** e)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
xcb_selinux_get_selection_data_context_sizeof(const void * _buffer)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
xcb_selinux_get_selection_data_context(xcb_connection_t * c,xcb_atom_t selection)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
xcb_selinux_get_selection_data_context_unchecked(xcb_connection_t * c,xcb_atom_t selection)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 *
xcb_selinux_get_selection_data_context_context(const xcb_selinux_get_selection_data_context_reply_t * R)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
xcb_selinux_get_selection_data_context_context_length(const xcb_selinux_get_selection_data_context_reply_t * R)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
xcb_selinux_get_selection_data_context_context_end(const xcb_selinux_get_selection_data_context_reply_t * R)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 *
xcb_selinux_get_selection_data_context_reply(xcb_connection_t * c,xcb_selinux_get_selection_data_context_cookie_t cookie,xcb_generic_error_t ** e)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
xcb_selinux_list_selections_sizeof(const void * _buffer)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
xcb_selinux_list_selections(xcb_connection_t * c)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
xcb_selinux_list_selections_unchecked(xcb_connection_t * c)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
xcb_selinux_list_selections_selections_length(const xcb_selinux_list_selections_reply_t * R)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
xcb_selinux_list_selections_selections_iterator(const xcb_selinux_list_selections_reply_t * R)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 *
xcb_selinux_list_selections_reply(xcb_connection_t * c,xcb_selinux_list_selections_cookie_t cookie,xcb_generic_error_t ** e)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
xcb_selinux_get_client_context_sizeof(const void * _buffer)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
xcb_selinux_get_client_context(xcb_connection_t * c,uint32_t resource)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
xcb_selinux_get_client_context_unchecked(xcb_connection_t * c,uint32_t resource)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 *
xcb_selinux_get_client_context_context(const xcb_selinux_get_client_context_reply_t * R)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
xcb_selinux_get_client_context_context_length(const xcb_selinux_get_client_context_reply_t * R)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
xcb_selinux_get_client_context_context_end(const xcb_selinux_get_client_context_reply_t * R)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 *
xcb_selinux_get_client_context_reply(xcb_connection_t * c,xcb_selinux_get_client_context_cookie_t cookie,xcb_generic_error_t ** e)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