Bug Summary

File:xkb/xkb.c
Location:line 4250, column 13
Description:Value stored to 'tmp' is never read

Annotated Source Code

1/************************************************************
2Copyright (c) 1993 by Silicon Graphics Computer Systems, Inc.
3
4Permission to use, copy, modify, and distribute this
5software and its documentation for any purpose and without
6fee is hereby granted, provided that the above copyright
7notice appear in all copies and that both that copyright
8notice and this permission notice appear in supporting
9documentation, and that the name of Silicon Graphics not be
10used in advertising or publicity pertaining to distribution
11of the software without specific prior written permission.
12Silicon Graphics makes no representation about the suitability
13of this software for any purpose. It is provided "as is"
14without any express or implied warranty.
15
16SILICON GRAPHICS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS
17SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
18AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SILICON
19GRAPHICS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
20DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
21DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
22OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH
23THE USE OR PERFORMANCE OF THIS SOFTWARE.
24
25********************************************************/
26
27#ifdef HAVE_DIX_CONFIG_H1
28#include <dix-config.h>
29#endif
30
31#include <stdio.h>
32#include <X11/X.h>
33#include <X11/Xproto.h>
34#include "misc.h"
35#include "inputstr.h"
36#define XKBSRV_NEED_FILE_FUNCS
37#include <xkbsrv.h>
38#include "extnsionst.h"
39#include "extinit.h"
40#include "xace.h"
41#include "xkb.h"
42#include "protocol-versions.h"
43
44#include <X11/extensions/XI.h>
45#include <X11/extensions/XKMformat.h>
46
47int XkbEventBase;
48static int XkbErrorBase;
49int XkbReqCode;
50int XkbKeyboardErrorCode;
51CARD32 xkbDebugFlags = 0;
52static CARD32 xkbDebugCtrls = 0;
53
54static RESTYPE RT_XKBCLIENT;
55
56/***====================================================================***/
57
58#define CHK_DEVICE(dev, id, client, access_mode, lf){ int why; int tmprc = lf(&(dev), id, client, access_mode
, &why); if (tmprc != 0) { client->errorValue = ((XID)
((((unsigned int)(why))<<24)|((id)&0xffffff))); return
tmprc; }}
{\
59 int why;\
60 int tmprc = lf(&(dev), id, client, access_mode, &why);\
61 if (tmprc != Success0) {\
62 client->errorValue = _XkbErrCode2(why, id)((XID)((((unsigned int)(why))<<24)|((id)&0xffffff))
)
;\
63 return tmprc;\
64 }\
65}
66
67#define CHK_KBD_DEVICE(dev, id, client, mode){ int why; int tmprc = _XkbLookupKeyboard(&(dev), id, client
, mode, &why); if (tmprc != 0) { client->errorValue = (
(XID)((((unsigned int)(why))<<24)|((id)&0xffffff)))
; return tmprc; }}
\
68 CHK_DEVICE(dev, id, client, mode, _XkbLookupKeyboard){ int why; int tmprc = _XkbLookupKeyboard(&(dev), id, client
, mode, &why); if (tmprc != 0) { client->errorValue = (
(XID)((((unsigned int)(why))<<24)|((id)&0xffffff)))
; return tmprc; }}
69#define CHK_LED_DEVICE(dev, id, client, mode){ int why; int tmprc = _XkbLookupLedDevice(&(dev), id, client
, mode, &why); if (tmprc != 0) { client->errorValue = (
(XID)((((unsigned int)(why))<<24)|((id)&0xffffff)))
; return tmprc; }}
\
70 CHK_DEVICE(dev, id, client, mode, _XkbLookupLedDevice){ int why; int tmprc = _XkbLookupLedDevice(&(dev), id, client
, mode, &why); if (tmprc != 0) { client->errorValue = (
(XID)((((unsigned int)(why))<<24)|((id)&0xffffff)))
; return tmprc; }}
71#define CHK_BELL_DEVICE(dev, id, client, mode){ int why; int tmprc = _XkbLookupBellDevice(&(dev), id, client
, mode, &why); if (tmprc != 0) { client->errorValue = (
(XID)((((unsigned int)(why))<<24)|((id)&0xffffff)))
; return tmprc; }}
\
72 CHK_DEVICE(dev, id, client, mode, _XkbLookupBellDevice){ int why; int tmprc = _XkbLookupBellDevice(&(dev), id, client
, mode, &why); if (tmprc != 0) { client->errorValue = (
(XID)((((unsigned int)(why))<<24)|((id)&0xffffff)))
; return tmprc; }}
73#define CHK_ANY_DEVICE(dev, id, client, mode){ int why; int tmprc = _XkbLookupAnyDevice(&(dev), id, client
, mode, &why); if (tmprc != 0) { client->errorValue = (
(XID)((((unsigned int)(why))<<24)|((id)&0xffffff)))
; return tmprc; }}
\
74 CHK_DEVICE(dev, id, client, mode, _XkbLookupAnyDevice){ int why; int tmprc = _XkbLookupAnyDevice(&(dev), id, client
, mode, &why); if (tmprc != 0) { client->errorValue = (
(XID)((((unsigned int)(why))<<24)|((id)&0xffffff)))
; return tmprc; }}
75
76#define CHK_ATOM_ONLY2(a,ev,er){ if (((a)==0L)||(!ValidAtom((a)))) { (ev)= (XID)(a); return er
; }}
{\
77 if (((a)==None0L)||(!ValidAtom((a)))) {\
78 (ev)= (XID)(a);\
79 return er;\
80 }\
81}
82#define CHK_ATOM_ONLY(a){ if (((a)==0L)||(!ValidAtom((a)))) { (client->errorValue)
= (XID)(a); return 5; }}
\
83 CHK_ATOM_ONLY2(a,client->errorValue,BadAtom){ if (((a)==0L)||(!ValidAtom((a)))) { (client->errorValue)
= (XID)(a); return 5; }}
84
85#define CHK_ATOM_OR_NONE3(a,ev,er,ret){ if (((a)!=0L)&&(!ValidAtom((a)))) { (ev)= (XID)(a);
(er)= 5; return ret; }}
{\
86 if (((a)!=None0L)&&(!ValidAtom((a)))) {\
87 (ev)= (XID)(a);\
88 (er)= BadAtom5;\
89 return ret;\
90 }\
91}
92#define CHK_ATOM_OR_NONE2(a,ev,er){ if (((a)!=0L)&&(!ValidAtom((a)))) { (ev)= (XID)(a);
return er; }}
{\
93 if (((a)!=None0L)&&(!ValidAtom((a)))) {\
94 (ev)= (XID)(a);\
95 return er;\
96 }\
97}
98#define CHK_ATOM_OR_NONE(a){ if (((a)!=0L)&&(!ValidAtom((a)))) { (client->errorValue
)= (XID)(a); return 5; }}
\
99 CHK_ATOM_OR_NONE2(a,client->errorValue,BadAtom){ if (((a)!=0L)&&(!ValidAtom((a)))) { (client->errorValue
)= (XID)(a); return 5; }}
100
101#define CHK_MASK_LEGAL3(err,mask,legal,ev,er,ret){ if ((mask)&(~(legal))) { (ev)= ((XID)((((unsigned int)(
(err)))<<24)|((((mask)&(~(legal))))&0xffffff)))
; (er)= 2; return ret; }}
{\
102 if ((mask)&(~(legal))) { \
103 (ev)= _XkbErrCode2((err),((mask)&(~(legal))))((XID)((((unsigned int)((err)))<<24)|((((mask)&(~(legal
))))&0xffffff)))
;\
104 (er)= BadValue2;\
105 return ret;\
106 }\
107}
108#define CHK_MASK_LEGAL2(err,mask,legal,ev,er){ if ((mask)&(~(legal))) { (ev)= ((XID)((((unsigned int)(
(err)))<<24)|((((mask)&(~(legal))))&0xffffff)))
; return er; }}
{\
109 if ((mask)&(~(legal))) { \
110 (ev)= _XkbErrCode2((err),((mask)&(~(legal))))((XID)((((unsigned int)((err)))<<24)|((((mask)&(~(legal
))))&0xffffff)))
;\
111 return er;\
112 }\
113}
114#define CHK_MASK_LEGAL(err,mask,legal){ if ((mask)&(~(legal))) { (client->errorValue)= ((XID
)((((unsigned int)((err)))<<24)|((((mask)&(~(legal)
)))&0xffffff))); return 2; }}
\
115 CHK_MASK_LEGAL2(err,mask,legal,client->errorValue,BadValue){ if ((mask)&(~(legal))) { (client->errorValue)= ((XID
)((((unsigned int)((err)))<<24)|((((mask)&(~(legal)
)))&0xffffff))); return 2; }}
116
117#define CHK_MASK_MATCH(err,affect,value){ if ((value)&(~(affect))) { client->errorValue= ((XID
)((((unsigned int)((err)))<<24)|((((value)&(~(affect
))))&0xffffff))); return 8; }}
{\
118 if ((value)&(~(affect))) { \
119 client->errorValue= _XkbErrCode2((err),((value)&(~(affect))))((XID)((((unsigned int)((err)))<<24)|((((value)&(~(
affect))))&0xffffff)))
;\
120 return BadMatch8;\
121 }\
122}
123#define CHK_MASK_OVERLAP(err,m1,m2){ if ((m1)&(m2)) { client->errorValue= ((XID)((((unsigned
int)((err)))<<24)|((((m1)&(m2)))&0xffffff))); return
8; }}
{\
124 if ((m1)&(m2)) { \
125 client->errorValue= _XkbErrCode2((err),((m1)&(m2)))((XID)((((unsigned int)((err)))<<24)|((((m1)&(m2)))
&0xffffff)))
;\
126 return BadMatch8;\
127 }\
128}
129#define CHK_KEY_RANGE2(err,first,num,x,ev,er){ if (((unsigned)(first)+(num)-1)>(x)->max_key_code) { (
ev)=((XID)((((unsigned int)(err))<<24)|(((((unsigned int
)((first)))<<16)|(((((unsigned int)((num)))<<8)|(
(x)->max_key_code))))&0xffffff))); return er; } else if
( (first)<(x)->min_key_code ) { (ev)=((XID)((((unsigned
int)(err+1))<<24)|(((((unsigned int)((first)))<<
16)|(xkb->min_key_code))&0xffffff))); return er; }}
{\
130 if (((unsigned)(first)+(num)-1)>(x)->max_key_code) {\
131 (ev)=_XkbErrCode4(err,(first),(num),(x)->max_key_code)((XID)((((unsigned int)(err))<<24)|(((((unsigned int)((
first)))<<16)|(((((unsigned int)((num)))<<8)|((x)
->max_key_code))))&0xffffff)))
;\
132 return er;\
133 }\
134 else if ( (first)<(x)->min_key_code ) {\
135 (ev)=_XkbErrCode3(err+1,(first),xkb->min_key_code)((XID)((((unsigned int)(err+1))<<24)|(((((unsigned int)
((first)))<<16)|(xkb->min_key_code))&0xffffff)))
;\
136 return er;\
137 }\
138}
139#define CHK_KEY_RANGE(err,first,num,x){ if (((unsigned)(first)+(num)-1)>(x)->max_key_code) { (
client->errorValue)=((XID)((((unsigned int)(err))<<24
)|(((((unsigned int)((first)))<<16)|(((((unsigned int)(
(num)))<<8)|((x)->max_key_code))))&0xffffff))); return
2; } else if ( (first)<(x)->min_key_code ) { (client->
errorValue)=((XID)((((unsigned int)(err+1))<<24)|(((((unsigned
int)((first)))<<16)|(xkb->min_key_code))&0xffffff
))); return 2; }}
\
140 CHK_KEY_RANGE2(err,first,num,x,client->errorValue,BadValue){ if (((unsigned)(first)+(num)-1)>(x)->max_key_code) { (
client->errorValue)=((XID)((((unsigned int)(err))<<24
)|(((((unsigned int)((first)))<<16)|(((((unsigned int)(
(num)))<<8)|((x)->max_key_code))))&0xffffff))); return
2; } else if ( (first)<(x)->min_key_code ) { (client->
errorValue)=((XID)((((unsigned int)(err+1))<<24)|(((((unsigned
int)((first)))<<16)|(xkb->min_key_code))&0xffffff
))); return 2; }}
141
142#define CHK_REQ_KEY_RANGE2(err,first,num,r,ev,er){ if (((unsigned)(first)+(num)-1)>(r)->maxKeyCode) { (ev
)=((XID)((((unsigned int)(err))<<24)|(((((unsigned int)
((first)))<<16)|(((((unsigned int)((num)))<<8)|((
r)->maxKeyCode))))&0xffffff))); return er; } else if (
(first)<(r)->minKeyCode ) { (ev)=((XID)((((unsigned int
)(err+1))<<24)|(((((unsigned int)((first)))<<16)|
((r)->minKeyCode))&0xffffff))); return er; }}
{\
143 if (((unsigned)(first)+(num)-1)>(r)->maxKeyCode) {\
144 (ev)=_XkbErrCode4(err,(first),(num),(r)->maxKeyCode)((XID)((((unsigned int)(err))<<24)|(((((unsigned int)((
first)))<<16)|(((((unsigned int)((num)))<<8)|((r)
->maxKeyCode))))&0xffffff)))
;\
145 return er;\
146 }\
147 else if ( (first)<(r)->minKeyCode ) {\
148 (ev)=_XkbErrCode3(err+1,(first),(r)->minKeyCode)((XID)((((unsigned int)(err+1))<<24)|(((((unsigned int)
((first)))<<16)|((r)->minKeyCode))&0xffffff)))
;\
149 return er;\
150 }\
151}
152#define CHK_REQ_KEY_RANGE(err,first,num,r){ if (((unsigned)(first)+(num)-1)>(r)->maxKeyCode) { (client
->errorValue)=((XID)((((unsigned int)(err))<<24)|(((
((unsigned int)((first)))<<16)|(((((unsigned int)((num)
))<<8)|((r)->maxKeyCode))))&0xffffff))); return 2
; } else if ( (first)<(r)->minKeyCode ) { (client->errorValue
)=((XID)((((unsigned int)(err+1))<<24)|(((((unsigned int
)((first)))<<16)|((r)->minKeyCode))&0xffffff)));
return 2; }}
\
153 CHK_REQ_KEY_RANGE2(err,first,num,r,client->errorValue,BadValue){ if (((unsigned)(first)+(num)-1)>(r)->maxKeyCode) { (client
->errorValue)=((XID)((((unsigned int)(err))<<24)|(((
((unsigned int)((first)))<<16)|(((((unsigned int)((num)
))<<8)|((r)->maxKeyCode))))&0xffffff))); return 2
; } else if ( (first)<(r)->minKeyCode ) { (client->errorValue
)=((XID)((((unsigned int)(err+1))<<24)|(((((unsigned int
)((first)))<<16)|((r)->minKeyCode))&0xffffff)));
return 2; }}
154
155/***====================================================================***/
156
157int
158ProcXkbUseExtension(ClientPtr client)
159{
160 REQUEST(xkbUseExtensionReq)xkbUseExtensionReq *stuff = (xkbUseExtensionReq *)client->
requestBuffer
;
161 xkbUseExtensionReply rep;
162 int supported;
163
164 REQUEST_SIZE_MATCH(xkbUseExtensionReq)if ((sizeof(xkbUseExtensionReq) >> 2) != client->req_len
) return(16)
;
165 if (stuff->wantedMajor != SERVER_XKB_MAJOR_VERSION1) {
166 /* pre-release version 0.65 is compatible with 1.00 */
167 supported = ((SERVER_XKB_MAJOR_VERSION1 == 1) &&
168 (stuff->wantedMajor == 0) && (stuff->wantedMinor == 65));
169 }
170 else
171 supported = 1;
172
173 if ((supported) && (!(client->xkbClientFlags & _XkbClientInitialized(1<<15)))) {
174 client->xkbClientFlags = _XkbClientInitialized(1<<15);
175 client->vMajor = stuff->wantedMajor;
176 client->vMinor = stuff->wantedMinor;
177 }
178 else if (xkbDebugFlags & 0x1) {
179 ErrorF
180 ("[xkb] Rejecting client %d (0x%lx) (wants %d.%02d, have %d.%02d)\n",
181 client->index, (long) client->clientAsMask, stuff->wantedMajor,
182 stuff->wantedMinor, SERVER_XKB_MAJOR_VERSION1,
183 SERVER_XKB_MINOR_VERSION0);
184 }
185 rep = (xkbUseExtensionReply) {
186 .type = X_Reply1,
187 .supported = supported,
188 .sequenceNumber = client->sequence,
189 .length = 0,
190 .serverMajor = SERVER_XKB_MAJOR_VERSION1,
191 .serverMinor = SERVER_XKB_MINOR_VERSION0
192 };
193 if (client->swapped) {
194 swaps(&rep.sequenceNumber)do { if (sizeof(*(&rep.sequenceNumber)) != 2) wrong_size(
); if (__builtin_constant_p((uintptr_t)(&rep.sequenceNumber
) & 1) && ((uintptr_t)(&rep.sequenceNumber) &
1) == 0) *(&rep.sequenceNumber) = lswaps(*(&rep.sequenceNumber
)); else swap_uint16((uint16_t *)(&rep.sequenceNumber)); }
while (0)
;
195 swaps(&rep.serverMajor)do { if (sizeof(*(&rep.serverMajor)) != 2) wrong_size(); if
(__builtin_constant_p((uintptr_t)(&rep.serverMajor) &
1) && ((uintptr_t)(&rep.serverMajor) & 1) ==
0) *(&rep.serverMajor) = lswaps(*(&rep.serverMajor))
; else swap_uint16((uint16_t *)(&rep.serverMajor)); } while
(0)
;
196 swaps(&rep.serverMinor)do { if (sizeof(*(&rep.serverMinor)) != 2) wrong_size(); if
(__builtin_constant_p((uintptr_t)(&rep.serverMinor) &
1) && ((uintptr_t)(&rep.serverMinor) & 1) ==
0) *(&rep.serverMinor) = lswaps(*(&rep.serverMinor))
; else swap_uint16((uint16_t *)(&rep.serverMinor)); } while
(0)
;
197 }
198 WriteToClient(client, SIZEOF(xkbUseExtensionReply)32, &rep);
199 return Success0;
200}
201
202/***====================================================================***/
203
204int
205ProcXkbSelectEvents(ClientPtr client)
206{
207 unsigned legal;
208 DeviceIntPtr dev;
209 XkbInterestPtr masks;
210
211 REQUEST(xkbSelectEventsReq)xkbSelectEventsReq *stuff = (xkbSelectEventsReq *)client->
requestBuffer
;
212
213 REQUEST_AT_LEAST_SIZE(xkbSelectEventsReq)if ((sizeof(xkbSelectEventsReq) >> 2) > client->req_len
) return(16)
;
214
215 if (!(client->xkbClientFlags & _XkbClientInitialized(1<<15)))
216 return BadAccess10;
217
218 CHK_ANY_DEVICE(dev, stuff->deviceSpec, client, DixUseAccess){ int why; int tmprc = _XkbLookupAnyDevice(&(dev), stuff->
deviceSpec, client, (1<<24), &why); if (tmprc != 0)
{ client->errorValue = ((XID)((((unsigned int)(why))<<
24)|((stuff->deviceSpec)&0xffffff))); return tmprc; }}
;
219
220 if (((stuff->affectWhich & XkbMapNotifyMask(1L << 1)) != 0) && (stuff->affectMap)) {
221 client->mapNotifyMask &= ~stuff->affectMap;
222 client->mapNotifyMask |= (stuff->affectMap & stuff->map);
223 }
224 if ((stuff->affectWhich & (~XkbMapNotifyMask(1L << 1))) == 0)
225 return Success0;
226
227 masks = XkbFindClientResource((DevicePtr) dev, client);
228 if (!masks) {
229 XID id = FakeClientID(client->index);
230
231 if (!AddResourceDarwin_X_AddResource(id, RT_XKBCLIENT, dev))
232 return BadAlloc11;
233 masks = XkbAddClientResource((DevicePtr) dev, client, id);
234 }
235 if (masks) {
236 union {
237 CARD8 *c8;
238 CARD16 *c16;
239 CARD32 *c32;
240 } from, to;
241 register unsigned bit, ndx, maskLeft, dataLeft, size;
242
243 from.c8 = (CARD8 *) &stuff[1];
244 dataLeft = (stuff->length * 4) - SIZEOF(xkbSelectEventsReq)16;
245 maskLeft = (stuff->affectWhich & (~XkbMapNotifyMask(1L << 1)));
246 for (ndx = 0, bit = 1; (maskLeft != 0); ndx++, bit <<= 1) {
247 if ((bit & maskLeft) == 0)
248 continue;
249 maskLeft &= ~bit;
250 switch (ndx) {
251 case XkbNewKeyboardNotify0:
252 to.c16 = &client->newKeyboardNotifyMask;
253 legal = XkbAllNewKeyboardEventsMask(0x7);
254 size = 2;
255 break;
256 case XkbStateNotify2:
257 to.c16 = &masks->stateNotifyMask;
258 legal = XkbAllStateEventsMask(0x3fff);
259 size = 2;
260 break;
261 case XkbControlsNotify3:
262 to.c32 = &masks->ctrlsNotifyMask;
263 legal = XkbAllControlEventsMask(0xF8001FFF);
264 size = 4;
265 break;
266 case XkbIndicatorStateNotify4:
267 to.c32 = &masks->iStateNotifyMask;
268 legal = XkbAllIndicatorEventsMask(0xffffffff);
269 size = 4;
270 break;
271 case XkbIndicatorMapNotify5:
272 to.c32 = &masks->iMapNotifyMask;
273 legal = XkbAllIndicatorEventsMask(0xffffffff);
274 size = 4;
275 break;
276 case XkbNamesNotify6:
277 to.c16 = &masks->namesNotifyMask;
278 legal = XkbAllNameEventsMask(0x3fff);
279 size = 2;
280 break;
281 case XkbCompatMapNotify7:
282 to.c8 = &masks->compatNotifyMask;
283 legal = XkbAllCompatMapEventsMask(0x3);
284 size = 1;
285 break;
286 case XkbBellNotify8:
287 to.c8 = &masks->bellNotifyMask;
288 legal = XkbAllBellEventsMask(1L << 0);
289 size = 1;
290 break;
291 case XkbActionMessage9:
292 to.c8 = &masks->actionMessageMask;
293 legal = XkbAllActionMessagesMask(1L << 0);
294 size = 1;
295 break;
296 case XkbAccessXNotify10:
297 to.c16 = &masks->accessXNotifyMask;
298 legal = XkbAllAccessXEventsMask(0x7f);
299 size = 2;
300 break;
301 case XkbExtensionDeviceNotify11:
302 to.c16 = &masks->extDevNotifyMask;
303 legal = XkbAllExtensionDeviceEventsMask(0x801f);
304 size = 2;
305 break;
306 default:
307 client->errorValue = _XkbErrCode2(33, bit)((XID)((((unsigned int)(33))<<24)|((bit)&0xffffff))
)
;
308 return BadValue2;
309 }
310
311 if (stuff->clear & bit) {
312 if (size == 2)
313 to.c16[0] = 0;
314 else if (size == 4)
315 to.c32[0] = 0;
316 else
317 to.c8[0] = 0;
318 }
319 else if (stuff->selectAll & bit) {
320 if (size == 2)
321 to.c16[0] = ~0;
322 else if (size == 4)
323 to.c32[0] = ~0;
324 else
325 to.c8[0] = ~0;
326 }
327 else {
328 if (dataLeft < (size * 2))
329 return BadLength16;
330 if (size == 2) {
331 CHK_MASK_MATCH(ndx, from.c16[0], from.c16[1]){ if ((from.c16[1])&(~(from.c16[0]))) { client->errorValue
= ((XID)((((unsigned int)((ndx)))<<24)|((((from.c16[1])
&(~(from.c16[0]))))&0xffffff))); return 8; }}
;
332 CHK_MASK_LEGAL(ndx, from.c16[0], legal){ if ((from.c16[0])&(~(legal))) { (client->errorValue)
= ((XID)((((unsigned int)((ndx)))<<24)|((((from.c16[0])
&(~(legal))))&0xffffff))); return 2; }}
;
333 to.c16[0] &= ~from.c16[0];
334 to.c16[0] |= (from.c16[0] & from.c16[1]);
335 }
336 else if (size == 4) {
337 CHK_MASK_MATCH(ndx, from.c32[0], from.c32[1]){ if ((from.c32[1])&(~(from.c32[0]))) { client->errorValue
= ((XID)((((unsigned int)((ndx)))<<24)|((((from.c32[1])
&(~(from.c32[0]))))&0xffffff))); return 8; }}
;
338 CHK_MASK_LEGAL(ndx, from.c32[0], legal){ if ((from.c32[0])&(~(legal))) { (client->errorValue)
= ((XID)((((unsigned int)((ndx)))<<24)|((((from.c32[0])
&(~(legal))))&0xffffff))); return 2; }}
;
339 to.c32[0] &= ~from.c32[0];
340 to.c32[0] |= (from.c32[0] & from.c32[1]);
341 }
342 else {
343 CHK_MASK_MATCH(ndx, from.c8[0], from.c8[1]){ if ((from.c8[1])&(~(from.c8[0]))) { client->errorValue
= ((XID)((((unsigned int)((ndx)))<<24)|((((from.c8[1])&
(~(from.c8[0]))))&0xffffff))); return 8; }}
;
344 CHK_MASK_LEGAL(ndx, from.c8[0], legal){ if ((from.c8[0])&(~(legal))) { (client->errorValue)=
((XID)((((unsigned int)((ndx)))<<24)|((((from.c8[0])&
(~(legal))))&0xffffff))); return 2; }}
;
345 to.c8[0] &= ~from.c8[0];
346 to.c8[0] |= (from.c8[0] & from.c8[1]);
347 size = 2;
348 }
349 from.c8 += (size * 2);
350 dataLeft -= (size * 2);
351 }
352 }
353 if (dataLeft > 2) {
354 ErrorF("[xkb] Extra data (%d bytes) after SelectEvents\n",
355 dataLeft);
356 return BadLength16;
357 }
358 return Success0;
359 }
360 return BadAlloc11;
361}
362
363/***====================================================================***/
364/**
365 * Ring a bell on the given device for the given client.
366 */
367static int
368_XkbBell(ClientPtr client, DeviceIntPtr dev, WindowPtr pWin,
369 int bellClass, int bellID, int pitch, int duration,
370 int percent, int forceSound, int eventOnly, Atom name)
371{
372 int base;
373 void *ctrl;
374 int oldPitch, oldDuration;
375 int newPercent;
376
377 if (bellClass == KbdFeedbackClass0) {
378 KbdFeedbackPtr k;
379
380 if (bellID == XkbDfltXIId0x0400)
381 k = dev->kbdfeed;
382 else {
383 for (k = dev->kbdfeed; k; k = k->next) {
384 if (k->ctrl.id == bellID)
385 break;
386 }
387 }
388 if (!k) {
389 client->errorValue = _XkbErrCode2(0x5, bellID)((XID)((((unsigned int)(0x5))<<24)|((bellID)&0xffffff
)))
;
390 return BadValue2;
391 }
392 base = k->ctrl.bell;
393 ctrl = (void *) &(k->ctrl);
394 oldPitch = k->ctrl.bell_pitch;
395 oldDuration = k->ctrl.bell_duration;
396 if (pitch != 0) {
397 if (pitch == -1)
398 k->ctrl.bell_pitch = defaultKeyboardControl.bell_pitch;
399 else
400 k->ctrl.bell_pitch = pitch;
401 }
402 if (duration != 0) {
403 if (duration == -1)
404 k->ctrl.bell_duration = defaultKeyboardControl.bell_duration;
405 else
406 k->ctrl.bell_duration = duration;
407 }
408 }
409 else if (bellClass == BellFeedbackClass5) {
410 BellFeedbackPtr b;
411
412 if (bellID == XkbDfltXIId0x0400)
413 b = dev->bell;
414 else {
415 for (b = dev->bell; b; b = b->next) {
416 if (b->ctrl.id == bellID)
417 break;
418 }
419 }
420 if (!b) {
421 client->errorValue = _XkbErrCode2(0x6, bellID)((XID)((((unsigned int)(0x6))<<24)|((bellID)&0xffffff
)))
;
422 return BadValue2;
423 }
424 base = b->ctrl.percent;
425 ctrl = (void *) &(b->ctrl);
426 oldPitch = b->ctrl.pitch;
427 oldDuration = b->ctrl.duration;
428 if (pitch != 0) {
429 if (pitch == -1)
430 b->ctrl.pitch = defaultKeyboardControl.bell_pitch;
431 else
432 b->ctrl.pitch = pitch;
433 }
434 if (duration != 0) {
435 if (duration == -1)
436 b->ctrl.duration = defaultKeyboardControl.bell_duration;
437 else
438 b->ctrl.duration = duration;
439 }
440 }
441 else {
442 client->errorValue = _XkbErrCode2(0x7, bellClass)((XID)((((unsigned int)(0x7))<<24)|((bellClass)&0xffffff
)))
;
443 return BadValue2;
444 }
445
446 newPercent = (base * percent) / 100;
447 if (percent < 0)
448 newPercent = base + newPercent;
449 else
450 newPercent = base - newPercent + percent;
451
452 XkbHandleBell(forceSound, eventOnly,
453 dev, newPercent, ctrl, bellClass, name, pWin, client);
454 if ((pitch != 0) || (duration != 0)) {
455 if (bellClass == KbdFeedbackClass0) {
456 KbdFeedbackPtr k;
457
458 k = (KbdFeedbackPtr) ctrl;
459 if (pitch != 0)
460 k->ctrl.bell_pitch = oldPitch;
461 if (duration != 0)
462 k->ctrl.bell_duration = oldDuration;
463 }
464 else {
465 BellFeedbackPtr b;
466
467 b = (BellFeedbackPtr) ctrl;
468 if (pitch != 0)
469 b->ctrl.pitch = oldPitch;
470 if (duration != 0)
471 b->ctrl.duration = oldDuration;
472 }
473 }
474
475 return Success0;
476}
477
478int
479ProcXkbBell(ClientPtr client)
480{
481 REQUEST(xkbBellReq)xkbBellReq *stuff = (xkbBellReq *)client->requestBuffer;
482 DeviceIntPtr dev;
483 WindowPtr pWin;
484 int rc;
485
486 REQUEST_SIZE_MATCH(xkbBellReq)if ((sizeof(xkbBellReq) >> 2) != client->req_len) return
(16)
;
487
488 if (!(client->xkbClientFlags & _XkbClientInitialized(1<<15)))
489 return BadAccess10;
490
491 CHK_BELL_DEVICE(dev, stuff->deviceSpec, client, DixBellAccess){ int why; int tmprc = _XkbLookupBellDevice(&(dev), stuff
->deviceSpec, client, (1<<27), &why); if (tmprc !=
0) { client->errorValue = ((XID)((((unsigned int)(why))<<
24)|((stuff->deviceSpec)&0xffffff))); return tmprc; }}
;
492 CHK_ATOM_OR_NONE(stuff->name){ if (((stuff->name)!=0L)&&(!ValidAtom((stuff->
name)))) { (client->errorValue)= (XID)(stuff->name); return
5; }}
;
493
494 /* device-independent checks request for sane values */
495 if ((stuff->forceSound) && (stuff->eventOnly)) {
496 client->errorValue =
497 _XkbErrCode3(0x1, stuff->forceSound, stuff->eventOnly)((XID)((((unsigned int)(0x1))<<24)|(((((unsigned int)(stuff
->forceSound))<<16)|(stuff->eventOnly))&0xffffff
)))
;
498 return BadMatch8;
499 }
500 if (stuff->percent < -100 || stuff->percent > 100) {
501 client->errorValue = _XkbErrCode2(0x2, stuff->percent)((XID)((((unsigned int)(0x2))<<24)|((stuff->percent)
&0xffffff)))
;
502 return BadValue2;
503 }
504 if (stuff->duration < -1) {
505 client->errorValue = _XkbErrCode2(0x3, stuff->duration)((XID)((((unsigned int)(0x3))<<24)|((stuff->duration
)&0xffffff)))
;
506 return BadValue2;
507 }
508 if (stuff->pitch < -1) {
509 client->errorValue = _XkbErrCode2(0x4, stuff->pitch)((XID)((((unsigned int)(0x4))<<24)|((stuff->pitch)&
0xffffff)))
;
510 return BadValue2;
511 }
512
513 if (stuff->bellClass == XkbDfltXIClass0x0300) {
514 if (dev->kbdfeed != NULL((void*)0))
515 stuff->bellClass = KbdFeedbackClass0;
516 else
517 stuff->bellClass = BellFeedbackClass5;
518 }
519
520 if (stuff->window != None0L) {
521 rc = dixLookupWindow(&pWin, stuff->window, client, DixGetAttrAccess(1<<4));
522 if (rc != Success0) {
523 client->errorValue = stuff->window;
524 return rc;
525 }
526 }
527 else
528 pWin = NULL((void*)0);
529
530 /* Client wants to ring a bell on the core keyboard?
531 Ring the bell on the core keyboard (which does nothing, but if that
532 fails the client is screwed anyway), and then on all extension devices.
533 Fail if the core keyboard fails but not the extension devices. this
534 may cause some keyboards to ding and others to stay silent. Fix
535 your client to use explicit keyboards to avoid this.
536
537 dev is the device the client requested.
538 */
539 rc = _XkbBell(client, dev, pWin, stuff->bellClass, stuff->bellID,
540 stuff->pitch, stuff->duration, stuff->percent,
541 stuff->forceSound, stuff->eventOnly, stuff->name);
542
543 if ((rc == Success0) && ((stuff->deviceSpec == XkbUseCoreKbd0x0100) ||
544 (stuff->deviceSpec == XkbUseCorePtr0x0200))) {
545 DeviceIntPtr other;
546
547 for (other = inputInfo.devices; other; other = other->next) {
548 if ((other != dev) && other->key && !IsMaster(other) &&
549 GetMaster(other, MASTER_KEYBOARD2) == dev) {
550 rc = XaceHook(XACE_DEVICE_ACCESS3, client, other, DixBellAccess(1<<27));
551 if (rc == Success0)
552 _XkbBell(client, other, pWin, stuff->bellClass,
553 stuff->bellID, stuff->pitch, stuff->duration,
554 stuff->percent, stuff->forceSound,
555 stuff->eventOnly, stuff->name);
556 }
557 }
558 rc = Success0; /* reset to success, that's what we got for the VCK */
559 }
560
561 return rc;
562}
563
564/***====================================================================***/
565
566int
567ProcXkbGetState(ClientPtr client)
568{
569 REQUEST(xkbGetStateReq)xkbGetStateReq *stuff = (xkbGetStateReq *)client->requestBuffer;
570 DeviceIntPtr dev;
571 xkbGetStateReply rep;
572 XkbStateRec *xkb;
573
574 REQUEST_SIZE_MATCH(xkbGetStateReq)if ((sizeof(xkbGetStateReq) >> 2) != client->req_len
) return(16)
;
575
576 if (!(client->xkbClientFlags & _XkbClientInitialized(1<<15)))
577 return BadAccess10;
578
579 CHK_KBD_DEVICE(dev, stuff->deviceSpec, client, DixGetAttrAccess){ int why; int tmprc = _XkbLookupKeyboard(&(dev), stuff->
deviceSpec, client, (1<<4), &why); if (tmprc != 0) {
client->errorValue = ((XID)((((unsigned int)(why))<<
24)|((stuff->deviceSpec)&0xffffff))); return tmprc; }}
;
580
581 xkb = &dev->key->xkbInfo->state;
582 rep = (xkbGetStateReply) {
583 .type = X_Reply1,
584 .deviceID = dev->id,
585 .sequenceNumber = client->sequence,
586 .length = 0,
587 .mods = XkbStateFieldFromRec(xkb)(((((xkb)->group)&0x3)<<13)|(((xkb)->lookup_mods
)&0xff))
& 0xff,
588 .baseMods = xkb->base_mods,
589 .latchedMods = xkb->latched_mods,
590 .lockedMods = xkb->locked_mods,
591 .group = xkb->group,
592 .lockedGroup = xkb->locked_group,
593 .baseGroup = xkb->base_group,
594 .latchedGroup = xkb->latched_group,
595 .compatState = xkb->compat_state,
596 .ptrBtnState = xkb->ptr_buttons
597 };
598 if (client->swapped) {
599 swaps(&rep.sequenceNumber)do { if (sizeof(*(&rep.sequenceNumber)) != 2) wrong_size(
); if (__builtin_constant_p((uintptr_t)(&rep.sequenceNumber
) & 1) && ((uintptr_t)(&rep.sequenceNumber) &
1) == 0) *(&rep.sequenceNumber) = lswaps(*(&rep.sequenceNumber
)); else swap_uint16((uint16_t *)(&rep.sequenceNumber)); }
while (0)
;
600 swaps(&rep.ptrBtnState)do { if (sizeof(*(&rep.ptrBtnState)) != 2) wrong_size(); if
(__builtin_constant_p((uintptr_t)(&rep.ptrBtnState) &
1) && ((uintptr_t)(&rep.ptrBtnState) & 1) ==
0) *(&rep.ptrBtnState) = lswaps(*(&rep.ptrBtnState))
; else swap_uint16((uint16_t *)(&rep.ptrBtnState)); } while
(0)
;
601 }
602 WriteToClient(client, SIZEOF(xkbGetStateReply)32, &rep);
603 return Success0;
604}
605
606/***====================================================================***/
607
608int
609ProcXkbLatchLockState(ClientPtr client)
610{
611 int status;
612 DeviceIntPtr dev, tmpd;
613 XkbStateRec oldState, *newState;
614 CARD16 changed;
615 xkbStateNotify sn;
616 XkbEventCauseRec cause;
617
618 REQUEST(xkbLatchLockStateReq)xkbLatchLockStateReq *stuff = (xkbLatchLockStateReq *)client->
requestBuffer
;
619 REQUEST_SIZE_MATCH(xkbLatchLockStateReq)if ((sizeof(xkbLatchLockStateReq) >> 2) != client->req_len
) return(16)
;
620
621 if (!(client->xkbClientFlags & _XkbClientInitialized(1<<15)))
622 return BadAccess10;
623
624 CHK_KBD_DEVICE(dev, stuff->deviceSpec, client, DixSetAttrAccess){ int why; int tmprc = _XkbLookupKeyboard(&(dev), stuff->
deviceSpec, client, (1<<5), &why); if (tmprc != 0) {
client->errorValue = ((XID)((((unsigned int)(why))<<
24)|((stuff->deviceSpec)&0xffffff))); return tmprc; }}
;
625 CHK_MASK_MATCH(0x01, stuff->affectModLocks, stuff->modLocks){ if ((stuff->modLocks)&(~(stuff->affectModLocks)))
{ client->errorValue= ((XID)((((unsigned int)((0x01)))<<
24)|((((stuff->modLocks)&(~(stuff->affectModLocks))
))&0xffffff))); return 8; }}
;
626 CHK_MASK_MATCH(0x01, stuff->affectModLatches, stuff->modLatches){ if ((stuff->modLatches)&(~(stuff->affectModLatches
))) { client->errorValue= ((XID)((((unsigned int)((0x01)))
<<24)|((((stuff->modLatches)&(~(stuff->affectModLatches
))))&0xffffff))); return 8; }}
;
627
628 status = Success0;
629
630 for (tmpd = inputInfo.devices; tmpd; tmpd = tmpd->next) {
631 if ((tmpd == dev) ||
632 (!IsMaster(tmpd) && GetMaster(tmpd, MASTER_KEYBOARD2) == dev)) {
633 if (!tmpd->key || !tmpd->key->xkbInfo)
634 continue;
635
636 oldState = tmpd->key->xkbInfo->state;
637 newState = &tmpd->key->xkbInfo->state;
638 if (stuff->affectModLocks) {
639 newState->locked_mods &= ~stuff->affectModLocks;
640 newState->locked_mods |=
641 (stuff->affectModLocks & stuff->modLocks);
642 }
643 if (status == Success0 && stuff->lockGroup)
644 newState->locked_group = stuff->groupLock;
645 if (status == Success0 && stuff->affectModLatches)
646 status = XkbLatchModifiersSrvXkbLatchModifiers(tmpd, stuff->affectModLatches,
647 stuff->modLatches);
648 if (status == Success0 && stuff->latchGroup)
649 status = XkbLatchGroupSrvXkbLatchGroup(tmpd, stuff->groupLatch);
650
651 if (status != Success0)
652 return status;
653
654 XkbComputeDerivedState(tmpd->key->xkbInfo);
655
656 changed = XkbStateChangedFlags(&oldState, newState);
657 if (changed) {
658 sn.keycode = 0;
659 sn.eventType = 0;
660 sn.requestMajor = XkbReqCode;
661 sn.requestMinor = X_kbLatchLockState5;
662 sn.changed = changed;
663 XkbSendStateNotify(tmpd, &sn);
664 changed = XkbIndicatorsToUpdate(tmpd, changed, FALSE0);
665 if (changed) {
666 XkbSetCauseXkbReq(&cause, X_kbLatchLockState, client){ (&cause)->kc= (&cause)->event= 0, (&cause
)->mjr= (XkbReqCode),(&cause)->mnr= (5); (&cause
)->client= (client); }
;
667 XkbUpdateIndicators(tmpd, changed, TRUE1, NULL((void*)0), &cause);
668 }
669 }
670 }
671 }
672
673 return Success0;
674}
675
676/***====================================================================***/
677
678int
679ProcXkbGetControls(ClientPtr client)
680{
681 xkbGetControlsReply rep;
682 XkbControlsPtr xkb;
683 DeviceIntPtr dev;
684
685 REQUEST(xkbGetControlsReq)xkbGetControlsReq *stuff = (xkbGetControlsReq *)client->requestBuffer;
686 REQUEST_SIZE_MATCH(xkbGetControlsReq)if ((sizeof(xkbGetControlsReq) >> 2) != client->req_len
) return(16)
;
687
688 if (!(client->xkbClientFlags & _XkbClientInitialized(1<<15)))
689 return BadAccess10;
690
691 CHK_KBD_DEVICE(dev, stuff->deviceSpec, client, DixGetAttrAccess){ int why; int tmprc = _XkbLookupKeyboard(&(dev), stuff->
deviceSpec, client, (1<<4), &why); if (tmprc != 0) {
client->errorValue = ((XID)((((unsigned int)(why))<<
24)|((stuff->deviceSpec)&0xffffff))); return tmprc; }}
;
692
693 xkb = dev->key->xkbInfo->desc->ctrls;
694 rep = (xkbGetControlsReply) {
695 .type = X_Reply1,
696 .deviceID = ((DeviceIntPtr) dev)->id,
697 .sequenceNumber = client->sequence,
698 .length = bytes_to_int32(SIZEOF(xkbGetControlsReply)92 -
699 SIZEOF(xGenericReply)32),
700 .mkDfltBtn = xkb->mk_dflt_btn,
701 .numGroups = xkb->num_groups,
702 .groupsWrap = xkb->groups_wrap,
703 .internalMods = xkb->internal.mask,
704 .ignoreLockMods = xkb->ignore_lock.mask,
705 .internalRealMods = xkb->internal.real_mods,
706 .ignoreLockRealMods = xkb->ignore_lock.real_mods,
707 .internalVMods = xkb->internal.vmods,
708 .ignoreLockVMods = xkb->ignore_lock.vmods,
709 .repeatDelay = xkb->repeat_delay,
710 .repeatInterval = xkb->repeat_interval,
711 .slowKeysDelay = xkb->slow_keys_delay,
712 .debounceDelay = xkb->debounce_delay,
713 .mkDelay = xkb->mk_delay,
714 .mkInterval = xkb->mk_interval,
715 .mkTimeToMax = xkb->mk_time_to_max,
716 .mkMaxSpeed = xkb->mk_max_speed,
717 .mkCurve = xkb->mk_curve,
718 .axOptions = xkb->ax_options,
719 .axTimeout = xkb->ax_timeout,
720 .axtOptsMask = xkb->axt_opts_mask,
721 .axtOptsValues = xkb->axt_opts_values,
722 .axtCtrlsMask = xkb->axt_ctrls_mask,
723 .axtCtrlsValues = xkb->axt_ctrls_values,
724 .enabledCtrls = xkb->enabled_ctrls,
725 };
726 memcpy(rep.perKeyRepeat, xkb->per_key_repeat, XkbPerKeyBitArraySize)__builtin___memcpy_chk (rep.perKeyRepeat, xkb->per_key_repeat
, ((255 +1)/8), __builtin_object_size (rep.perKeyRepeat, 0))
;
727 if (client->swapped) {
728 swaps(&rep.sequenceNumber)do { if (sizeof(*(&rep.sequenceNumber)) != 2) wrong_size(
); if (__builtin_constant_p((uintptr_t)(&rep.sequenceNumber
) & 1) && ((uintptr_t)(&rep.sequenceNumber) &
1) == 0) *(&rep.sequenceNumber) = lswaps(*(&rep.sequenceNumber
)); else swap_uint16((uint16_t *)(&rep.sequenceNumber)); }
while (0)
;
729 swapl(&rep.length)do { if (sizeof(*(&rep.length)) != 4) wrong_size(); if (__builtin_constant_p
((uintptr_t)(&rep.length) & 3) && ((uintptr_t
)(&rep.length) & 3) == 0) *(&rep.length) = lswapl
(*(&rep.length)); else swap_uint32((uint32_t *)(&rep.
length)); } while (0)
;
730 swaps(&rep.internalVMods)do { if (sizeof(*(&rep.internalVMods)) != 2) wrong_size()
; if (__builtin_constant_p((uintptr_t)(&rep.internalVMods
) & 1) && ((uintptr_t)(&rep.internalVMods) &
1) == 0) *(&rep.internalVMods) = lswaps(*(&rep.internalVMods
)); else swap_uint16((uint16_t *)(&rep.internalVMods)); }
while (0)
;
731 swaps(&rep.ignoreLockVMods)do { if (sizeof(*(&rep.ignoreLockVMods)) != 2) wrong_size
(); if (__builtin_constant_p((uintptr_t)(&rep.ignoreLockVMods
) & 1) && ((uintptr_t)(&rep.ignoreLockVMods) &
1) == 0) *(&rep.ignoreLockVMods) = lswaps(*(&rep.ignoreLockVMods
)); else swap_uint16((uint16_t *)(&rep.ignoreLockVMods));
} while (0)
;
732 swapl(&rep.enabledCtrls)do { if (sizeof(*(&rep.enabledCtrls)) != 4) wrong_size();
if (__builtin_constant_p((uintptr_t)(&rep.enabledCtrls) &
3) && ((uintptr_t)(&rep.enabledCtrls) & 3) ==
0) *(&rep.enabledCtrls) = lswapl(*(&rep.enabledCtrls
)); else swap_uint32((uint32_t *)(&rep.enabledCtrls)); } while
(0)
;
733 swaps(&rep.repeatDelay)do { if (sizeof(*(&rep.repeatDelay)) != 2) wrong_size(); if
(__builtin_constant_p((uintptr_t)(&rep.repeatDelay) &
1) && ((uintptr_t)(&rep.repeatDelay) & 1) ==
0) *(&rep.repeatDelay) = lswaps(*(&rep.repeatDelay))
; else swap_uint16((uint16_t *)(&rep.repeatDelay)); } while
(0)
;
734 swaps(&rep.repeatInterval)do { if (sizeof(*(&rep.repeatInterval)) != 2) wrong_size(
); if (__builtin_constant_p((uintptr_t)(&rep.repeatInterval
) & 1) && ((uintptr_t)(&rep.repeatInterval) &
1) == 0) *(&rep.repeatInterval) = lswaps(*(&rep.repeatInterval
)); else swap_uint16((uint16_t *)(&rep.repeatInterval)); }
while (0)
;
735 swaps(&rep.slowKeysDelay)do { if (sizeof(*(&rep.slowKeysDelay)) != 2) wrong_size()
; if (__builtin_constant_p((uintptr_t)(&rep.slowKeysDelay
) & 1) && ((uintptr_t)(&rep.slowKeysDelay) &
1) == 0) *(&rep.slowKeysDelay) = lswaps(*(&rep.slowKeysDelay
)); else swap_uint16((uint16_t *)(&rep.slowKeysDelay)); }
while (0)
;
736 swaps(&rep.debounceDelay)do { if (sizeof(*(&rep.debounceDelay)) != 2) wrong_size()
; if (__builtin_constant_p((uintptr_t)(&rep.debounceDelay
) & 1) && ((uintptr_t)(&rep.debounceDelay) &
1) == 0) *(&rep.debounceDelay) = lswaps(*(&rep.debounceDelay
)); else swap_uint16((uint16_t *)(&rep.debounceDelay)); }
while (0)
;
737 swaps(&rep.mkDelay)do { if (sizeof(*(&rep.mkDelay)) != 2) wrong_size(); if (
__builtin_constant_p((uintptr_t)(&rep.mkDelay) & 1) &&
((uintptr_t)(&rep.mkDelay) & 1) == 0) *(&rep.mkDelay
) = lswaps(*(&rep.mkDelay)); else swap_uint16((uint16_t *
)(&rep.mkDelay)); } while (0)
;
738 swaps(&rep.mkInterval)do { if (sizeof(*(&rep.mkInterval)) != 2) wrong_size(); if
(__builtin_constant_p((uintptr_t)(&rep.mkInterval) &
1) && ((uintptr_t)(&rep.mkInterval) & 1) == 0
) *(&rep.mkInterval) = lswaps(*(&rep.mkInterval)); else
swap_uint16((uint16_t *)(&rep.mkInterval)); } while (0)
;
739 swaps(&rep.mkTimeToMax)do { if (sizeof(*(&rep.mkTimeToMax)) != 2) wrong_size(); if
(__builtin_constant_p((uintptr_t)(&rep.mkTimeToMax) &
1) && ((uintptr_t)(&rep.mkTimeToMax) & 1) ==
0) *(&rep.mkTimeToMax) = lswaps(*(&rep.mkTimeToMax))
; else swap_uint16((uint16_t *)(&rep.mkTimeToMax)); } while
(0)
;
740 swaps(&rep.mkMaxSpeed)do { if (sizeof(*(&rep.mkMaxSpeed)) != 2) wrong_size(); if
(__builtin_constant_p((uintptr_t)(&rep.mkMaxSpeed) &
1) && ((uintptr_t)(&rep.mkMaxSpeed) & 1) == 0
) *(&rep.mkMaxSpeed) = lswaps(*(&rep.mkMaxSpeed)); else
swap_uint16((uint16_t *)(&rep.mkMaxSpeed)); } while (0)
;
741 swaps(&rep.mkCurve)do { if (sizeof(*(&rep.mkCurve)) != 2) wrong_size(); if (
__builtin_constant_p((uintptr_t)(&rep.mkCurve) & 1) &&
((uintptr_t)(&rep.mkCurve) & 1) == 0) *(&rep.mkCurve
) = lswaps(*(&rep.mkCurve)); else swap_uint16((uint16_t *
)(&rep.mkCurve)); } while (0)
;
742 swaps(&rep.axTimeout)do { if (sizeof(*(&rep.axTimeout)) != 2) wrong_size(); if
(__builtin_constant_p((uintptr_t)(&rep.axTimeout) & 1
) && ((uintptr_t)(&rep.axTimeout) & 1) == 0) *
(&rep.axTimeout) = lswaps(*(&rep.axTimeout)); else swap_uint16
((uint16_t *)(&rep.axTimeout)); } while (0)
;
743 swapl(&rep.axtCtrlsMask)do { if (sizeof(*(&rep.axtCtrlsMask)) != 4) wrong_size();
if (__builtin_constant_p((uintptr_t)(&rep.axtCtrlsMask) &
3) && ((uintptr_t)(&rep.axtCtrlsMask) & 3) ==
0) *(&rep.axtCtrlsMask) = lswapl(*(&rep.axtCtrlsMask
)); else swap_uint32((uint32_t *)(&rep.axtCtrlsMask)); } while
(0)
;
744 swapl(&rep.axtCtrlsValues)do { if (sizeof(*(&rep.axtCtrlsValues)) != 4) wrong_size(
); if (__builtin_constant_p((uintptr_t)(&rep.axtCtrlsValues
) & 3) && ((uintptr_t)(&rep.axtCtrlsValues) &
3) == 0) *(&rep.axtCtrlsValues) = lswapl(*(&rep.axtCtrlsValues
)); else swap_uint32((uint32_t *)(&rep.axtCtrlsValues)); }
while (0)
;
745 swaps(&rep.axtOptsMask)do { if (sizeof(*(&rep.axtOptsMask)) != 2) wrong_size(); if
(__builtin_constant_p((uintptr_t)(&rep.axtOptsMask) &
1) && ((uintptr_t)(&rep.axtOptsMask) & 1) ==
0) *(&rep.axtOptsMask) = lswaps(*(&rep.axtOptsMask))
; else swap_uint16((uint16_t *)(&rep.axtOptsMask)); } while
(0)
;
746 swaps(&rep.axtOptsValues)do { if (sizeof(*(&rep.axtOptsValues)) != 2) wrong_size()
; if (__builtin_constant_p((uintptr_t)(&rep.axtOptsValues
) & 1) && ((uintptr_t)(&rep.axtOptsValues) &
1) == 0) *(&rep.axtOptsValues) = lswaps(*(&rep.axtOptsValues
)); else swap_uint16((uint16_t *)(&rep.axtOptsValues)); }
while (0)
;
747 swaps(&rep.axOptions)do { if (sizeof(*(&rep.axOptions)) != 2) wrong_size(); if
(__builtin_constant_p((uintptr_t)(&rep.axOptions) & 1
) && ((uintptr_t)(&rep.axOptions) & 1) == 0) *
(&rep.axOptions) = lswaps(*(&rep.axOptions)); else swap_uint16
((uint16_t *)(&rep.axOptions)); } while (0)
;
748 }
749 WriteToClient(client, SIZEOF(xkbGetControlsReply)92, &rep);
750 return Success0;
751}
752
753int
754ProcXkbSetControls(ClientPtr client)
755{
756 DeviceIntPtr dev, tmpd;
757 XkbSrvInfoPtr xkbi;
758 XkbControlsPtr ctrl;
759 XkbControlsRec new, old;
760 xkbControlsNotify cn;
761 XkbEventCauseRec cause;
762 XkbSrvLedInfoPtr sli;
763
764 REQUEST(xkbSetControlsReq)xkbSetControlsReq *stuff = (xkbSetControlsReq *)client->requestBuffer;
765 REQUEST_SIZE_MATCH(xkbSetControlsReq)if ((sizeof(xkbSetControlsReq) >> 2) != client->req_len
) return(16)
;
766
767 if (!(client->xkbClientFlags & _XkbClientInitialized(1<<15)))
768 return BadAccess10;
769
770 CHK_KBD_DEVICE(dev, stuff->deviceSpec, client, DixManageAccess){ int why; int tmprc = _XkbLookupKeyboard(&(dev), stuff->
deviceSpec, client, (1<<25), &why); if (tmprc != 0)
{ client->errorValue = ((XID)((((unsigned int)(why))<<
24)|((stuff->deviceSpec)&0xffffff))); return tmprc; }}
;
771 CHK_MASK_LEGAL(0x01, stuff->changeCtrls, XkbAllControlsMask){ if ((stuff->changeCtrls)&(~((0xF8001FFF)))) { (client
->errorValue)= ((XID)((((unsigned int)((0x01)))<<24)
|((((stuff->changeCtrls)&(~((0xF8001FFF)))))&0xffffff
))); return 2; }}
;
772
773 for (tmpd = inputInfo.devices; tmpd; tmpd = tmpd->next) {
774 if (!tmpd->key || !tmpd->key->xkbInfo)
775 continue;
776 if ((tmpd == dev) ||
777 (!IsMaster(tmpd) && GetMaster(tmpd, MASTER_KEYBOARD2) == dev)) {
778 xkbi = tmpd->key->xkbInfo;
779 ctrl = xkbi->desc->ctrls;
780 new = *ctrl;
781 XkbSetCauseXkbReq(&cause, X_kbSetControls, client){ (&cause)->kc= (&cause)->event= 0, (&cause
)->mjr= (XkbReqCode),(&cause)->mnr= (7); (&cause
)->client= (client); }
;
782
783 if (stuff->changeCtrls & XkbInternalModsMask(1L << 28)) {
784 CHK_MASK_MATCH(0x02, stuff->affectInternalMods,{ if ((stuff->internalMods)&(~(stuff->affectInternalMods
))) { client->errorValue= ((XID)((((unsigned int)((0x02)))
<<24)|((((stuff->internalMods)&(~(stuff->affectInternalMods
))))&0xffffff))); return 8; }}
785 stuff->internalMods){ if ((stuff->internalMods)&(~(stuff->affectInternalMods
))) { client->errorValue= ((XID)((((unsigned int)((0x02)))
<<24)|((((stuff->internalMods)&(~(stuff->affectInternalMods
))))&0xffffff))); return 8; }}
;
786 CHK_MASK_MATCH(0x03, stuff->affectInternalVMods,{ if ((stuff->internalVMods)&(~(stuff->affectInternalVMods
))) { client->errorValue= ((XID)((((unsigned int)((0x03)))
<<24)|((((stuff->internalVMods)&(~(stuff->affectInternalVMods
))))&0xffffff))); return 8; }}
787 stuff->internalVMods){ if ((stuff->internalVMods)&(~(stuff->affectInternalVMods
))) { client->errorValue= ((XID)((((unsigned int)((0x03)))
<<24)|((((stuff->internalVMods)&(~(stuff->affectInternalVMods
))))&0xffffff))); return 8; }}
;
788
789 new.internal.real_mods &= ~(stuff->affectInternalMods);
790 new.internal.real_mods |= (stuff->affectInternalMods &
791 stuff->internalMods);
792 new.internal.vmods &= ~(stuff->affectInternalVMods);
793 new.internal.vmods |= (stuff->affectInternalVMods &
794 stuff->internalVMods);
795 new.internal.mask = new.internal.real_mods |
796 XkbMaskForVMask(xkbi->desc, new.internal.vmods);
797 }
798
799 if (stuff->changeCtrls & XkbIgnoreLockModsMask(1L << 29)) {
800 CHK_MASK_MATCH(0x4, stuff->affectIgnoreLockMods,{ if ((stuff->ignoreLockMods)&(~(stuff->affectIgnoreLockMods
))) { client->errorValue= ((XID)((((unsigned int)((0x4)))<<
24)|((((stuff->ignoreLockMods)&(~(stuff->affectIgnoreLockMods
))))&0xffffff))); return 8; }}
801 stuff->ignoreLockMods){ if ((stuff->ignoreLockMods)&(~(stuff->affectIgnoreLockMods
))) { client->errorValue= ((XID)((((unsigned int)((0x4)))<<
24)|((((stuff->ignoreLockMods)&(~(stuff->affectIgnoreLockMods
))))&0xffffff))); return 8; }}
;
802 CHK_MASK_MATCH(0x5, stuff->affectIgnoreLockVMods,{ if ((stuff->ignoreLockVMods)&(~(stuff->affectIgnoreLockVMods
))) { client->errorValue= ((XID)((((unsigned int)((0x5)))<<
24)|((((stuff->ignoreLockVMods)&(~(stuff->affectIgnoreLockVMods
))))&0xffffff))); return 8; }}
803 stuff->ignoreLockVMods){ if ((stuff->ignoreLockVMods)&(~(stuff->affectIgnoreLockVMods
))) { client->errorValue= ((XID)((((unsigned int)((0x5)))<<
24)|((((stuff->ignoreLockVMods)&(~(stuff->affectIgnoreLockVMods
))))&0xffffff))); return 8; }}
;
804
805 new.ignore_lock.real_mods &= ~(stuff->affectIgnoreLockMods);
806 new.ignore_lock.real_mods |= (stuff->affectIgnoreLockMods &
807 stuff->ignoreLockMods);
808 new.ignore_lock.vmods &= ~(stuff->affectIgnoreLockVMods);
809 new.ignore_lock.vmods |= (stuff->affectIgnoreLockVMods &
810 stuff->ignoreLockVMods);
811 new.ignore_lock.mask = new.ignore_lock.real_mods |
812 XkbMaskForVMask(xkbi->desc, new.ignore_lock.vmods);
813 }
814
815 CHK_MASK_MATCH(0x06, stuff->affectEnabledCtrls,{ if ((stuff->enabledCtrls)&(~(stuff->affectEnabledCtrls
))) { client->errorValue= ((XID)((((unsigned int)((0x06)))
<<24)|((((stuff->enabledCtrls)&(~(stuff->affectEnabledCtrls
))))&0xffffff))); return 8; }}
816 stuff->enabledCtrls){ if ((stuff->enabledCtrls)&(~(stuff->affectEnabledCtrls
))) { client->errorValue= ((XID)((((unsigned int)((0x06)))
<<24)|((((stuff->enabledCtrls)&(~(stuff->affectEnabledCtrls
))))&0xffffff))); return 8; }}
;
817 if (stuff->affectEnabledCtrls) {
818 CHK_MASK_LEGAL(0x07, stuff->affectEnabledCtrls,{ if ((stuff->affectEnabledCtrls)&(~((0x00001FFF)))) {
(client->errorValue)= ((XID)((((unsigned int)((0x07)))<<
24)|((((stuff->affectEnabledCtrls)&(~((0x00001FFF)))))
&0xffffff))); return 2; }}
819 XkbAllBooleanCtrlsMask){ if ((stuff->affectEnabledCtrls)&(~((0x00001FFF)))) {
(client->errorValue)= ((XID)((((unsigned int)((0x07)))<<
24)|((((stuff->affectEnabledCtrls)&(~((0x00001FFF)))))
&0xffffff))); return 2; }}
;
820
821 new.enabled_ctrls &= ~(stuff->affectEnabledCtrls);
822 new.enabled_ctrls |= (stuff->affectEnabledCtrls &
823 stuff->enabledCtrls);
824 }
825
826 if (stuff->changeCtrls & XkbRepeatKeysMask(1L << 0)) {
827 if (stuff->repeatDelay < 1 || stuff->repeatInterval < 1) {
828 client->errorValue = _XkbErrCode3(0x08, stuff->repeatDelay,((XID)((((unsigned int)(0x08))<<24)|(((((unsigned int)(
stuff->repeatDelay))<<16)|(stuff->repeatInterval)
)&0xffffff)))
829 stuff->repeatInterval)((XID)((((unsigned int)(0x08))<<24)|(((((unsigned int)(
stuff->repeatDelay))<<16)|(stuff->repeatInterval)
)&0xffffff)))
;
830 return BadValue2;
831 }
832
833 new.repeat_delay = stuff->repeatDelay;
834 new.repeat_interval = stuff->repeatInterval;
835 }
836
837 if (stuff->changeCtrls & XkbSlowKeysMask(1L << 1)) {
838 if (stuff->slowKeysDelay < 1) {
839 client->errorValue = _XkbErrCode2(0x09,((XID)((((unsigned int)(0x09))<<24)|((stuff->slowKeysDelay
)&0xffffff)))
840 stuff->slowKeysDelay)((XID)((((unsigned int)(0x09))<<24)|((stuff->slowKeysDelay
)&0xffffff)))
;
841 return BadValue2;
842 }
843
844 new.slow_keys_delay = stuff->slowKeysDelay;
845 }
846
847 if (stuff->changeCtrls & XkbBounceKeysMask(1L << 2)) {
848 if (stuff->debounceDelay < 1) {
849 client->errorValue = _XkbErrCode2(0x0A,((XID)((((unsigned int)(0x0A))<<24)|((stuff->debounceDelay
)&0xffffff)))
850 stuff->debounceDelay)((XID)((((unsigned int)(0x0A))<<24)|((stuff->debounceDelay
)&0xffffff)))
;
851 return BadValue2;
852 }
853
854 new.debounce_delay = stuff->debounceDelay;
855 }
856
857 if (stuff->changeCtrls & XkbMouseKeysMask(1L << 4)) {
858 if (stuff->mkDfltBtn > XkbMaxMouseKeysBtn4) {
859 client->errorValue = _XkbErrCode2(0x0B, stuff->mkDfltBtn)((XID)((((unsigned int)(0x0B))<<24)|((stuff->mkDfltBtn
)&0xffffff)))
;
860 return BadValue2;
861 }
862
863 new.mk_dflt_btn = stuff->mkDfltBtn;
864 }
865
866 if (stuff->changeCtrls & XkbMouseKeysAccelMask(1L << 5)) {
867 if (stuff->mkDelay < 1 || stuff->mkInterval < 1 ||
868 stuff->mkTimeToMax < 1 || stuff->mkMaxSpeed < 1 ||
869 stuff->mkCurve < -1000) {
870 client->errorValue = _XkbErrCode2(0x0C, 0)((XID)((((unsigned int)(0x0C))<<24)|((0)&0xffffff))
)
;
871 return BadValue2;
872 }
873
874 new.mk_delay = stuff->mkDelay;
875 new.mk_interval = stuff->mkInterval;
876 new.mk_time_to_max = stuff->mkTimeToMax;
877 new.mk_max_speed = stuff->mkMaxSpeed;
878 new.mk_curve = stuff->mkCurve;
879 AccessXComputeCurveFactor(xkbi, &new);
880 }
881
882 if (stuff->changeCtrls & XkbGroupsWrapMask(1L << 27)) {
883 unsigned act, num;
884
885 act = XkbOutOfRangeGroupAction(stuff->groupsWrap)((stuff->groupsWrap)&0xc0);
886 switch (act) {
887 case XkbRedirectIntoRange(0x80):
888 num = XkbOutOfRangeGroupNumber(stuff->groupsWrap)(((stuff->groupsWrap)&0x30)>>4);
889 if (num >= new.num_groups) {
890 client->errorValue = _XkbErrCode3(0x0D, new.num_groups,((XID)((((unsigned int)(0x0D))<<24)|(((((unsigned int)(
new.num_groups))<<16)|(num))&0xffffff)))
891 num)((XID)((((unsigned int)(0x0D))<<24)|(((((unsigned int)(
new.num_groups))<<16)|(num))&0xffffff)))
;
892 return BadValue2;
893 }
894 case XkbWrapIntoRange(0x00):
895 case XkbClampIntoRange(0x40):
896 break;
897 default:
898 client->errorValue = _XkbErrCode2(0x0E, act)((XID)((((unsigned int)(0x0E))<<24)|((act)&0xffffff
)))
;
899 return BadValue2;
900 }
901
902 new.groups_wrap = stuff->groupsWrap;
903 }
904
905 CHK_MASK_LEGAL(0x0F, stuff->axOptions, XkbAX_AllOptionsMask){ if ((stuff->axOptions)&(~((0xFFF)))) { (client->errorValue
)= ((XID)((((unsigned int)((0x0F)))<<24)|((((stuff->
axOptions)&(~((0xFFF)))))&0xffffff))); return 2; }}
;
906 if (stuff->changeCtrls & XkbAccessXKeysMask(1L << 6)) {
907 new.ax_options = stuff->axOptions & XkbAX_AllOptionsMask(0xFFF);
908 }
909 else {
910 if (stuff->changeCtrls & XkbStickyKeysMask(1L << 3)) {
911 new.ax_options &= ~(XkbAX_SKOptionsMask(0x0C0));
912 new.ax_options |= (stuff->axOptions & XkbAX_SKOptionsMask(0x0C0));
913 }
914
915 if (stuff->changeCtrls & XkbAccessXFeedbackMask(1L << 8)) {
916 new.ax_options &= ~(XkbAX_FBOptionsMask(0xF3F));
917 new.ax_options |= (stuff->axOptions & XkbAX_FBOptionsMask(0xF3F));
918 }
919 }
920
921 if (stuff->changeCtrls & XkbAccessXTimeoutMask(1L << 7)) {
922 if (stuff->axTimeout < 1) {
923 client->errorValue = _XkbErrCode2(0x10, stuff->axTimeout)((XID)((((unsigned int)(0x10))<<24)|((stuff->axTimeout
)&0xffffff)))
;
924 return BadValue2;
925 }
926 CHK_MASK_MATCH(0x11, stuff->axtCtrlsMask,{ if ((stuff->axtCtrlsValues)&(~(stuff->axtCtrlsMask
))) { client->errorValue= ((XID)((((unsigned int)((0x11)))
<<24)|((((stuff->axtCtrlsValues)&(~(stuff->axtCtrlsMask
))))&0xffffff))); return 8; }}
927 stuff->axtCtrlsValues){ if ((stuff->axtCtrlsValues)&(~(stuff->axtCtrlsMask
))) { client->errorValue= ((XID)((((unsigned int)((0x11)))
<<24)|((((stuff->axtCtrlsValues)&(~(stuff->axtCtrlsMask
))))&0xffffff))); return 8; }}
;
928 CHK_MASK_LEGAL(0x12, stuff->axtCtrlsMask,{ if ((stuff->axtCtrlsMask)&(~((0x00001FFF)))) { (client
->errorValue)= ((XID)((((unsigned int)((0x12)))<<24)
|((((stuff->axtCtrlsMask)&(~((0x00001FFF)))))&0xffffff
))); return 2; }}
929 XkbAllBooleanCtrlsMask){ if ((stuff->axtCtrlsMask)&(~((0x00001FFF)))) { (client
->errorValue)= ((XID)((((unsigned int)((0x12)))<<24)
|((((stuff->axtCtrlsMask)&(~((0x00001FFF)))))&0xffffff
))); return 2; }}
;
930 CHK_MASK_MATCH(0x13, stuff->axtOptsMask, stuff->axtOptsValues){ if ((stuff->axtOptsValues)&(~(stuff->axtOptsMask)
)) { client->errorValue= ((XID)((((unsigned int)((0x13)))<<
24)|((((stuff->axtOptsValues)&(~(stuff->axtOptsMask
))))&0xffffff))); return 8; }}
;
931 CHK_MASK_LEGAL(0x14, stuff->axtOptsMask, XkbAX_AllOptionsMask){ if ((stuff->axtOptsMask)&(~((0xFFF)))) { (client->
errorValue)= ((XID)((((unsigned int)((0x14)))<<24)|((((
stuff->axtOptsMask)&(~((0xFFF)))))&0xffffff))); return
2; }}
;
932 new.ax_timeout = stuff->axTimeout;
933 new.axt_ctrls_mask = stuff->axtCtrlsMask;
934 new.axt_ctrls_values = (stuff->axtCtrlsValues &
935 stuff->axtCtrlsMask);
936 new.axt_opts_mask = stuff->axtOptsMask;
937 new.axt_opts_values = (stuff->axtOptsValues &
938 stuff->axtOptsMask);
939 }
940
941 if (stuff->changeCtrls & XkbPerKeyRepeatMask(1L << 30)) {
942 memcpy(new.per_key_repeat, stuff->perKeyRepeat,__builtin___memcpy_chk (new.per_key_repeat, stuff->perKeyRepeat
, ((255 +1)/8), __builtin_object_size (new.per_key_repeat, 0)
)
943 XkbPerKeyBitArraySize)__builtin___memcpy_chk (new.per_key_repeat, stuff->perKeyRepeat
, ((255 +1)/8), __builtin_object_size (new.per_key_repeat, 0)
)
;
944 if (xkbi->repeatKey &&
945 !BitIsOn(new.per_key_repeat, xkbi->repeatKey)(!!(((const BYTE *) (new.per_key_repeat))[(xkbi->repeatKey
)>>3] & (1 << ((xkbi->repeatKey) & 7))
))
) {
946 AccessXCancelRepeatKey(xkbi, xkbi->repeatKey);
947 }
948 }
949
950 old = *ctrl;
951 *ctrl = new;
952 XkbDDXChangeControls(tmpd, &old, ctrl);
953
954 if (XkbComputeControlsNotify(tmpd, &old, ctrl, &cn, FALSE0)) {
955 cn.keycode = 0;
956 cn.eventType = 0;
957 cn.requestMajor = XkbReqCode;
958 cn.requestMinor = X_kbSetControls7;
959 XkbSendControlsNotify(tmpd, &cn);
960 }
961
962 sli = XkbFindSrvLedInfo(tmpd, XkbDfltXIClass0x0300, XkbDfltXIId0x0400, 0);
963 if (sli)
964 XkbUpdateIndicators(tmpd, sli->usesControls, TRUE1, NULL((void*)0),
965 &cause);
966
967 /* If sticky keys were disabled, clear all locks and latches */
968 if ((old.enabled_ctrls & XkbStickyKeysMask(1L << 3)) &&
969 !(ctrl->enabled_ctrls & XkbStickyKeysMask(1L << 3)))
970 XkbClearAllLatchesAndLocks(tmpd, xkbi, TRUE1, &cause);
971 }
972 }
973
974 return Success0;
975}
976
977/***====================================================================***/
978
979static int
980XkbSizeKeyTypes(XkbDescPtr xkb, xkbGetMapReply * rep)
981{
982 XkbKeyTypeRec *type;
983 unsigned i, len;
984
985 len = 0;
986 if (((rep->present & XkbKeyTypesMask(1<<0)) == 0) || (rep->nTypes < 1) ||
987 (!xkb) || (!xkb->map) || (!xkb->map->types)) {
988 rep->present &= ~XkbKeyTypesMask(1<<0);
989 rep->firstType = rep->nTypes = 0;
990 return 0;
991 }
992 type = &xkb->map->types[rep->firstType];
993 for (i = 0; i < rep->nTypes; i++, type++) {
994 len += SIZEOF(xkbKeyTypeWireDesc)8;
995 if (type->map_count > 0) {
996 len += (type->map_count * SIZEOF(xkbKTMapEntryWireDesc)8);
997 if (type->preserve)
998 len += (type->map_count * SIZEOF(xkbModsWireDesc)4);
999 }
1000 }
1001 return len;
1002}
1003
1004static char *
1005XkbWriteKeyTypes(XkbDescPtr xkb,
1006 xkbGetMapReply * rep, char *buf, ClientPtr client)
1007{
1008 XkbKeyTypePtr type;
1009 unsigned i;
1010 xkbKeyTypeWireDesc *wire;
1011
1012 type = &xkb->map->types[rep->firstType];
1013 for (i = 0; i < rep->nTypes; i++, type++) {
1014 register unsigned n;
1015
1016 wire = (xkbKeyTypeWireDesc *) buf;
1017 wire->mask = type->mods.mask;
1018 wire->realMods = type->mods.real_mods;
1019 wire->virtualMods = type->mods.vmods;
1020 wire->numLevels = type->num_levels;
1021 wire->nMapEntries = type->map_count;
1022 wire->preserve = (type->preserve != NULL((void*)0));
1023 if (client->swapped) {
1024 swaps(&wire->virtualMods)do { if (sizeof(*(&wire->virtualMods)) != 2) wrong_size
(); if (__builtin_constant_p((uintptr_t)(&wire->virtualMods
) & 1) && ((uintptr_t)(&wire->virtualMods)
& 1) == 0) *(&wire->virtualMods) = lswaps(*(&
wire->virtualMods)); else swap_uint16((uint16_t *)(&wire
->virtualMods)); } while (0)
;
1025 }
1026
1027 buf = (char *) &wire[1];
1028 if (wire->nMapEntries > 0) {
1029 xkbKTMapEntryWireDesc *ewire;
1030 XkbKTMapEntryPtr entry;
1031
1032 ewire = (xkbKTMapEntryWireDesc *) buf;
1033 entry = type->map;
1034 for (n = 0; n < type->map_count; n++, ewire++, entry++) {
1035 ewire->active = entry->active;
1036 ewire->mask = entry->mods.mask;
1037 ewire->level = entry->level;
1038 ewire->realMods = entry->mods.real_mods;
1039 ewire->virtualMods = entry->mods.vmods;
1040 if (client->swapped) {
1041 swaps(&ewire->virtualMods)do { if (sizeof(*(&ewire->virtualMods)) != 2) wrong_size
(); if (__builtin_constant_p((uintptr_t)(&ewire->virtualMods
) & 1) && ((uintptr_t)(&ewire->virtualMods
) & 1) == 0) *(&ewire->virtualMods) = lswaps(*(&
ewire->virtualMods)); else swap_uint16((uint16_t *)(&ewire
->virtualMods)); } while (0)
;
1042 }
1043 }
1044 buf = (char *) ewire;
1045 if (type->preserve != NULL((void*)0)) {
1046 xkbModsWireDesc *pwire;
1047 XkbModsPtr preserve;
1048
1049 pwire = (xkbModsWireDesc *) buf;
1050 preserve = type->preserve;
1051 for (n = 0; n < type->map_count; n++, pwire++, preserve++) {
1052 pwire->mask = preserve->mask;
1053 pwire->realMods = preserve->real_mods;
1054 pwire->virtualMods = preserve->vmods;
1055 if (client->swapped) {
1056 swaps(&pwire->virtualMods)do { if (sizeof(*(&pwire->virtualMods)) != 2) wrong_size
(); if (__builtin_constant_p((uintptr_t)(&pwire->virtualMods
) & 1) && ((uintptr_t)(&pwire->virtualMods
) & 1) == 0) *(&pwire->virtualMods) = lswaps(*(&
pwire->virtualMods)); else swap_uint16((uint16_t *)(&pwire
->virtualMods)); } while (0)
;
1057 }
1058 }
1059 buf = (char *) pwire;
1060 }
1061 }
1062 }
1063 return buf;
1064}
1065
1066static int
1067XkbSizeKeySyms(XkbDescPtr xkb, xkbGetMapReply * rep)
1068{
1069 XkbSymMapPtr symMap;
1070 unsigned i, len;
1071 unsigned nSyms, nSymsThisKey;
1072
1073 if (((rep->present & XkbKeySymsMask(1<<1)) == 0) || (rep->nKeySyms < 1) ||
1074 (!xkb) || (!xkb->map) || (!xkb->map->key_sym_map)) {
1075 rep->present &= ~XkbKeySymsMask(1<<1);
1076 rep->firstKeySym = rep->nKeySyms = 0;
1077 rep->totalSyms = 0;
1078 return 0;
1079 }
1080 len = rep->nKeySyms * SIZEOF(xkbSymMapWireDesc)8;
1081 symMap = &xkb->map->key_sym_map[rep->firstKeySym];
1082 for (i = nSyms = 0; i < rep->nKeySyms; i++, symMap++) {
1083 if (symMap->offset != 0) {
1084 nSymsThisKey = XkbNumGroups(symMap->group_info)((symMap->group_info)&0x0f) * symMap->width;
1085 nSyms += nSymsThisKey;
1086 }
1087 }
1088 len += nSyms * 4;
1089 rep->totalSyms = nSyms;
1090 return len;
1091}
1092
1093static int
1094XkbSizeVirtualMods(XkbDescPtr xkb, xkbGetMapReply * rep)
1095{
1096 register unsigned i, nMods, bit;
1097
1098 if (((rep->present & XkbVirtualModsMask(1<<6)) == 0) || (rep->virtualMods == 0) ||
1099 (!xkb) || (!xkb->server)) {
1100 rep->present &= ~XkbVirtualModsMask(1<<6);
1101 rep->virtualMods = 0;
1102 return 0;
1103 }
1104 for (i = nMods = 0, bit = 1; i < XkbNumVirtualMods16; i++, bit <<= 1) {
1105 if (rep->virtualMods & bit)
1106 nMods++;
1107 }
1108 return XkbPaddedSize(nMods)((((unsigned int)(nMods)+3) >> 2) << 2);
1109}
1110
1111static char *
1112XkbWriteKeySyms(XkbDescPtr xkb, xkbGetMapReply * rep, char *buf,
1113 ClientPtr client)
1114{
1115 register KeySym *pSym;
1116 XkbSymMapPtr symMap;
1117 xkbSymMapWireDesc *outMap;
1118 register unsigned i;
1119
1120 symMap = &xkb->map->key_sym_map[rep->firstKeySym];
1121 for (i = 0; i < rep->nKeySyms; i++, symMap++) {
1122 outMap = (xkbSymMapWireDesc *) buf;
1123 outMap->ktIndex[0] = symMap->kt_index[0];
1124 outMap->ktIndex[1] = symMap->kt_index[1];
1125 outMap->ktIndex[2] = symMap->kt_index[2];
1126 outMap->ktIndex[3] = symMap->kt_index[3];
1127 outMap->groupInfo = symMap->group_info;
1128 outMap->width = symMap->width;
1129 outMap->nSyms = symMap->width * XkbNumGroups(symMap->group_info)((symMap->group_info)&0x0f);
1130 buf = (char *) &outMap[1];
1131 if (outMap->nSyms == 0)
1132 continue;
1133
1134 pSym = &xkb->map->syms[symMap->offset];
1135 memcpy((char *) buf, (char *) pSym, outMap->nSyms * 4)__builtin___memcpy_chk ((char *) buf, (char *) pSym, outMap->
nSyms * 4, __builtin_object_size ((char *) buf, 0))
;
1136 if (client->swapped) {
1137 register int nSyms = outMap->nSyms;
1138
1139 swaps(&outMap->nSyms)do { if (sizeof(*(&outMap->nSyms)) != 2) wrong_size();
if (__builtin_constant_p((uintptr_t)(&outMap->nSyms) &
1) && ((uintptr_t)(&outMap->nSyms) & 1) ==
0) *(&outMap->nSyms) = lswaps(*(&outMap->nSyms
)); else swap_uint16((uint16_t *)(&outMap->nSyms)); } while
(0)
;
1140 while (nSyms-- > 0) {
1141 swapl((int *) buf)do { if (sizeof(*((int *) buf)) != 4) wrong_size(); if (__builtin_constant_p
((uintptr_t)((int *) buf) & 3) && ((uintptr_t)((int
*) buf) & 3) == 0) *((int *) buf) = lswapl(*((int *) buf
)); else swap_uint32((uint32_t *)((int *) buf)); } while (0)
;
1142 buf += 4;
1143 }
1144 }
1145 else
1146 buf += outMap->nSyms * 4;
1147 }
1148 return buf;
1149}
1150
1151static int
1152XkbSizeKeyActions(XkbDescPtr xkb, xkbGetMapReply * rep)
1153{
1154 unsigned i, len, nActs;
1155 register KeyCode firstKey;
1156
1157 if (((rep->present & XkbKeyActionsMask(1<<4)) == 0) || (rep->nKeyActs < 1) ||
1158 (!xkb) || (!xkb->server) || (!xkb->server->key_acts)) {
1159 rep->present &= ~XkbKeyActionsMask(1<<4);
1160 rep->firstKeyAct = rep->nKeyActs = 0;
1161 rep->totalActs = 0;
1162 return 0;
1163 }
1164 firstKey = rep->firstKeyAct;
1165 for (nActs = i = 0; i < rep->nKeyActs; i++) {
1166 if (xkb->server->key_acts[i + firstKey] != 0)
1167 nActs += XkbKeyNumActions(xkb, i + firstKey)((!!((xkb))->server->key_acts[((i + firstKey))]) ? ((((
(((xkb))->map))->key_sym_map[((((i + firstKey))))].width
) * (((((((xkb))->map))->key_sym_map[((((i + firstKey))
))].group_info)&0x0f)))) : 1)
;
1168 }
1169 len = XkbPaddedSize(rep->nKeyActs)((((unsigned int)(rep->nKeyActs)+3) >> 2) << 2
)
+ (nActs * SIZEOF(xkbActionWireDesc)8);
1170 rep->totalActs = nActs;
1171 return len;
1172}
1173
1174static char *
1175XkbWriteKeyActions(XkbDescPtr xkb, xkbGetMapReply * rep, char *buf,
1176 ClientPtr client)
1177{
1178 unsigned i;
1179 CARD8 *numDesc;
1180 XkbAnyAction *actDesc;
1181
1182 numDesc = (CARD8 *) buf;
1183 for (i = 0; i < rep->nKeyActs; i++) {
1184 if (xkb->server->key_acts[i + rep->firstKeyAct] == 0)
1185 numDesc[i] = 0;
1186 else
1187 numDesc[i] = XkbKeyNumActions(xkb, (i + rep->firstKeyAct))((!!((xkb))->server->key_acts[(((i + rep->firstKeyAct
)))]) ? (((((((xkb))->map))->key_sym_map[(((((i + rep->
firstKeyAct)))))].width) * (((((((xkb))->map))->key_sym_map
[(((((i + rep->firstKeyAct)))))].group_info)&0x0f)))) :
1)
;
1188 }
1189 buf += XkbPaddedSize(rep->nKeyActs)((((unsigned int)(rep->nKeyActs)+3) >> 2) << 2
)
;
1190
1191 actDesc = (XkbAnyAction *) buf;
1192 for (i = 0; i < rep->nKeyActs; i++) {
1193 if (xkb->server->key_acts[i + rep->firstKeyAct] != 0) {
1194 unsigned int num;
1195
1196 num = XkbKeyNumActions(xkb, (i + rep->firstKeyAct))((!!((xkb))->server->key_acts[(((i + rep->firstKeyAct
)))]) ? (((((((xkb))->map))->key_sym_map[(((((i + rep->
firstKeyAct)))))].width) * (((((((xkb))->map))->key_sym_map
[(((((i + rep->firstKeyAct)))))].group_info)&0x0f)))) :
1)
;
1197 memcpy((char *) actDesc,__builtin___memcpy_chk ((char *) actDesc, (char *) ((&((xkb
)->server)->acts[((xkb)->server)->key_acts[(((i +
rep->firstKeyAct)))]])), num * 8, __builtin_object_size (
(char *) actDesc, 0))
1198 (char *) XkbKeyActionsPtr(xkb, (i + rep->firstKeyAct)),__builtin___memcpy_chk ((char *) actDesc, (char *) ((&((xkb
)->server)->acts[((xkb)->server)->key_acts[(((i +
rep->firstKeyAct)))]])), num * 8, __builtin_object_size (
(char *) actDesc, 0))
1199 num * SIZEOF(xkbActionWireDesc))__builtin___memcpy_chk ((char *) actDesc, (char *) ((&((xkb
)->server)->acts[((xkb)->server)->key_acts[(((i +
rep->firstKeyAct)))]])), num * 8, __builtin_object_size (
(char *) actDesc, 0))
;
1200 actDesc += num;
1201 }
1202 }
1203 buf = (char *) actDesc;
1204 return buf;
1205}
1206
1207static int
1208XkbSizeKeyBehaviors(XkbDescPtr xkb, xkbGetMapReply * rep)
1209{
1210 unsigned i, len, nBhvr;
1211 XkbBehavior *bhv;
1212
1213 if (((rep->present & XkbKeyBehaviorsMask(1<<5)) == 0) || (rep->nKeyBehaviors < 1)
1214 || (!xkb) || (!xkb->server) || (!xkb->server->behaviors)) {
1215 rep->present &= ~XkbKeyBehaviorsMask(1<<5);
1216 rep->firstKeyBehavior = rep->nKeyBehaviors = 0;
1217 rep->totalKeyBehaviors = 0;
1218 return 0;
1219 }
1220 bhv = &xkb->server->behaviors[rep->firstKeyBehavior];
1221 for (nBhvr = i = 0; i < rep->nKeyBehaviors; i++, bhv++) {
1222 if (bhv->type != XkbKB_Default0x00)
1223 nBhvr++;
1224 }
1225 len = nBhvr * SIZEOF(xkbBehaviorWireDesc)4;
1226 rep->totalKeyBehaviors = nBhvr;
1227 return len;
1228}
1229
1230static char *
1231XkbWriteKeyBehaviors(XkbDescPtr xkb, xkbGetMapReply * rep, char *buf,
1232 ClientPtr client)
1233{
1234 unsigned i;
1235 xkbBehaviorWireDesc *wire;
1236 XkbBehavior *pBhvr;
1237
1238 wire = (xkbBehaviorWireDesc *) buf;
1239 pBhvr = &xkb->server->behaviors[rep->firstKeyBehavior];
1240 for (i = 0; i < rep->nKeyBehaviors; i++, pBhvr++) {
1241 if (pBhvr->type != XkbKB_Default0x00) {
1242 wire->key = i + rep->firstKeyBehavior;
1243 wire->type = pBhvr->type;
1244 wire->data = pBhvr->data;
1245 wire++;
1246 }
1247 }
1248 buf = (char *) wire;
1249 return buf;
1250}
1251
1252static int
1253XkbSizeExplicit(XkbDescPtr xkb, xkbGetMapReply * rep)
1254{
1255 unsigned i, len, nRtrn;
1256
1257 if (((rep->present & XkbExplicitComponentsMask(1<<3)) == 0) ||
1258 (rep->nKeyExplicit < 1) || (!xkb) || (!xkb->server) ||
1259 (!xkb->server->explicit)) {
1260 rep->present &= ~XkbExplicitComponentsMask(1<<3);
1261 rep->firstKeyExplicit = rep->nKeyExplicit = 0;
1262 rep->totalKeyExplicit = 0;
1263 return 0;
1264 }
1265 for (nRtrn = i = 0; i < rep->nKeyExplicit; i++) {
1266 if (xkb->server->explicit[i + rep->firstKeyExplicit] != 0)
1267 nRtrn++;
1268 }
1269 rep->totalKeyExplicit = nRtrn;
1270 len = XkbPaddedSize(nRtrn * 2)((((unsigned int)(nRtrn * 2)+3) >> 2) << 2); /* two bytes per non-zero explicit component */
1271 return len;
1272}
1273
1274static char *
1275XkbWriteExplicit(XkbDescPtr xkb, xkbGetMapReply * rep, char *buf,
1276 ClientPtr client)
1277{
1278 unsigned i;
1279 char *start;
1280 unsigned char *pExp;
1281
1282 start = buf;
1283 pExp = &xkb->server->explicit[rep->firstKeyExplicit];
1284 for (i = 0; i < rep->nKeyExplicit; i++, pExp++) {
1285 if (*pExp != 0) {
1286 *buf++ = i + rep->firstKeyExplicit;
1287 *buf++ = *pExp;
1288 }
1289 }
1290 i = XkbPaddedSize(buf - start)((((unsigned int)(buf - start)+3) >> 2) << 2) - (buf - start); /* pad to word boundary */
1291 return buf + i;
1292}
1293
1294static int
1295XkbSizeModifierMap(XkbDescPtr xkb, xkbGetMapReply * rep)
1296{
1297 unsigned i, len, nRtrn;
1298
1299 if (((rep->present & XkbModifierMapMask(1<<2)) == 0) || (rep->nModMapKeys < 1) ||
1300 (!xkb) || (!xkb->map) || (!xkb->map->modmap)) {
1301 rep->present &= ~XkbModifierMapMask(1<<2);
1302 rep->firstModMapKey = rep->nModMapKeys = 0;
1303 rep->totalModMapKeys = 0;
1304 return 0;
1305 }
1306 for (nRtrn = i = 0; i < rep->nModMapKeys; i++) {
1307 if (xkb->map->modmap[i + rep->firstModMapKey] != 0)
1308 nRtrn++;
1309 }
1310 rep->totalModMapKeys = nRtrn;
1311 len = XkbPaddedSize(nRtrn * 2)((((unsigned int)(nRtrn * 2)+3) >> 2) << 2); /* two bytes per non-zero modmap component */
1312 return len;
1313}
1314
1315static char *
1316XkbWriteModifierMap(XkbDescPtr xkb, xkbGetMapReply * rep, char *buf,
1317 ClientPtr client)
1318{
1319 unsigned i;
1320 char *start;
1321 unsigned char *pMap;
1322
1323 start = buf;
1324 pMap = &xkb->map->modmap[rep->firstModMapKey];
1325 for (i = 0; i < rep->nModMapKeys; i++, pMap++) {
1326 if (*pMap != 0) {
1327 *buf++ = i + rep->firstModMapKey;
1328 *buf++ = *pMap;
1329 }
1330 }
1331 i = XkbPaddedSize(buf - start)((((unsigned int)(buf - start)+3) >> 2) << 2) - (buf - start); /* pad to word boundary */
1332 return buf + i;
1333}
1334
1335static int
1336XkbSizeVirtualModMap(XkbDescPtr xkb, xkbGetMapReply * rep)
1337{
1338 unsigned i, len, nRtrn;
1339
1340 if (((rep->present & XkbVirtualModMapMask(1<<7)) == 0) || (rep->nVModMapKeys < 1)
1341 || (!xkb) || (!xkb->server) || (!xkb->server->vmodmap)) {
1342 rep->present &= ~XkbVirtualModMapMask(1<<7);
1343 rep->firstVModMapKey = rep->nVModMapKeys = 0;
1344 rep->totalVModMapKeys = 0;
1345 return 0;
1346 }
1347 for (nRtrn = i = 0; i < rep->nVModMapKeys; i++) {
1348 if (xkb->server->vmodmap[i + rep->firstVModMapKey] != 0)
1349 nRtrn++;
1350 }
1351 rep->totalVModMapKeys = nRtrn;
1352 len = nRtrn * SIZEOF(xkbVModMapWireDesc)4;
1353 return len;
1354}
1355
1356static char *
1357XkbWriteVirtualModMap(XkbDescPtr xkb, xkbGetMapReply * rep, char *buf,
1358 ClientPtr client)
1359{
1360 unsigned i;
1361 xkbVModMapWireDesc *wire;
1362 unsigned short *pMap;
1363
1364 wire = (xkbVModMapWireDesc *) buf;
1365 pMap = &xkb->server->vmodmap[rep->firstVModMapKey];
1366 for (i = 0; i < rep->nVModMapKeys; i++, pMap++) {
1367 if (*pMap != 0) {
1368 wire->key = i + rep->firstVModMapKey;
1369 wire->vmods = *pMap;
1370 wire++;
1371 }
1372 }
1373 return (char *) wire;
1374}
1375
1376static Statusint
1377XkbComputeGetMapReplySize(XkbDescPtr xkb, xkbGetMapReply * rep)
1378{
1379 int len;
1380
1381 rep->minKeyCode = xkb->min_key_code;
1382 rep->maxKeyCode = xkb->max_key_code;
1383 len = XkbSizeKeyTypes(xkb, rep);
1384 len += XkbSizeKeySyms(xkb, rep);
1385 len += XkbSizeKeyActions(xkb, rep);
1386 len += XkbSizeKeyBehaviors(xkb, rep);
1387 len += XkbSizeVirtualMods(xkb, rep);
1388 len += XkbSizeExplicit(xkb, rep);
1389 len += XkbSizeModifierMap(xkb, rep);
1390 len += XkbSizeVirtualModMap(xkb, rep);
1391 rep->length += (len / 4);
1392 return Success0;
1393}
1394
1395static int
1396XkbSendMap(ClientPtr client, XkbDescPtr xkb, xkbGetMapReply * rep)
1397{
1398 unsigned i, len;
1399 char *desc, *start;
1400
1401 len = (rep->length * 4) - (SIZEOF(xkbGetMapReply)40 - SIZEOF(xGenericReply)32);
1402 start = desc = calloc(1, len);
1403 if (!start)
1404 return BadAlloc11;
1405 if (rep->nTypes > 0)
1406 desc = XkbWriteKeyTypes(xkb, rep, desc, client);
1407 if (rep->nKeySyms > 0)
1408 desc = XkbWriteKeySyms(xkb, rep, desc, client);
1409 if (rep->nKeyActs > 0)
1410 desc = XkbWriteKeyActions(xkb, rep, desc, client);
1411 if (rep->totalKeyBehaviors > 0)
1412 desc = XkbWriteKeyBehaviors(xkb, rep, desc, client);
1413 if (rep->virtualMods) {
1414 register int sz, bit;
1415
1416 for (i = sz = 0, bit = 1; i < XkbNumVirtualMods16; i++, bit <<= 1) {
1417 if (rep->virtualMods & bit) {
1418 desc[sz++] = xkb->server->vmods[i];
1419 }
1420 }
1421 desc += XkbPaddedSize(sz)((((unsigned int)(sz)+3) >> 2) << 2);
1422 }
1423 if (rep->totalKeyExplicit > 0)
1424 desc = XkbWriteExplicit(xkb, rep, desc, client);
1425 if (rep->totalModMapKeys > 0)
1426 desc = XkbWriteModifierMap(xkb, rep, desc, client);
1427 if (rep->totalVModMapKeys > 0)
1428 desc = XkbWriteVirtualModMap(xkb, rep, desc, client);
1429 if ((desc - start) != (len)) {
1430 ErrorF
1431 ("[xkb] BOGUS LENGTH in write keyboard desc, expected %d, got %ld\n",
1432 len, (unsigned long) (desc - start));
1433 }
1434 if (client->swapped) {
1435 swaps(&rep->sequenceNumber)do { if (sizeof(*(&rep->sequenceNumber)) != 2) wrong_size
(); if (__builtin_constant_p((uintptr_t)(&rep->sequenceNumber
) & 1) && ((uintptr_t)(&rep->sequenceNumber
) & 1) == 0) *(&rep->sequenceNumber) = lswaps(*(&
rep->sequenceNumber)); else swap_uint16((uint16_t *)(&
rep->sequenceNumber)); } while (0)
;
1436 swapl(&rep->length)do { if (sizeof(*(&rep->length)) != 4) wrong_size(); if
(__builtin_constant_p((uintptr_t)(&rep->length) &
3) && ((uintptr_t)(&rep->length) & 3) == 0
) *(&rep->length) = lswapl(*(&rep->length)); else
swap_uint32((uint32_t *)(&rep->length)); } while (0)
;
1437 swaps(&rep->present)do { if (sizeof(*(&rep->present)) != 2) wrong_size(); if
(__builtin_constant_p((uintptr_t)(&rep->present) &
1) && ((uintptr_t)(&rep->present) & 1) ==
0) *(&rep->present) = lswaps(*(&rep->present))
; else swap_uint16((uint16_t *)(&rep->present)); } while
(0)
;
1438 swaps(&rep->totalSyms)do { if (sizeof(*(&rep->totalSyms)) != 2) wrong_size()
; if (__builtin_constant_p((uintptr_t)(&rep->totalSyms
) & 1) && ((uintptr_t)(&rep->totalSyms) &
1) == 0) *(&rep->totalSyms) = lswaps(*(&rep->totalSyms
)); else swap_uint16((uint16_t *)(&rep->totalSyms)); }
while (0)
;
1439 swaps(&rep->totalActs)do { if (sizeof(*(&rep->totalActs)) != 2) wrong_size()
; if (__builtin_constant_p((uintptr_t)(&rep->totalActs
) & 1) && ((uintptr_t)(&rep->totalActs) &
1) == 0) *(&rep->totalActs) = lswaps(*(&rep->totalActs
)); else swap_uint16((uint16_t *)(&rep->totalActs)); }
while (0)
;
1440 }
1441 WriteToClient(client, (i = SIZEOF(xkbGetMapReply)40), rep);
1442 WriteToClient(client, len, start);
1443 free((char *) start);
1444 return Success0;
1445}
1446
1447int
1448ProcXkbGetMap(ClientPtr client)
1449{
1450 DeviceIntPtr dev;
1451 xkbGetMapReply rep;
1452 XkbDescRec *xkb;
1453 int n, status;
1454
1455 REQUEST(xkbGetMapReq)xkbGetMapReq *stuff = (xkbGetMapReq *)client->requestBuffer;
1456 REQUEST_SIZE_MATCH(xkbGetMapReq)if ((sizeof(xkbGetMapReq) >> 2) != client->req_len) return
(16)
;
1457
1458 if (!(client->xkbClientFlags & _XkbClientInitialized(1<<15)))
1459 return BadAccess10;
1460
1461 CHK_KBD_DEVICE(dev, stuff->deviceSpec, client, DixGetAttrAccess){ int why; int tmprc = _XkbLookupKeyboard(&(dev), stuff->
deviceSpec, client, (1<<4), &why); if (tmprc != 0) {
client->errorValue = ((XID)((((unsigned int)(why))<<
24)|((stuff->deviceSpec)&0xffffff))); return tmprc; }}
;
1462 CHK_MASK_OVERLAP(0x01, stuff->full, stuff->partial){ if ((stuff->full)&(stuff->partial)) { client->
errorValue= ((XID)((((unsigned int)((0x01)))<<24)|((((stuff
->full)&(stuff->partial)))&0xffffff))); return 8
; }}
;
1463 CHK_MASK_LEGAL(0x02, stuff->full, XkbAllMapComponentsMask){ if ((stuff->full)&(~((((1<<0)|(1<<1)|(1<<
2))|((1<<3)|(1<<4)|(1<<5)|(1<<6)|(1<<
7)))))) { (client->errorValue)= ((XID)((((unsigned int)((0x02
)))<<24)|((((stuff->full)&(~((((1<<0)|(1<<
1)|(1<<2))|((1<<3)|(1<<4)|(1<<5)|(1<<
6)|(1<<7)))))))&0xffffff))); return 2; }}
;
1464 CHK_MASK_LEGAL(0x03, stuff->partial, XkbAllMapComponentsMask){ if ((stuff->partial)&(~((((1<<0)|(1<<1)|
(1<<2))|((1<<3)|(1<<4)|(1<<5)|(1<<
6)|(1<<7)))))) { (client->errorValue)= ((XID)((((unsigned
int)((0x03)))<<24)|((((stuff->partial)&(~((((1<<
0)|(1<<1)|(1<<2))|((1<<3)|(1<<4)|(1<<
5)|(1<<6)|(1<<7)))))))&0xffffff))); return 2;
}}
;
1465
1466 xkb = dev->key->xkbInfo->desc;
1467 rep = (xkbGetMapReply) {
1468 .type = X_Reply1,
1469 .deviceID = dev->id,
1470 .sequenceNumber = client->sequence,
1471 .length = (SIZEOF(xkbGetMapReply)40 - SIZEOF(xGenericReply)32) >> 2,
1472 .present = stuff->partial | stuff->full,
1473 .minKeyCode = xkb->min_key_code,
1474 .maxKeyCode = xkb->max_key_code
1475 };
1476
1477 if (stuff->full & XkbKeyTypesMask(1<<0)) {
1478 rep.firstType = 0;
1479 rep.nTypes = xkb->map->num_types;
1480 }
1481 else if (stuff->partial & XkbKeyTypesMask(1<<0)) {
1482 if (((unsigned) stuff->firstType + stuff->nTypes) > xkb->map->num_types) {
1483 client->errorValue = _XkbErrCode4(0x04, xkb->map->num_types,((XID)((((unsigned int)(0x04))<<24)|(((((unsigned int)(
xkb->map->num_types))<<16)|(((((unsigned int)(stuff
->firstType))<<8)|(stuff->nTypes))))&0xffffff
)))
1484 stuff->firstType, stuff->nTypes)((XID)((((unsigned int)(0x04))<<24)|(((((unsigned int)(
xkb->map->num_types))<<16)|(((((unsigned int)(stuff
->firstType))<<8)|(stuff->nTypes))))&0xffffff
)))
;
1485 return BadValue2;
1486 }
1487 rep.firstType = stuff->firstType;
1488 rep.nTypes = stuff->nTypes;
1489 }
1490 else
1491 rep.nTypes = 0;
1492 rep.totalTypes = xkb->map->num_types;
1493
1494 n = XkbNumKeys(xkb)((xkb)->max_key_code-(xkb)->min_key_code+1);
1495 if (stuff->full & XkbKeySymsMask(1<<1)) {
1496 rep.firstKeySym = xkb->min_key_code;
1497 rep.nKeySyms = n;
1498 }
1499 else if (stuff->partial & XkbKeySymsMask(1<<1)) {
1500 CHK_KEY_RANGE(0x05, stuff->firstKeySym, stuff->nKeySyms, xkb){ if (((unsigned)(stuff->firstKeySym)+(stuff->nKeySyms)
-1)>(xkb)->max_key_code) { (client->errorValue)=((XID
)((((unsigned int)(0x05))<<24)|(((((unsigned int)((stuff
->firstKeySym)))<<16)|(((((unsigned int)((stuff->
nKeySyms)))<<8)|((xkb)->max_key_code))))&0xffffff
))); return 2; } else if ( (stuff->firstKeySym)<(xkb)->
min_key_code ) { (client->errorValue)=((XID)((((unsigned int
)(0x05 +1))<<24)|(((((unsigned int)((stuff->firstKeySym
)))<<16)|(xkb->min_key_code))&0xffffff))); return
2; }}
;
1501 rep.firstKeySym = stuff->firstKeySym;
1502 rep.nKeySyms = stuff->nKeySyms;
1503 }
1504 else
1505 rep.nKeySyms = 0;
1506 rep.totalSyms = 0;
1507
1508 if (stuff->full & XkbKeyActionsMask(1<<4)) {
1509 rep.firstKeyAct = xkb->min_key_code;
1510 rep.nKeyActs = n;
1511 }
1512 else if (stuff->partial & XkbKeyActionsMask(1<<4)) {
1513 CHK_KEY_RANGE(0x07, stuff->firstKeyAct, stuff->nKeyActs, xkb){ if (((unsigned)(stuff->firstKeyAct)+(stuff->nKeyActs)
-1)>(xkb)->max_key_code) { (client->errorValue)=((XID
)((((unsigned int)(0x07))<<24)|(((((unsigned int)((stuff
->firstKeyAct)))<<16)|(((((unsigned int)((stuff->
nKeyActs)))<<8)|((xkb)->max_key_code))))&0xffffff
))); return 2; } else if ( (stuff->firstKeyAct)<(xkb)->
min_key_code ) { (client->errorValue)=((XID)((((unsigned int
)(0x07 +1))<<24)|(((((unsigned int)((stuff->firstKeyAct
)))<<16)|(xkb->min_key_code))&0xffffff))); return
2; }}
;
1514 rep.firstKeyAct = stuff->firstKeyAct;
1515 rep.nKeyActs = stuff->nKeyActs;
1516 }
1517 else
1518 rep.nKeyActs = 0;
1519 rep.totalActs = 0;
1520
1521 if (stuff->full & XkbKeyBehaviorsMask(1<<5)) {
1522 rep.firstKeyBehavior = xkb->min_key_code;
1523 rep.nKeyBehaviors = n;
1524 }
1525 else if (stuff->partial & XkbKeyBehaviorsMask(1<<5)) {
1526 CHK_KEY_RANGE(0x09, stuff->firstKeyBehavior, stuff->nKeyBehaviors, xkb){ if (((unsigned)(stuff->firstKeyBehavior)+(stuff->nKeyBehaviors
)-1)>(xkb)->max_key_code) { (client->errorValue)=((XID
)((((unsigned int)(0x09))<<24)|(((((unsigned int)((stuff
->firstKeyBehavior)))<<16)|(((((unsigned int)((stuff
->nKeyBehaviors)))<<8)|((xkb)->max_key_code))))&
0xffffff))); return 2; } else if ( (stuff->firstKeyBehavior
)<(xkb)->min_key_code ) { (client->errorValue)=((XID
)((((unsigned int)(0x09 +1))<<24)|(((((unsigned int)((stuff
->firstKeyBehavior)))<<16)|(xkb->min_key_code))&
0xffffff))); return 2; }}
;
1527 rep.firstKeyBehavior = stuff->firstKeyBehavior;
1528 rep.nKeyBehaviors = stuff->nKeyBehaviors;
1529 }
1530 else
1531 rep.nKeyBehaviors = 0;
1532 rep.totalKeyBehaviors = 0;
1533
1534 if (stuff->full & XkbVirtualModsMask(1<<6))
1535 rep.virtualMods = ~0;
1536 else if (stuff->partial & XkbVirtualModsMask(1<<6))
1537 rep.virtualMods = stuff->virtualMods;
1538
1539 if (stuff->full & XkbExplicitComponentsMask(1<<3)) {
1540 rep.firstKeyExplicit = xkb->min_key_code;
1541 rep.nKeyExplicit = n;
1542 }
1543 else if (stuff->partial & XkbExplicitComponentsMask(1<<3)) {
1544 CHK_KEY_RANGE(0x0B, stuff->firstKeyExplicit, stuff->nKeyExplicit, xkb){ if (((unsigned)(stuff->firstKeyExplicit)+(stuff->nKeyExplicit
)-1)>(xkb)->max_key_code) { (client->errorValue)=((XID
)((((unsigned int)(0x0B))<<24)|(((((unsigned int)((stuff
->firstKeyExplicit)))<<16)|(((((unsigned int)((stuff
->nKeyExplicit)))<<8)|((xkb)->max_key_code))))&
0xffffff))); return 2; } else if ( (stuff->firstKeyExplicit
)<(xkb)->min_key_code ) { (client->errorValue)=((XID
)((((unsigned int)(0x0B +1))<<24)|(((((unsigned int)((stuff
->firstKeyExplicit)))<<16)|(xkb->min_key_code))&
0xffffff))); return 2; }}
;
1545 rep.firstKeyExplicit = stuff->firstKeyExplicit;
1546 rep.nKeyExplicit = stuff->nKeyExplicit;
1547 }
1548 else
1549 rep.nKeyExplicit = 0;
1550 rep.totalKeyExplicit = 0;
1551
1552 if (stuff->full & XkbModifierMapMask(1<<2)) {
1553 rep.firstModMapKey = xkb->min_key_code;
1554 rep.nModMapKeys = n;
1555 }
1556 else if (stuff->partial & XkbModifierMapMask(1<<2)) {
1557 CHK_KEY_RANGE(0x0D, stuff->firstModMapKey, stuff->nModMapKeys, xkb){ if (((unsigned)(stuff->firstModMapKey)+(stuff->nModMapKeys
)-1)>(xkb)->max_key_code) { (client->errorValue)=((XID
)((((unsigned int)(0x0D))<<24)|(((((unsigned int)((stuff
->firstModMapKey)))<<16)|(((((unsigned int)((stuff->
nModMapKeys)))<<8)|((xkb)->max_key_code))))&0xffffff
))); return 2; } else if ( (stuff->firstModMapKey)<(xkb
)->min_key_code ) { (client->errorValue)=((XID)((((unsigned
int)(0x0D +1))<<24)|(((((unsigned int)((stuff->firstModMapKey
)))<<16)|(xkb->min_key_code))&0xffffff))); return
2; }}
;
1558 rep.firstModMapKey = stuff->firstModMapKey;
1559 rep.nModMapKeys = stuff->nModMapKeys;
1560 }
1561 else
1562 rep.nModMapKeys = 0;
1563 rep.totalModMapKeys = 0;
1564
1565 if (stuff->full & XkbVirtualModMapMask(1<<7)) {
1566 rep.firstVModMapKey = xkb->min_key_code;
1567 rep.nVModMapKeys = n;
1568 }
1569 else if (stuff->partial & XkbVirtualModMapMask(1<<7)) {
1570 CHK_KEY_RANGE(0x0F, stuff->firstVModMapKey, stuff->nVModMapKeys, xkb){ if (((unsigned)(stuff->firstVModMapKey)+(stuff->nVModMapKeys
)-1)>(xkb)->max_key_code) { (client->errorValue)=((XID
)((((unsigned int)(0x0F))<<24)|(((((unsigned int)((stuff
->firstVModMapKey)))<<16)|(((((unsigned int)((stuff->
nVModMapKeys)))<<8)|((xkb)->max_key_code))))&0xffffff
))); return 2; } else if ( (stuff->firstVModMapKey)<(xkb
)->min_key_code ) { (client->errorValue)=((XID)((((unsigned
int)(0x0F +1))<<24)|(((((unsigned int)((stuff->firstVModMapKey
)))<<16)|(xkb->min_key_code))&0xffffff))); return
2; }}
;
1571 rep.firstVModMapKey = stuff->firstVModMapKey;
1572 rep.nVModMapKeys = stuff->nVModMapKeys;
1573 }
1574 else
1575 rep.nVModMapKeys = 0;
1576 rep.totalVModMapKeys = 0;
1577
1578 if ((status = XkbComputeGetMapReplySize(xkb, &rep)) != Success0)
1579 return status;
1580 return XkbSendMap(client, xkb, &rep);
1581}
1582
1583/***====================================================================***/
1584
1585static int
1586CheckKeyTypes(ClientPtr client,
1587 XkbDescPtr xkb,
1588 xkbSetMapReq * req,
1589 xkbKeyTypeWireDesc ** wireRtrn,
1590 int *nMapsRtrn, CARD8 *mapWidthRtrn)
1591{
1592 unsigned nMaps;
1593 register unsigned i, n;
1594 register CARD8 *map;
1595 register xkbKeyTypeWireDesc *wire = *wireRtrn;
1596
1597 if (req->firstType > ((unsigned) xkb->map->num_types)) {
1598 *nMapsRtrn = _XkbErrCode3(0x01, req->firstType, xkb->map->num_types)((XID)((((unsigned int)(0x01))<<24)|(((((unsigned int)(
req->firstType))<<16)|(xkb->map->num_types))&
0xffffff)))
;
1599 return 0;
1600 }
1601 if (req->flags & XkbSetMapResizeTypes(1L<<0)) {
1602 nMaps = req->firstType + req->nTypes;
1603 if (nMaps < XkbNumRequiredTypes(3 +1)) { /* canonical types must be there */
1604 *nMapsRtrn = _XkbErrCode4(0x02, req->firstType, req->nTypes, 4)((XID)((((unsigned int)(0x02))<<24)|(((((unsigned int)(
req->firstType))<<16)|(((((unsigned int)(req->nTypes
))<<8)|(4))))&0xffffff)))
;
1605 return 0;
1606 }
1607 }
1608 else if (req->present & XkbKeyTypesMask(1<<0)) {
1609 nMaps = xkb->map->num_types;
1610 if ((req->firstType + req->nTypes) > nMaps) {
1611 *nMapsRtrn = req->firstType + req->nTypes;
1612 return 0;
1613 }
1614 }
1615 else {
1616 *nMapsRtrn = xkb->map->num_types;
1617 for (i = 0; i < xkb->map->num_types; i++) {
1618 mapWidthRtrn[i] = xkb->map->types[i].num_levels;
1619 }
1620 return 1;
1621 }
1622
1623 for (i = 0; i < req->firstType; i++) {
1624 mapWidthRtrn[i] = xkb->map->types[i].num_levels;
1625 }
1626 for (i = 0; i < req->nTypes; i++) {
1627 unsigned width;
1628
1629 if (client->swapped) {
1630 swaps(&wire->virtualMods)do { if (sizeof(*(&wire->virtualMods)) != 2) wrong_size
(); if (__builtin_constant_p((uintptr_t)(&wire->virtualMods
) & 1) && ((uintptr_t)(&wire->virtualMods)
& 1) == 0) *(&wire->virtualMods) = lswaps(*(&
wire->virtualMods)); else swap_uint16((uint16_t *)(&wire
->virtualMods)); } while (0)
;
1631 }
1632 n = i + req->firstType;
1633 width = wire->numLevels;
1634 if (width < 1) {
1635 *nMapsRtrn = _XkbErrCode3(0x04, n, width)((XID)((((unsigned int)(0x04))<<24)|(((((unsigned int)(
n))<<16)|(width))&0xffffff)))
;
1636 return 0;
1637 }
1638 else if ((n == XkbOneLevelIndex0) && (width != 1)) { /* must be width 1 */
1639 *nMapsRtrn = _XkbErrCode3(0x05, n, width)((XID)((((unsigned int)(0x05))<<24)|(((((unsigned int)(
n))<<16)|(width))&0xffffff)))
;
1640 return 0;
1641 }
1642 else if ((width != 2) &&
1643 ((n == XkbTwoLevelIndex1) || (n == XkbKeypadIndex3) ||
1644 (n == XkbAlphabeticIndex2))) {
1645 /* TWO_LEVEL, ALPHABETIC and KEYPAD must be width 2 */
1646 *nMapsRtrn = _XkbErrCode3(0x05, n, width)((XID)((((unsigned int)(0x05))<<24)|(((((unsigned int)(
n))<<16)|(width))&0xffffff)))
;
1647 return 0;
1648 }
1649 if (wire->nMapEntries > 0) {
1650 xkbKTSetMapEntryWireDesc *mapWire;
1651 xkbModsWireDesc *preWire;
1652
1653 mapWire = (xkbKTSetMapEntryWireDesc *) &wire[1];
1654 preWire = (xkbModsWireDesc *) &mapWire[wire->nMapEntries];
1655 for (n = 0; n < wire->nMapEntries; n++) {
1656 if (client->swapped) {
1657 swaps(&mapWire[n].virtualMods)do { if (sizeof(*(&mapWire[n].virtualMods)) != 2) wrong_size
(); if (__builtin_constant_p((uintptr_t)(&mapWire[n].virtualMods
) & 1) && ((uintptr_t)(&mapWire[n].virtualMods
) & 1) == 0) *(&mapWire[n].virtualMods) = lswaps(*(&
mapWire[n].virtualMods)); else swap_uint16((uint16_t *)(&
mapWire[n].virtualMods)); } while (0)
;
1658 }
1659 if (mapWire[n].realMods & (~wire->realMods)) {
1660 *nMapsRtrn = _XkbErrCode4(0x06, n, mapWire[n].realMods,((XID)((((unsigned int)(0x06))<<24)|(((((unsigned int)(
n))<<16)|(((((unsigned int)(mapWire[n].realMods))<<
8)|(wire->realMods))))&0xffffff)))
1661 wire->realMods)((XID)((((unsigned int)(0x06))<<24)|(((((unsigned int)(
n))<<16)|(((((unsigned int)(mapWire[n].realMods))<<
8)|(wire->realMods))))&0xffffff)))
;
1662 return 0;
1663 }
1664 if (mapWire[n].virtualMods & (~wire->virtualMods)) {
1665 *nMapsRtrn = _XkbErrCode3(0x07, n, mapWire[n].virtualMods)((XID)((((unsigned int)(0x07))<<24)|(((((unsigned int)(
n))<<16)|(mapWire[n].virtualMods))&0xffffff)))
;
1666 return 0;
1667 }
1668 if (mapWire[n].level >= wire->numLevels) {
1669 *nMapsRtrn = _XkbErrCode4(0x08, n, wire->numLevels,((XID)((((unsigned int)(0x08))<<24)|(((((unsigned int)(
n))<<16)|(((((unsigned int)(wire->numLevels))<<
8)|(mapWire[n].level))))&0xffffff)))
1670 mapWire[n].level)((XID)((((unsigned int)(0x08))<<24)|(((((unsigned int)(
n))<<16)|(((((unsigned int)(wire->numLevels))<<
8)|(mapWire[n].level))))&0xffffff)))
;
1671 return 0;
1672 }
1673 if (wire->preserve) {
1674 if (client->swapped) {
1675 swaps(&preWire[n].virtualMods)do { if (sizeof(*(&preWire[n].virtualMods)) != 2) wrong_size
(); if (__builtin_constant_p((uintptr_t)(&preWire[n].virtualMods
) & 1) && ((uintptr_t)(&preWire[n].virtualMods
) & 1) == 0) *(&preWire[n].virtualMods) = lswaps(*(&
preWire[n].virtualMods)); else swap_uint16((uint16_t *)(&
preWire[n].virtualMods)); } while (0)
;
1676 }
1677 if (preWire[n].realMods & (~mapWire[n].realMods)) {
1678 *nMapsRtrn = _XkbErrCode4(0x09, n, preWire[n].realMods,((XID)((((unsigned int)(0x09))<<24)|(((((unsigned int)(
n))<<16)|(((((unsigned int)(preWire[n].realMods))<<
8)|(mapWire[n].realMods))))&0xffffff)))
1679 mapWire[n].realMods)((XID)((((unsigned int)(0x09))<<24)|(((((unsigned int)(
n))<<16)|(((((unsigned int)(preWire[n].realMods))<<
8)|(mapWire[n].realMods))))&0xffffff)))
;
1680 return 0;
1681 }
1682 if (preWire[n].virtualMods & (~mapWire[n].virtualMods)) {
1683 *nMapsRtrn =
1684 _XkbErrCode3(0x0a, n, preWire[n].virtualMods)((XID)((((unsigned int)(0x0a))<<24)|(((((unsigned int)(
n))<<16)|(preWire[n].virtualMods))&0xffffff)))
;
1685 return 0;
1686 }
1687 }
1688 }
1689 if (wire->preserve)
1690 map = (CARD8 *) &preWire[wire->nMapEntries];
1691 else
1692 map = (CARD8 *) &mapWire[wire->nMapEntries];
1693 }
1694 else
1695 map = (CARD8 *) &wire[1];
1696 mapWidthRtrn[i + req->firstType] = wire->numLevels;
1697 wire = (xkbKeyTypeWireDesc *) map;
1698 }
1699 for (i = req->firstType + req->nTypes; i < nMaps; i++) {
1700 mapWidthRtrn[i] = xkb->map->types[i].num_levels;
1701 }
1702 *nMapsRtrn = nMaps;
1703 *wireRtrn = wire;
1704 return 1;
1705}
1706
1707static int
1708CheckKeySyms(ClientPtr client,
1709 XkbDescPtr xkb,
1710 xkbSetMapReq * req,
1711 int nTypes,
1712 CARD8 *mapWidths,
1713 CARD16 *symsPerKey, xkbSymMapWireDesc ** wireRtrn, int *errorRtrn)
1714{
1715 register unsigned i;
1716 XkbSymMapPtr map;
1717 xkbSymMapWireDesc *wire = *wireRtrn;
1718
1719 if (!(XkbKeySymsMask(1<<1) & req->present))
1720 return 1;
1721 CHK_REQ_KEY_RANGE2(0x11, req->firstKeySym, req->nKeySyms, req, (*errorRtrn),{ if (((unsigned)(req->firstKeySym)+(req->nKeySyms)-1)>
(req)->maxKeyCode) { ((*errorRtrn))=((XID)((((unsigned int
)(0x11))<<24)|(((((unsigned int)((req->firstKeySym))
)<<16)|(((((unsigned int)((req->nKeySyms)))<<8
)|((req)->maxKeyCode))))&0xffffff))); return 0; } else
if ( (req->firstKeySym)<(req)->minKeyCode ) { ((*errorRtrn
))=((XID)((((unsigned int)(0x11 +1))<<24)|(((((unsigned
int)((req->firstKeySym)))<<16)|((req)->minKeyCode
))&0xffffff))); return 0; }}
1722 0){ if (((unsigned)(req->firstKeySym)+(req->nKeySyms)-1)>
(req)->maxKeyCode) { ((*errorRtrn))=((XID)((((unsigned int
)(0x11))<<24)|(((((unsigned int)((req->firstKeySym))
)<<16)|(((((unsigned int)((req->nKeySyms)))<<8
)|((req)->maxKeyCode))))&0xffffff))); return 0; } else
if ( (req->firstKeySym)<(req)->minKeyCode ) { ((*errorRtrn
))=((XID)((((unsigned int)(0x11 +1))<<24)|(((((unsigned
int)((req->firstKeySym)))<<16)|((req)->minKeyCode
))&0xffffff))); return 0; }}
;
1723 for (i = 0; i < req->nKeySyms; i++) {
1724 KeySym *pSyms;
1725 register unsigned nG;
1726
1727 if (client->swapped) {
1728 swaps(&wire->nSyms)do { if (sizeof(*(&wire->nSyms)) != 2) wrong_size(); if
(__builtin_constant_p((uintptr_t)(&wire->nSyms) &
1) && ((uintptr_t)(&wire->nSyms) & 1) == 0
) *(&wire->nSyms) = lswaps(*(&wire->nSyms)); else
swap_uint16((uint16_t *)(&wire->nSyms)); } while (0)
;
1729 }
1730 nG = XkbNumGroups(wire->groupInfo)((wire->groupInfo)&0x0f);
1731 if (nG > XkbNumKbdGroups4) {
1732 *errorRtrn = _XkbErrCode3(0x14, i + req->firstKeySym, nG)((XID)((((unsigned int)(0x14))<<24)|(((((unsigned int)(
i + req->firstKeySym))<<16)|(nG))&0xffffff)))
;
1733 return 0;
1734 }
1735 if (nG > 0) {
1736 register int g, w;
1737
1738 for (g = w = 0; g < nG; g++) {
1739 if (wire->ktIndex[g] >= (unsigned) nTypes) {
1740 *errorRtrn = _XkbErrCode4(0x15, i + req->firstKeySym, g,((XID)((((unsigned int)(0x15))<<24)|(((((unsigned int)(
i + req->firstKeySym))<<16)|(((((unsigned int)(g))<<
8)|(wire->ktIndex[g]))))&0xffffff)))
1741 wire->ktIndex[g])((XID)((((unsigned int)(0x15))<<24)|(((((unsigned int)(
i + req->firstKeySym))<<16)|(((((unsigned int)(g))<<
8)|(wire->ktIndex[g]))))&0xffffff)))
;
1742 return 0;
1743 }
1744 if (mapWidths[wire->ktIndex[g]] > w)
1745 w = mapWidths[wire->ktIndex[g]];
1746 }
1747 if (wire->width != w) {
1748 *errorRtrn =
1749 _XkbErrCode3(0x16, i + req->firstKeySym, wire->width)((XID)((((unsigned int)(0x16))<<24)|(((((unsigned int)(
i + req->firstKeySym))<<16)|(wire->width))&0xffffff
)))
;
1750 return 0;
1751 }
1752 w *= nG;
1753 symsPerKey[i + req->firstKeySym] = w;
1754 if (w != wire->nSyms) {
1755 *errorRtrn =
1756 _XkbErrCode4(0x16, i + req->firstKeySym, wire->nSyms, w)((XID)((((unsigned int)(0x16))<<24)|(((((unsigned int)(
i + req->firstKeySym))<<16)|(((((unsigned int)(wire->
nSyms))<<8)|(w))))&0xffffff)))
;
1757 return 0;
1758 }
1759 }
1760 else if (wire->nSyms != 0) {
1761 *errorRtrn = _XkbErrCode3(0x17, i + req->firstKeySym, wire->nSyms)((XID)((((unsigned int)(0x17))<<24)|(((((unsigned int)(
i + req->firstKeySym))<<16)|(wire->nSyms))&0xffffff
)))
;
1762 return 0;
1763 }
1764 pSyms = (KeySym *) &wire[1];
1765 wire = (xkbSymMapWireDesc *) &pSyms[wire->nSyms];
1766 }
1767
1768 map = &xkb->map->key_sym_map[i];
1769 for (; i <= (unsigned) xkb->max_key_code; i++, map++) {
1770 register int g, nG, w;
1771
1772 nG = XkbKeyNumGroups(xkb, i)((((((xkb)->map)->key_sym_map[((i))].group_info)&0x0f
)))
;
1773 for (w = g = 0; g < nG; g++) {
1774 if (map->kt_index[g] >= (unsigned) nTypes) {
1775 *errorRtrn = _XkbErrCode4(0x18, i, g, map->kt_index[g])((XID)((((unsigned int)(0x18))<<24)|(((((unsigned int)(
i))<<16)|(((((unsigned int)(g))<<8)|(map->kt_index
[g]))))&0xffffff)))
;
1776 return 0;
1777 }
1778 if (mapWidths[map->kt_index[g]] > w)
1779 w = mapWidths[map->kt_index[g]];
1780 }
1781 symsPerKey[i] = w * nG;
1782 }
1783 *wireRtrn = wire;
1784 return 1;
1785}
1786
1787static int
1788CheckKeyActions(XkbDescPtr xkb,
1789 xkbSetMapReq * req,
1790 int nTypes,
1791 CARD8 *mapWidths,
1792 CARD16 *symsPerKey, CARD8 **wireRtrn, int *nActsRtrn)
1793{
1794 int nActs;
1795 CARD8 *wire = *wireRtrn;
1796 register unsigned i;
1797
1798 if (!(XkbKeyActionsMask(1<<4) & req->present))
1799 return 1;
1800 CHK_REQ_KEY_RANGE2(0x21, req->firstKeyAct, req->nKeyActs, req, (*nActsRtrn),{ if (((unsigned)(req->firstKeyAct)+(req->nKeyActs)-1)>
(req)->maxKeyCode) { ((*nActsRtrn))=((XID)((((unsigned int
)(0x21))<<24)|(((((unsigned int)((req->firstKeyAct))
)<<16)|(((((unsigned int)((req->nKeyActs)))<<8
)|((req)->maxKeyCode))))&0xffffff))); return 0; } else
if ( (req->firstKeyAct)<(req)->minKeyCode ) { ((*nActsRtrn
))=((XID)((((unsigned int)(0x21 +1))<<24)|(((((unsigned
int)((req->firstKeyAct)))<<16)|((req)->minKeyCode
))&0xffffff))); return 0; }}
1801 0){ if (((unsigned)(req->firstKeyAct)+(req->nKeyActs)-1)>
(req)->maxKeyCode) { ((*nActsRtrn))=((XID)((((unsigned int
)(0x21))<<24)|(((((unsigned int)((req->firstKeyAct))
)<<16)|(((((unsigned int)((req->nKeyActs)))<<8
)|((req)->maxKeyCode))))&0xffffff))); return 0; } else
if ( (req->firstKeyAct)<(req)->minKeyCode ) { ((*nActsRtrn
))=((XID)((((unsigned int)(0x21 +1))<<24)|(((((unsigned
int)((req->firstKeyAct)))<<16)|((req)->minKeyCode
))&0xffffff))); return 0; }}
;
1802 for (nActs = i = 0; i < req->nKeyActs; i++) {
1803 if (wire[0] != 0) {
1804 if (wire[0] == symsPerKey[i + req->firstKeyAct])
1805 nActs += wire[0];
1806 else {
1807 *nActsRtrn = _XkbErrCode3(0x23, i + req->firstKeyAct, wire[0])((XID)((((unsigned int)(0x23))<<24)|(((((unsigned int)(
i + req->firstKeyAct))<<16)|(wire[0]))&0xffffff)
))
;
1808 return 0;
1809 }
1810 }
1811 wire++;
1812 }
1813 if (req->nKeyActs % 4)
1814 wire += 4 - (req->nKeyActs % 4);
1815 *wireRtrn = (CARD8 *) (((XkbAnyAction *) wire) + nActs);
1816 *nActsRtrn = nActs;
1817 return 1;
1818}
1819
1820static int
1821CheckKeyBehaviors(XkbDescPtr xkb,
1822 xkbSetMapReq * req,
1823 xkbBehaviorWireDesc ** wireRtrn, int *errorRtrn)
1824{
1825 register xkbBehaviorWireDesc *wire = *wireRtrn;
1826 register XkbServerMapPtr server = xkb->server;
1827 register unsigned i;
1828 unsigned first, last;
1829
1830 if (((req->present & XkbKeyBehaviorsMask(1<<5)) == 0) || (req->nKeyBehaviors < 1)) {
1831 req->present &= ~XkbKeyBehaviorsMask(1<<5);
1832 req->nKeyBehaviors = 0;
1833 return 1;
1834 }
1835 first = req->firstKeyBehavior;
1836 last = req->firstKeyBehavior + req->nKeyBehaviors - 1;
1837 if (first < req->minKeyCode) {
1838 *errorRtrn = _XkbErrCode3(0x31, first, req->minKeyCode)((XID)((((unsigned int)(0x31))<<24)|(((((unsigned int)(
first))<<16)|(req->minKeyCode))&0xffffff)))
;
1839 return 0;
1840 }
1841 if (last > req->maxKeyCode) {
1842 *errorRtrn = _XkbErrCode3(0x32, last, req->maxKeyCode)((XID)((((unsigned int)(0x32))<<24)|(((((unsigned int)(
last))<<16)|(req->maxKeyCode))&0xffffff)))
;
1843 return 0;
1844 }
1845
1846 for (i = 0; i < req->totalKeyBehaviors; i++, wire++) {
1847 if ((wire->key < first) || (wire->key > last)) {
1848 *errorRtrn = _XkbErrCode4(0x33, first, last, wire->key)((XID)((((unsigned int)(0x33))<<24)|(((((unsigned int)(
first))<<16)|(((((unsigned int)(last))<<8)|(wire->
key))))&0xffffff)))
;
1849 return 0;
1850 }
1851 if ((wire->type & XkbKB_Permanent0x80) &&
1852 ((server->behaviors[wire->key].type != wire->type) ||
1853 (server->behaviors[wire->key].data != wire->data))) {
1854 *errorRtrn = _XkbErrCode3(0x33, wire->key, wire->type)((XID)((((unsigned int)(0x33))<<24)|(((((unsigned int)(
wire->key))<<16)|(wire->type))&0xffffff)))
;
1855 return 0;
1856 }
1857 if ((wire->type == XkbKB_RadioGroup0x02) &&
1858 ((wire->data & (~XkbKB_RGAllowNone0x80)) > XkbMaxRadioGroups32)) {
1859 *errorRtrn = _XkbErrCode4(0x34, wire->key, wire->data,((XID)((((unsigned int)(0x34))<<24)|(((((unsigned int)(
wire->key))<<16)|(((((unsigned int)(wire->data))<<
8)|(32))))&0xffffff)))
1860 XkbMaxRadioGroups)((XID)((((unsigned int)(0x34))<<24)|(((((unsigned int)(
wire->key))<<16)|(((((unsigned int)(wire->data))<<
8)|(32))))&0xffffff)))
;
1861 return 0;
1862 }
1863 if ((wire->type == XkbKB_Overlay10x03) || (wire->type == XkbKB_Overlay20x04)) {
1864 CHK_KEY_RANGE2(0x35, wire->key, 1, xkb, *errorRtrn, 0){ if (((unsigned)(wire->key)+(1)-1)>(xkb)->max_key_code
) { (*errorRtrn)=((XID)((((unsigned int)(0x35))<<24)|((
(((unsigned int)((wire->key)))<<16)|(((((unsigned int
)((1)))<<8)|((xkb)->max_key_code))))&0xffffff)))
; return 0; } else if ( (wire->key)<(xkb)->min_key_code
) { (*errorRtrn)=((XID)((((unsigned int)(0x35 +1))<<24
)|(((((unsigned int)((wire->key)))<<16)|(xkb->min_key_code
))&0xffffff))); return 0; }}
;
1865 }
1866 }
1867 *wireRtrn = wire;
1868 return 1;
1869}
1870
1871static int
1872CheckVirtualMods(XkbDescRec * xkb,
1873 xkbSetMapReq * req, CARD8 **wireRtrn, int *errorRtrn)
1874{
1875 register CARD8 *wire = *wireRtrn;
1876 register unsigned i, nMods, bit;
1877
1878 if (((req->present & XkbVirtualModsMask(1<<6)) == 0) || (req->virtualMods == 0))
1879 return 1;
1880 for (i = nMods = 0, bit = 1; i < XkbNumVirtualMods16; i++, bit <<= 1) {
1881 if (req->virtualMods & bit)
1882 nMods++;
1883 }
1884 *wireRtrn = (wire + XkbPaddedSize(nMods)((((unsigned int)(nMods)+3) >> 2) << 2));
1885 return 1;
1886}
1887
1888static int
1889CheckKeyExplicit(XkbDescPtr xkb,
1890 xkbSetMapReq * req, CARD8 **wireRtrn, int *errorRtrn)
1891{
1892 register CARD8 *wire = *wireRtrn;
1893 CARD8 *start;
1894 register unsigned i;
1895 int first, last;
1896
1897 if (((req->present & XkbExplicitComponentsMask(1<<3)) == 0) ||
1898 (req->nKeyExplicit < 1)) {
1899 req->present &= ~XkbExplicitComponentsMask(1<<3);
1900 req->nKeyExplicit = 0;
1901 return 1;
1902 }
1903 first = req->firstKeyExplicit;
1904 last = first + req->nKeyExplicit - 1;
1905 if (first < req->minKeyCode) {
1906 *errorRtrn = _XkbErrCode3(0x51, first, req->minKeyCode)((XID)((((unsigned int)(0x51))<<24)|(((((unsigned int)(
first))<<16)|(req->minKeyCode))&0xffffff)))
;
1907 return 0;
1908 }
1909 if (last > req->maxKeyCode) {
1910 *errorRtrn = _XkbErrCode3(0x52, last, req->maxKeyCode)((XID)((((unsigned int)(0x52))<<24)|(((((unsigned int)(
last))<<16)|(req->maxKeyCode))&0xffffff)))
;
1911 return 0;
1912 }
1913 start = wire;
1914 for (i = 0; i < req->totalKeyExplicit; i++, wire += 2) {
1915 if ((wire[0] < first) || (wire[0] > last)) {
1916 *errorRtrn = _XkbErrCode4(0x53, first, last, wire[0])((XID)((((unsigned int)(0x53))<<24)|(((((unsigned int)(
first))<<16)|(((((unsigned int)(last))<<8)|(wire[
0]))))&0xffffff)))
;
1917 return 0;
1918 }
1919 if (wire[1] & (~XkbAllExplicitMask(0xff))) {
1920 *errorRtrn = _XkbErrCode3(0x52, ~XkbAllExplicitMask, wire[1])((XID)((((unsigned int)(0x52))<<24)|(((((unsigned int)(
~(0xff)))<<16)|(wire[1]))&0xffffff)))
;
1921 return 0;
1922 }
1923 }
1924 wire += XkbPaddedSize(wire - start)((((unsigned int)(wire - start)+3) >> 2) << 2) - (wire - start);
1925 *wireRtrn = wire;
1926 return 1;
1927}
1928
1929static int
1930CheckModifierMap(XkbDescPtr xkb, xkbSetMapReq * req, CARD8 **wireRtrn,
1931 int *errRtrn)
1932{
1933 register CARD8 *wire = *wireRtrn;
1934 CARD8 *start;
1935 register unsigned i;
1936 int first, last;
1937
1938 if (((req->present & XkbModifierMapMask(1<<2)) == 0) || (req->nModMapKeys < 1)) {
1939 req->present &= ~XkbModifierMapMask(1<<2);
1940 req->nModMapKeys = 0;
1941 return 1;
1942 }
1943 first = req->firstModMapKey;
1944 last = first + req->nModMapKeys - 1;
1945 if (first < req->minKeyCode) {
1946 *errRtrn = _XkbErrCode3(0x61, first, req->minKeyCode)((XID)((((unsigned int)(0x61))<<24)|(((((unsigned int)(
first))<<16)|(req->minKeyCode))&0xffffff)))
;
1947 return 0;
1948 }
1949 if (last > req->maxKeyCode) {
1950 *errRtrn = _XkbErrCode3(0x62, last, req->maxKeyCode)((XID)((((unsigned int)(0x62))<<24)|(((((unsigned int)(
last))<<16)|(req->maxKeyCode))&0xffffff)))
;
1951 return 0;
1952 }
1953 start = wire;
1954 for (i = 0; i < req->totalModMapKeys; i++, wire += 2) {
1955 if ((wire[0] < first) || (wire[0] > last)) {
1956 *errRtrn = _XkbErrCode4(0x63, first, last, wire[0])((XID)((((unsigned int)(0x63))<<24)|(((((unsigned int)(
first))<<16)|(((((unsigned int)(last))<<8)|(wire[
0]))))&0xffffff)))
;
1957 return 0;
1958 }
1959 }
1960 wire += XkbPaddedSize(wire - start)((((unsigned int)(wire - start)+3) >> 2) << 2) - (wire - start);
1961 *wireRtrn = wire;
1962 return 1;
1963}
1964
1965static int
1966CheckVirtualModMap(XkbDescPtr xkb,
1967 xkbSetMapReq * req,
1968 xkbVModMapWireDesc ** wireRtrn, int *errRtrn)
1969{
1970 register xkbVModMapWireDesc *wire = *wireRtrn;
1971 register unsigned i;
1972 int first, last;
1973
1974 if (((req->present & XkbVirtualModMapMask(1<<7)) == 0) || (req->nVModMapKeys < 1)) {
1975 req->present &= ~XkbVirtualModMapMask(1<<7);
1976 req->nVModMapKeys = 0;
1977 return 1;
1978 }
1979 first = req->firstVModMapKey;
1980 last = first + req->nVModMapKeys - 1;
1981 if (first < req->minKeyCode) {
1982 *errRtrn = _XkbErrCode3(0x71, first, req->minKeyCode)((XID)((((unsigned int)(0x71))<<24)|(((((unsigned int)(
first))<<16)|(req->minKeyCode))&0xffffff)))
;
1983 return 0;
1984 }
1985 if (last > req->maxKeyCode) {
1986 *errRtrn = _XkbErrCode3(0x72, last, req->maxKeyCode)((XID)((((unsigned int)(0x72))<<24)|(((((unsigned int)(
last))<<16)|(req->maxKeyCode))&0xffffff)))
;
1987 return 0;
1988 }
1989 for (i = 0; i < req->totalVModMapKeys; i++, wire++) {
1990 if ((wire->key < first) || (wire->key > last)) {
1991 *errRtrn = _XkbErrCode4(0x73, first, last, wire->key)((XID)((((unsigned int)(0x73))<<24)|(((((unsigned int)(
first))<<16)|(((((unsigned int)(last))<<8)|(wire->
key))))&0xffffff)))
;
1992 return 0;
1993 }
1994 }
1995 *wireRtrn = wire;
1996 return 1;
1997}
1998
1999static char *
2000SetKeyTypes(XkbDescPtr xkb,
2001 xkbSetMapReq * req,
2002 xkbKeyTypeWireDesc * wire, XkbChangesPtr changes)
2003{
2004 register unsigned i;
2005 unsigned first, last;
2006 CARD8 *map;
2007
2008 if ((unsigned) (req->firstType + req->nTypes) > xkb->map->size_types) {
2009 i = req->firstType + req->nTypes;
2010 if (XkbAllocClientMapSrvXkbAllocClientMap(xkb, XkbKeyTypesMask(1<<0), i) != Success0) {
2011 return NULL((void*)0);
2012 }
2013 }
2014 if ((unsigned) (req->firstType + req->nTypes) > xkb->map->num_types)
2015 xkb->map->num_types = req->firstType + req->nTypes;
2016
2017 for (i = 0; i < req->nTypes; i++) {
2018 XkbKeyTypePtr pOld;
2019 register unsigned n;
2020
2021 if (XkbResizeKeyTypeSrvXkbResizeKeyType(xkb, i + req->firstType, wire->nMapEntries,
2022 wire->preserve, wire->numLevels) != Success0) {
2023 return NULL((void*)0);
2024 }
2025 pOld = &xkb->map->types[i + req->firstType];
2026 map = (CARD8 *) &wire[1];
2027
2028 pOld->mods.real_mods = wire->realMods;
2029 pOld->mods.vmods = wire->virtualMods;
2030 pOld->num_levels = wire->numLevels;
2031 pOld->map_count = wire->nMapEntries;
2032
2033 pOld->mods.mask = pOld->mods.real_mods |
2034 XkbMaskForVMask(xkb, pOld->mods.vmods);
2035
2036 if (wire->nMapEntries) {
2037 xkbKTSetMapEntryWireDesc *mapWire;
2038 xkbModsWireDesc *preWire;
2039 unsigned tmp;
2040
2041 mapWire = (xkbKTSetMapEntryWireDesc *) map;
2042 preWire = (xkbModsWireDesc *) &mapWire[wire->nMapEntries];
2043 for (n = 0; n < wire->nMapEntries; n++) {
2044 pOld->map[n].active = 1;
2045 pOld->map[n].mods.mask = mapWire[n].realMods;
2046 pOld->map[n].mods.real_mods = mapWire[n].realMods;
2047 pOld->map[n].mods.vmods = mapWire[n].virtualMods;
2048 pOld->map[n].level = mapWire[n].level;
2049 if (mapWire[n].virtualMods != 0) {
2050 tmp = XkbMaskForVMask(xkb, mapWire[n].virtualMods);
2051 pOld->map[n].active = (tmp != 0);
2052 pOld->map[n].mods.mask |= tmp;
2053 }
2054 if (wire->preserve) {
2055 pOld->preserve[n].real_mods = preWire[n].realMods;
2056 pOld->preserve[n].vmods = preWire[n].virtualMods;
2057 tmp = XkbMaskForVMask(xkb, preWire[n].virtualMods);
2058 pOld->preserve[n].mask = preWire[n].realMods | tmp;
2059 }
2060 }
2061 if (wire->preserve)
2062 map = (CARD8 *) &preWire[wire->nMapEntries];
2063 else
2064 map = (CARD8 *) &mapWire[wire->nMapEntries];
2065 }
2066 else
2067 map = (CARD8 *) &wire[1];
2068 wire = (xkbKeyTypeWireDesc *) map;
2069 }
2070 first = req->firstType;
2071 last = first + req->nTypes - 1; /* last changed type */
2072 if (changes->map.changed & XkbKeyTypesMask(1<<0)) {
2073 int oldLast;
2074
2075 oldLast = changes->map.first_type + changes->map.num_types - 1;
2076 if (changes->map.first_type < first)
2077 first = changes->map.first_type;
2078 if (oldLast > last)
2079 last = oldLast;
2080 }
2081 changes->map.changed |= XkbKeyTypesMask(1<<0);
2082 changes->map.first_type = first;
2083 changes->map.num_types = (last - first) + 1;
2084 return (char *) wire;
2085}
2086
2087static char *
2088SetKeySyms(ClientPtr client,
2089 XkbDescPtr xkb,
2090 xkbSetMapReq * req,
2091 xkbSymMapWireDesc * wire, XkbChangesPtr changes, DeviceIntPtr dev)
2092{
2093 register unsigned i, s;
2094 XkbSymMapPtr oldMap;
2095 KeySym *newSyms;
2096 KeySym *pSyms;
2097 unsigned first, last;
2098
2099 oldMap = &xkb->map->key_sym_map[req->firstKeySym];
2100 for (i = 0; i < req->nKeySyms; i++, oldMap++) {
2101 pSyms = (KeySym *) &wire[1];
2102 if (wire->nSyms > 0) {
2103 newSyms = XkbResizeKeySymsSrvXkbResizeKeySyms(xkb, i + req->firstKeySym, wire->nSyms);
2104 for (s = 0; s < wire->nSyms; s++) {
2105 newSyms[s] = pSyms[s];
2106 }
2107 if (client->swapped) {
2108 for (s = 0; s < wire->nSyms; s++) {
2109 swapl(&newSyms[s])do { if (sizeof(*(&newSyms[s])) != 4) wrong_size(); if (__builtin_constant_p
((uintptr_t)(&newSyms[s]) & 3) && ((uintptr_t
)(&newSyms[s]) & 3) == 0) *(&newSyms[s]) = lswapl
(*(&newSyms[s])); else swap_uint32((uint32_t *)(&newSyms
[s])); } while (0)
;
2110 }
2111 }
2112 }
2113 oldMap->kt_index[0] = wire->ktIndex[0];
2114 oldMap->kt_index[1] = wire->ktIndex[1];
2115 oldMap->kt_index[2] = wire->ktIndex[2];
2116 oldMap->kt_index[3] = wire->ktIndex[3];
2117 oldMap->group_info = wire->groupInfo;
2118 oldMap->width = wire->width;
2119 wire = (xkbSymMapWireDesc *) &pSyms[wire->nSyms];
2120 }
2121 first = req->firstKeySym;
2122 last = first + req->nKeySyms - 1;
2123 if (changes->map.changed & XkbKeySymsMask(1<<1)) {
2124 int oldLast =
2125 (changes->map.first_key_sym + changes->map.num_key_syms - 1);
2126 if (changes->map.first_key_sym < first)
2127 first = changes->map.first_key_sym;
2128 if (oldLast > last)
2129 last = oldLast;
2130 }
2131 changes->map.changed |= XkbKeySymsMask(1<<1);
2132 changes->map.first_key_sym = first;
2133 changes->map.num_key_syms = (last - first + 1);
2134
2135 s = 0;
2136 for (i = xkb->min_key_code; i <= xkb->max_key_code; i++) {
2137 if (XkbKeyNumGroups(xkb, i)((((((xkb)->map)->key_sym_map[((i))].group_info)&0x0f
)))
> s)
2138 s = XkbKeyNumGroups(xkb, i)((((((xkb)->map)->key_sym_map[((i))].group_info)&0x0f
)))
;
2139 }
2140 if (s != xkb->ctrls->num_groups) {
2141 xkbControlsNotify cn;
2142 XkbControlsRec old;
2143
2144 cn.keycode = 0;
2145 cn.eventType = 0;
2146 cn.requestMajor = XkbReqCode;
2147 cn.requestMinor = X_kbSetMap9;
2148 old = *xkb->ctrls;
2149 xkb->ctrls->num_groups = s;
2150 if (XkbComputeControlsNotify(dev, &old, xkb->ctrls, &cn, FALSE0))
2151 XkbSendControlsNotify(dev, &cn);
2152 }
2153 return (char *) wire;
2154}
2155
2156static char *
2157SetKeyActions(XkbDescPtr xkb,
2158 xkbSetMapReq * req, CARD8 *wire, XkbChangesPtr changes)
2159{
2160 register unsigned i, first, last;
2161 CARD8 *nActs = wire;
2162 XkbAction *newActs;
2163
2164 wire += XkbPaddedSize(req->nKeyActs)((((unsigned int)(req->nKeyActs)+3) >> 2) << 2
)
;
2165 for (i = 0; i < req->nKeyActs; i++) {
2166 if (nActs[i] == 0)
2167 xkb->server->key_acts[i + req->firstKeyAct] = 0;
2168 else {
2169 newActs = XkbResizeKeyActionsSrvXkbResizeKeyActions(xkb, i + req->firstKeyAct, nActs[i]);
2170 memcpy((char *) newActs, (char *) wire,__builtin___memcpy_chk ((char *) newActs, (char *) wire, nActs
[i] * 8, __builtin_object_size ((char *) newActs, 0))
2171 nActs[i] * SIZEOF(xkbActionWireDesc))__builtin___memcpy_chk ((char *) newActs, (char *) wire, nActs
[i] * 8, __builtin_object_size ((char *) newActs, 0))
;
2172 wire += nActs[i] * SIZEOF(xkbActionWireDesc)8;
2173 }
2174 }
2175 first = req->firstKeyAct;
2176 last = (first + req->nKeyActs - 1);
2177 if (changes->map.changed & XkbKeyActionsMask(1<<4)) {
2178 int oldLast;
2179
2180 oldLast = changes->map.first_key_act + changes->map.num_key_acts - 1;
2181 if (changes->map.first_key_act < first)
2182 first = changes->map.first_key_act;
2183 if (oldLast > last)
2184 last = oldLast;
2185 }
2186 changes->map.changed |= XkbKeyActionsMask(1<<4);
2187 changes->map.first_key_act = first;
2188 changes->map.num_key_acts = (last - first + 1);
2189 return (char *) wire;
2190}
2191
2192static char *
2193SetKeyBehaviors(XkbSrvInfoPtr xkbi,
2194 xkbSetMapReq * req,
2195 xkbBehaviorWireDesc * wire, XkbChangesPtr changes)
2196{
2197 register unsigned i;
2198 int maxRG = -1;
2199 XkbDescPtr xkb = xkbi->desc;
2200 XkbServerMapPtr server = xkb->server;
2201 unsigned first, last;
2202
2203 first = req->firstKeyBehavior;
2204 last = req->firstKeyBehavior + req->nKeyBehaviors - 1;
2205 memset(&server->behaviors[first], 0,__builtin___memset_chk (&server->behaviors[first], 0, req
->nKeyBehaviors * sizeof(XkbBehavior), __builtin_object_size
(&server->behaviors[first], 0))
2206 req->nKeyBehaviors * sizeof(XkbBehavior))__builtin___memset_chk (&server->behaviors[first], 0, req
->nKeyBehaviors * sizeof(XkbBehavior), __builtin_object_size
(&server->behaviors[first], 0))
;
2207 for (i = 0; i < req->totalKeyBehaviors; i++) {
2208 if ((server->behaviors[wire->key].type & XkbKB_Permanent0x80) == 0) {
2209 server->behaviors[wire->key].type = wire->type;
2210 server->behaviors[wire->key].data = wire->data;
2211 if ((wire->type == XkbKB_RadioGroup0x02) &&
2212 (((int) wire->data) > maxRG))
2213 maxRG = wire->data + 1;
2214 }
2215 wire++;
2216 }
2217
2218 if (maxRG > (int) xkbi->nRadioGroups) {
2219 if (xkbi->radioGroups)
2220 xkbi->radioGroups = reallocarrayxreallocarray(xkbi->radioGroups, maxRG,
2221 sizeof(XkbRadioGroupRec));
2222 else
2223 xkbi->radioGroups = calloc(maxRG, sizeof(XkbRadioGroupRec));
2224 if (xkbi->radioGroups) {
2225 if (xkbi->nRadioGroups)
2226 memset(&xkbi->radioGroups[xkbi->nRadioGroups], 0,__builtin___memset_chk (&xkbi->radioGroups[xkbi->nRadioGroups
], 0, (maxRG - xkbi->nRadioGroups) * sizeof(XkbRadioGroupRec
), __builtin_object_size (&xkbi->radioGroups[xkbi->
nRadioGroups], 0))
2227 (maxRG - xkbi->nRadioGroups) * sizeof(XkbRadioGroupRec))__builtin___memset_chk (&xkbi->radioGroups[xkbi->nRadioGroups
], 0, (maxRG - xkbi->nRadioGroups) * sizeof(XkbRadioGroupRec
), __builtin_object_size (&xkbi->radioGroups[xkbi->
nRadioGroups], 0))
;
2228 xkbi->nRadioGroups = maxRG;
2229 }
2230 else
2231 xkbi->nRadioGroups = 0;
2232 /* should compute members here */
2233 }
2234 if (changes->map.changed & XkbKeyBehaviorsMask(1<<5)) {
2235 unsigned oldLast;
2236
2237 oldLast = changes->map.first_key_behavior +
2238 changes->map.num_key_behaviors - 1;
2239 if (changes->map.first_key_behavior < req->firstKeyBehavior)
2240 first = changes->map.first_key_behavior;
2241 if (oldLast > last)
2242 last = oldLast;
2243 }
2244 changes->map.changed |= XkbKeyBehaviorsMask(1<<5);
2245 changes->map.first_key_behavior = first;
2246 changes->map.num_key_behaviors = (last - first + 1);
2247 return (char *) wire;
2248}
2249
2250static char *
2251SetVirtualMods(XkbSrvInfoPtr xkbi, xkbSetMapReq * req, CARD8 *wire,
2252 XkbChangesPtr changes)
2253{
2254 register int i, bit, nMods;
2255 XkbServerMapPtr srv = xkbi->desc->server;
2256
2257 if (((req->present & XkbVirtualModsMask(1<<6)) == 0) || (req->virtualMods == 0))
2258 return (char *) wire;
2259 for (i = nMods = 0, bit = 1; i < XkbNumVirtualMods16; i++, bit <<= 1) {
2260 if (req->virtualMods & bit) {
2261 if (srv->vmods[i] != wire[nMods]) {
2262 changes->map.changed |= XkbVirtualModsMask(1<<6);
2263 changes->map.vmods |= bit;
2264 srv->vmods[i] = wire[nMods];
2265 }
2266 nMods++;
2267 }
2268 }
2269 return (char *) (wire + XkbPaddedSize(nMods)((((unsigned int)(nMods)+3) >> 2) << 2));
2270}
2271
2272static char *
2273SetKeyExplicit(XkbSrvInfoPtr xkbi, xkbSetMapReq * req, CARD8 *wire,
2274 XkbChangesPtr changes)
2275{
2276 register unsigned i, first, last;
2277 XkbServerMapPtr xkb = xkbi->desc->server;
2278 CARD8 *start;
2279
2280 start = wire;
2281 first = req->firstKeyExplicit;
2282 last = req->firstKeyExplicit + req->nKeyExplicit - 1;
2283 memset(&xkb->explicit[first], 0, req->nKeyExplicit)__builtin___memset_chk (&xkb->explicit[first], 0, req->
nKeyExplicit, __builtin_object_size (&xkb->explicit[first
], 0))
;
2284 for (i = 0; i < req->totalKeyExplicit; i++, wire += 2) {
2285 xkb->explicit[wire[0]] = wire[1];
2286 }
2287 if (first > 0) {
2288 if (changes->map.changed & XkbExplicitComponentsMask(1<<3)) {
2289 int oldLast;
2290
2291 oldLast = changes->map.first_key_explicit +
2292 changes->map.num_key_explicit - 1;
2293 if (changes->map.first_key_explicit < first)
2294 first = changes->map.first_key_explicit;
2295 if (oldLast > last)
2296 last = oldLast;
2297 }
2298 changes->map.first_key_explicit = first;
2299 changes->map.num_key_explicit = (last - first) + 1;
2300 }
2301 wire += XkbPaddedSize(wire - start)((((unsigned int)(wire - start)+3) >> 2) << 2) - (wire - start);
2302 return (char *) wire;
2303}
2304
2305static char *
2306SetModifierMap(XkbSrvInfoPtr xkbi,
2307 xkbSetMapReq * req, CARD8 *wire, XkbChangesPtr changes)
2308{
2309 register unsigned i, first, last;
2310 XkbClientMapPtr xkb = xkbi->desc->map;
2311 CARD8 *start;
2312
2313 start = wire;
2314 first = req->firstModMapKey;
2315 last = req->firstModMapKey + req->nModMapKeys - 1;
2316 memset(&xkb->modmap[first], 0, req->nModMapKeys)__builtin___memset_chk (&xkb->modmap[first], 0, req->
nModMapKeys, __builtin_object_size (&xkb->modmap[first
], 0))
;
2317 for (i = 0; i < req->totalModMapKeys; i++, wire += 2) {
2318 xkb->modmap[wire[0]] = wire[1];
2319 }
2320 if (first > 0) {
2321 if (changes->map.changed & XkbModifierMapMask(1<<2)) {
2322 int oldLast;
2323
2324 oldLast = changes->map.first_modmap_key +
2325 changes->map.num_modmap_keys - 1;
2326 if (changes->map.first_modmap_key < first)
2327 first = changes->map.first_modmap_key;
2328 if (oldLast > last)
2329 last = oldLast;
2330 }
2331 changes->map.first_modmap_key = first;
2332 changes->map.num_modmap_keys = (last - first) + 1;
2333 }
2334 wire += XkbPaddedSize(wire - start)((((unsigned int)(wire - start)+3) >> 2) << 2) - (wire - start);
2335 return (char *) wire;
2336}
2337
2338static char *
2339SetVirtualModMap(XkbSrvInfoPtr xkbi,
2340 xkbSetMapReq * req,
2341 xkbVModMapWireDesc * wire, XkbChangesPtr changes)
2342{
2343 register unsigned i, first, last;
2344 XkbServerMapPtr srv = xkbi->desc->server;
2345
2346 first = req->firstVModMapKey;
2347 last = req->firstVModMapKey + req->nVModMapKeys - 1;
2348 memset(&srv->vmodmap[first], 0, req->nVModMapKeys * sizeof(unsigned short))__builtin___memset_chk (&srv->vmodmap[first], 0, req->
nVModMapKeys * sizeof(unsigned short), __builtin_object_size (
&srv->vmodmap[first], 0))
;
2349 for (i = 0; i < req->totalVModMapKeys; i++, wire++) {
2350 srv->vmodmap[wire->key] = wire->vmods;
2351 }
2352 if (first > 0) {
2353 if (changes->map.changed & XkbVirtualModMapMask(1<<7)) {
2354 int oldLast;
2355
2356 oldLast = changes->map.first_vmodmap_key +
2357 changes->map.num_vmodmap_keys - 1;
2358 if (changes->map.first_vmodmap_key < first)
2359 first = changes->map.first_vmodmap_key;
2360 if (oldLast > last)
2361 last = oldLast;
2362 }
2363 changes->map.first_vmodmap_key = first;
2364 changes->map.num_vmodmap_keys = (last - first) + 1;
2365 }
2366 return (char *) wire;
2367}
2368
2369/**
2370 * Check if the given request can be applied to the given device but don't
2371 * actually do anything..
2372 */
2373static int
2374_XkbSetMapChecks(ClientPtr client, DeviceIntPtr dev, xkbSetMapReq * req,
2375 char *values)
2376{
2377 XkbSrvInfoPtr xkbi;
2378 XkbDescPtr xkb;
2379 int error;
2380 int nTypes = 0, nActions;
2381 CARD8 mapWidths[XkbMaxLegalKeyCode255 + 1] = { 0 };
2382 CARD16 symsPerKey[XkbMaxLegalKeyCode255 + 1] = { 0 };
2383 XkbSymMapPtr map;
2384 int i;
2385
2386 xkbi = dev->key->xkbInfo;
2387 xkb = xkbi->desc;
2388
2389 if ((xkb->min_key_code != req->minKeyCode) ||
2390 (xkb->max_key_code != req->maxKeyCode)) {
2391 if (client->vMajor != 1) { /* pre 1.0 versions of Xlib have a bug */
2392 req->minKeyCode = xkb->min_key_code;
2393 req->maxKeyCode = xkb->max_key_code;
2394 }
2395 else {
2396 if (!XkbIsLegalKeycode(req->minKeyCode)((req->minKeyCode)>=8)) {
2397 client->errorValue =
2398 _XkbErrCode3(2, req->minKeyCode, req->maxKeyCode)((XID)((((unsigned int)(2))<<24)|(((((unsigned int)(req
->minKeyCode))<<16)|(req->maxKeyCode))&0xffffff
)))
;
2399 return BadValue2;
2400 }
2401 if (req->minKeyCode > req->maxKeyCode) {
2402 client->errorValue =
2403 _XkbErrCode3(3, req->minKeyCode, req->maxKeyCode)((XID)((((unsigned int)(3))<<24)|(((((unsigned int)(req
->minKeyCode))<<16)|(req->maxKeyCode))&0xffffff
)))
;
2404 return BadMatch8;
2405 }
2406 }
2407 }
2408
2409 if ((req->present & XkbKeyTypesMask(1<<0)) &&
2410 (!CheckKeyTypes(client, xkb, req, (xkbKeyTypeWireDesc **) &values,
2411 &nTypes, mapWidths))) {
2412 client->errorValue = nTypes;
2413 return BadValue2;
2414 }
2415
2416 /* symsPerKey/mapWidths must be filled regardless of client-side flags */
2417 map = &xkb->map->key_sym_map[xkb->min_key_code];
2418 for (i = xkb->min_key_code; i < xkb->max_key_code; i++, map++) {
2419 register int g, ng, w;
2420
2421 ng = XkbNumGroups(map->group_info)((map->group_info)&0x0f);
2422 for (w = g = 0; g < ng; g++) {
2423 if (map->kt_index[g] >= (unsigned) nTypes) {
2424 client->errorValue = _XkbErrCode4(0x13, i, g, map->kt_index[g])((XID)((((unsigned int)(0x13))<<24)|(((((unsigned int)(
i))<<16)|(((((unsigned int)(g))<<8)|(map->kt_index
[g]))))&0xffffff)))
;
2425 return 0;
2426 }
2427 if (mapWidths[map->kt_index[g]] > w)
2428 w = mapWidths[map->kt_index[g]];
2429 }
2430 symsPerKey[i] = w * ng;
2431 }
2432
2433 if ((req->present & XkbKeySymsMask(1<<1)) &&
2434 (!CheckKeySyms(client, xkb, req, nTypes, mapWidths, symsPerKey,
2435 (xkbSymMapWireDesc **) &values, &error))) {
2436 client->errorValue = error;
2437 return BadValue2;
2438 }
2439
2440 if ((req->present & XkbKeyActionsMask(1<<4)) &&
2441 (!CheckKeyActions(xkb, req, nTypes, mapWidths, symsPerKey,
2442 (CARD8 **) &values, &nActions))) {
2443 client->errorValue = nActions;
2444 return BadValue2;
2445 }
2446
2447 if ((req->present & XkbKeyBehaviorsMask(1<<5)) &&
2448 (!CheckKeyBehaviors
2449 (xkb, req, (xkbBehaviorWireDesc **) &values, &error))) {
2450 client->errorValue = error;
2451 return BadValue2;
2452 }
2453
2454 if ((req->present & XkbVirtualModsMask(1<<6)) &&
2455 (!CheckVirtualMods(xkb, req, (CARD8 **) &values, &error))) {
2456 client->errorValue = error;
2457 return BadValue2;
2458 }
2459 if ((req->present & XkbExplicitComponentsMask(1<<3)) &&
2460 (!CheckKeyExplicit(xkb, req, (CARD8 **) &values, &error))) {
2461 client->errorValue = error;
2462 return BadValue2;
2463 }
2464 if ((req->present & XkbModifierMapMask(1<<2)) &&
2465 (!CheckModifierMap(xkb, req, (CARD8 **) &values, &error))) {
2466 client->errorValue = error;
2467 return BadValue2;
2468 }
2469 if ((req->present & XkbVirtualModMapMask(1<<7)) &&
2470 (!CheckVirtualModMap
2471 (xkb, req, (xkbVModMapWireDesc **) &values, &error))) {
2472 client->errorValue = error;
2473 return BadValue2;
2474 }
2475
2476 if (((values - ((char *) req)) / 4) != req->length) {
2477 ErrorF("[xkb] Internal error! Bad length in XkbSetMap (after check)\n");
2478 client->errorValue = values - ((char *) &req[1]);
2479 return BadLength16;
2480 }
2481
2482 return Success0;
2483}
2484
2485/**
2486 * Apply the given request on the given device.
2487 */
2488static int
2489_XkbSetMap(ClientPtr client, DeviceIntPtr dev, xkbSetMapReq * req, char *values)
2490{
2491 XkbEventCauseRec cause;
2492 XkbChangesRec change;
2493 Bool sentNKN;
2494 XkbSrvInfoPtr xkbi;
2495 XkbDescPtr xkb;
2496
2497 xkbi = dev->key->xkbInfo;
2498 xkb = xkbi->desc;
2499
2500 XkbSetCauseXkbReq(&cause, X_kbSetMap, client){ (&cause)->kc= (&cause)->event= 0, (&cause
)->mjr= (XkbReqCode),(&cause)->mnr= (9); (&cause
)->client= (client); }
;
2501 memset(&change, 0, sizeof(change))__builtin___memset_chk (&change, 0, sizeof(change), __builtin_object_size
(&change, 0))
;
2502 sentNKN = FALSE0;
2503 if ((xkb->min_key_code != req->minKeyCode) ||
2504 (xkb->max_key_code != req->maxKeyCode)) {
2505 Statusint status;
2506 xkbNewKeyboardNotify nkn;
2507
2508 nkn.deviceID = nkn.oldDeviceID = dev->id;
2509 nkn.oldMinKeyCode = xkb->min_key_code;
2510 nkn.oldMaxKeyCode = xkb->max_key_code;
2511 status = XkbChangeKeycodeRangeSrvXkbChangeKeycodeRange(xkb, req->minKeyCode,
2512 req->maxKeyCode, &change);
2513 if (status != Success0)
2514 return status; /* oh-oh. what about the other keyboards? */
2515 nkn.minKeyCode = xkb->min_key_code;
2516 nkn.maxKeyCode = xkb->max_key_code;
2517 nkn.requestMajor = XkbReqCode;
2518 nkn.requestMinor = X_kbSetMap9;
2519 nkn.changed = XkbNKN_KeycodesMask(1L << 0);
2520 XkbSendNewKeyboardNotify(dev, &nkn);
2521 sentNKN = TRUE1;
2522 }
2523
2524 if (req->present & XkbKeyTypesMask(1<<0)) {
2525 values = SetKeyTypes(xkb, req, (xkbKeyTypeWireDesc *) values, &change);
2526 if (!values)
2527 goto allocFailure;
2528 }
2529 if (req->present & XkbKeySymsMask(1<<1)) {
2530 values =
2531 SetKeySyms(client, xkb, req, (xkbSymMapWireDesc *) values, &change,
2532 dev);
2533 if (!values)
2534 goto allocFailure;
2535 }
2536 if (req->present & XkbKeyActionsMask(1<<4)) {
2537 values = SetKeyActions(xkb, req, (CARD8 *) values, &change);
2538 if (!values)
2539 goto allocFailure;
2540 }
2541 if (req->present & XkbKeyBehaviorsMask(1<<5)) {
2542 values =
2543 SetKeyBehaviors(xkbi, req, (xkbBehaviorWireDesc *) values, &change);
2544 if (!values)
2545 goto allocFailure;
2546 }
2547 if (req->present & XkbVirtualModsMask(1<<6))
2548 values = SetVirtualMods(xkbi, req, (CARD8 *) values, &change);
2549 if (req->present & XkbExplicitComponentsMask(1<<3))
2550 values = SetKeyExplicit(xkbi, req, (CARD8 *) values, &change);
2551 if (req->present & XkbModifierMapMask(1<<2))
2552 values = SetModifierMap(xkbi, req, (CARD8 *) values, &change);
2553 if (req->present & XkbVirtualModMapMask(1<<7))
2554 values =
2555 SetVirtualModMap(xkbi, req, (xkbVModMapWireDesc *) values, &change);
2556 if (((values - ((char *) req)) / 4) != req->length) {
2557 ErrorF("[xkb] Internal error! Bad length in XkbSetMap (after set)\n");
2558 client->errorValue = values - ((char *) &req[1]);
2559 return BadLength16;
2560 }
2561 if (req->flags & XkbSetMapRecomputeActions(1L<<1)) {
2562 KeyCode first, last, firstMM, lastMM;
2563
2564 if (change.map.num_key_syms > 0) {
2565 first = change.map.first_key_sym;
2566 last = first + change.map.num_key_syms - 1;
2567 }
2568 else
2569 first = last = 0;
2570 if (change.map.num_modmap_keys > 0) {
2571 firstMM = change.map.first_modmap_key;
2572 lastMM = first + change.map.num_modmap_keys - 1;
2573 }
2574 else
2575 firstMM = lastMM = 0;
2576 if ((last > 0) && (lastMM > 0)) {
2577 if (firstMM < first)
2578 first = firstMM;
2579 if (lastMM > last)
2580 last = lastMM;
2581 }
2582 else if (lastMM > 0) {
2583 first = firstMM;
2584 last = lastMM;
2585 }
2586 if (last > 0) {
2587 unsigned check = 0;
2588
2589 XkbUpdateActions(dev, first, (last - first + 1), &change, &check,
2590 &cause);
2591 if (check)
2592 XkbCheckSecondaryEffects(xkbi, check, &change, &cause);
2593 }
2594 }
2595 if (!sentNKN)
2596 XkbSendNotification(dev, &change, &cause);
2597
2598 return Success0;
2599 allocFailure:
2600 return BadAlloc11;
2601}
2602
2603int
2604ProcXkbSetMap(ClientPtr client)
2605{
2606 DeviceIntPtr dev;
2607 char *tmp;
2608 int rc;
2609
2610 REQUEST(xkbSetMapReq)xkbSetMapReq *stuff = (xkbSetMapReq *)client->requestBuffer;
2611 REQUEST_AT_LEAST_SIZE(xkbSetMapReq)if ((sizeof(xkbSetMapReq) >> 2) > client->req_len
) return(16)
;
2612
2613 if (!(client->xkbClientFlags & _XkbClientInitialized(1<<15)))
2614 return BadAccess10;
2615
2616 CHK_KBD_DEVICE(dev, stuff->deviceSpec, client, DixManageAccess){ int why; int tmprc = _XkbLookupKeyboard(&(dev), stuff->
deviceSpec, client, (1<<25), &why); if (tmprc != 0)
{ client->errorValue = ((XID)((((unsigned int)(why))<<
24)|((stuff->deviceSpec)&0xffffff))); return tmprc; }}
;
2617 CHK_MASK_LEGAL(0x01, stuff->present, XkbAllMapComponentsMask){ if ((stuff->present)&(~((((1<<0)|(1<<1)|
(1<<2))|((1<<3)|(1<<4)|(1<<5)|(1<<
6)|(1<<7)))))) { (client->errorValue)= ((XID)((((unsigned
int)((0x01)))<<24)|((((stuff->present)&(~((((1<<
0)|(1<<1)|(1<<2))|((1<<3)|(1<<4)|(1<<
5)|(1<<6)|(1<<7)))))))&0xffffff))); return 2;
}}
;
2618
2619 tmp = (char *) &stuff[1];
2620
2621 /* Check if we can to the SetMap on the requested device. If this
2622 succeeds, do the same thing for all extension devices (if needed).
2623 If any of them fails, fail. */
2624 rc = _XkbSetMapChecks(client, dev, stuff, tmp);
2625
2626 if (rc != Success0)
2627 return rc;
2628
2629 if (stuff->deviceSpec == XkbUseCoreKbd0x0100) {
2630 DeviceIntPtr other;
2631
2632 for (other = inputInfo.devices; other; other = other->next) {
2633 if ((other != dev) && other->key && !IsMaster(other) &&
2634 GetMaster(other, MASTER_KEYBOARD2) == dev) {
2635 rc = XaceHook(XACE_DEVICE_ACCESS3, client, other,
2636 DixManageAccess(1<<25));
2637 if (rc == Success0) {
2638 rc = _XkbSetMapChecks(client, other, stuff, tmp);
2639 if (rc != Success0)
2640 return rc;
2641 }
2642 }
2643 }
2644 }
2645
2646 /* We know now that we will succed with the SetMap. In theory anyway. */
2647 rc = _XkbSetMap(client, dev, stuff, tmp);
2648 if (rc != Success0)
2649 return rc;
2650
2651 if (stuff->deviceSpec == XkbUseCoreKbd0x0100) {
2652 DeviceIntPtr other;
2653
2654 for (other = inputInfo.devices; other; other = other->next) {
2655 if ((other != dev) && other->key && !IsMaster(other) &&
2656 GetMaster(other, MASTER_KEYBOARD2) == dev) {
2657 rc = XaceHook(XACE_DEVICE_ACCESS3, client, other,
2658 DixManageAccess(1<<25));
2659 if (rc == Success0)
2660 _XkbSetMap(client, other, stuff, tmp);
2661 /* ignore rc. if the SetMap failed although the check above
2662 reported true there isn't much we can do. we still need to
2663 set all other devices, hoping that at least they stay in
2664 sync. */
2665 }
2666 }
2667 }
2668
2669 return Success0;
2670}
2671
2672/***====================================================================***/
2673
2674static Statusint
2675XkbComputeGetCompatMapReplySize(XkbCompatMapPtr compat,
2676 xkbGetCompatMapReply * rep)
2677{
2678 unsigned size, nGroups;
2679
2680 nGroups = 0;
2681 if (rep->groups != 0) {
2682 register int i, bit;
2683
2684 for (i = 0, bit = 1; i < XkbNumKbdGroups4; i++, bit <<= 1) {
2685 if (rep->groups & bit)
2686 nGroups++;
2687 }
2688 }
2689 size = nGroups * SIZEOF(xkbModsWireDesc)4;
2690 size += (rep->nSI * SIZEOF(xkbSymInterpretWireDesc)16);
2691 rep->length = size / 4;
2692 return Success0;
2693}
2694
2695static int
2696XkbSendCompatMap(ClientPtr client,
2697 XkbCompatMapPtr compat, xkbGetCompatMapReply * rep)
2698{
2699 char *data;
2700 int size;
2701
2702 if (rep->length > 0) {
2703 data = xallocarray(rep->length, 4)xreallocarray(((void*)0), (rep->length), (4));
2704 if (data) {
2705 register unsigned i, bit;
2706 xkbModsWireDesc *grp;
2707 XkbSymInterpretPtr sym = &compat->sym_interpret[rep->firstSI];
2708 xkbSymInterpretWireDesc *wire = (xkbSymInterpretWireDesc *) data;
2709
2710 size = rep->length * 4;
2711
2712 for (i = 0; i < rep->nSI; i++, sym++, wire++) {
2713 wire->sym = sym->sym;
2714 wire->mods = sym->mods;
2715 wire->match = sym->match;
2716 wire->virtualMod = sym->virtual_mod;
2717 wire->flags = sym->flags;
2718 memcpy((char *) &wire->act, (char *) &sym->act,__builtin___memcpy_chk ((char *) &wire->act, (char *) &
sym->act, 8, __builtin_object_size ((char *) &wire->
act, 0))
2719 sz_xkbActionWireDesc)__builtin___memcpy_chk ((char *) &wire->act, (char *) &
sym->act, 8, __builtin_object_size ((char *) &wire->
act, 0))
;
2720 if (client->swapped) {
2721 swapl(&wire->sym)do { if (sizeof(*(&wire->sym)) != 4) wrong_size(); if (
__builtin_constant_p((uintptr_t)(&wire->sym) & 3) &&
((uintptr_t)(&wire->sym) & 3) == 0) *(&wire->
sym) = lswapl(*(&wire->sym)); else swap_uint32((uint32_t
*)(&wire->sym)); } while (0)
;
2722 }
2723 }
2724 if (rep->groups) {
2725 grp = (xkbModsWireDesc *) wire;
2726 for (i = 0, bit = 1; i < XkbNumKbdGroups4; i++, bit <<= 1) {
2727 if (rep->groups & bit) {
2728 grp->mask = compat->groups[i].mask;
2729 grp->realMods = compat->groups[i].real_mods;
2730 grp->virtualMods = compat->groups[i].vmods;
2731 if (client->swapped) {
2732 swaps(&grp->virtualMods)do { if (sizeof(*(&grp->virtualMods)) != 2) wrong_size
(); if (__builtin_constant_p((uintptr_t)(&grp->virtualMods
) & 1) && ((uintptr_t)(&grp->virtualMods) &
1) == 0) *(&grp->virtualMods) = lswaps(*(&grp->
virtualMods)); else swap_uint16((uint16_t *)(&grp->virtualMods
)); } while (0)
;
2733 }
2734 grp++;
2735 }
2736 }
2737 wire = (xkbSymInterpretWireDesc *) grp;
2738 }
2739 }
2740 else
2741 return BadAlloc11;
2742 }
2743 else
2744 data = NULL((void*)0);
2745
2746 if (client->swapped) {
2747 swaps(&rep->sequenceNumber)do { if (sizeof(*(&rep->sequenceNumber)) != 2) wrong_size
(); if (__builtin_constant_p((uintptr_t)(&rep->sequenceNumber
) & 1) && ((uintptr_t)(&rep->sequenceNumber
) & 1) == 0) *(&rep->sequenceNumber) = lswaps(*(&
rep->sequenceNumber)); else swap_uint16((uint16_t *)(&
rep->sequenceNumber)); } while (0)
;
2748 swapl(&rep->length)do { if (sizeof(*(&rep->length)) != 4) wrong_size(); if
(__builtin_constant_p((uintptr_t)(&rep->length) &
3) && ((uintptr_t)(&rep->length) & 3) == 0
) *(&rep->length) = lswapl(*(&rep->length)); else
swap_uint32((uint32_t *)(&rep->length)); } while (0)
;
2749 swaps(&rep->firstSI)do { if (sizeof(*(&rep->firstSI)) != 2) wrong_size(); if
(__builtin_constant_p((uintptr_t)(&rep->firstSI) &
1) && ((uintptr_t)(&rep->firstSI) & 1) ==
0) *(&rep->firstSI) = lswaps(*(&rep->firstSI))
; else swap_uint16((uint16_t *)(&rep->firstSI)); } while
(0)
;
2750 swaps(&rep->nSI)do { if (sizeof(*(&rep->nSI)) != 2) wrong_size(); if (
__builtin_constant_p((uintptr_t)(&rep->nSI) & 1) &&
((uintptr_t)(&rep->nSI) & 1) == 0) *(&rep->
nSI) = lswaps(*(&rep->nSI)); else swap_uint16((uint16_t
*)(&rep->nSI)); } while (0)
;
2751 swaps(&rep->nTotalSI)do { if (sizeof(*(&rep->nTotalSI)) != 2) wrong_size();
if (__builtin_constant_p((uintptr_t)(&rep->nTotalSI) &
1) && ((uintptr_t)(&rep->nTotalSI) & 1) ==
0) *(&rep->nTotalSI) = lswaps(*(&rep->nTotalSI
)); else swap_uint16((uint16_t *)(&rep->nTotalSI)); } while
(0)
;
2752 }
2753
2754 WriteToClient(client, SIZEOF(xkbGetCompatMapReply)32, rep);
2755 if (data) {
2756 WriteToClient(client, size, data);
2757 free((char *) data);
2758 }
2759 return Success0;
2760}
2761
2762int
2763ProcXkbGetCompatMap(ClientPtr client)
2764{
2765 xkbGetCompatMapReply rep;
2766 DeviceIntPtr dev;
2767 XkbDescPtr xkb;
2768 XkbCompatMapPtr compat;
2769
2770 REQUEST(xkbGetCompatMapReq)xkbGetCompatMapReq *stuff = (xkbGetCompatMapReq *)client->
requestBuffer
;
2771 REQUEST_SIZE_MATCH(xkbGetCompatMapReq)if ((sizeof(xkbGetCompatMapReq) >> 2) != client->req_len
) return(16)
;
2772
2773 if (!(client->xkbClientFlags & _XkbClientInitialized(1<<15)))
2774 return BadAccess10;
2775
2776 CHK_KBD_DEVICE(dev, stuff->deviceSpec, client, DixGetAttrAccess){ int why; int tmprc = _XkbLookupKeyboard(&(dev), stuff->
deviceSpec, client, (1<<4), &why); if (tmprc != 0) {
client->errorValue = ((XID)((((unsigned int)(why))<<
24)|((stuff->deviceSpec)&0xffffff))); return tmprc; }}
;
2777
2778 xkb = dev->key->xkbInfo->desc;
2779 compat = xkb->compat;
2780
2781 rep = (xkbGetCompatMapReply) {
2782 .type = X_Reply1,
2783 .sequenceNumber = client->sequence,
2784 .length = 0,
2785 .deviceID = dev->id,
2786 .firstSI = stuff->firstSI,
2787 .nSI = stuff->nSI
2788 };
2789 if (stuff->getAllSI) {
2790 rep.firstSI = 0;
2791 rep.nSI = compat->num_si;
2792 }
2793 else if ((((unsigned) stuff->nSI) > 0) &&
2794 ((unsigned) (stuff->firstSI + stuff->nSI - 1) >= compat->num_si)) {
2795 client->errorValue = _XkbErrCode2(0x05, compat->num_si)((XID)((((unsigned int)(0x05))<<24)|((compat->num_si
)&0xffffff)))
;
2796 return BadValue2;
2797 }
2798 rep.nTotalSI = compat->num_si;
2799 rep.groups = stuff->groups;
2800 XkbComputeGetCompatMapReplySize(compat, &rep);
2801 return XkbSendCompatMap(client, compat, &rep);
2802}
2803
2804/**
2805 * Apply the given request on the given device.
2806 * If dryRun is TRUE, then value checks are performed, but the device isn't
2807 * modified.
2808 */
2809static int
2810_XkbSetCompatMap(ClientPtr client, DeviceIntPtr dev,
2811 xkbSetCompatMapReq * req, char *data, BOOL dryRun)
2812{
2813 XkbSrvInfoPtr xkbi;
2814 XkbDescPtr xkb;
2815 XkbCompatMapPtr compat;
2816 int nGroups;
2817 unsigned i, bit;
2818
2819 xkbi = dev->key->xkbInfo;
2820 xkb = xkbi->desc;
2821 compat = xkb->compat;
2822
2823 if ((req->nSI > 0) || (req->truncateSI)) {
2824 xkbSymInterpretWireDesc *wire;
2825
2826 if (req->firstSI > compat->num_si) {
2827 client->errorValue = _XkbErrCode2(0x02, compat->num_si)((XID)((((unsigned int)(0x02))<<24)|((compat->num_si
)&0xffffff)))
;
2828 return BadValue2;
2829 }
2830 wire = (xkbSymInterpretWireDesc *) data;
2831 wire += req->nSI;
2832 data = (char *) wire;
2833 }
2834
2835 nGroups = 0;
2836 if (req->groups != 0) {
2837 for (i = 0, bit = 1; i < XkbNumKbdGroups4; i++, bit <<= 1) {
2838 if (req->groups & bit)
2839 nGroups++;
2840 }
2841 }
2842 data += nGroups * SIZEOF(xkbModsWireDesc)4;
2843 if (((data - ((char *) req)) / 4) != req->length) {
2844 return BadLength16;
2845 }
2846
2847 /* Done all the checks we can do */
2848 if (dryRun)
2849 return Success0;
2850
2851 data = (char *) &req[1];
2852 if (req->nSI > 0) {
2853 xkbSymInterpretWireDesc *wire = (xkbSymInterpretWireDesc *) data;
2854 XkbSymInterpretPtr sym;
2855 unsigned int skipped = 0;
2856
2857 if ((unsigned) (req->firstSI + req->nSI) > compat->num_si) {
2858 compat->num_si = req->firstSI + req->nSI;
2859 compat->sym_interpret = reallocarrayxreallocarray(compat->sym_interpret,
2860 compat->num_si,
2861 sizeof(XkbSymInterpretRec));
2862 if (!compat->sym_interpret) {
2863 compat->num_si = 0;
2864 return BadAlloc11;
2865 }
2866 }
2867 else if (req->truncateSI) {
2868 compat->num_si = req->firstSI + req->nSI;
2869 }
2870 sym = &compat->sym_interpret[req->firstSI];
2871 for (i = 0; i < req->nSI; i++, wire++) {
2872 if (client->swapped) {
2873 swapl(&wire->sym)do { if (sizeof(*(&wire->sym)) != 4) wrong_size(); if (
__builtin_constant_p((uintptr_t)(&wire->sym) & 3) &&
((uintptr_t)(&wire->sym) & 3) == 0) *(&wire->
sym) = lswapl(*(&wire->sym)); else swap_uint32((uint32_t
*)(&wire->sym)); } while (0)
;
2874 }
2875 if (wire->sym == NoSymbol0L && wire->match == XkbSI_AnyOfOrNone(1) &&
2876 (wire->mods & 0xff) == 0xff &&
2877 wire->act.type == XkbSA_XFree86Private0x86) {
2878 ErrorF("XKB: Skipping broken Any+AnyOfOrNone(All) -> Private "
2879 "action from client\n");
2880 skipped++;
2881 continue;
2882 }
2883 sym->sym = wire->sym;
2884 sym->mods = wire->mods;
2885 sym->match = wire->match;
2886 sym->flags = wire->flags;
2887 sym->virtual_mod = wire->virtualMod;
2888 memcpy((char *) &sym->act, (char *) &wire->act,__builtin___memcpy_chk ((char *) &sym->act, (char *) &
wire->act, 8, __builtin_object_size ((char *) &sym->
act, 0))
2889 SIZEOF(xkbActionWireDesc))__builtin___memcpy_chk ((char *) &sym->act, (char *) &
wire->act, 8, __builtin_object_size ((char *) &sym->
act, 0))
;
2890 sym++;
2891 }
2892 if (skipped) {
2893 if (req->firstSI + req->nSI < compat->num_si)
2894 memmove(sym, sym + skipped,__builtin___memmove_chk (sym, sym + skipped, (compat->num_si
- req->firstSI - req->nSI) * sizeof(*sym), __builtin_object_size
(sym, 0))
2895 (compat->num_si - req->firstSI - req->nSI) *__builtin___memmove_chk (sym, sym + skipped, (compat->num_si
- req->firstSI - req->nSI) * sizeof(*sym), __builtin_object_size
(sym, 0))
2896 sizeof(*sym))__builtin___memmove_chk (sym, sym + skipped, (compat->num_si
- req->firstSI - req->nSI) * sizeof(*sym), __builtin_object_size
(sym, 0))
;
2897 compat->num_si -= skipped;
2898 }
2899 data = (char *) wire;
2900 }
2901 else if (req->truncateSI) {
2902 compat->num_si = req->firstSI;
2903 }
2904
2905 if (req->groups != 0) {
2906 xkbModsWireDesc *wire = (xkbModsWireDesc *) data;
2907
2908 for (i = 0, bit = 1; i < XkbNumKbdGroups4; i++, bit <<= 1) {
2909 if (req->groups & bit) {
2910 if (client->swapped) {
2911 swaps(&wire->virtualMods)do { if (sizeof(*(&wire->virtualMods)) != 2) wrong_size
(); if (__builtin_constant_p((uintptr_t)(&wire->virtualMods
) & 1) && ((uintptr_t)(&wire->virtualMods)
& 1) == 0) *(&wire->virtualMods) = lswaps(*(&
wire->virtualMods)); else swap_uint16((uint16_t *)(&wire
->virtualMods)); } while (0)
;
2912 }
2913 compat->groups[i].mask = wire->realMods;
2914 compat->groups[i].real_mods = wire->realMods;
2915 compat->groups[i].vmods = wire->virtualMods;
2916 if (wire->virtualMods != 0) {
2917 unsigned tmp;
2918
2919 tmp = XkbMaskForVMask(xkb, wire->virtualMods);
2920 compat->groups[i].mask |= tmp;
2921 }
2922 data += SIZEOF(xkbModsWireDesc)4;
2923 wire = (xkbModsWireDesc *) data;
2924 }
2925 }
2926 }
2927 i = XkbPaddedSize((data - ((char *) req)))((((unsigned int)((data - ((char *) req)))+3) >> 2) <<
2)
;
2928 if ((i / 4) != req->length) {
2929 ErrorF("[xkb] Internal length error on read in _XkbSetCompatMap\n");
2930 return BadLength16;
2931 }
2932
2933 if (dev->xkb_interest) {
2934 xkbCompatMapNotify ev;
2935
2936 ev.deviceID = dev->id;
2937 ev.changedGroups = req->groups;
2938 ev.firstSI = req->firstSI;
2939 ev.nSI = req->nSI;
2940 ev.nTotalSI = compat->num_si;
2941 XkbSendCompatMapNotify(dev, &ev);
2942 }
2943
2944 if (req->recomputeActions) {
2945 XkbChangesRec change;
2946 unsigned check;
2947 XkbEventCauseRec cause;
2948
2949 XkbSetCauseXkbReq(&cause, X_kbSetCompatMap, client){ (&cause)->kc= (&cause)->event= 0, (&cause
)->mjr= (XkbReqCode),(&cause)->mnr= (11); (&cause
)->client= (client); }
;
2950 memset(&change, 0, sizeof(XkbChangesRec))__builtin___memset_chk (&change, 0, sizeof(XkbChangesRec)
, __builtin_object_size (&change, 0))
;
2951 XkbUpdateActions(dev, xkb->min_key_code, XkbNumKeys(xkb)((xkb)->max_key_code-(xkb)->min_key_code+1), &change,
2952 &check, &cause);
2953 if (check)
2954 XkbCheckSecondaryEffects(xkbi, check, &change, &cause);
2955 XkbSendNotification(dev, &change, &cause);
2956 }
2957 return Success0;
2958}
2959
2960int
2961ProcXkbSetCompatMap(ClientPtr client)
2962{
2963 DeviceIntPtr dev;
2964 char *data;
2965 int rc;
2966
2967 REQUEST(xkbSetCompatMapReq)xkbSetCompatMapReq *stuff = (xkbSetCompatMapReq *)client->
requestBuffer
;
2968 REQUEST_AT_LEAST_SIZE(xkbSetCompatMapReq)if ((sizeof(xkbSetCompatMapReq) >> 2) > client->req_len
) return(16)
;
2969
2970 if (!(client->xkbClientFlags & _XkbClientInitialized(1<<15)))
2971 return BadAccess10;
2972
2973 CHK_KBD_DEVICE(dev, stuff->deviceSpec, client, DixManageAccess){ int why; int tmprc = _XkbLookupKeyboard(&(dev), stuff->
deviceSpec, client, (1<<25), &why); if (tmprc != 0)
{ client->errorValue = ((XID)((((unsigned int)(why))<<
24)|((stuff->deviceSpec)&0xffffff))); return tmprc; }}
;
2974
2975 data = (char *) &stuff[1];
2976
2977 /* check first using a dry-run */
2978 rc = _XkbSetCompatMap(client, dev, stuff, data, TRUE1);
2979 if (rc != Success0)
2980 return rc;
2981 if (stuff->deviceSpec == XkbUseCoreKbd0x0100) {
2982 DeviceIntPtr other;
2983
2984 for (other = inputInfo.devices; other; other = other->next) {
2985 if ((other != dev) && other->key && !IsMaster(other) &&
2986 GetMaster(other, MASTER_KEYBOARD2) == dev) {
2987 rc = XaceHook(XACE_DEVICE_ACCESS3, client, other,
2988 DixManageAccess(1<<25));
2989 if (rc == Success0) {
2990 /* dry-run */
2991 rc = _XkbSetCompatMap(client, other, stuff, data, TRUE1);
2992 if (rc != Success0)
2993 return rc;
2994 }
2995 }
2996 }
2997 }
2998
2999 /* Yay, the dry-runs succeed. Let's apply */
3000 rc = _XkbSetCompatMap(client, dev, stuff, data, FALSE0);
3001 if (rc != Success0)
3002 return rc;
3003 if (stuff->deviceSpec == XkbUseCoreKbd0x0100) {
3004 DeviceIntPtr other;
3005
3006 for (other = inputInfo.devices; other; other = other->next) {
3007 if ((other != dev) && other->key && !IsMaster(other) &&
3008 GetMaster(other, MASTER_KEYBOARD2) == dev) {
3009 rc = XaceHook(XACE_DEVICE_ACCESS3, client, other,
3010 DixManageAccess(1<<25));
3011 if (rc == Success0) {
3012 rc = _XkbSetCompatMap(client, other, stuff, data, FALSE0);
3013 if (rc != Success0)
3014 return rc;
3015 }
3016 }
3017 }
3018 }
3019
3020 return Success0;
3021}
3022
3023/***====================================================================***/
3024
3025int
3026ProcXkbGetIndicatorState(ClientPtr client)
3027{
3028 xkbGetIndicatorStateReply rep;
3029 XkbSrvLedInfoPtr sli;
3030 DeviceIntPtr dev;
3031
3032 REQUEST(xkbGetIndicatorStateReq)xkbGetIndicatorStateReq *stuff = (xkbGetIndicatorStateReq *)client
->requestBuffer
;
3033 REQUEST_SIZE_MATCH(xkbGetIndicatorStateReq)if ((sizeof(xkbGetIndicatorStateReq) >> 2) != client->
req_len) return(16)
;
3034
3035 if (!(client->xkbClientFlags & _XkbClientInitialized(1<<15)))
3036 return BadAccess10;
3037
3038 CHK_KBD_DEVICE(dev, stuff->deviceSpec, client, DixReadAccess){ int why; int tmprc = _XkbLookupKeyboard(&(dev), stuff->
deviceSpec, client, (1<<0), &why); if (tmprc != 0) {
client->errorValue = ((XID)((((unsigned int)(why))<<
24)|((stuff->deviceSpec)&0xffffff))); return tmprc; }}
;
3039
3040 sli = XkbFindSrvLedInfo(dev, XkbDfltXIClass0x0300, XkbDfltXIId0x0400,
3041 XkbXI_IndicatorStateMask(1L << 4));
3042 if (!sli)
3043 return BadAlloc11;
3044
3045 rep = (xkbGetIndicatorStateReply) {
3046 .type = X_Reply1,
3047 .deviceID = dev->id,
3048 .sequenceNumber = client->sequence,
3049 .length = 0,
3050 .state = sli->effectiveState
3051 };
3052
3053 if (client->swapped) {
3054 swaps(&rep.sequenceNumber)do { if (sizeof(*(&rep.sequenceNumber)) != 2) wrong_size(
); if (__builtin_constant_p((uintptr_t)(&rep.sequenceNumber
) & 1) && ((uintptr_t)(&rep.sequenceNumber) &
1) == 0) *(&rep.sequenceNumber) = lswaps(*(&rep.sequenceNumber
)); else swap_uint16((uint16_t *)(&rep.sequenceNumber)); }
while (0)
;
3055 swapl(&rep.state)do { if (sizeof(*(&rep.state)) != 4) wrong_size(); if (__builtin_constant_p
((uintptr_t)(&rep.state) & 3) && ((uintptr_t)
(&rep.state) & 3) == 0) *(&rep.state) = lswapl(*(
&rep.state)); else swap_uint32((uint32_t *)(&rep.state
)); } while (0)
;
3056 }
3057 WriteToClient(client, SIZEOF(xkbGetIndicatorStateReply)32, &rep);
3058 return Success0;
3059}
3060
3061/***====================================================================***/
3062
3063static Statusint
3064XkbComputeGetIndicatorMapReplySize(XkbIndicatorPtr indicators,
3065 xkbGetIndicatorMapReply * rep)
3066{
3067 register int i, bit;
3068 int nIndicators;
3069
3070 rep->realIndicators = indicators->phys_indicators;
3071 for (i = nIndicators = 0, bit = 1; i < XkbNumIndicators32; i++, bit <<= 1) {
3072 if (rep->which & bit)
3073 nIndicators++;
3074 }
3075 rep->length = (nIndicators * SIZEOF(xkbIndicatorMapWireDesc)12) / 4;
3076 rep->nIndicators = nIndicators;
3077 return Success0;
3078}
3079
3080static int
3081XkbSendIndicatorMap(ClientPtr client,
3082 XkbIndicatorPtr indicators, xkbGetIndicatorMapReply * rep)
3083{
3084 int length;
3085 CARD8 *map;
3086 register int i;
3087 register unsigned bit;
3088
3089 if (rep->length > 0) {
3090 CARD8 *to;
3091
3092 to = map = xallocarray(rep->length, 4)xreallocarray(((void*)0), (rep->length), (4));
3093 if (map) {
3094 xkbIndicatorMapWireDesc *wire = (xkbIndicatorMapWireDesc *) to;
3095
3096 length = rep->length * 4;
3097
3098 for (i = 0, bit = 1; i < XkbNumIndicators32; i++, bit <<= 1) {
3099 if (rep->which & bit) {
3100 wire->flags = indicators->maps[i].flags;
3101 wire->whichGroups = indicators->maps[i].which_groups;
3102 wire->groups = indicators->maps[i].groups;
3103 wire->whichMods = indicators->maps[i].which_mods;
3104 wire->mods = indicators->maps[i].mods.mask;
3105 wire->realMods = indicators->maps[i].mods.real_mods;
3106 wire->virtualMods = indicators->maps[i].mods.vmods;
3107 wire->ctrls = indicators->maps[i].ctrls;
3108 if (client->swapped) {
3109 swaps(&wire->virtualMods)do { if (sizeof(*(&wire->virtualMods)) != 2) wrong_size
(); if (__builtin_constant_p((uintptr_t)(&wire->virtualMods
) & 1) && ((uintptr_t)(&wire->virtualMods)
& 1) == 0) *(&wire->virtualMods) = lswaps(*(&
wire->virtualMods)); else swap_uint16((uint16_t *)(&wire
->virtualMods)); } while (0)
;
3110 swapl(&wire->ctrls)do { if (sizeof(*(&wire->ctrls)) != 4) wrong_size(); if
(__builtin_constant_p((uintptr_t)(&wire->ctrls) &
3) && ((uintptr_t)(&wire->ctrls) & 3) == 0
) *(&wire->ctrls) = lswapl(*(&wire->ctrls)); else
swap_uint32((uint32_t *)(&wire->ctrls)); } while (0)
;
3111 }
3112 wire++;
3113 }
3114 }
3115 to = (CARD8 *) wire;
3116 if ((to - map) != length) {
3117 client->errorValue = _XkbErrCode2(0xff, length)((XID)((((unsigned int)(0xff))<<24)|((length)&0xffffff
)))
;
3118 free(map);
3119 return BadLength16;
3120 }
3121 }
3122 else
3123 return BadAlloc11;
3124 }
3125 else
3126 map = NULL((void*)0);
3127 if (client->swapped) {
3128 swaps(&rep->sequenceNumber)do { if (sizeof(*(&rep->sequenceNumber)) != 2) wrong_size
(); if (__builtin_constant_p((uintptr_t)(&rep->sequenceNumber
) & 1) && ((uintptr_t)(&rep->sequenceNumber
) & 1) == 0) *(&rep->sequenceNumber) = lswaps(*(&
rep->sequenceNumber)); else swap_uint16((uint16_t *)(&
rep->sequenceNumber)); } while (0)
;
3129 swapl(&rep->length)do { if (sizeof(*(&rep->length)) != 4) wrong_size(); if
(__builtin_constant_p((uintptr_t)(&rep->length) &
3) && ((uintptr_t)(&rep->length) & 3) == 0
) *(&rep->length) = lswapl(*(&rep->length)); else
swap_uint32((uint32_t *)(&rep->length)); } while (0)
;
3130 swapl(&rep->which)do { if (sizeof(*(&rep->which)) != 4) wrong_size(); if
(__builtin_constant_p((uintptr_t)(&rep->which) & 3
) && ((uintptr_t)(&rep->which) & 3) == 0) *
(&rep->which) = lswapl(*(&rep->which)); else swap_uint32
((uint32_t *)(&rep->which)); } while (0)
;
3131 swapl(&rep->realIndicators)do { if (sizeof(*(&rep->realIndicators)) != 4) wrong_size
(); if (__builtin_constant_p((uintptr_t)(&rep->realIndicators
) & 3) && ((uintptr_t)(&rep->realIndicators
) & 3) == 0) *(&rep->realIndicators) = lswapl(*(&
rep->realIndicators)); else swap_uint32((uint32_t *)(&
rep->realIndicators)); } while (0)
;
3132 }
3133 WriteToClient(client, SIZEOF(xkbGetIndicatorMapReply)32, rep);
3134 if (map) {
3135 WriteToClient(client, length, map);
3136 free((char *) map);
3137 }
3138 return Success0;
3139}
3140
3141int
3142ProcXkbGetIndicatorMap(ClientPtr client)
3143{
3144 xkbGetIndicatorMapReply rep;
3145 DeviceIntPtr dev;
3146 XkbDescPtr xkb;
3147 XkbIndicatorPtr leds;
3148
3149 REQUEST(xkbGetIndicatorMapReq)xkbGetIndicatorMapReq *stuff = (xkbGetIndicatorMapReq *)client
->requestBuffer
;
3150 REQUEST_SIZE_MATCH(xkbGetIndicatorMapReq)if ((sizeof(xkbGetIndicatorMapReq) >> 2) != client->
req_len) return(16)
;
3151
3152 if (!(client->xkbClientFlags & _XkbClientInitialized(1<<15)))
3153 return BadAccess10;
3154
3155 CHK_KBD_DEVICE(dev, stuff->deviceSpec, client, DixGetAttrAccess){ int why; int tmprc = _XkbLookupKeyboard(&(dev), stuff->
deviceSpec, client, (1<<4), &why); if (tmprc != 0) {
client->errorValue = ((XID)((((unsigned int)(why))<<
24)|((stuff->deviceSpec)&0xffffff))); return tmprc; }}
;
3156
3157 xkb = dev->key->xkbInfo->desc;
3158 leds = xkb->indicators;
3159
3160 rep = (xkbGetIndicatorMapReply) {
3161 .type = X_Reply1,
3162 .deviceID = dev->id,
3163 .sequenceNumber = client->sequence,
3164 .length = 0,
3165 .which = stuff->which
3166 };
3167 XkbComputeGetIndicatorMapReplySize(leds, &rep);
3168 return XkbSendIndicatorMap(client, leds, &rep);
3169}
3170
3171/**
3172 * Apply the given map to the given device. Which specifies which components
3173 * to apply.
3174 */
3175static int
3176_XkbSetIndicatorMap(ClientPtr client, DeviceIntPtr dev,
3177 int which, xkbIndicatorMapWireDesc * desc)
3178{
3179 XkbSrvInfoPtr xkbi;
3180 XkbSrvLedInfoPtr sli;
3181 XkbEventCauseRec cause;
3182 int i, bit;
3183
3184 xkbi = dev->key->xkbInfo;
3185
3186 sli = XkbFindSrvLedInfo(dev, XkbDfltXIClass0x0300, XkbDfltXIId0x0400,
3187 XkbXI_IndicatorMapsMask(1L << 3));
3188 if (!sli)
3189 return BadAlloc11;
3190
3191 for (i = 0, bit = 1; i < XkbNumIndicators32; i++, bit <<= 1) {
3192 if (which & bit) {
3193 sli->maps[i].flags = desc->flags;
3194 sli->maps[i].which_groups = desc->whichGroups;
3195 sli->maps[i].groups = desc->groups;
3196 sli->maps[i].which_mods = desc->whichMods;
3197 sli->maps[i].mods.mask = desc->mods;
3198 sli->maps[i].mods.real_mods = desc->mods;
3199 sli->maps[i].mods.vmods = desc->virtualMods;
3200 sli->maps[i].ctrls = desc->ctrls;
3201 if (desc->virtualMods != 0) {
3202 unsigned tmp;
3203
3204 tmp = XkbMaskForVMask(xkbi->desc, desc->virtualMods);
3205 sli->maps[i].mods.mask = desc->mods | tmp;
3206 }
3207 desc++;
3208 }
3209 }
3210
3211 XkbSetCauseXkbReq(&cause, X_kbSetIndicatorMap, client){ (&cause)->kc= (&cause)->event= 0, (&cause
)->mjr= (XkbReqCode),(&cause)->mnr= (14); (&cause
)->client= (client); }
;
3212 XkbApplyLedMapChanges(dev, sli, which, NULL((void*)0), NULL((void*)0), &cause);
3213
3214 return Success0;
3215}
3216
3217int
3218ProcXkbSetIndicatorMap(ClientPtr client)
3219{
3220 int i, bit;
3221 int nIndicators;
3222 DeviceIntPtr dev;
3223 xkbIndicatorMapWireDesc *from;
3224 int rc;
3225
3226 REQUEST(xkbSetIndicatorMapReq)xkbSetIndicatorMapReq *stuff = (xkbSetIndicatorMapReq *)client
->requestBuffer
;
3227 REQUEST_AT_LEAST_SIZE(xkbSetIndicatorMapReq)if ((sizeof(xkbSetIndicatorMapReq) >> 2) > client->
req_len ) return(16)
;
3228
3229 if (!(client->xkbClientFlags & _XkbClientInitialized(1<<15)))
3230 return BadAccess10;
3231
3232 CHK_KBD_DEVICE(dev, stuff->deviceSpec, client, DixSetAttrAccess){ int why; int tmprc = _XkbLookupKeyboard(&(dev), stuff->
deviceSpec, client, (1<<5), &why); if (tmprc != 0) {
client->errorValue = ((XID)((((unsigned int)(why))<<
24)|((stuff->deviceSpec)&0xffffff))); return tmprc; }}
;
3233
3234 if (stuff->which == 0)
3235 return Success0;
3236
3237 for (nIndicators = i = 0, bit = 1; i < XkbNumIndicators32; i++, bit <<= 1) {
3238 if (stuff->which & bit)
3239 nIndicators++;
3240 }
3241 if (stuff->length != ((SIZEOF(xkbSetIndicatorMapReq)12 +
3242 (nIndicators * SIZEOF(xkbIndicatorMapWireDesc)12)) /
3243 4)) {
3244 return BadLength16;
3245 }
3246
3247 from = (xkbIndicatorMapWireDesc *) &stuff[1];
3248 for (i = 0, bit = 1; i < XkbNumIndicators32; i++, bit <<= 1) {
3249 if (stuff->which & bit) {
3250 if (client->swapped) {
3251 swaps(&from->virtualMods)do { if (sizeof(*(&from->virtualMods)) != 2) wrong_size
(); if (__builtin_constant_p((uintptr_t)(&from->virtualMods
) & 1) && ((uintptr_t)(&from->virtualMods)
& 1) == 0) *(&from->virtualMods) = lswaps(*(&
from->virtualMods)); else swap_uint16((uint16_t *)(&from
->virtualMods)); } while (0)
;
3252 swapl(&from->ctrls)do { if (sizeof(*(&from->ctrls)) != 4) wrong_size(); if
(__builtin_constant_p((uintptr_t)(&from->ctrls) &
3) && ((uintptr_t)(&from->ctrls) & 3) == 0
) *(&from->ctrls) = lswapl(*(&from->ctrls)); else
swap_uint32((uint32_t *)(&from->ctrls)); } while (0)
;
3253 }
3254 CHK_MASK_LEGAL(i, from->whichGroups, XkbIM_UseAnyGroup){ if ((from->whichGroups)&(~(((1L << 0)|(1L <<
1)|(1L << 2) |(1L << 3))))) { (client->errorValue
)= ((XID)((((unsigned int)((i)))<<24)|((((from->whichGroups
)&(~(((1L << 0)|(1L << 1)|(1L << 2) |(1L
<< 3))))))&0xffffff))); return 2; }}
;
3255 CHK_MASK_LEGAL(i, from->whichMods, XkbIM_UseAnyMods){ if ((from->whichMods)&(~((((1L << 0)|(1L <<
1)|(1L << 2) |(1L << 3))|(1L << 4))))) { (
client->errorValue)= ((XID)((((unsigned int)((i)))<<
24)|((((from->whichMods)&(~((((1L << 0)|(1L <<
1)|(1L << 2) |(1L << 3))|(1L << 4))))))&
0xffffff))); return 2; }}
;
3256 from++;
3257 }
3258 }
3259
3260 from = (xkbIndicatorMapWireDesc *) &stuff[1];
3261 rc = _XkbSetIndicatorMap(client, dev, stuff->which, from);
3262 if (rc != Success0)
3263 return rc;
3264
3265 if (stuff->deviceSpec == XkbUseCoreKbd0x0100) {
3266 DeviceIntPtr other;
3267
3268 for (other = inputInfo.devices; other; other = other->next) {
3269 if ((other != dev) && other->key && !IsMaster(other) &&
3270 GetMaster(other, MASTER_KEYBOARD2) == dev) {
3271 rc = XaceHook(XACE_DEVICE_ACCESS3, client, other,
3272 DixSetAttrAccess(1<<5));
3273 if (rc == Success0)
3274 _XkbSetIndicatorMap(client, other, stuff->which, from);
3275 }
3276 }
3277 }
3278
3279 return Success0;
3280}
3281
3282/***====================================================================***/
3283
3284int
3285ProcXkbGetNamedIndicator(ClientPtr client)
3286{
3287 DeviceIntPtr dev;
3288 xkbGetNamedIndicatorReply rep;
3289 register int i = 0;
3290 XkbSrvLedInfoPtr sli;
3291 XkbIndicatorMapPtr map = NULL((void*)0);
3292
3293 REQUEST(xkbGetNamedIndicatorReq)xkbGetNamedIndicatorReq *stuff = (xkbGetNamedIndicatorReq *)client
->requestBuffer
;
3294 REQUEST_SIZE_MATCH(xkbGetNamedIndicatorReq)if ((sizeof(xkbGetNamedIndicatorReq) >> 2) != client->
req_len) return(16)
;
3295
3296 if (!(client->xkbClientFlags & _XkbClientInitialized(1<<15)))
3297 return BadAccess10;
3298
3299 CHK_LED_DEVICE(dev, stuff->deviceSpec, client, DixReadAccess){ int why; int tmprc = _XkbLookupLedDevice(&(dev), stuff->
deviceSpec, client, (1<<0), &why); if (tmprc != 0) {
client->errorValue = ((XID)((((unsigned int)(why))<<
24)|((stuff->deviceSpec)&0xffffff))); return tmprc; }}
;
3300 CHK_ATOM_ONLY(stuff->indicator){ if (((stuff->indicator)==0L)||(!ValidAtom((stuff->indicator
)))) { (client->errorValue)= (XID)(stuff->indicator); return
5; }}
;
3301
3302 sli = XkbFindSrvLedInfo(dev, stuff->ledClass, stuff->ledID, 0);
3303 if (!sli)
3304 return BadAlloc11;
3305
3306 i = 0;
3307 map = NULL((void*)0);
3308 if ((sli->names) && (sli->maps)) {
3309 for (i = 0; i < XkbNumIndicators32; i++) {
3310 if (stuff->indicator == sli->names[i]) {
3311 map = &sli->maps[i];
3312 break;
3313 }
3314 }
3315 }
3316
3317 rep = (xkbGetNamedIndicatorReply) {
3318 .type = X_Reply1,
3319 .sequenceNumber = client->sequence,
3320 .length = 0,
3321 .deviceID = dev->id,
3322 .indicator = stuff->indicator
3323 };
3324 if (map != NULL((void*)0)) {
3325 rep.found = TRUE1;
3326 rep.on = ((sli->effectiveState & (1 << i)) != 0);
3327 rep.realIndicator = ((sli->physIndicators & (1 << i)) != 0);
3328 rep.ndx = i;
3329 rep.flags = map->flags;
3330 rep.whichGroups = map->which_groups;
3331 rep.groups = map->groups;
3332 rep.whichMods = map->which_mods;
3333 rep.mods = map->mods.mask;
3334 rep.realMods = map->mods.real_mods;
3335 rep.virtualMods = map->mods.vmods;
3336 rep.ctrls = map->ctrls;
3337 rep.supported = TRUE1;
3338 }
3339 else {
3340 rep.found = FALSE0;
3341 rep.on = FALSE0;
3342 rep.realIndicator = FALSE0;
3343 rep.ndx = XkbNoIndicator0xff;
3344 rep.flags = 0;
3345 rep.whichGroups = 0;
3346 rep.groups = 0;
3347 rep.whichMods = 0;
3348 rep.mods = 0;
3349 rep.realMods = 0;
3350 rep.virtualMods = 0;
3351 rep.ctrls = 0;
3352 rep.supported = TRUE1;
3353 }
3354 if (client->swapped) {
3355 swapl(&rep.length)do { if (sizeof(*(&rep.length)) != 4) wrong_size(); if (__builtin_constant_p
((uintptr_t)(&rep.length) & 3) && ((uintptr_t
)(&rep.length) & 3) == 0) *(&rep.length) = lswapl
(*(&rep.length)); else swap_uint32((uint32_t *)(&rep.
length)); } while (0)
;
3356 swaps(&rep.sequenceNumber)do { if (sizeof(*(&rep.sequenceNumber)) != 2) wrong_size(
); if (__builtin_constant_p((uintptr_t)(&rep.sequenceNumber
) & 1) && ((uintptr_t)(&rep.sequenceNumber) &
1) == 0) *(&rep.sequenceNumber) = lswaps(*(&rep.sequenceNumber
)); else swap_uint16((uint16_t *)(&rep.sequenceNumber)); }
while (0)
;
3357 swapl(&rep.indicator)do { if (sizeof(*(&rep.indicator)) != 4) wrong_size(); if
(__builtin_constant_p((uintptr_t)(&rep.indicator) & 3
) && ((uintptr_t)(&rep.indicator) & 3) == 0) *
(&rep.indicator) = lswapl(*(&rep.indicator)); else swap_uint32
((uint32_t *)(&rep.indicator)); } while (0)
;
3358 swaps(&rep.virtualMods)do { if (sizeof(*(&rep.virtualMods)) != 2) wrong_size(); if
(__builtin_constant_p((uintptr_t)(&rep.virtualMods) &
1) && ((uintptr_t)(&rep.virtualMods) & 1) ==
0) *(&rep.virtualMods) = lswaps(*(&rep.virtualMods))
; else swap_uint16((uint16_t *)(&rep.virtualMods)); } while
(0)
;
3359 swapl(&rep.ctrls)do { if (sizeof(*(&rep.ctrls)) != 4) wrong_size(); if (__builtin_constant_p
((uintptr_t)(&rep.ctrls) & 3) && ((uintptr_t)
(&rep.ctrls) & 3) == 0) *(&rep.ctrls) = lswapl(*(
&rep.ctrls)); else swap_uint32((uint32_t *)(&rep.ctrls
)); } while (0)
;
3360 }
3361
3362 WriteToClient(client, SIZEOF(xkbGetNamedIndicatorReply)32, &rep);
3363 return Success0;
3364}
3365
3366/**
3367 * Find the IM on the device.
3368 * Returns the map, or NULL if the map doesn't exist.
3369 * If the return value is NULL, led_return is undefined. Otherwise, led_return
3370 * is set to the led index of the map.
3371 */
3372static XkbIndicatorMapPtr
3373_XkbFindNamedIndicatorMap(XkbSrvLedInfoPtr sli, Atom indicator, int *led_return)
3374{
3375 XkbIndicatorMapPtr map;
3376
3377 /* search for the right indicator */
3378 map = NULL((void*)0);
3379 if (sli->names && sli->maps) {
3380 int led;
3381
3382 for (led = 0; (led < XkbNumIndicators32) && (map == NULL((void*)0)); led++) {
3383 if (sli->names[led] == indicator) {
3384 map = &sli->maps[led];
3385 *led_return = led;
3386 break;
3387 }
3388 }
3389 }
3390
3391 return map;
3392}
3393
3394/**
3395 * Creates an indicator map on the device. If dryRun is TRUE, it only checks
3396 * if creation is possible, but doesn't actually create it.
3397 */
3398static int
3399_XkbCreateIndicatorMap(DeviceIntPtr dev, Atom indicator,
3400 int ledClass, int ledID,
3401 XkbIndicatorMapPtr * map_return, int *led_return,
3402 Bool dryRun)
3403{
3404 XkbSrvLedInfoPtr sli;
3405 XkbIndicatorMapPtr map;
3406 int led;
3407
3408 sli = XkbFindSrvLedInfo(dev, ledClass, ledID, XkbXI_IndicatorsMask(0x001c));
3409 if (!sli)
3410 return BadAlloc11;
3411
3412 map = _XkbFindNamedIndicatorMap(sli, indicator, &led);
3413
3414 if (!map) {
3415 /* find first unused indicator maps and assign the name to it */
3416 for (led = 0, map = NULL((void*)0); (led < XkbNumIndicators32) && (map == NULL((void*)0));
3417 led++) {
3418 if ((sli->names) && (sli->maps) && (sli->names[led] == None0L) &&
3419 (!XkbIM_InUse(&sli->maps[led])((&sli->maps[led])->flags || (&sli->maps[led
])->which_groups || (&sli->maps[led])->which_mods
|| (&sli->maps[led])->ctrls)
)) {
3420 map = &sli->maps[led];
3421 if (!dryRun)
3422 sli->names[led] = indicator;
3423 break;
3424 }
3425 }
3426 }
3427
3428 if (!map)
3429 return BadAlloc11;
3430
3431 *led_return = led;
3432 *map_return = map;
3433 return Success0;
3434}
3435
3436static int
3437_XkbSetNamedIndicator(ClientPtr client, DeviceIntPtr dev,
3438 xkbSetNamedIndicatorReq * stuff)
3439{
3440 unsigned int extDevReason;
3441 unsigned int statec, namec, mapc;
3442 XkbSrvLedInfoPtr sli;
3443 int led = 0;
3444 XkbIndicatorMapPtr map;
3445 DeviceIntPtr kbd;
3446 XkbEventCauseRec cause;
3447 xkbExtensionDeviceNotify ed;
3448 XkbChangesRec changes;
3449 int rc;
3450
3451 rc = _XkbCreateIndicatorMap(dev, stuff->indicator, stuff->ledClass,
3452 stuff->ledID, &map, &led, FALSE0);
3453 if (rc != Success0 || !map) /* oh-oh */
3454 return rc;
3455
3456 sli = XkbFindSrvLedInfo(dev, stuff->ledClass, stuff->ledID,
3457 XkbXI_IndicatorsMask(0x001c));
3458 if (!sli)
3459 return BadAlloc11;
3460
3461 namec = mapc = statec = 0;
3462 extDevReason = 0;
3463
3464 namec |= (1 << led);
3465 sli->namesPresent |= ((stuff->indicator != None0L) ? (1 << led) : 0);
3466 extDevReason |= XkbXI_IndicatorNamesMask(1L << 2);
3467
3468 if (stuff->setMap) {
3469 map->flags = stuff->flags;
3470 map->which_groups = stuff->whichGroups;
3471 map->groups = stuff->groups;
3472 map->which_mods = stuff->whichMods;
3473 map->mods.mask = stuff->realMods;
3474 map->mods.real_mods = stuff->realMods;
3475 map->mods.vmods = stuff->virtualMods;
3476 map->ctrls = stuff->ctrls;
3477 mapc |= (1 << led);
3478 }
3479
3480 if ((stuff->setState) && ((map->flags & XkbIM_NoExplicit(1L << 7)) == 0)) {
3481 if (stuff->on)
3482 sli->explicitState |= (1 << led);
3483 else
3484 sli->explicitState &= ~(1 << led);
3485 statec |= ((sli->effectiveState ^ sli->explicitState) & (1 << led));
3486 }
3487
3488 memset((char *) &ed, 0, sizeof(xkbExtensionDeviceNotify))__builtin___memset_chk ((char *) &ed, 0, sizeof(xkbExtensionDeviceNotify
), __builtin_object_size ((char *) &ed, 0))
;
3489 memset((char *) &changes, 0, sizeof(XkbChangesRec))__builtin___memset_chk ((char *) &changes, 0, sizeof(XkbChangesRec
), __builtin_object_size ((char *) &changes, 0))
;
3490 XkbSetCauseXkbReq(&cause, X_kbSetNamedIndicator, client){ (&cause)->kc= (&cause)->event= 0, (&cause
)->mjr= (XkbReqCode),(&cause)->mnr= (16); (&cause
)->client= (client); }
;
3491 if (namec)
3492 XkbApplyLedNameChanges(dev, sli, namec, &ed, &changes, &cause);
3493 if (mapc)
3494 XkbApplyLedMapChanges(dev, sli, mapc, &ed, &changes, &cause);
3495 if (statec)
3496 XkbApplyLedStateChanges(dev, sli, statec, &ed, &changes, &cause);
3497
3498 kbd = dev;
3499 if ((sli->flags & XkbSLI_HasOwnState(1L<<1)) == 0)
3500 kbd = inputInfo.keyboard;
3501 XkbFlushLedEvents(dev, kbd, sli, &ed, &changes, &cause);
3502
3503 return Success0;
3504}
3505
3506int
3507ProcXkbSetNamedIndicator(ClientPtr client)
3508{
3509 int rc;
3510 DeviceIntPtr dev;
3511 int led = 0;
3512 XkbIndicatorMapPtr map;
3513
3514 REQUEST(xkbSetNamedIndicatorReq)xkbSetNamedIndicatorReq *stuff = (xkbSetNamedIndicatorReq *)client
->requestBuffer
;
3515 REQUEST_SIZE_MATCH(xkbSetNamedIndicatorReq)if ((sizeof(xkbSetNamedIndicatorReq) >> 2) != client->
req_len) return(16)
;
3516
3517 if (!(client->xkbClientFlags & _XkbClientInitialized(1<<15)))
3518 return BadAccess10;
3519
3520 CHK_LED_DEVICE(dev, stuff->deviceSpec, client, DixSetAttrAccess){ int why; int tmprc = _XkbLookupLedDevice(&(dev), stuff->
deviceSpec, client, (1<<5), &why); if (tmprc != 0) {
client->errorValue = ((XID)((((unsigned int)(why))<<
24)|((stuff->deviceSpec)&0xffffff))); return tmprc; }}
;
3521 CHK_ATOM_ONLY(stuff->indicator){ if (((stuff->indicator)==0L)||(!ValidAtom((stuff->indicator
)))) { (client->errorValue)= (XID)(stuff->indicator); return
5; }}
;
3522 CHK_MASK_LEGAL(0x10, stuff->whichGroups, XkbIM_UseAnyGroup){ if ((stuff->whichGroups)&(~(((1L << 0)|(1L <<
1)|(1L << 2) |(1L << 3))))) { (client->errorValue
)= ((XID)((((unsigned int)((0x10)))<<24)|((((stuff->
whichGroups)&(~(((1L << 0)|(1L << 1)|(1L <<
2) |(1L << 3))))))&0xffffff))); return 2; }}
;
3523 CHK_MASK_LEGAL(0x11, stuff->whichMods, XkbIM_UseAnyMods){ if ((stuff->whichMods)&(~((((1L << 0)|(1L <<
1)|(1L << 2) |(1L << 3))|(1L << 4))))) { (
client->errorValue)= ((XID)((((unsigned int)((0x11)))<<
24)|((((stuff->whichMods)&(~((((1L << 0)|(1L <<
1)|(1L << 2) |(1L << 3))|(1L << 4))))))&
0xffffff))); return 2; }}
;
3524
3525 /* Dry-run for checks */
3526 rc = _XkbCreateIndicatorMap(dev, stuff->indicator,
3527 stuff->ledClass, stuff->ledID,
3528 &map, &led, TRUE1);
3529 if (rc != Success0 || !map) /* couldn't be created or didn't exist */
3530 return rc;
3531
3532 if (stuff->deviceSpec == XkbUseCoreKbd0x0100 ||
3533 stuff->deviceSpec == XkbUseCorePtr0x0200) {
3534 DeviceIntPtr other;
3535
3536 for (other = inputInfo.devices; other; other = other->next) {
3537 if ((other != dev) && !IsMaster(other) &&
3538 GetMaster(other, MASTER_KEYBOARD2) == dev && (other->kbdfeed ||
3539 other->leds) &&
3540 (XaceHook(XACE_DEVICE_ACCESS3, client, other, DixSetAttrAccess(1<<5))
3541 == Success0)) {
3542 rc = _XkbCreateIndicatorMap(other, stuff->indicator,
3543 stuff->ledClass, stuff->ledID, &map,
3544 &led, TRUE1);
3545 if (rc != Success0 || !map)
3546 return rc;
3547 }
3548 }
3549 }
3550
3551 /* All checks passed, let's do it */
3552 rc = _XkbSetNamedIndicator(client, dev, stuff);
3553 if (rc != Success0)
3554 return rc;
3555
3556 if (stuff->deviceSpec == XkbUseCoreKbd0x0100 ||
3557 stuff->deviceSpec == XkbUseCorePtr0x0200) {
3558 DeviceIntPtr other;
3559
3560 for (other = inputInfo.devices; other; other = other->next) {
3561 if ((other != dev) && !IsMaster(other) &&
3562 GetMaster(other, MASTER_KEYBOARD2) == dev && (other->kbdfeed ||
3563 other->leds) &&
3564 (XaceHook(XACE_DEVICE_ACCESS3, client, other, DixSetAttrAccess(1<<5))
3565 == Success0)) {
3566 _XkbSetNamedIndicator(client, other, stuff);
3567 }
3568 }
3569 }
3570
3571 return Success0;
3572}
3573
3574/***====================================================================***/
3575
3576static CARD32
3577_XkbCountAtoms(Atom *atoms, int maxAtoms, int *count)
3578{
3579 register unsigned int i, bit, nAtoms;
3580 register CARD32 atomsPresent;
3581
3582 for (i = nAtoms = atomsPresent = 0, bit = 1; i < maxAtoms; i++, bit <<= 1) {
3583 if (atoms[i] != None0L) {
3584 atomsPresent |= bit;
3585 nAtoms++;
3586 }
3587 }
3588 if (count)
3589 *count = nAtoms;
3590 return atomsPresent;
3591}
3592
3593static char *
3594_XkbWriteAtoms(char *wire, Atom *atoms, int maxAtoms, int swap)
3595{
3596 register unsigned int i;
3597 Atom *atm;
3598
3599 atm = (Atom *) wire;
3600 for (i = 0; i < maxAtoms; i++) {
3601 if (atoms[i] != None0L) {
3602 *atm = atoms[i];
3603 if (swap) {
3604 swapl(atm)do { if (sizeof(*(atm)) != 4) wrong_size(); if (__builtin_constant_p
((uintptr_t)(atm) & 3) && ((uintptr_t)(atm) &
3) == 0) *(atm) = lswapl(*(atm)); else swap_uint32((uint32_t
*)(atm)); } while (0)
;
3605 }
3606 atm++;
3607 }
3608 }
3609 return (char *) atm;
3610}
3611
3612static Statusint
3613XkbComputeGetNamesReplySize(XkbDescPtr xkb, xkbGetNamesReply * rep)
3614{
3615 register unsigned which, length;
3616 register int i;
3617
3618 rep->minKeyCode = xkb->min_key_code;
3619 rep->maxKeyCode = xkb->max_key_code;
3620 which = rep->which;
3621 length = 0;
3622 if (xkb->names != NULL((void*)0)) {
3623 if (which & XkbKeycodesNameMask(1<<0))
3624 length++;
3625 if (which & XkbGeometryNameMask(1<<1))
3626 length++;
3627 if (which & XkbSymbolsNameMask(1<<2))
3628 length++;
3629 if (which & XkbPhysSymbolsNameMask(1<<3))
3630 length++;
3631 if (which & XkbTypesNameMask(1<<4))
3632 length++;
3633 if (which & XkbCompatNameMask(1<<5))
3634 length++;
3635 }
3636 else
3637 which &= ~XkbComponentNamesMask(0x3f);
3638
3639 if (xkb->map != NULL((void*)0)) {
3640 if (which & XkbKeyTypeNamesMask(1<<6))
3641 length += xkb->map->num_types;
3642 rep->nTypes = xkb->map->num_types;
3643 if (which & XkbKTLevelNamesMask(1<<7)) {
3644 XkbKeyTypePtr pType = xkb->map->types;
3645 int nKTLevels = 0;
3646
3647 length += XkbPaddedSize(xkb->map->num_types)((((unsigned int)(xkb->map->num_types)+3) >> 2) <<
2)
/ 4;
3648 for (i = 0; i < xkb->map->num_types; i++, pType++) {
3649 if (pType->level_names != NULL((void*)0))
3650 nKTLevels += pType->num_levels;
3651 }
3652 rep->nKTLevels = nKTLevels;
3653 length += nKTLevels;
3654 }
3655 }
3656 else {
3657 rep->nTypes = 0;
3658 rep->nKTLevels = 0;
3659 which &= ~(XkbKeyTypeNamesMask(1<<6) | XkbKTLevelNamesMask(1<<7));
3660 }
3661
3662 rep->minKeyCode = xkb->min_key_code;
3663 rep->maxKeyCode = xkb->max_key_code;
3664 rep->indicators = 0;
3665 rep->virtualMods = 0;
3666 rep->groupNames = 0;
3667 if (xkb->names != NULL((void*)0)) {
3668 if (which & XkbIndicatorNamesMask(1<<8)) {
3669 int nLeds;
3670
3671 rep->indicators =
3672 _XkbCountAtoms(xkb->names->indicators, XkbNumIndicators32,
3673 &nLeds);
3674 length += nLeds;
3675 if (nLeds == 0)
3676 which &= ~XkbIndicatorNamesMask(1<<8);
3677 }
3678
3679 if (which & XkbVirtualModNamesMask(1<<11)) {
3680 int nVMods;
3681
3682 rep->virtualMods =
3683 _XkbCountAtoms(xkb->names->vmods, XkbNumVirtualMods16, &nVMods);
3684 length += nVMods;
3685 if (nVMods == 0)
3686 which &= ~XkbVirtualModNamesMask(1<<11);
3687 }
3688
3689 if (which & XkbGroupNamesMask(1<<12)) {
3690 int nGroups;
3691
3692 rep->groupNames =
3693 _XkbCountAtoms(xkb->names->groups, XkbNumKbdGroups4, &nGroups);
3694 length += nGroups;
3695 if (nGroups == 0)
3696 which &= ~XkbGroupNamesMask(1<<12);
3697 }
3698
3699 if ((which & XkbKeyNamesMask(1<<9)) && (xkb->names->keys))
3700 length += rep->nKeys;
3701 else
3702 which &= ~XkbKeyNamesMask(1<<9);
3703
3704 if ((which & XkbKeyAliasesMask(1<<10)) &&
3705 (xkb->names->key_aliases) && (xkb->names->num_key_aliases > 0)) {
3706 rep->nKeyAliases = xkb->names->num_key_aliases;
3707 length += rep->nKeyAliases * 2;
3708 }
3709 else {
3710 which &= ~XkbKeyAliasesMask(1<<10);
3711 rep->nKeyAliases = 0;
3712 }
3713
3714 if ((which & XkbRGNamesMask(1<<13)) && (xkb->names->num_rg > 0))
3715 length += xkb->names->num_rg;
3716 else
3717 which &= ~XkbRGNamesMask(1<<13);
3718 }
3719 else {
3720 which &= ~(XkbIndicatorNamesMask(1<<8) | XkbVirtualModNamesMask(1<<11));
3721 which &= ~(XkbGroupNamesMask(1<<12) | XkbKeyNamesMask(1<<9) | XkbKeyAliasesMask(1<<10));
3722 which &= ~XkbRGNamesMask(1<<13);
3723 }
3724
3725 rep->length = length;
3726 rep->which = which;
3727 return Success0;
3728}
3729
3730static int
3731XkbSendNames(ClientPtr client, XkbDescPtr xkb, xkbGetNamesReply * rep)
3732{
3733 register unsigned i, length, which;
3734 char *start;
3735 char *desc;
3736
3737 length = rep->length * 4;
3738 which = rep->which;
3739 if (client->swapped) {
3740 swaps(&rep->sequenceNumber)do { if (sizeof(*(&rep->sequenceNumber)) != 2) wrong_size
(); if (__builtin_constant_p((uintptr_t)(&rep->sequenceNumber
) & 1) && ((uintptr_t)(&rep->sequenceNumber
) & 1) == 0) *(&rep->sequenceNumber) = lswaps(*(&
rep->sequenceNumber)); else swap_uint16((uint16_t *)(&
rep->sequenceNumber)); } while (0)
;
3741 swapl(&rep->length)do { if (sizeof(*(&rep->length)) != 4) wrong_size(); if
(__builtin_constant_p((uintptr_t)(&rep->length) &
3) && ((uintptr_t)(&rep->length) & 3) == 0
) *(&rep->length) = lswapl(*(&rep->length)); else
swap_uint32((uint32_t *)(&rep->length)); } while (0)
;
3742 swapl(&rep->which)do { if (sizeof(*(&rep->which)) != 4) wrong_size(); if
(__builtin_constant_p((uintptr_t)(&rep->which) & 3
) && ((uintptr_t)(&rep->which) & 3) == 0) *
(&rep->which) = lswapl(*(&rep->which)); else swap_uint32
((uint32_t *)(&rep->which)); } while (0)
;
3743 swaps(&rep->virtualMods)do { if (sizeof(*(&rep->virtualMods)) != 2) wrong_size
(); if (__builtin_constant_p((uintptr_t)(&rep->virtualMods
) & 1) && ((uintptr_t)(&rep->virtualMods) &
1) == 0) *(&rep->virtualMods) = lswaps(*(&rep->
virtualMods)); else swap_uint16((uint16_t *)(&rep->virtualMods
)); } while (0)
;
3744 swapl(&rep->indicators)do { if (sizeof(*(&rep->indicators)) != 4) wrong_size(
); if (__builtin_constant_p((uintptr_t)(&rep->indicators
) & 3) && ((uintptr_t)(&rep->indicators) &
3) == 0) *(&rep->indicators) = lswapl(*(&rep->
indicators)); else swap_uint32((uint32_t *)(&rep->indicators
)); } while (0)
;
3745 }
3746
3747 start = desc = calloc(1, length);
3748 if (!start)
3749 return BadAlloc11;
3750 if (xkb->names) {
3751 if (which & XkbKeycodesNameMask(1<<0)) {
3752 *((CARD32 *) desc) = xkb->names->keycodes;
3753 if (client->swapped) {
3754 swapl((int *) desc)do { if (sizeof(*((int *) desc)) != 4) wrong_size(); if (__builtin_constant_p
((uintptr_t)((int *) desc) & 3) && ((uintptr_t)((
int *) desc) & 3) == 0) *((int *) desc) = lswapl(*((int *
) desc)); else swap_uint32((uint32_t *)((int *) desc)); } while
(0)
;
3755 }
3756 desc += 4;
3757 }
3758 if (which & XkbGeometryNameMask(1<<1)) {
3759 *((CARD32 *) desc) = xkb->names->geometry;
3760 if (client->swapped) {
3761 swapl((int *) desc)do { if (sizeof(*((int *) desc)) != 4) wrong_size(); if (__builtin_constant_p
((uintptr_t)((int *) desc) & 3) && ((uintptr_t)((
int *) desc) & 3) == 0) *((int *) desc) = lswapl(*((int *
) desc)); else swap_uint32((uint32_t *)((int *) desc)); } while
(0)
;
3762 }
3763 desc += 4;
3764 }
3765 if (which & XkbSymbolsNameMask(1<<2)) {
3766 *((CARD32 *) desc) = xkb->names->symbols;
3767 if (client->swapped) {
3768 swapl((int *) desc)do { if (sizeof(*((int *) desc)) != 4) wrong_size(); if (__builtin_constant_p
((uintptr_t)((int *) desc) & 3) && ((uintptr_t)((
int *) desc) & 3) == 0) *((int *) desc) = lswapl(*((int *
) desc)); else swap_uint32((uint32_t *)((int *) desc)); } while
(0)
;
3769 }
3770 desc += 4;
3771 }
3772 if (which & XkbPhysSymbolsNameMask(1<<3)) {
3773 register CARD32 *atm = (CARD32 *) desc;
3774
3775 atm[0] = (CARD32) xkb->names->phys_symbols;
3776 if (client->swapped) {
3777 swapl(&atm[0])do { if (sizeof(*(&atm[0])) != 4) wrong_size(); if (__builtin_constant_p
((uintptr_t)(&atm[0]) & 3) && ((uintptr_t)(&
atm[0]) & 3) == 0) *(&atm[0]) = lswapl(*(&atm[0])
); else swap_uint32((uint32_t *)(&atm[0])); } while (0)
;
3778 }
3779 desc += 4;
3780 }
3781 if (which & XkbTypesNameMask(1<<4)) {
3782 *((CARD32 *) desc) = (CARD32) xkb->names->types;
3783 if (client->swapped) {
3784 swapl((int *) desc)do { if (sizeof(*((int *) desc)) != 4) wrong_size(); if (__builtin_constant_p
((uintptr_t)((int *) desc) & 3) && ((uintptr_t)((
int *) desc) & 3) == 0) *((int *) desc) = lswapl(*((int *
) desc)); else swap_uint32((uint32_t *)((int *) desc)); } while
(0)
;
3785 }
3786 desc += 4;
3787 }
3788 if (which & XkbCompatNameMask(1<<5)) {
3789 *((CARD32 *) desc) = (CARD32) xkb->names->compat;
3790 if (client->swapped) {
3791 swapl((int *) desc)do { if (sizeof(*((int *) desc)) != 4) wrong_size(); if (__builtin_constant_p
((uintptr_t)((int *) desc) & 3) && ((uintptr_t)((
int *) desc) & 3) == 0) *((int *) desc) = lswapl(*((int *
) desc)); else swap_uint32((uint32_t *)((int *) desc)); } while
(0)
;
3792 }
3793 desc += 4;
3794 }
3795 if (which & XkbKeyTypeNamesMask(1<<6)) {
3796 register CARD32 *atm = (CARD32 *) desc;
3797 register XkbKeyTypePtr type = xkb->map->types;
3798
3799 for (i = 0; i < xkb->map->num_types; i++, atm++, type++) {
3800 *atm = (CARD32) type->name;
3801 if (client->swapped) {
3802 swapl(atm)do { if (sizeof(*(atm)) != 4) wrong_size(); if (__builtin_constant_p
((uintptr_t)(atm) & 3) && ((uintptr_t)(atm) &
3) == 0) *(atm) = lswapl(*(atm)); else swap_uint32((uint32_t
*)(atm)); } while (0)
;
3803 }
3804 }
3805 desc = (char *) atm;
3806 }
3807 if (which & XkbKTLevelNamesMask(1<<7) && xkb->map) {
3808 XkbKeyTypePtr type = xkb->map->types;
3809 register CARD32 *atm;
3810
3811 for (i = 0; i < rep->nTypes; i++, type++) {
3812 *desc++ = type->num_levels;
3813 }
3814 desc += XkbPaddedSize(rep->nTypes)((((unsigned int)(rep->nTypes)+3) >> 2) << 2) - rep->nTypes;
3815
3816 atm = (CARD32 *) desc;
3817 type = xkb->map->types;
3818 for (i = 0; i < xkb->map->num_types; i++, type++) {
3819 register unsigned l;
3820
3821 if (type->level_names) {
3822 for (l = 0; l < type->num_levels; l++, atm++) {
3823 *atm = type->level_names[l];
3824 if (client->swapped) {
3825 swapl(atm)do { if (sizeof(*(atm)) != 4) wrong_size(); if (__builtin_constant_p
((uintptr_t)(atm) & 3) && ((uintptr_t)(atm) &
3) == 0) *(atm) = lswapl(*(atm)); else swap_uint32((uint32_t
*)(atm)); } while (0)
;
3826 }
3827 }
3828 desc += type->num_levels * 4;
3829 }
3830 }
3831 }
3832 if (which & XkbIndicatorNamesMask(1<<8)) {
3833 desc =
3834 _XkbWriteAtoms(desc, xkb->names->indicators, XkbNumIndicators32,
3835 client->swapped);
3836 }
3837 if (which & XkbVirtualModNamesMask(1<<11)) {
3838 desc = _XkbWriteAtoms(desc, xkb->names->vmods, XkbNumVirtualMods16,
3839 client->swapped);
3840 }
3841 if (which & XkbGroupNamesMask(1<<12)) {
3842 desc = _XkbWriteAtoms(desc, xkb->names->groups, XkbNumKbdGroups4,
3843 client->swapped);
3844 }
3845 if (which & XkbKeyNamesMask(1<<9)) {
3846 for (i = 0; i < rep->nKeys; i++, desc += sizeof(XkbKeyNameRec)) {
3847 *((XkbKeyNamePtr) desc) = xkb->names->keys[i + rep->firstKey];
3848 }
3849 }
3850 if (which & XkbKeyAliasesMask(1<<10)) {
3851 XkbKeyAliasPtr pAl;
3852
3853 pAl = xkb->names->key_aliases;
3854 for (i = 0; i < rep->nKeyAliases;
3855 i++, pAl++, desc += 2 * XkbKeyNameLength4) {
3856 *((XkbKeyAliasPtr) desc) = *pAl;
3857 }
3858 }
3859 if ((which & XkbRGNamesMask(1<<13)) && (rep->nRadioGroups > 0)) {
3860 register CARD32 *atm = (CARD32 *) desc;
3861
3862 for (i = 0; i < rep->nRadioGroups; i++, atm++) {
3863 *atm = (CARD32) xkb->names->radio_groups[i];
3864 if (client->swapped) {
3865 swapl(atm)do { if (sizeof(*(atm)) != 4) wrong_size(); if (__builtin_constant_p
((uintptr_t)(atm) & 3) && ((uintptr_t)(atm) &
3) == 0) *(atm) = lswapl(*(atm)); else swap_uint32((uint32_t
*)(atm)); } while (0)
;
3866 }
3867 }
3868 desc += rep->nRadioGroups * 4;
3869 }
3870 }
3871
3872 if ((desc - start) != (length)) {
3873 ErrorF("[xkb] BOGUS LENGTH in write names, expected %d, got %ld\n",
3874 length, (unsigned long) (desc - start));
3875 }
3876 WriteToClient(client, SIZEOF(xkbGetNamesReply)32, rep);
3877 WriteToClient(client, length, start);
3878 free((char *) start);
3879 return Success0;
3880}
3881
3882int
3883ProcXkbGetNames(ClientPtr client)
3884{
3885 DeviceIntPtr dev;
3886 XkbDescPtr xkb;
3887 xkbGetNamesReply rep;
3888
3889 REQUEST(xkbGetNamesReq)xkbGetNamesReq *stuff = (xkbGetNamesReq *)client->requestBuffer;
3890 REQUEST_SIZE_MATCH(xkbGetNamesReq)if ((sizeof(xkbGetNamesReq) >> 2) != client->req_len
) return(16)
;
3891
3892 if (!(client->xkbClientFlags & _XkbClientInitialized(1<<15)))
3893 return BadAccess10;
3894
3895 CHK_KBD_DEVICE(dev, stuff->deviceSpec, client, DixGetAttrAccess){ int why; int tmprc = _XkbLookupKeyboard(&(dev), stuff->
deviceSpec, client, (1<<4), &why); if (tmprc != 0) {
client->errorValue = ((XID)((((unsigned int)(why))<<
24)|((stuff->deviceSpec)&0xffffff))); return tmprc; }}
;
3896 CHK_MASK_LEGAL(0x01, stuff->which, XkbAllNamesMask){ if ((stuff->which)&(~((0x3fff)))) { (client->errorValue
)= ((XID)((((unsigned int)((0x01)))<<24)|((((stuff->
which)&(~((0x3fff)))))&0xffffff))); return 2; }}
;
3897
3898 xkb = dev->key->xkbInfo->desc;
3899 rep = (xkbGetNamesReply) {
3900 .type = X_Reply1,
3901 .deviceID = dev->id,
3902 .sequenceNumber = client->sequence,
3903 .length = 0,
3904 .which = stuff->which,
3905 .nTypes = xkb->map->num_types,
3906 .firstKey = xkb->min_key_code,
3907 .nKeys = XkbNumKeys(xkb)((xkb)->max_key_code-(xkb)->min_key_code+1),
3908 .nKeyAliases = xkb->names ? xkb->names->num_key_aliases : 0,
3909 .nRadioGroups = xkb->names ? xkb->names->num_rg : 0
3910 };
3911 XkbComputeGetNamesReplySize(xkb, &rep);
3912 return XkbSendNames(client, xkb, &rep);
3913}
3914
3915/***====================================================================***/
3916
3917static CARD32 *
3918_XkbCheckAtoms(CARD32 *wire, int nAtoms, int swapped, Atom *pError)
3919{
3920 register int i;
3921
3922 for (i = 0; i < nAtoms; i++, wire++) {
3923 if (swapped) {
3924 swapl(wire)do { if (sizeof(*(wire)) != 4) wrong_size(); if (__builtin_constant_p
((uintptr_t)(wire) & 3) && ((uintptr_t)(wire) &
3) == 0) *(wire) = lswapl(*(wire)); else swap_uint32((uint32_t
*)(wire)); } while (0)
;
3925 }
3926 if ((((Atom) *wire) != None0L) && (!ValidAtom((Atom) *wire))) {
3927 *pError = ((Atom) *wire);
3928 return NULL((void*)0);
3929 }
3930 }
3931 return wire;
3932}
3933
3934static CARD32 *
3935_XkbCheckMaskedAtoms(CARD32 *wire, int nAtoms, CARD32 present, int swapped,
3936 Atom *pError)
3937{
3938 register unsigned i, bit;
3939
3940 for (i = 0, bit = 1; (i < nAtoms) && (present); i++, bit <<= 1) {
3941 if ((present & bit) == 0)
3942 continue;
3943 if (swapped) {
3944 swapl(wire)do { if (sizeof(*(wire)) != 4) wrong_size(); if (__builtin_constant_p
((uintptr_t)(wire) & 3) && ((uintptr_t)(wire) &
3) == 0) *(wire) = lswapl(*(wire)); else swap_uint32((uint32_t
*)(wire)); } while (0)
;
3945 }
3946 if ((((Atom) *wire) != None0L) && (!ValidAtom(((Atom) *wire)))) {
3947 *pError = (Atom) *wire;
3948 return NULL((void*)0);
3949 }
3950 wire++;
3951 }
3952 return wire;
3953}
3954
3955static Atom *
3956_XkbCopyMaskedAtoms(Atom *wire, Atom *dest, int nAtoms, CARD32 present)
3957{
3958 register int i, bit;
3959
3960 for (i = 0, bit = 1; (i < nAtoms) && (present); i++, bit <<= 1) {
3961 if ((present & bit) == 0)
3962 continue;
3963 dest[i] = *wire++;
3964 }
3965 return wire;
3966}
3967
3968static Bool
3969_XkbCheckTypeName(Atom name, int typeNdx)
3970{
3971 const char *str;
3972
3973 str = NameForAtom(name);
3974 if ((strcmp(str, "ONE_LEVEL") == 0) || (strcmp(str, "TWO_LEVEL") == 0) ||
3975 (strcmp(str, "ALPHABETIC") == 0) || (strcmp(str, "KEYPAD") == 0))
3976 return FALSE0;
3977 return TRUE1;
3978}
3979
3980/**
3981 * Check the device-dependent data in the request against the device. Returns
3982 * Success, or the appropriate error code.
3983 */
3984static int
3985_XkbSetNamesCheck(ClientPtr client, DeviceIntPtr dev,
3986 xkbSetNamesReq * stuff, CARD32 *data)
3987{
3988 XkbDescRec *xkb;
3989 CARD32 *tmp;
3990 Atom bad = None0L;
3991
3992 tmp = data;
3993 xkb = dev->key->xkbInfo->desc;
3994
3995 if (stuff->which & XkbKeyTypeNamesMask(1<<6)) {
3996 int i;
3997 CARD32 *old;
3998
3999 if (stuff->nTypes < 1) {
4000 client->errorValue = _XkbErrCode2(0x02, stuff->nTypes)((XID)((((unsigned int)(0x02))<<24)|((stuff->nTypes)
&0xffffff)))
;
4001 return BadValue2;
4002 }
4003 if ((unsigned) (stuff->firstType + stuff->nTypes - 1) >=
4004 xkb->map->num_types) {
4005 client->errorValue =
4006 _XkbErrCode4(0x03, stuff->firstType, stuff->nTypes,((XID)((((unsigned int)(0x03))<<24)|(((((unsigned int)(
stuff->firstType))<<16)|(((((unsigned int)(stuff->
nTypes))<<8)|(xkb->map->num_types))))&0xffffff
)))
4007 xkb->map->num_types)((XID)((((unsigned int)(0x03))<<24)|(((((unsigned int)(
stuff->firstType))<<16)|(((((unsigned int)(stuff->
nTypes))<<8)|(xkb->map->num_types))))&0xffffff
)))
;
4008 return BadValue2;
4009 }
4010 if (((unsigned) stuff->firstType) <= XkbLastRequiredType3) {
4011 client->errorValue = _XkbErrCode2(0x04, stuff->firstType)((XID)((((unsigned int)(0x04))<<24)|((stuff->firstType
)&0xffffff)))
;
4012 return BadAccess10;
4013 }
4014 old = tmp;
4015 tmp = _XkbCheckAtoms(tmp, stuff->nTypes, client->swapped, &bad);
4016 if (!tmp) {
4017 client->errorValue = bad;
4018 return BadAtom5;
4019 }
4020 for (i = 0; i < stuff->nTypes; i++, old++) {
4021 if (!_XkbCheckTypeName((Atom) *old, stuff->firstType + i))
4022 client->errorValue = _XkbErrCode2(0x05, i)((XID)((((unsigned int)(0x05))<<24)|((i)&0xffffff))
)
;
4023 }
4024 }
4025 if (stuff->which & XkbKTLevelNamesMask(1<<7)) {
4026 unsigned i;
4027 XkbKeyTypePtr type;
4028 CARD8 *width;
4029
4030 if (stuff->nKTLevels < 1) {
4031 client->errorValue = _XkbErrCode2(0x05, stuff->nKTLevels)((XID)((((unsigned int)(0x05))<<24)|((stuff->nKTLevels
)&0xffffff)))
;
4032 return BadValue2;
4033 }
4034 if ((unsigned) (stuff->firstKTLevel + stuff->nKTLevels - 1) >=
4035 xkb->map->num_types) {
4036 client->errorValue = _XkbErrCode4(0x06, stuff->firstKTLevel,((XID)((((unsigned int)(0x06))<<24)|(((((unsigned int)(
stuff->firstKTLevel))<<16)|(((((unsigned int)(stuff->
nKTLevels))<<8)|(xkb->map->num_types))))&0xffffff
)))
4037 stuff->nKTLevels,((XID)((((unsigned int)(0x06))<<24)|(((((unsigned int)(
stuff->firstKTLevel))<<16)|(((((unsigned int)(stuff->
nKTLevels))<<8)|(xkb->map->num_types))))&0xffffff
)))
4038 xkb->map->num_types)((XID)((((unsigned int)(0x06))<<24)|(((((unsigned int)(
stuff->firstKTLevel))<<16)|(((((unsigned int)(stuff->
nKTLevels))<<8)|(xkb->map->num_types))))&0xffffff
)))
;
4039 return BadValue2;
4040 }
4041 width = (CARD8 *) tmp;
4042 tmp = (CARD32 *) (((char *) tmp) + XkbPaddedSize(stuff->nKTLevels)((((unsigned int)(stuff->nKTLevels)+3) >> 2) <<
2)
);
4043 type = &xkb->map->types[stuff->firstKTLevel];
4044 for (i = 0; i < stuff->nKTLevels; i++, type++) {
4045 if (width[i] == 0)
4046 continue;
4047 else if (width[i] != type->num_levels) {
4048 client->errorValue = _XkbErrCode4(0x07, i + stuff->firstKTLevel,((XID)((((unsigned int)(0x07))<<24)|(((((unsigned int)(
i + stuff->firstKTLevel))<<16)|(((((unsigned int)(type
->num_levels))<<8)|(width[i]))))&0xffffff)))
4049 type->num_levels, width[i])((XID)((((unsigned int)(0x07))<<24)|(((((unsigned int)(
i + stuff->firstKTLevel))<<16)|(((((unsigned int)(type
->num_levels))<<8)|(width[i]))))&0xffffff)))
;
4050 return BadMatch8;
4051 }
4052 tmp = _XkbCheckAtoms(tmp, width[i], client->swapped, &bad);
4053 if (!tmp) {
4054 client->errorValue = bad;
4055 return BadAtom5;
4056 }
4057 }
4058 }
4059 if (stuff->which & XkbIndicatorNamesMask(1<<8)) {
4060 if (stuff->indicators == 0) {
4061 client->errorValue = 0x08;
4062 return BadMatch8;
4063 }
4064 tmp = _XkbCheckMaskedAtoms(tmp, XkbNumIndicators32, stuff->indicators,
4065 client->swapped, &bad);
4066 if (!tmp) {
4067 client->errorValue = bad;
4068 return BadAtom5;
4069 }
4070 }
4071 if (stuff->which & XkbVirtualModNamesMask(1<<11)) {
4072 if (stuff->virtualMods == 0) {
4073 client->errorValue = 0x09;
4074 return BadMatch8;
4075 }
4076 tmp = _XkbCheckMaskedAtoms(tmp, XkbNumVirtualMods16,
4077 (CARD32) stuff->virtualMods,
4078 client->swapped, &bad);
4079 if (!tmp) {
4080 client->errorValue = bad;
4081 return BadAtom5;
4082 }
4083 }
4084 if (stuff->which & XkbGroupNamesMask(1<<12)) {
4085 if (stuff->groupNames == 0) {
4086 client->errorValue = 0x0a;
4087 return BadMatch8;
4088 }
4089 tmp = _XkbCheckMaskedAtoms(tmp, XkbNumKbdGroups4,
4090 (CARD32) stuff->groupNames,
4091 client->swapped, &bad);
4092 if (!tmp) {
4093 client->errorValue = bad;
4094 return BadAtom5;
4095 }
4096 }
4097 if (stuff->which & XkbKeyNamesMask(1<<9)) {
4098 if (stuff->firstKey < (unsigned) xkb->min_key_code) {
4099 client->errorValue = _XkbErrCode3(0x0b, xkb->min_key_code,((XID)((((unsigned int)(0x0b))<<24)|(((((unsigned int)(
xkb->min_key_code))<<16)|(stuff->firstKey))&0xffffff
)))
4100 stuff->firstKey)((XID)((((unsigned int)(0x0b))<<24)|(((((unsigned int)(
xkb->min_key_code))<<16)|(stuff->firstKey))&0xffffff
)))
;
4101 return BadValue2;
4102 }
4103 if (((unsigned) (stuff->firstKey + stuff->nKeys - 1) >
4104 xkb->max_key_code) || (stuff->nKeys < 1)) {
4105 client->errorValue =
4106 _XkbErrCode4(0x0c, xkb->max_key_code, stuff->firstKey,((XID)((((unsigned int)(0x0c))<<24)|(((((unsigned int)(
xkb->max_key_code))<<16)|(((((unsigned int)(stuff->
firstKey))<<8)|(stuff->nKeys))))&0xffffff)))
4107 stuff->nKeys)((XID)((((unsigned int)(0x0c))<<24)|(((((unsigned int)(
xkb->max_key_code))<<16)|(((((unsigned int)(stuff->
firstKey))<<8)|(stuff->nKeys))))&0xffffff)))
;
4108 return BadValue2;
4109 }
4110 tmp += stuff->nKeys;
4111 }
4112 if ((stuff->which & XkbKeyAliasesMask(1<<10)) && (stuff->nKeyAliases > 0)) {
4113 tmp += stuff->nKeyAliases * 2;
4114 }
4115 if (stuff->which & XkbRGNamesMask(1<<13)) {
4116 if (stuff->nRadioGroups < 1) {
4117 client->errorValue = _XkbErrCode2(0x0d, stuff->nRadioGroups)((XID)((((unsigned int)(0x0d))<<24)|((stuff->nRadioGroups
)&0xffffff)))
;
4118 return BadValue2;
4119 }
4120 tmp = _XkbCheckAtoms(tmp, stuff->nRadioGroups, client->swapped, &bad);
4121 if (!tmp) {
4122 client->errorValue = bad;
4123 return BadAtom5;
4124 }
4125 }
4126 if ((tmp - ((CARD32 *) stuff)) != stuff->length) {
4127 client->errorValue = stuff->length;
4128 return BadLength16;
4129 }
4130
4131 return Success0;
4132}
4133
4134static int
4135_XkbSetNames(ClientPtr client, DeviceIntPtr dev, xkbSetNamesReq * stuff)
4136{
4137 XkbDescRec *xkb;
4138 XkbNamesRec *names;
4139 CARD32 *tmp;
4140 xkbNamesNotify nn;
4141
4142 tmp = (CARD32 *) &stuff[1];
4143 xkb = dev->key->xkbInfo->desc;
4144 names = xkb->names;
4145
4146 if (XkbAllocNamesSrvXkbAllocNames(xkb, stuff->which, stuff->nRadioGroups,
4147 stuff->nKeyAliases) != Success0) {
4148 return BadAlloc11;
4149 }
4150
4151 memset(&nn, 0, sizeof(xkbNamesNotify))__builtin___memset_chk (&nn, 0, sizeof(xkbNamesNotify), __builtin_object_size
(&nn, 0))
;
4152 nn.changed = stuff->which;
4153 tmp = (CARD32 *) &stuff[1];
4154 if (stuff->which & XkbKeycodesNameMask(1<<0))
4155 names->keycodes = *tmp++;
4156 if (stuff->which & XkbGeometryNameMask(1<<1))
4157 names->geometry = *tmp++;
4158 if (stuff->which & XkbSymbolsNameMask(1<<2))
4159 names->symbols = *tmp++;
4160 if (stuff->which & XkbPhysSymbolsNameMask(1<<3))
4161 names->phys_symbols = *tmp++;
4162 if (stuff->which & XkbTypesNameMask(1<<4))
4163 names->types = *tmp++;
4164 if (stuff->which & XkbCompatNameMask(1<<5))
4165 names->compat = *tmp++;
4166 if ((stuff->which & XkbKeyTypeNamesMask(1<<6)) && (stuff->nTypes > 0)) {
4167 register unsigned i;
4168 register XkbKeyTypePtr type;
4169
4170 type = &xkb->map->types[stuff->firstType];
4171 for (i = 0; i < stuff->nTypes; i++, type++) {
4172 type->name = *tmp++;
4173 }
4174 nn.firstType = stuff->firstType;
4175 nn.nTypes = stuff->nTypes;
4176 }
4177 if (stuff->which & XkbKTLevelNamesMask(1<<7)) {
4178 register XkbKeyTypePtr type;
4179 register unsigned i;
4180 CARD8 *width;
4181
4182 width = (CARD8 *) tmp;
4183 tmp = (CARD32 *) (((char *) tmp) + XkbPaddedSize(stuff->nKTLevels)((((unsigned int)(stuff->nKTLevels)+3) >> 2) <<
2)
);
4184 type = &xkb->map->types[stuff->firstKTLevel];
4185 for (i = 0; i < stuff->nKTLevels; i++, type++) {
4186 if (width[i] > 0) {
4187 if (type->level_names) {
4188 register unsigned n;
4189
4190 for (n = 0; n < width[i]; n++) {
4191 type->level_names[n] = tmp[n];
4192 }
4193 }
4194 tmp += width[i];
4195 }
4196 }
4197 nn.firstLevelName = 0;
4198 nn.nLevelNames = stuff->nTypes;
4199 }
4200 if (stuff->which & XkbIndicatorNamesMask(1<<8)) {
4201 tmp = _XkbCopyMaskedAtoms(tmp, names->indicators, XkbNumIndicators32,
4202 stuff->indicators);
4203 nn.changedIndicators = stuff->indicators;
4204 }
4205 if (stuff->which & XkbVirtualModNamesMask(1<<11)) {
4206 tmp = _XkbCopyMaskedAtoms(tmp, names->vmods, XkbNumVirtualMods16,
4207 stuff->virtualMods);
4208 nn.changedVirtualMods = stuff->virtualMods;
4209 }
4210 if (stuff->which & XkbGroupNamesMask(1<<12)) {
4211 tmp = _XkbCopyMaskedAtoms(tmp, names->groups, XkbNumKbdGroups4,
4212 stuff->groupNames);
4213 nn.changedVirtualMods = stuff->groupNames;
4214 }
4215 if (stuff->which & XkbKeyNamesMask(1<<9)) {
4216 memcpy((char *) &names->keys[stuff->firstKey], (char *) tmp,__builtin___memcpy_chk ((char *) &names->keys[stuff->
firstKey], (char *) tmp, stuff->nKeys * 4, __builtin_object_size
((char *) &names->keys[stuff->firstKey], 0))
4217 stuff->nKeys * XkbKeyNameLength)__builtin___memcpy_chk ((char *) &names->keys[stuff->
firstKey], (char *) tmp, stuff->nKeys * 4, __builtin_object_size
((char *) &names->keys[stuff->firstKey], 0))
;
4218 tmp += stuff->nKeys;
4219 nn.firstKey = stuff->firstKey;
4220 nn.nKeys = stuff->nKeys;
4221 }
4222 if (stuff->which & XkbKeyAliasesMask(1<<10)) {
4223 if (stuff->nKeyAliases > 0) {
4224 register int na = stuff->nKeyAliases;
4225
4226 if (XkbAllocNamesSrvXkbAllocNames(xkb, XkbKeyAliasesMask(1<<10), 0, na) != Success0)
4227 return BadAlloc11;
4228 memcpy((char *) names->key_aliases, (char *) tmp,__builtin___memcpy_chk ((char *) names->key_aliases, (char
*) tmp, stuff->nKeyAliases * sizeof(XkbKeyAliasRec), __builtin_object_size
((char *) names->key_aliases, 0))
4229 stuff->nKeyAliases * sizeof(XkbKeyAliasRec))__builtin___memcpy_chk ((char *) names->key_aliases, (char
*) tmp, stuff->nKeyAliases * sizeof(XkbKeyAliasRec), __builtin_object_size
((char *) names->key_aliases, 0))
;
4230 tmp += stuff->nKeyAliases * 2;
4231 }
4232 else if (names->key_aliases != NULL((void*)0)) {
4233 free(names->key_aliases);
4234 names->key_aliases = NULL((void*)0);
4235 names->num_key_aliases = 0;
4236 }
4237 nn.nAliases = names->num_key_aliases;
4238 }
4239 if (stuff->which & XkbRGNamesMask(1<<13)) {
4240 if (stuff->nRadioGroups > 0) {
4241 register unsigned i, nrg;
4242
4243 nrg = stuff->nRadioGroups;
4244 if (XkbAllocNamesSrvXkbAllocNames(xkb, XkbRGNamesMask(1<<13), nrg, 0) != Success0)
4245 return BadAlloc11;
4246
4247 for (i = 0; i < stuff->nRadioGroups; i++) {
4248 names->radio_groups[i] = tmp[i];
4249 }
4250 tmp += stuff->nRadioGroups;
Value stored to 'tmp' is never read
4251 }
4252 else if (names->radio_groups) {
4253 free(names->radio_groups);
4254 names->radio_groups = NULL((void*)0);
4255 names->num_rg = 0;
4256 }
4257 nn.nRadioGroups = names->num_rg;
4258 }
4259 if (nn.changed) {
4260 Bool needExtEvent;
4261
4262 needExtEvent = (nn.changed & XkbIndicatorNamesMask(1<<8)) != 0;
4263 XkbSendNamesNotify(dev, &nn);
4264 if (needExtEvent) {
4265 XkbSrvLedInfoPtr sli;
4266 xkbExtensionDeviceNotify edev;
4267 register int i;
4268 register unsigned bit;
4269
4270 sli = XkbFindSrvLedInfo(dev, XkbDfltXIClass0x0300, XkbDfltXIId0x0400,
4271 XkbXI_IndicatorsMask(0x001c));
4272 sli->namesPresent = 0;
4273 for (i = 0, bit = 1; i < XkbNumIndicators32; i++, bit <<= 1) {
4274 if (names->indicators[i] != None0L)
4275 sli->namesPresent |= bit;
4276 }
4277 memset(&edev, 0, sizeof(xkbExtensionDeviceNotify))__builtin___memset_chk (&edev, 0, sizeof(xkbExtensionDeviceNotify
), __builtin_object_size (&edev, 0))
;
4278 edev.reason = XkbXI_IndicatorNamesMask(1L << 2);
4279 edev.ledClass = KbdFeedbackClass0;
4280 edev.ledID = dev->kbdfeed->ctrl.id;
4281 edev.ledsDefined = sli->namesPresent | sli->mapsPresent;
4282 edev.ledState = sli->effectiveState;
4283 edev.firstBtn = 0;
4284 edev.nBtns = 0;
4285 edev.supported = XkbXI_AllFeaturesMask(0x001f);
4286 edev.unsupported = 0;
4287 XkbSendExtensionDeviceNotify(dev, client, &edev);
4288 }
4289 }
4290 return Success0;
4291}
4292
4293int
4294ProcXkbSetNames(ClientPtr client)
4295{
4296 DeviceIntPtr dev;
4297 CARD32 *tmp;
4298 Atom bad;
4299 int rc;
4300
4301 REQUEST(xkbSetNamesReq)xkbSetNamesReq *stuff = (xkbSetNamesReq *)client->requestBuffer;
4302 REQUEST_AT_LEAST_SIZE(xkbSetNamesReq)if ((sizeof(xkbSetNamesReq) >> 2) > client->req_len
) return(16)
;
4303
4304 if (!(client->xkbClientFlags & _XkbClientInitialized(1<<15)))
4305 return BadAccess10;
4306
4307 CHK_KBD_DEVICE(dev, stuff->deviceSpec, client, DixManageAccess){ int why; int tmprc = _XkbLookupKeyboard(&(dev), stuff->
deviceSpec, client, (1<<25), &why); if (tmprc != 0)
{ client->errorValue = ((XID)((((unsigned int)(why))<<
24)|((stuff->deviceSpec)&0xffffff))); return tmprc; }}
;
4308 CHK_MASK_LEGAL(0x01, stuff->which, XkbAllNamesMask){ if ((stuff->which)&(~((0x3fff)))) { (client->errorValue
)= ((XID)((((unsigned int)((0x01)))<<24)|((((stuff->
which)&(~((0x3fff)))))&0xffffff))); return 2; }}
;
4309
4310 /* check device-independent stuff */
4311 tmp = (CARD32 *) &stuff[1];
4312
4313 if (stuff->which & XkbKeycodesNameMask(1<<0)) {
4314 tmp = _XkbCheckAtoms(tmp, 1, client->swapped, &bad);
4315 if (!tmp) {
4316 client->errorValue = bad;
4317 return BadAtom5;
4318 }
4319 }
4320 if (stuff->which & XkbGeometryNameMask(1<<1)) {
4321 tmp = _XkbCheckAtoms(tmp, 1, client->swapped, &bad);
4322 if (!tmp) {
4323 client->errorValue = bad;
4324 return BadAtom5;
4325 }
4326 }
4327 if (stuff->which & XkbSymbolsNameMask(1<<2)) {
4328 tmp = _XkbCheckAtoms(tmp, 1, client->swapped, &bad);
4329 if (!tmp) {
4330 client->errorValue = bad;
4331 return BadAtom5;
4332 }
4333 }
4334 if (stuff->which & XkbPhysSymbolsNameMask(1<<3)) {
4335 tmp = _XkbCheckAtoms(tmp, 1, client->swapped, &bad);
4336 if (!tmp) {
4337 client->errorValue = bad;
4338 return BadAtom5;
4339 }
4340 }
4341 if (stuff->which & XkbTypesNameMask(1<<4)) {
4342 tmp = _XkbCheckAtoms(tmp, 1, client->swapped, &bad);
4343 if (!tmp) {
4344 client->errorValue = bad;
4345 return BadAtom5;
4346 }
4347 }
4348 if (stuff->which & XkbCompatNameMask(1<<5)) {
4349 tmp = _XkbCheckAtoms(tmp, 1, client->swapped, &bad);
4350 if (!tmp) {
4351 client->errorValue = bad;
4352 return BadAtom5;
4353 }
4354 }
4355
4356 /* start of device-dependent tests */
4357 rc = _XkbSetNamesCheck(client, dev, stuff, tmp);
4358 if (rc != Success0)
4359 return rc;
4360
4361 if (stuff->deviceSpec == XkbUseCoreKbd0x0100) {
4362 DeviceIntPtr other;
4363
4364 for (other = inputInfo.devices; other; other = other->next) {
4365 if ((other != dev) && other->key && !IsMaster(other) &&
4366 GetMaster(other, MASTER_KEYBOARD2) == dev) {
4367
4368 rc = XaceHook(XACE_DEVICE_ACCESS3, client, other,
4369 DixManageAccess(1<<25));
4370 if (rc == Success0) {
4371 rc = _XkbSetNamesCheck(client, other, stuff, tmp);
4372 if (rc != Success0)
4373 return rc;
4374 }
4375 }
4376 }
4377 }
4378
4379 /* everything is okay -- update names */
4380
4381 rc = _XkbSetNames(client, dev, stuff);
4382 if (rc != Success0)
4383 return rc;
4384
4385 if (stuff->deviceSpec == XkbUseCoreKbd0x0100) {
4386 DeviceIntPtr other;
4387
4388 for (other = inputInfo.devices; other; other = other->next) {
4389 if ((other != dev) && other->key && !IsMaster(other) &&
4390 GetMaster(other, MASTER_KEYBOARD2) == dev) {
4391
4392 rc = XaceHook(XACE_DEVICE_ACCESS3, client, other,
4393 DixManageAccess(1<<25));
4394 if (rc == Success0)
4395 _XkbSetNames(client, other, stuff);
4396 }
4397 }
4398 }
4399
4400 /* everything is okay -- update names */
4401
4402 return Success0;
4403}
4404
4405/***====================================================================***/
4406
4407#include "xkbgeom.h"
4408
4409#define XkbSizeCountedString(s)((s)?((((2+strlen(s))+3)/4)*4):4) ((s)?((((2+strlen(s))+3)/4)*4):4)
4410
4411/**
4412 * Write the zero-terminated string str into wire as a pascal string with a
4413 * 16-bit length field prefixed before the actual string.
4414 *
4415 * @param wire The destination array, usually the wire struct
4416 * @param str The source string as zero-terminated C string
4417 * @param swap If TRUE, the length field is swapped.
4418 *
4419 * @return The input string in the format <string length><string> with a
4420 * (swapped) 16 bit string length, non-zero terminated.
4421 */
4422static char *
4423XkbWriteCountedString(char *wire, const char *str, Bool swap)
4424{
4425 CARD16 len, *pLen, paddedLen;
4426
4427 if (!str)
4428 return wire;
4429
4430 len = strlen(str);
4431 pLen = (CARD16 *) wire;
4432 *pLen = len;
4433 if (swap) {
4434 swaps(pLen)do { if (sizeof(*(pLen)) != 2) wrong_size(); if (__builtin_constant_p
((uintptr_t)(pLen) & 1) && ((uintptr_t)(pLen) &
1) == 0) *(pLen) = lswaps(*(pLen)); else swap_uint16((uint16_t
*)(pLen)); } while (0)
;
4435 }
4436 paddedLen = pad_to_int32(sizeof(len) + len) - sizeof(len);
4437 strncpy(&wire[sizeof(len)], str, paddedLen)__builtin___strncpy_chk (&wire[sizeof(len)], str, paddedLen
, __builtin_object_size (&wire[sizeof(len)], 2 > 1 ? 1
: 0))
;
4438 wire += sizeof(len) + paddedLen;
4439 return wire;
4440}
4441
4442static int
4443XkbSizeGeomProperties(XkbGeometryPtr geom)
4444{
4445 register int i, size;
4446 XkbPropertyPtr prop;
4447
4448 for (size = i = 0, prop = geom->properties; i < geom->num_properties;
4449 i++, prop++) {
4450 size += XkbSizeCountedString(prop->name)((prop->name)?((((2+strlen(prop->name))+3)/4)*4):4);
4451 size += XkbSizeCountedString(prop->value)((prop->value)?((((2+strlen(prop->value))+3)/4)*4):4);
4452 }
4453 return size;
4454}
4455
4456static char *
4457XkbWriteGeomProperties(char *wire, XkbGeometryPtr geom, Bool swap)
4458{
4459 register int i;
4460 register XkbPropertyPtr prop;
4461
4462 for (i = 0, prop = geom->properties; i < geom->num_properties; i++, prop++) {
4463 wire = XkbWriteCountedString(wire, prop->name, swap);
4464 wire = XkbWriteCountedString(wire, prop->value, swap);
4465 }
4466 return wire;
4467}
4468
4469static int
4470XkbSizeGeomKeyAliases(XkbGeometryPtr geom)
4471{
4472 return geom->num_key_aliases * (2 * XkbKeyNameLength4);
4473}
4474
4475static char *
4476XkbWriteGeomKeyAliases(char *wire, XkbGeometryPtr geom, Bool swap)
4477{
4478 register int sz;
4479
4480 sz = geom->num_key_aliases * (XkbKeyNameLength4 * 2);
4481 if (sz > 0) {
4482 memcpy(wire, (char *) geom->key_aliases, sz)__builtin___memcpy_chk (wire, (char *) geom->key_aliases, sz
, __builtin_object_size (wire, 0))
;
4483 wire += sz;
4484 }
4485 return wire;
4486}
4487
4488static int
4489XkbSizeGeomColors(XkbGeometryPtr geom)
4490{
4491 register int i, size;
4492 register XkbColorPtr color;
4493
4494 for (i = size = 0, color = geom->colors; i < geom->num_colors; i++, color++) {
4495 size += XkbSizeCountedString(color->spec)((color->spec)?((((2+strlen(color->spec))+3)/4)*4):4);
4496 }
4497 return size;
4498}
4499
4500static char *
4501XkbWriteGeomColors(char *wire, XkbGeometryPtr geom, Bool swap)
4502{
4503 register int i;
4504 register XkbColorPtr color;
4505
4506 for (i = 0, color = geom->colors; i < geom->num_colors; i++, color++) {
4507 wire = XkbWriteCountedString(wire, color->spec, swap);
4508 }
4509 return wire;
4510}
4511
4512static int
4513XkbSizeGeomShapes(XkbGeometryPtr geom)
4514{
4515 register int i, size;
4516 register XkbShapePtr shape;
4517
4518 for (i = size = 0, shape = geom->shapes; i < geom->num_shapes; i++, shape++) {
4519 register int n;
4520 register XkbOutlinePtr ol;
4521
4522 size += SIZEOF(xkbShapeWireDesc)8;
4523 for (n = 0, ol = shape->outlines; n < shape->num_outlines; n++, ol++) {
4524 size += SIZEOF(xkbOutlineWireDesc)4;
4525 size += ol->num_points * SIZEOF(xkbPointWireDesc)4;
4526 }
4527 }
4528 return size;
4529}
4530
4531static char *
4532XkbWriteGeomShapes(char *wire, XkbGeometryPtr geom, Bool swap)
4533{
4534 int i;
4535 XkbShapePtr shape;
4536 xkbShapeWireDesc *shapeWire;
4537
4538 for (i = 0, shape = geom->shapes; i < geom->num_shapes; i++, shape++) {
4539 register int o;
4540 XkbOutlinePtr ol;
4541 xkbOutlineWireDesc *olWire;
4542
4543 shapeWire = (xkbShapeWireDesc *) wire;
4544 shapeWire->name = shape->name;
4545 shapeWire->nOutlines = shape->num_outlines;
4546 if (shape->primary != NULL((void*)0))
4547 shapeWire->primaryNdx = XkbOutlineIndex(shape, shape->primary)((int)((shape->primary)-&(shape)->outlines[0]));
4548 else
4549 shapeWire->primaryNdx = XkbNoShape0xff;
4550 if (shape->approx != NULL((void*)0))
4551 shapeWire->approxNdx = XkbOutlineIndex(shape, shape->approx)((int)((shape->approx)-&(shape)->outlines[0]));
4552 else
4553 shapeWire->approxNdx = XkbNoShape0xff;
4554 shapeWire->pad = 0;
4555 if (swap) {
4556 swapl(&shapeWire->name)do { if (sizeof(*(&shapeWire->name)) != 4) wrong_size(
); if (__builtin_constant_p((uintptr_t)(&shapeWire->name
) & 3) && ((uintptr_t)(&shapeWire->name) &
3) == 0) *(&shapeWire->name) = lswapl(*(&shapeWire
->name)); else swap_uint32((uint32_t *)(&shapeWire->
name)); } while (0)
;
4557 }
4558 wire = (char *) &shapeWire[1];
4559 for (o = 0, ol = shape->outlines; o < shape->num_outlines; o++, ol++) {
4560 register int p;
4561 XkbPointPtr pt;
4562 xkbPointWireDesc *ptWire;
4563
4564 olWire = (xkbOutlineWireDesc *) wire;
4565 olWire->nPoints = ol->num_points;
4566 olWire->cornerRadius = ol->corner_radius;
4567 olWire->pad = 0;
4568 wire = (char *) &olWire[1];
4569 ptWire = (xkbPointWireDesc *) wire;
4570 for (p = 0, pt = ol->points; p < ol->num_points; p++, pt++) {
4571 ptWire[p].x = pt->x;
4572 ptWire[p].y = pt->y;
4573 if (swap) {
4574 swaps(&ptWire[p].x)do { if (sizeof(*(&ptWire[p].x)) != 2) wrong_size(); if (
__builtin_constant_p((uintptr_t)(&ptWire[p].x) & 1) &&
((uintptr_t)(&ptWire[p].x) & 1) == 0) *(&ptWire[
p].x) = lswaps(*(&ptWire[p].x)); else swap_uint16((uint16_t
*)(&ptWire[p].x)); } while (0)
;
4575 swaps(&ptWire[p].y)do { if (sizeof(*(&ptWire[p].y)) != 2) wrong_size(); if (
__builtin_constant_p((uintptr_t)(&ptWire[p].y) & 1) &&
((uintptr_t)(&ptWire[p].y) & 1) == 0) *(&ptWire[
p].y) = lswaps(*(&ptWire[p].y)); else swap_uint16((uint16_t
*)(&ptWire[p].y)); } while (0)
;
4576 }
4577 }
4578 wire = (char *) &ptWire[ol->num_points];
4579 }
4580 }
4581 return wire;
4582}
4583
4584static int
4585XkbSizeGeomDoodads(int num_doodads, XkbDoodadPtr doodad)
4586{
4587 register int i, size;
4588
4589 for (i = size = 0; i < num_doodads; i++, doodad++) {
4590 size += SIZEOF(xkbAnyDoodadWireDesc)20;
4591 if (doodad->any.type == XkbTextDoodad3) {
4592 size += XkbSizeCountedString(doodad->text.text)((doodad->text.text)?((((2+strlen(doodad->text.text))+3
)/4)*4):4)
;
4593 size += XkbSizeCountedString(doodad->text.font)((doodad->text.font)?((((2+strlen(doodad->text.font))+3
)/4)*4):4)
;
4594 }
4595 else if (doodad->any.type == XkbLogoDoodad5) {
4596 size += XkbSizeCountedString(doodad->logo.logo_name)((doodad->logo.logo_name)?((((2+strlen(doodad->logo.logo_name
))+3)/4)*4):4)
;
4597 }
4598 }
4599 return size;
4600}
4601
4602static char *
4603XkbWriteGeomDoodads(char *wire, int num_doodads, XkbDoodadPtr doodad, Bool swap)
4604{
4605 register int i;
4606 xkbDoodadWireDesc *doodadWire;
4607
4608 for (i = 0; i < num_doodads; i++, doodad++) {
4609 doodadWire = (xkbDoodadWireDesc *) wire;
4610 wire = (char *) &doodadWire[1];
4611 memset(doodadWire, 0, SIZEOF(xkbDoodadWireDesc))__builtin___memset_chk (doodadWire, 0, 20, __builtin_object_size
(doodadWire, 0))
;
4612 doodadWire->any.name = doodad->any.name;
4613 doodadWire->any.type = doodad->any.type;
4614 doodadWire->any.priority = doodad->any.priority;
4615 doodadWire->any.top = doodad->any.top;
4616 doodadWire->any.left = doodad->any.left;
4617 if (swap) {
4618 swapl(&doodadWire->any.name)do { if (sizeof(*(&doodadWire->any.name)) != 4) wrong_size
(); if (__builtin_constant_p((uintptr_t)(&doodadWire->
any.name) & 3) && ((uintptr_t)(&doodadWire->
any.name) & 3) == 0) *(&doodadWire->any.name) = lswapl
(*(&doodadWire->any.name)); else swap_uint32((uint32_t
*)(&doodadWire->any.name)); } while (0)
;
4619 swaps(&doodadWire->any.top)do { if (sizeof(*(&doodadWire->any.top)) != 2) wrong_size
(); if (__builtin_constant_p((uintptr_t)(&doodadWire->
any.top) & 1) && ((uintptr_t)(&doodadWire->
any.top) & 1) == 0) *(&doodadWire->any.top) = lswaps
(*(&doodadWire->any.top)); else swap_uint16((uint16_t *
)(&doodadWire->any.top)); } while (0)
;
4620 swaps(&doodadWire->any.left)do { if (sizeof(*(&doodadWire->any.left)) != 2) wrong_size
(); if (__builtin_constant_p((uintptr_t)(&doodadWire->
any.left) & 1) && ((uintptr_t)(&doodadWire->
any.left) & 1) == 0) *(&doodadWire->any.left) = lswaps
(*(&doodadWire->any.left)); else swap_uint16((uint16_t
*)(&doodadWire->any.left)); } while (0)
;
4621 }
4622 switch (doodad->any.type) {
4623 case XkbOutlineDoodad1:
4624 case XkbSolidDoodad2:
4625 doodadWire->shape.angle = doodad->shape.angle;
4626 doodadWire->shape.colorNdx = doodad->shape.color_ndx;
4627 doodadWire->shape.shapeNdx = doodad->shape.shape_ndx;
4628 if (swap) {
4629 swaps(&doodadWire->shape.angle)do { if (sizeof(*(&doodadWire->shape.angle)) != 2) wrong_size
(); if (__builtin_constant_p((uintptr_t)(&doodadWire->
shape.angle) & 1) && ((uintptr_t)(&doodadWire
->shape.angle) & 1) == 0) *(&doodadWire->shape.
angle) = lswaps(*(&doodadWire->shape.angle)); else swap_uint16
((uint16_t *)(&doodadWire->shape.angle)); } while (0)
;
4630 }
4631 break;
4632 case XkbTextDoodad3:
4633 doodadWire->text.angle = doodad->text.angle;
4634 doodadWire->text.width = doodad->text.width;
4635 doodadWire->text.height = doodad->text.height;
4636 doodadWire->text.colorNdx = doodad->text.color_ndx;
4637 if (swap) {
4638 swaps(&doodadWire->text.angle)do { if (sizeof(*(&doodadWire->text.angle)) != 2) wrong_size
(); if (__builtin_constant_p((uintptr_t)(&doodadWire->
text.angle) & 1) && ((uintptr_t)(&doodadWire->
text.angle) & 1) == 0) *(&doodadWire->text.angle) =
lswaps(*(&doodadWire->text.angle)); else swap_uint16(
(uint16_t *)(&doodadWire->text.angle)); } while (0)
;
4639 swaps(&doodadWire->text.width)do { if (sizeof(*(&doodadWire->text.width)) != 2) wrong_size
(); if (__builtin_constant_p((uintptr_t)(&doodadWire->
text.width) & 1) && ((uintptr_t)(&doodadWire->
text.width) & 1) == 0) *(&doodadWire->text.width) =
lswaps(*(&doodadWire->text.width)); else swap_uint16(
(uint16_t *)(&doodadWire->text.width)); } while (0)
;
4640 swaps(&doodadWire->text.height)do { if (sizeof(*(&doodadWire->text.height)) != 2) wrong_size
(); if (__builtin_constant_p((uintptr_t)(&doodadWire->
text.height) & 1) && ((uintptr_t)(&doodadWire
->text.height) & 1) == 0) *(&doodadWire->text.height
) = lswaps(*(&doodadWire->text.height)); else swap_uint16
((uint16_t *)(&doodadWire->text.height)); } while (0)
;
4641 }
4642 wire = XkbWriteCountedString(wire, doodad->text.text, swap);
4643 wire = XkbWriteCountedString(wire, doodad->text.font, swap);
4644 break;
4645 case XkbIndicatorDoodad4:
4646 doodadWire->indicator.shapeNdx = doodad->indicator.shape_ndx;
4647 doodadWire->indicator.onColorNdx = doodad->indicator.on_color_ndx;
4648 doodadWire->indicator.offColorNdx = doodad->indicator.off_color_ndx;
4649 break;
4650 case XkbLogoDoodad5:
4651 doodadWire->logo.angle = doodad->logo.angle;
4652 doodadWire->logo.colorNdx = doodad->logo.color_ndx;
4653 doodadWire->logo.shapeNdx = doodad->logo.shape_ndx;
4654 wire = XkbWriteCountedString(wire, doodad->logo.logo_name, swap);
4655 break;
4656 default:
4657 ErrorF("[xkb] Unknown doodad type %d in XkbWriteGeomDoodads\n",
4658 doodad->any.type);
4659 ErrorF("[xkb] Ignored\n");
4660 break;
4661 }
4662 }
4663 return wire;
4664}
4665
4666static char *
4667XkbWriteGeomOverlay(char *wire, XkbOverlayPtr ol, Bool swap)
4668{
4669 register int r;
4670 XkbOverlayRowPtr row;
4671 xkbOverlayWireDesc *olWire;
4672
4673 olWire = (xkbOverlayWireDesc *) wire;
4674 olWire->name = ol->name;
4675 olWire->nRows = ol->num_rows;
4676 olWire->pad1 = 0;
4677 olWire->pad2 = 0;
4678 if (swap) {
4679 swapl(&olWire->name)do { if (sizeof(*(&olWire->name)) != 4) wrong_size(); if
(__builtin_constant_p((uintptr_t)(&olWire->name) &
3) && ((uintptr_t)(&olWire->name) & 3) ==
0) *(&olWire->name) = lswapl(*(&olWire->name))
; else swap_uint32((uint32_t *)(&olWire->name)); } while
(0)
;
4680 }
4681 wire = (char *) &olWire[1];
4682 for (r = 0, row = ol->rows; r < ol->num_rows; r++, row++) {
4683 unsigned int k;
4684 XkbOverlayKeyPtr key;
4685 xkbOverlayRowWireDesc *rowWire;
4686
4687 rowWire = (xkbOverlayRowWireDesc *) wire;
4688 rowWire->rowUnder = row->row_under;
4689 rowWire->nKeys = row->num_keys;
4690 rowWire->pad1 = 0;
4691 wire = (char *) &rowWire[1];
4692 for (k = 0, key = row->keys; k < row->num_keys; k++, key++) {
4693 xkbOverlayKeyWireDesc *keyWire;
4694
4695 keyWire = (xkbOverlayKeyWireDesc *) wire;
4696 memcpy(keyWire->over, key->over.name, XkbKeyNameLength)__builtin___memcpy_chk (keyWire->over, key->over.name, 4
, __builtin_object_size (keyWire->over, 0))
;
4697 memcpy(keyWire->under, key->under.name, XkbKeyNameLength)__builtin___memcpy_chk (keyWire->under, key->under.name
, 4, __builtin_object_size (keyWire->under, 0))
;
4698 wire = (char *) &keyWire[1];
4699 }
4700 }
4701 return wire;
4702}
4703
4704static int
4705XkbSizeGeomSections(XkbGeometryPtr geom)
4706{
4707 register int i, size;
4708 XkbSectionPtr section;
4709
4710 for (i = size = 0, section = geom->sections; i < geom->num_sections;
4711 i++, section++) {
4712 size += SIZEOF(xkbSectionWireDesc)20;
4713 if (section->rows) {
4714 int r;
4715 XkbRowPtr row;
4716
4717 for (r = 0, row = section->rows; r < section->num_rows; row++, r++) {
4718 size += SIZEOF(xkbRowWireDesc)8;
4719 size += row->num_keys * SIZEOF(xkbKeyWireDesc)8;
4720 }
4721 }
4722 if (section->doodads)
4723 size += XkbSizeGeomDoodads(section->num_doodads, section->doodads);
4724 if (section->overlays) {
4725 int o;
4726 XkbOverlayPtr ol;
4727
4728 for (o = 0, ol = section->overlays; o < section->num_overlays;
4729 o++, ol++) {
4730 int r;
4731 XkbOverlayRowPtr row;
4732
4733 size += SIZEOF(xkbOverlayWireDesc)8;
4734 for (r = 0, row = ol->rows; r < ol->num_rows; r++, row++) {
4735 size += SIZEOF(xkbOverlayRowWireDesc)4;
4736 size += row->num_keys * SIZEOF(xkbOverlayKeyWireDesc)8;
4737 }
4738 }
4739 }
4740 }
4741 return size;
4742}
4743
4744static char *
4745XkbWriteGeomSections(char *wire, XkbGeometryPtr geom, Bool swap)
4746{
4747 register int i;
4748 XkbSectionPtr section;
4749 xkbSectionWireDesc *sectionWire;
4750
4751 for (i = 0, section = geom->sections; i < geom->num_sections;
4752 i++, section++) {
4753 sectionWire = (xkbSectionWireDesc *) wire;
4754 sectionWire->name = section->name;
4755 sectionWire->top = section->top;
4756 sectionWire->left = section->left;
4757 sectionWire->width = section->width;
4758 sectionWire->height = section->height;
4759 sectionWire->angle = section->angle;
4760 sectionWire->priority = section->priority;
4761 sectionWire->nRows = section->num_rows;
4762 sectionWire->nDoodads = section->num_doodads;
4763 sectionWire->nOverlays = section->num_overlays;
4764 sectionWire->pad = 0;
4765 if (swap) {
4766 swapl(&sectionWire->name)do { if (sizeof(*(&sectionWire->name)) != 4) wrong_size
(); if (__builtin_constant_p((uintptr_t)(&sectionWire->
name) & 3) && ((uintptr_t)(&sectionWire->name
) & 3) == 0) *(&sectionWire->name) = lswapl(*(&
sectionWire->name)); else swap_uint32((uint32_t *)(&sectionWire
->name)); } while (0)
;
4767 swaps(&sectionWire->top)do { if (sizeof(*(&sectionWire->top)) != 2) wrong_size
(); if (__builtin_constant_p((uintptr_t)(&sectionWire->
top) & 1) && ((uintptr_t)(&sectionWire->top
) & 1) == 0) *(&sectionWire->top) = lswaps(*(&
sectionWire->top)); else swap_uint16((uint16_t *)(&sectionWire
->top)); } while (0)
;
4768 swaps(&sectionWire->left)do { if (sizeof(*(&sectionWire->left)) != 2) wrong_size
(); if (__builtin_constant_p((uintptr_t)(&sectionWire->
left) & 1) && ((uintptr_t)(&sectionWire->left
) & 1) == 0) *(&sectionWire->left) = lswaps(*(&
sectionWire->left)); else swap_uint16((uint16_t *)(&sectionWire
->left)); } while (0)
;
4769 swaps(&sectionWire->width)do { if (sizeof(*(&sectionWire->width)) != 2) wrong_size
(); if (__builtin_constant_p((uintptr_t)(&sectionWire->
width) & 1) && ((uintptr_t)(&sectionWire->
width) & 1) == 0) *(&sectionWire->width) = lswaps(
*(&sectionWire->width)); else swap_uint16((uint16_t *)
(&sectionWire->width)); } while (0)
;
4770 swaps(&sectionWire->height)do { if (sizeof(*(&sectionWire->height)) != 2) wrong_size
(); if (__builtin_constant_p((uintptr_t)(&sectionWire->
height) & 1) && ((uintptr_t)(&sectionWire->
height) & 1) == 0) *(&sectionWire->height) = lswaps
(*(&sectionWire->height)); else swap_uint16((uint16_t *
)(&sectionWire->height)); } while (0)
;
4771 swaps(&sectionWire->angle)do { if (sizeof(*(&sectionWire->angle)) != 2) wrong_size
(); if (__builtin_constant_p((uintptr_t)(&sectionWire->
angle) & 1) && ((uintptr_t)(&sectionWire->
angle) & 1) == 0) *(&sectionWire->angle) = lswaps(
*(&sectionWire->angle)); else swap_uint16((uint16_t *)
(&sectionWire->angle)); } while (0)
;
4772 }
4773 wire = (char *) &sectionWire[1];
4774 if (section->rows) {
4775 int r;
4776 XkbRowPtr row;
4777 xkbRowWireDesc *rowWire;
4778
4779 for (r = 0, row = section->rows; r < section->num_rows; r++, row++) {
4780 rowWire = (xkbRowWireDesc *) wire;
4781 rowWire->top = row->top;
4782 rowWire->left = row->left;
4783 rowWire->nKeys = row->num_keys;
4784 rowWire->vertical = row->vertical;
4785 rowWire->pad = 0;
4786 if (swap) {
4787 swaps(&rowWire->top)do { if (sizeof(*(&rowWire->top)) != 2) wrong_size(); if
(__builtin_constant_p((uintptr_t)(&rowWire->top) &
1) && ((uintptr_t)(&rowWire->top) & 1) ==
0) *(&rowWire->top) = lswaps(*(&rowWire->top))
; else swap_uint16((uint16_t *)(&rowWire->top)); } while
(0)
;
4788 swaps(&rowWire->left)do { if (sizeof(*(&rowWire->left)) != 2) wrong_size();
if (__builtin_constant_p((uintptr_t)(&rowWire->left) &
1) && ((uintptr_t)(&rowWire->left) & 1) ==
0) *(&rowWire->left) = lswaps(*(&rowWire->left
)); else swap_uint16((uint16_t *)(&rowWire->left)); } while
(0)
;
4789 }
4790 wire = (char *) &rowWire[1];
4791 if (row->keys) {
4792 int k;
4793 XkbKeyPtr key;
4794 xkbKeyWireDesc *keyWire;
4795
4796 keyWire = (xkbKeyWireDesc *) wire;
4797 for (k = 0, key = row->keys; k < row->num_keys; k++, key++) {
4798 memcpy(keyWire[k].name, key->name.name,__builtin___memcpy_chk (keyWire[k].name, key->name.name, 4
, __builtin_object_size (keyWire[k].name, 0))
4799 XkbKeyNameLength)__builtin___memcpy_chk (keyWire[k].name, key->name.name, 4
, __builtin_object_size (keyWire[k].name, 0))
;
4800 keyWire[k].gap = key->gap;
4801 keyWire[k].shapeNdx = key->shape_ndx;
4802 keyWire[k].colorNdx = key->color_ndx;
4803 if (swap) {
4804 swaps(&keyWire[k].gap)do { if (sizeof(*(&keyWire[k].gap)) != 2) wrong_size(); if
(__builtin_constant_p((uintptr_t)(&keyWire[k].gap) &
1) && ((uintptr_t)(&keyWire[k].gap) & 1) == 0
) *(&keyWire[k].gap) = lswaps(*(&keyWire[k].gap)); else
swap_uint16((uint16_t *)(&keyWire[k].gap)); } while (0)
;
4805 }
4806 }
4807 wire = (char *) &keyWire[row->num_keys];
4808 }
4809 }
4810 }
4811 if (section->doodads) {
4812 wire = XkbWriteGeomDoodads(wire,
4813 section->num_doodads, section->doodads,
4814 swap);
4815 }
4816 if (section->overlays) {
4817 register int o;
4818
4819 for (o = 0; o < section->num_overlays; o++) {
4820 wire = XkbWriteGeomOverlay(wire, &section->overlays[o], swap);
4821 }
4822 }
4823 }
4824 return wire;
4825}
4826
4827static Statusint
4828XkbComputeGetGeometryReplySize(XkbGeometryPtr geom,
4829 xkbGetGeometryReply * rep, Atom name)
4830{
4831 int len;
4832
4833 if (geom != NULL((void*)0)) {
4834 len = XkbSizeCountedString(geom->label_font)((geom->label_font)?((((2+strlen(geom->label_font))+3)/
4)*4):4)
;
4835 len += XkbSizeGeomProperties(geom);
4836 len += XkbSizeGeomColors(geom);
4837 len += XkbSizeGeomShapes(geom);
4838 len += XkbSizeGeomSections(geom);
4839 len += XkbSizeGeomDoodads(geom->num_doodads, geom->doodads);
4840 len += XkbSizeGeomKeyAliases(geom);
4841 rep->length = len / 4;
4842 rep->found = TRUE1;
4843 rep->name = geom->name;
4844 rep->widthMM = geom->width_mm;
4845 rep->heightMM = geom->height_mm;
4846 rep->nProperties = geom->num_properties;
4847 rep->nColors = geom->num_colors;
4848 rep->nShapes = geom->num_shapes;
4849 rep->nSections = geom->num_sections;
4850 rep->nDoodads = geom->num_doodads;
4851 rep->nKeyAliases = geom->num_key_aliases;
4852 rep->baseColorNdx = XkbGeomColorIndex(geom, geom->base_color)((int)((geom->base_color)-&(geom)->colors[0]));
4853 rep->labelColorNdx = XkbGeomColorIndex(geom, geom->label_color)((int)((geom->label_color)-&(geom)->colors[0]));
4854 }
4855 else {
4856 rep->length = 0;
4857 rep->found = FALSE0;
4858 rep->name = name;
4859 rep->widthMM = rep->heightMM = 0;
4860 rep->nProperties = rep->nColors = rep->nShapes = 0;
4861 rep->nSections = rep->nDoodads = 0;
4862 rep->nKeyAliases = 0;
4863 rep->labelColorNdx = rep->baseColorNdx = 0;
4864 }
4865 return Success0;
4866}
4867static int
4868XkbSendGeometry(ClientPtr client,
4869 XkbGeometryPtr geom, xkbGetGeometryReply * rep, Bool freeGeom)
4870{
4871 char *desc, *start;
4872 int len;
4873
4874 if (geom != NULL((void*)0)) {
4875 start = desc = xallocarray(rep->length, 4)xreallocarray(((void*)0), (rep->length), (4));
4876 if (!start)
4877 return BadAlloc11;
4878 len = rep->length * 4;
4879 desc = XkbWriteCountedString(desc, geom->label_font, client->swapped);
4880 if (rep->nProperties > 0)
4881 desc = XkbWriteGeomProperties(desc, geom, client->swapped);
4882 if (rep->nColors > 0)
4883 desc = XkbWriteGeomColors(desc, geom, client->swapped);
4884 if (rep->nShapes > 0)
4885 desc = XkbWriteGeomShapes(desc, geom, client->swapped);
4886 if (rep->nSections > 0)
4887 desc = XkbWriteGeomSections(desc, geom, client->swapped);
4888 if (rep->nDoodads > 0)
4889 desc = XkbWriteGeomDoodads(desc, geom->num_doodads, geom->doodads,
4890 client->swapped);
4891 if (rep->nKeyAliases > 0)
4892 desc = XkbWriteGeomKeyAliases(desc, geom, client->swapped);
4893 if ((desc - start) != (len)) {
4894 ErrorF
4895 ("[xkb] BOGUS LENGTH in XkbSendGeometry, expected %d, got %ld\n",
4896 len, (unsigned long) (desc - start));
4897 }
4898 }
4899 else {
4900 len = 0;
4901 start = NULL((void*)0);
4902 }
4903 if (client->swapped) {
4904 swaps(&rep->sequenceNumber)do { if (sizeof(*(&rep->sequenceNumber)) != 2) wrong_size
(); if (__builtin_constant_p((uintptr_t)(&rep->sequenceNumber
) & 1) && ((uintptr_t)(&rep->sequenceNumber
) & 1) == 0) *(&rep->sequenceNumber) = lswaps(*(&
rep->sequenceNumber)); else swap_uint16((uint16_t *)(&
rep->sequenceNumber)); } while (0)
;
4905 swapl(&rep->length)do { if (sizeof(*(&rep->length)) != 4) wrong_size(); if
(__builtin_constant_p((uintptr_t)(&rep->length) &
3) && ((uintptr_t)(&rep->length) & 3) == 0
) *(&rep->length) = lswapl(*(&rep->length)); else
swap_uint32((uint32_t *)(&rep->length)); } while (0)
;
4906 swapl(&rep->name)do { if (sizeof(*(&rep->name)) != 4) wrong_size(); if (
__builtin_constant_p((uintptr_t)(&rep->name) & 3) &&
((uintptr_t)(&rep->name) & 3) == 0) *(&rep->
name) = lswapl(*(&rep->name)); else swap_uint32((uint32_t
*)(&rep->name)); } while (0)
;
4907 swaps(&rep->widthMM)do { if (sizeof(*(&rep->widthMM)) != 2) wrong_size(); if
(__builtin_constant_p((uintptr_t)(&rep->widthMM) &
1) && ((uintptr_t)(&rep->widthMM) & 1) ==
0) *(&rep->widthMM) = lswaps(*(&rep->widthMM))
; else swap_uint16((uint16_t *)(&rep->widthMM)); } while
(0)
;
4908 swaps(&rep->heightMM)do { if (sizeof(*(&rep->heightMM)) != 2) wrong_size();
if (__builtin_constant_p((uintptr_t)(&rep->heightMM) &
1) && ((uintptr_t)(&rep->heightMM) & 1) ==
0) *(&rep->heightMM) = lswaps(*(&rep->heightMM
)); else swap_uint16((uint16_t *)(&rep->heightMM)); } while
(0)
;
4909 swaps(&rep->nProperties)do { if (sizeof(*(&rep->nProperties)) != 2) wrong_size
(); if (__builtin_constant_p((uintptr_t)(&rep->nProperties
) & 1) && ((uintptr_t)(&rep->nProperties) &
1) == 0) *(&rep->nProperties) = lswaps(*(&rep->
nProperties)); else swap_uint16((uint16_t *)(&rep->nProperties
)); } while (0)
;
4910 swaps(&rep->nColors)do { if (sizeof(*(&rep->nColors)) != 2) wrong_size(); if
(__builtin_constant_p((uintptr_t)(&rep->nColors) &
1) && ((uintptr_t)(&rep->nColors) & 1) ==
0) *(&rep->nColors) = lswaps(*(&rep->nColors))
; else swap_uint16((uint16_t *)(&rep->nColors)); } while
(0)
;
4911 swaps(&rep->nShapes)do { if (sizeof(*(&rep->nShapes)) != 2) wrong_size(); if
(__builtin_constant_p((uintptr_t)(&rep->nShapes) &
1) && ((uintptr_t)(&rep->nShapes) & 1) ==
0) *(&rep->nShapes) = lswaps(*(&rep->nShapes))
; else swap_uint16((uint16_t *)(&rep->nShapes)); } while
(0)
;
4912 swaps(&rep->nSections)do { if (sizeof(*(&rep->nSections)) != 2) wrong_size()
; if (__builtin_constant_p((uintptr_t)(&rep->nSections
) & 1) && ((uintptr_t)(&rep->nSections) &
1) == 0) *(&rep->nSections) = lswaps(*(&rep->nSections
)); else swap_uint16((uint16_t *)(&rep->nSections)); }
while (0)
;
4913 swaps(&rep->nDoodads)do { if (sizeof(*(&rep->nDoodads)) != 2) wrong_size();
if (__builtin_constant_p((uintptr_t)(&rep->nDoodads) &
1) && ((uintptr_t)(&rep->nDoodads) & 1) ==
0) *(&rep->nDoodads) = lswaps(*(&rep->nDoodads
)); else swap_uint16((uint16_t *)(&rep->nDoodads)); } while
(0)
;
4914 swaps(&rep->nKeyAliases)do { if (sizeof(*(&rep->nKeyAliases)) != 2) wrong_size
(); if (__builtin_constant_p((uintptr_t)(&rep->nKeyAliases
) & 1) && ((uintptr_t)(&rep->nKeyAliases) &
1) == 0) *(&rep->nKeyAliases) = lswaps(*(&rep->
nKeyAliases)); else swap_uint16((uint16_t *)(&rep->nKeyAliases
)); } while (0)
;
4915 }
4916 WriteToClient(client, SIZEOF(xkbGetGeometryReply)32, rep);
4917 if (len > 0)
4918 WriteToClient(client, len, start);
4919 if (start != NULL((void*)0))
4920 free((char *) start);
4921 if (freeGeom)
4922 XkbFreeGeometrySrvXkbFreeGeometry(geom, XkbGeomAllMask(0x3f), TRUE1);
4923 return Success0;
4924}
4925
4926int
4927ProcXkbGetGeometry(ClientPtr client)
4928{
4929 DeviceIntPtr dev;
4930 xkbGetGeometryReply rep;
4931 XkbGeometryPtr geom;
4932 Bool shouldFree;
4933 Statusint status;
4934
4935 REQUEST(xkbGetGeometryReq)xkbGetGeometryReq *stuff = (xkbGetGeometryReq *)client->requestBuffer;
4936 REQUEST_SIZE_MATCH(xkbGetGeometryReq)if ((sizeof(xkbGetGeometryReq) >> 2) != client->req_len
) return(16)
;
4937
4938 if (!(client->xkbClientFlags & _XkbClientInitialized(1<<15)))
4939 return BadAccess10;
4940
4941 CHK_KBD_DEVICE(dev, stuff->deviceSpec, client, DixGetAttrAccess){ int why; int tmprc = _XkbLookupKeyboard(&(dev), stuff->
deviceSpec, client, (1<<4), &why); if (tmprc != 0) {
client->errorValue = ((XID)((((unsigned int)(why))<<
24)|((stuff->deviceSpec)&0xffffff))); return tmprc; }}
;
4942 CHK_ATOM_OR_NONE(stuff->name){ if (((stuff->name)!=0L)&&(!ValidAtom((stuff->
name)))) { (client->errorValue)= (XID)(stuff->name); return
5; }}
;
4943
4944 geom = XkbLookupNamedGeometry(dev, stuff->name, &shouldFree);
4945 rep = (xkbGetGeometryReply) {
4946 .type = X_Reply1,
4947 .deviceID = dev->id,
4948 .sequenceNumber = client->sequence,
4949 .length = 0
4950 };
4951 status = XkbComputeGetGeometryReplySize(geom, &rep, stuff->name);
4952 if (status != Success0)
4953 return status;
4954 else
4955 return XkbSendGeometry(client, geom, &rep, shouldFree);
4956}
4957
4958/***====================================================================***/
4959
4960static Statusint
4961_GetCountedString(char **wire_inout, ClientPtr client, char **str)
4962{
4963 char *wire, *next;
4964 CARD16 len;
4965
4966 wire = *wire_inout;
4967 len = *(CARD16 *) wire;
4968 if (client->swapped) {
4969 swaps(&len)do { if (sizeof(*(&len)) != 2) wrong_size(); if (__builtin_constant_p
((uintptr_t)(&len) & 1) && ((uintptr_t)(&
len) & 1) == 0) *(&len) = lswaps(*(&len)); else swap_uint16
((uint16_t *)(&len)); } while (0)
;
4970 }
4971 next = wire + XkbPaddedSize(len + 2)((((unsigned int)(len + 2)+3) >> 2) << 2);
4972 /* Check we're still within the size of the request */
4973 if (client->req_len <
4974 bytes_to_int32(next - (char *) client->requestBuffer))
4975 return BadValue2;
4976 *str = malloc(len + 1);
4977 if (!*str)
4978 return BadAlloc11;
4979 memcpy(*str, &wire[2], len)__builtin___memcpy_chk (*str, &wire[2], len, __builtin_object_size
(*str, 0))
;
4980 *(*str + len) = '\0';
4981 *wire_inout = next;
4982 return Success0;
4983}
4984
4985static Statusint
4986_CheckSetDoodad(char **wire_inout,
4987 XkbGeometryPtr geom, XkbSectionPtr section, ClientPtr client)
4988{
4989 char *wire;
4990 xkbDoodadWireDesc *dWire;
4991 xkbAnyDoodadWireDesc any;
4992 xkbTextDoodadWireDesc text;
4993 XkbDoodadPtr doodad;
4994 Statusint status;
4995
4996 dWire = (xkbDoodadWireDesc *) (*wire_inout);
4997 any = dWire->any;
4998 wire = (char *) &dWire[1];
4999 if (client->swapped) {
5000 swapl(&any.name)do { if (sizeof(*(&any.name)) != 4) wrong_size(); if (__builtin_constant_p
((uintptr_t)(&any.name) & 3) && ((uintptr_t)(
&any.name) & 3) == 0) *(&any.name) = lswapl(*(&
any.name)); else swap_uint32((uint32_t *)(&any.name)); } while
(0)
;
5001 swaps(&any.top)do { if (sizeof(*(&any.top)) != 2) wrong_size(); if (__builtin_constant_p
((uintptr_t)(&any.top) & 1) && ((uintptr_t)(&
any.top) & 1) == 0) *(&any.top) = lswaps(*(&any.top
)); else swap_uint16((uint16_t *)(&any.top)); } while (0)
;
5002 swaps(&any.left)do { if (sizeof(*(&any.left)) != 2) wrong_size(); if (__builtin_constant_p
((uintptr_t)(&any.left) & 1) && ((uintptr_t)(
&any.left) & 1) == 0) *(&any.left) = lswaps(*(&
any.left)); else swap_uint16((uint16_t *)(&any.left)); } while
(0)
;
5003 swaps(&any.angle)do { if (sizeof(*(&any.angle)) != 2) wrong_size(); if (__builtin_constant_p
((uintptr_t)(&any.angle) & 1) && ((uintptr_t)
(&any.angle) & 1) == 0) *(&any.angle) = lswaps(*(
&any.angle)); else swap_uint16((uint16_t *)(&any.angle
)); } while (0)
;
5004 }
5005 CHK_ATOM_ONLY(dWire->any.name){ if (((dWire->any.name)==0L)||(!ValidAtom((dWire->any.
name)))) { (client->errorValue)= (XID)(dWire->any.name)
; return 5; }}
;
5006 doodad = XkbAddGeomDoodadSrvXkbAddGeomDoodad(geom, section, any.name);
5007 if (!doodad)
5008 return BadAlloc11;
5009 doodad->any.type = dWire->any.type;
5010 doodad->any.priority = dWire->any.priority;
5011 doodad->any.top = any.top;
5012 doodad->any.left = any.left;
5013 doodad->any.angle = any.angle;
5014 switch (doodad->any.type) {
5015 case XkbOutlineDoodad1:
5016 case XkbSolidDoodad2:
5017 if (dWire->shape.colorNdx >= geom->num_colors) {
5018 client->errorValue = _XkbErrCode3(0x40, geom->num_colors,((XID)((((unsigned int)(0x40))<<24)|(((((unsigned int)(
geom->num_colors))<<16)|(dWire->shape.colorNdx))&
0xffffff)))
5019 dWire->shape.colorNdx)((XID)((((unsigned int)(0x40))<<24)|(((((unsigned int)(
geom->num_colors))<<16)|(dWire->shape.colorNdx))&
0xffffff)))
;
5020 return BadMatch8;
5021 }
5022 if (dWire->shape.shapeNdx >= geom->num_shapes) {
5023 client->errorValue = _XkbErrCode3(0x41, geom->num_shapes,((XID)((((unsigned int)(0x41))<<24)|(((((unsigned int)(
geom->num_shapes))<<16)|(dWire->shape.shapeNdx))&
0xffffff)))
5024 dWire->shape.shapeNdx)((XID)((((unsigned int)(0x41))<<24)|(((((unsigned int)(
geom->num_shapes))<<16)|(dWire->shape.shapeNdx))&
0xffffff)))
;
5025 return BadMatch8;
5026 }
5027 doodad->shape.color_ndx = dWire->shape.colorNdx;
5028 doodad->shape.shape_ndx = dWire->shape.shapeNdx;
5029 break;
5030 case XkbTextDoodad3:
5031 if (dWire->text.colorNdx >= geom->num_colors) {
5032 client->errorValue = _XkbErrCode3(0x42, geom->num_colors,((XID)((((unsigned int)(0x42))<<24)|(((((unsigned int)(
geom->num_colors))<<16)|(dWire->text.colorNdx))&
0xffffff)))
5033 dWire->text.colorNdx)((XID)((((unsigned int)(0x42))<<24)|(((((unsigned int)(
geom->num_colors))<<16)|(dWire->text.colorNdx))&
0xffffff)))
;
5034 return BadMatch8;
5035 }
5036 text = dWire->text;
5037 if (client->swapped) {
5038 swaps(&text.width)do { if (sizeof(*(&text.width)) != 2) wrong_size(); if (__builtin_constant_p
((uintptr_t)(&text.width) & 1) && ((uintptr_t
)(&text.width) & 1) == 0) *(&text.width) = lswaps
(*(&text.width)); else swap_uint16((uint16_t *)(&text
.width)); } while (0)
;
5039 swaps(&text.height)do { if (sizeof(*(&text.height)) != 2) wrong_size(); if (
__builtin_constant_p((uintptr_t)(&text.height) & 1) &&
((uintptr_t)(&text.height) & 1) == 0) *(&text.height
) = lswaps(*(&text.height)); else swap_uint16((uint16_t *
)(&text.height)); } while (0)
;
5040 }
5041 doodad->text.width = text.width;
5042 doodad->text.height = text.height;
5043 doodad->text.color_ndx = dWire->text.colorNdx;
5044 status = _GetCountedString(&wire, client, &doodad->text.text);
5045 if (status != Success0)
5046 return status;
5047 status = _GetCountedString(&wire, client, &doodad->text.font);
5048 if (status != Success0) {
5049 free (doodad->text.text);
5050 return status;
5051 }
5052 break;
5053 case XkbIndicatorDoodad4:
5054 if (dWire->indicator.onColorNdx >= geom->num_colors) {
5055 client->errorValue = _XkbErrCode3(0x43, geom->num_colors,((XID)((((unsigned int)(0x43))<<24)|(((((unsigned int)(
geom->num_colors))<<16)|(dWire->indicator.onColorNdx
))&0xffffff)))
5056 dWire->indicator.onColorNdx)((XID)((((unsigned int)(0x43))<<24)|(((((unsigned int)(
geom->num_colors))<<16)|(dWire->indicator.onColorNdx
))&0xffffff)))
;
5057 return BadMatch8;
5058 }
5059 if (dWire->indicator.offColorNdx >= geom->num_colors) {
5060 client->errorValue = _XkbErrCode3(0x44, geom->num_colors,((XID)((((unsigned int)(0x44))<<24)|(((((unsigned int)(
geom->num_colors))<<16)|(dWire->indicator.offColorNdx
))&0xffffff)))
5061 dWire->indicator.offColorNdx)((XID)((((unsigned int)(0x44))<<24)|(((((unsigned int)(
geom->num_colors))<<16)|(dWire->indicator.offColorNdx
))&0xffffff)))
;
5062 return BadMatch8;
5063 }
5064 if (dWire->indicator.shapeNdx >= geom->num_shapes) {
5065 client->errorValue = _XkbErrCode3(0x45, geom->num_shapes,((XID)((((unsigned int)(0x45))<<24)|(((((unsigned int)(
geom->num_shapes))<<16)|(dWire->indicator.shapeNdx
))&0xffffff)))
5066 dWire->indicator.shapeNdx)((XID)((((unsigned int)(0x45))<<24)|(((((unsigned int)(
geom->num_shapes))<<16)|(dWire->indicator.shapeNdx
))&0xffffff)))
;
5067 return BadMatch8;
5068 }
5069 doodad->indicator.shape_ndx = dWire->indicator.shapeNdx;
5070 doodad->indicator.on_color_ndx = dWire->indicator.onColorNdx;
5071 doodad->indicator.off_color_ndx = dWire->indicator.offColorNdx;
5072 break;
5073 case XkbLogoDoodad5:
5074 if (dWire->logo.colorNdx >= geom->num_colors) {
5075 client->errorValue = _XkbErrCode3(0x46, geom->num_colors,((XID)((((unsigned int)(0x46))<<24)|(((((unsigned int)(
geom->num_colors))<<16)|(dWire->logo.colorNdx))&
0xffffff)))
5076 dWire->logo.colorNdx)((XID)((((unsigned int)(0x46))<<24)|(((((unsigned int)(
geom->num_colors))<<16)|(dWire->logo.colorNdx))&
0xffffff)))
;
5077 return BadMatch8;
5078 }
5079 if (dWire->logo.shapeNdx >= geom->num_shapes) {
5080 client->errorValue = _XkbErrCode3(0x47, geom->num_shapes,((XID)((((unsigned int)(0x47))<<24)|(((((unsigned int)(
geom->num_shapes))<<16)|(dWire->logo.shapeNdx))&
0xffffff)))
5081 dWire->logo.shapeNdx)((XID)((((unsigned int)(0x47))<<24)|(((((unsigned int)(
geom->num_shapes))<<16)|(dWire->logo.shapeNdx))&
0xffffff)))
;
5082 return BadMatch8;
5083 }
5084 doodad->logo.color_ndx = dWire->logo.colorNdx;
5085 doodad->logo.shape_ndx = dWire->logo.shapeNdx;
5086 status = _GetCountedString(&wire, client, &doodad->logo.logo_name);
5087 if (status != Success0)
5088 return status;
5089 break;
5090 default:
5091 client->errorValue = _XkbErrCode2(0x4F, dWire->any.type)((XID)((((unsigned int)(0x4F))<<24)|((dWire->any.type
)&0xffffff)))
;
5092 return BadValue2;
5093 }
5094 *wire_inout = wire;
5095 return Success0;
5096}
5097
5098static Statusint
5099_CheckSetOverlay(char **wire_inout,
5100 XkbGeometryPtr geom, XkbSectionPtr section, ClientPtr client)
5101{
5102 register int r;
5103 char *wire;
5104 XkbOverlayPtr ol;
5105 xkbOverlayWireDesc *olWire;
5106 xkbOverlayRowWireDesc *rWire;
5107
5108 wire = *wire_inout;
5109 olWire = (xkbOverlayWireDesc *) wire;
5110 if (client->swapped) {
5111 swapl(&olWire->name)do { if (sizeof(*(&olWire->name)) != 4) wrong_size(); if
(__builtin_constant_p((uintptr_t)(&olWire->name) &
3) && ((uintptr_t)(&olWire->name) & 3) ==
0) *(&olWire->name) = lswapl(*(&olWire->name))
; else swap_uint32((uint32_t *)(&olWire->name)); } while
(0)
;
5112 }
5113 CHK_ATOM_ONLY(olWire->name){ if (((olWire->name)==0L)||(!ValidAtom((olWire->name))
)) { (client->errorValue)= (XID)(olWire->name); return 5
; }}
;
5114 ol = XkbAddGeomOverlaySrvXkbAddGeomOverlay(section, olWire->name, olWire->nRows);
5115 rWire = (xkbOverlayRowWireDesc *) &olWire[1];
5116 for (r = 0; r < olWire->nRows; r++) {
5117 register int k;
5118 xkbOverlayKeyWireDesc *kWire;
5119 XkbOverlayRowPtr row;
5120
5121 if (rWire->rowUnder > section->num_rows) {
5122 client->errorValue = _XkbErrCode4(0x20, r, section->num_rows,((XID)((((unsigned int)(0x20))<<24)|(((((unsigned int)(
r))<<16)|(((((unsigned int)(section->num_rows))<<
8)|(rWire->rowUnder))))&0xffffff)))
5123 rWire->rowUnder)((XID)((((unsigned int)(0x20))<<24)|(((((unsigned int)(
r))<<16)|(((((unsigned int)(section->num_rows))<<
8)|(rWire->rowUnder))))&0xffffff)))
;
5124 return BadMatch8;
5125 }
5126 row = XkbAddGeomOverlayRowSrvXkbAddGeomOverlayRow(ol, rWire->rowUnder, rWire->nKeys);
5127 kWire = (xkbOverlayKeyWireDesc *) &rWire[1];
5128 for (k = 0; k < rWire->nKeys; k++, kWire++) {
5129 if (XkbAddGeomOverlayKeySrvXkbAddGeomOverlayKey(ol, row,
5130 (char *) kWire->over,
5131 (char *) kWire->under) == NULL((void*)0)) {
5132 client->errorValue = _XkbErrCode3(0x21, r, k)((XID)((((unsigned int)(0x21))<<24)|(((((unsigned int)(
r))<<16)|(k))&0xffffff)))
;
5133 return BadMatch8;
5134 }
5135 }
5136 rWire = (xkbOverlayRowWireDesc *) kWire;
5137 }
5138 olWire = (xkbOverlayWireDesc *) rWire;
5139 wire = (char *) olWire;
5140 *wire_inout = wire;
5141 return Success0;
5142}
5143
5144static Statusint
5145_CheckSetSections(XkbGeometryPtr geom,
5146 xkbSetGeometryReq * req, char **wire_inout, ClientPtr client)
5147{
5148 Statusint status;
5149 register int s;
5150 char *wire;
5151 xkbSectionWireDesc *sWire;
5152 XkbSectionPtr section;
5153
5154 wire = *wire_inout;
5155 if (req->nSections < 1)
5156 return Success0;
5157 sWire = (xkbSectionWireDesc *) wire;
5158 for (s = 0; s < req->nSections; s++) {
5159 register int r;
5160 xkbRowWireDesc *rWire;
5161
5162 if (client->swapped) {
5163 swapl(&sWire->name)do { if (sizeof(*(&sWire->name)) != 4) wrong_size(); if
(__builtin_constant_p((uintptr_t)(&sWire->name) &
3) && ((uintptr_t)(&sWire->name) & 3) == 0
) *(&sWire->name) = lswapl(*(&sWire->name)); else
swap_uint32((uint32_t *)(&sWire->name)); } while (0)
;
5164 swaps(&sWire->top)do { if (sizeof(*(&sWire->top)) != 2) wrong_size(); if
(__builtin_constant_p((uintptr_t)(&sWire->top) & 1
) && ((uintptr_t)(&sWire->top) & 1) == 0) *
(&sWire->top) = lswaps(*(&sWire->top)); else swap_uint16
((uint16_t *)(&sWire->top)); } while (0)
;
5165 swaps(&sWire->left)do { if (sizeof(*(&sWire->left)) != 2) wrong_size(); if
(__builtin_constant_p((uintptr_t)(&sWire->left) &
1) && ((uintptr_t)(&sWire->left) & 1) == 0
) *(&sWire->left) = lswaps(*(&sWire->left)); else
swap_uint16((uint16_t *)(&sWire->left)); } while (0)
;
5166 swaps(&sWire->width)do { if (sizeof(*(&sWire->width)) != 2) wrong_size(); if
(__builtin_constant_p((uintptr_t)(&sWire->width) &
1) && ((uintptr_t)(&sWire->width) & 1) ==
0) *(&sWire->width) = lswaps(*(&sWire->width))
; else swap_uint16((uint16_t *)(&sWire->width)); } while
(0)
;
5167 swaps(&sWire->height)do { if (sizeof(*(&sWire->height)) != 2) wrong_size();
if (__builtin_constant_p((uintptr_t)(&sWire->height) &
1) && ((uintptr_t)(&sWire->height) & 1) ==
0) *(&sWire->height) = lswaps(*(&sWire->height
)); else swap_uint16((uint16_t *)(&sWire->height)); } while
(0)
;
5168 swaps(&sWire->angle)do { if (sizeof(*(&sWire->angle)) != 2) wrong_size(); if
(__builtin_constant_p((uintptr_t)(&sWire->angle) &
1) && ((uintptr_t)(&sWire->angle) & 1) ==
0) *(&sWire->angle) = lswaps(*(&sWire->angle))
; else swap_uint16((uint16_t *)(&sWire->angle)); } while
(0)
;
5169 }
5170 CHK_ATOM_ONLY(sWire->name){ if (((sWire->name)==0L)||(!ValidAtom((sWire->name))))
{ (client->errorValue)= (XID)(sWire->name); return 5; }
}
;
5171 section = XkbAddGeomSectionSrvXkbAddGeomSection(geom, sWire->name, sWire->nRows,
5172 sWire->nDoodads, sWire->nOverlays);
5173 if (!section)
5174 return BadAlloc11;
5175 section->priority = sWire->priority;
5176 section->top = sWire->top;
5177 section->left = sWire->left;
5178 section->width = sWire->width;
5179 section->height = sWire->height;
5180 section->angle = sWire->angle;
5181 rWire = (xkbRowWireDesc *) &sWire[1];
5182 for (r = 0; r < sWire->nRows; r++) {
5183 register int k;
5184 XkbRowPtr row;
5185 xkbKeyWireDesc *kWire;
5186
5187 if (client->swapped) {
5188 swaps(&rWire->top)do { if (sizeof(*(&rWire->top)) != 2) wrong_size(); if
(__builtin_constant_p((uintptr_t)(&rWire->top) & 1
) && ((uintptr_t)(&rWire->top) & 1) == 0) *
(&rWire->top) = lswaps(*(&rWire->top)); else swap_uint16
((uint16_t *)(&rWire->top)); } while (0)
;
5189 swaps(&rWire->left)do { if (sizeof(*(&rWire->left)) != 2) wrong_size(); if
(__builtin_constant_p((uintptr_t)(&rWire->left) &
1) && ((uintptr_t)(&rWire->left) & 1) == 0
) *(&rWire->left) = lswaps(*(&rWire->left)); else
swap_uint16((uint16_t *)(&rWire->left)); } while (0)
;
5190 }
5191 row = XkbAddGeomRowSrvXkbAddGeomRow(section, rWire->nKeys);
5192 if (!row)
5193 return BadAlloc11;
5194 row->top = rWire->top;
5195 row->left = rWire->left;
5196 row->vertical = rWire->vertical;
5197 kWire = (xkbKeyWireDesc *) &rWire[1];
5198 for (k = 0; k < rWire->nKeys; k++) {
5199 XkbKeyPtr key;
5200
5201 key = XkbAddGeomKeySrvXkbAddGeomKey(row);
5202 if (!key)
5203 return BadAlloc11;
5204 memcpy(key->name.name, kWire[k].name, XkbKeyNameLength)__builtin___memcpy_chk (key->name.name, kWire[k].name, 4, __builtin_object_size
(key->name.name, 0))
;
5205 key->gap = kWire[k].gap;
5206 key->shape_ndx = kWire[k].shapeNdx;
5207 key->color_ndx = kWire[k].colorNdx;
5208 if (key->shape_ndx >= geom->num_shapes) {
5209 client->errorValue = _XkbErrCode3(0x10, key->shape_ndx,((XID)((((unsigned int)(0x10))<<24)|(((((unsigned int)(
key->shape_ndx))<<16)|(geom->num_shapes))&0xffffff
)))
5210 geom->num_shapes)((XID)((((unsigned int)(0x10))<<24)|(((((unsigned int)(
key->shape_ndx))<<16)|(geom->num_shapes))&0xffffff
)))
;
5211 return BadMatch8;
5212 }
5213 if (key->color_ndx >= geom->num_colors) {
5214 client->errorValue = _XkbErrCode3(0x11, key->color_ndx,((XID)((((unsigned int)(0x11))<<24)|(((((unsigned int)(
key->color_ndx))<<16)|(geom->num_colors))&0xffffff
)))
5215 geom->num_colors)((XID)((((unsigned int)(0x11))<<24)|(((((unsigned int)(
key->color_ndx))<<16)|(geom->num_colors))&0xffffff
)))
;
5216 return BadMatch8;
5217 }
5218 }
5219 rWire = (xkbRowWireDesc *) &kWire[rWire->nKeys];
5220 }
5221 wire = (char *) rWire;
5222 if (sWire->nDoodads > 0) {
5223 register int d;
5224
5225 for (d = 0; d < sWire->nDoodads; d++) {
5226 status = _CheckSetDoodad(&wire, geom, section, client);
5227 if (status != Success0)
5228 return status;
5229 }
5230 }
5231 if (sWire->nOverlays > 0) {
5232 register int o;
5233
5234 for (o = 0; o < sWire->nOverlays; o++) {
5235 status = _CheckSetOverlay(&wire, geom, section, client);
5236 if (status != Success0)
5237 return status;
5238 }
5239 }
5240 sWire = (xkbSectionWireDesc *) wire;
5241 }
5242 wire = (char *) sWire;
5243 *wire_inout = wire;
5244 return Success0;
5245}
5246
5247static Statusint
5248_CheckSetShapes(XkbGeometryPtr geom,
5249 xkbSetGeometryReq * req, char **wire_inout, ClientPtr client)
5250{
5251 register int i;
5252 char *wire;
5253
5254 wire = *wire_inout;
5255 if (req->nShapes < 1) {
5256 client->errorValue = _XkbErrCode2(0x06, req->nShapes)((XID)((((unsigned int)(0x06))<<24)|((req->nShapes)&
0xffffff)))
;
5257 return BadValue2;
5258 }
5259 else {
5260 xkbShapeWireDesc *shapeWire;
5261 XkbShapePtr shape;
5262 register int o;
5263
5264 shapeWire = (xkbShapeWireDesc *) wire;
5265 for (i = 0; i < req->nShapes; i++) {
5266 xkbOutlineWireDesc *olWire;
5267 XkbOutlinePtr ol;
5268
5269 shape =
5270 XkbAddGeomShapeSrvXkbAddGeomShape(geom, shapeWire->name, shapeWire->nOutlines);
5271 if (!shape)
5272 return BadAlloc11;
5273 olWire = (xkbOutlineWireDesc *) (&shapeWire[1]);
5274 for (o = 0; o < shapeWire->nOutlines; o++) {
5275 register int p;
5276 XkbPointPtr pt;
5277 xkbPointWireDesc *ptWire;
5278
5279 ol = XkbAddGeomOutlineSrvXkbAddGeomOutline(shape, olWire->nPoints);
5280 if (!ol)
5281 return BadAlloc11;
5282 ol->corner_radius = olWire->cornerRadius;
5283 ptWire = (xkbPointWireDesc *) &olWire[1];
5284 for (p = 0, pt = ol->points; p < olWire->nPoints; p++, pt++) {
5285 pt->x = ptWire[p].x;
5286 pt->y = ptWire[p].y;
5287 if (client->swapped) {
5288 swaps(&pt->x)do { if (sizeof(*(&pt->x)) != 2) wrong_size(); if (__builtin_constant_p
((uintptr_t)(&pt->x) & 1) && ((uintptr_t)(
&pt->x) & 1) == 0) *(&pt->x) = lswaps(*(&
pt->x)); else swap_uint16((uint16_t *)(&pt->x)); } while
(0)
;
5289 swaps(&pt->y)do { if (sizeof(*(&pt->y)) != 2) wrong_size(); if (__builtin_constant_p
((uintptr_t)(&pt->y) & 1) && ((uintptr_t)(
&pt->y) & 1) == 0) *(&pt->y) = lswaps(*(&
pt->y)); else swap_uint16((uint16_t *)(&pt->y)); } while
(0)
;
5290 }
5291 }
5292 ol->num_points = olWire->nPoints;
5293 olWire = (xkbOutlineWireDesc *) (&ptWire[olWire->nPoints]);
5294 }
5295 if (shapeWire->primaryNdx != XkbNoShape0xff)
5296 shape->primary = &shape->outlines[shapeWire->primaryNdx];
5297 if (shapeWire->approxNdx != XkbNoShape0xff)
5298 shape->approx = &shape->outlines[shapeWire->approxNdx];
5299 shapeWire = (xkbShapeWireDesc *) olWire;
5300 }
5301 wire = (char *) shapeWire;
5302 }
5303 if (geom->num_shapes != req->nShapes) {
5304 client->errorValue = _XkbErrCode3(0x07, geom->num_shapes, req->nShapes)((XID)((((unsigned int)(0x07))<<24)|(((((unsigned int)(
geom->num_shapes))<<16)|(req->nShapes))&0xffffff
)))
;
5305 return BadMatch8;
5306 }
5307
5308 *wire_inout = wire;
5309 return Success0;
5310}
5311
5312static Statusint
5313_CheckSetGeom(XkbGeometryPtr geom, xkbSetGeometryReq * req, ClientPtr client)
5314{
5315 register int i;
5316 Statusint status;
5317 char *wire;
5318
5319 wire = (char *) &req[1];
5320 status = _GetCountedString(&wire, client, &geom->label_font);
5321 if (status != Success0)
5322 return status;
5323
5324 for (i = 0; i < req->nProperties; i++) {
5325 char *name, *val;
5326
5327 status = _GetCountedString(&wire, client, &name);
5328 if (status != Success0)
5329 return status;
5330 status = _GetCountedString(&wire, client, &val);
5331 if (status != Success0) {
5332 free(name);
5333 return status;
5334 }
5335 if (XkbAddGeomPropertySrvXkbAddGeomProperty(geom, name, val) == NULL((void*)0)) {
5336 free(name);
5337 free(val);
5338 return BadAlloc11;
5339 }
5340 free(name);
5341 free(val);
5342 }
5343
5344 if (req->nColors < 2) {
5345 client->errorValue = _XkbErrCode3(0x01, 2, req->nColors)((XID)((((unsigned int)(0x01))<<24)|(((((unsigned int)(
2))<<16)|(req->nColors))&0xffffff)))
;
5346 return BadValue2;
5347 }
5348 if (req->baseColorNdx > req->nColors) {
5349 client->errorValue =
5350 _XkbErrCode3(0x03, req->nColors, req->baseColorNdx)((XID)((((unsigned int)(0x03))<<24)|(((((unsigned int)(
req->nColors))<<16)|(req->baseColorNdx))&0xffffff
)))
;
5351 return BadMatch8;
5352 }
5353 if (req->labelColorNdx > req->nColors) {
5354 client->errorValue =
5355 _XkbErrCode3(0x03, req->nColors, req->labelColorNdx)((XID)((((unsigned int)(0x03))<<24)|(((((unsigned int)(
req->nColors))<<16)|(req->labelColorNdx))&0xffffff
)))
;
5356 return BadMatch8;
5357 }
5358 if (req->labelColorNdx == req->baseColorNdx) {
5359 client->errorValue = _XkbErrCode3(0x04, req->baseColorNdx,((XID)((((unsigned int)(0x04))<<24)|(((((unsigned int)(
req->baseColorNdx))<<16)|(req->labelColorNdx))&
0xffffff)))
5360 req->labelColorNdx)((XID)((((unsigned int)(0x04))<<24)|(((((unsigned int)(
req->baseColorNdx))<<16)|(req->labelColorNdx))&
0xffffff)))
;
5361 return BadMatch8;
5362 }
5363
5364 for (i = 0; i < req->nColors; i++) {
5365 char *name;
5366
5367 status = _GetCountedString(&wire, client, &name);
5368 if (status != Success0)
5369 return status;
5370 if (!XkbAddGeomColorSrvXkbAddGeomColor(geom, name, geom->num_colors)) {
5371 free(name);
5372 return BadAlloc11;
5373 }
5374 free(name);
5375 }
5376 if (req->nColors != geom->num_colors) {
5377 client->errorValue = _XkbErrCode3(0x05, req->nColors, geom->num_colors)((XID)((((unsigned int)(0x05))<<24)|(((((unsigned int)(
req->nColors))<<16)|(geom->num_colors))&0xffffff
)))
;
5378 return BadMatch8;
5379 }
5380 geom->label_color = &geom->colors[req->labelColorNdx];
5381 geom->base_color = &geom->colors[req->baseColorNdx];
5382
5383 if ((status = _CheckSetShapes(geom, req, &wire, client)) != Success0)
5384 return status;
5385
5386 if ((status = _CheckSetSections(geom, req, &wire, client)) != Success0)
5387 return status;
5388
5389 for (i = 0; i < req->nDoodads; i++) {
5390 status = _CheckSetDoodad(&wire, geom, NULL((void*)0), client);
5391 if (status != Success0)
5392 return status;
5393 }
5394
5395 for (i = 0; i < req->nKeyAliases; i++) {
5396 if (XkbAddGeomKeyAliasSrvXkbAddGeomKeyAlias(geom, &wire[XkbKeyNameLength4], wire) == NULL((void*)0))
5397 return BadAlloc11;
5398 wire += 2 * XkbKeyNameLength4;
5399 }
5400 return Success0;
5401}
5402
5403static int
5404_XkbSetGeometry(ClientPtr client, DeviceIntPtr dev, xkbSetGeometryReq * stuff)
5405{
5406 XkbDescPtr xkb;
5407 Bool new_name;
5408 xkbNewKeyboardNotify nkn;
5409 XkbGeometryPtr geom, old;
5410 XkbGeometrySizesRec sizes;
5411 Statusint status;
5412
5413 xkb = dev->key->xkbInfo->desc;
5414 old = xkb->geom;
5415 xkb->geom = NULL((void*)0);
5416
5417 sizes.which = XkbGeomAllMask(0x3f);
5418 sizes.num_properties = stuff->nProperties;
5419 sizes.num_colors = stuff->nColors;
5420 sizes.num_shapes = stuff->nShapes;
5421 sizes.num_sections = stuff->nSections;
5422 sizes.num_doodads = stuff->nDoodads;
5423 sizes.num_key_aliases = stuff->nKeyAliases;
5424 if ((status = XkbAllocGeometrySrvXkbAllocGeometry(xkb, &sizes)) != Success0) {
5425 xkb->geom = old;
5426 return status;
5427 }
5428 geom = xkb->geom;
5429 geom->name = stuff->name;
5430 geom->width_mm = stuff->widthMM;
5431 geom->height_mm = stuff->heightMM;
5432 if ((status = _CheckSetGeom(geom, stuff, client)) != Success0) {
5433 XkbFreeGeometrySrvXkbFreeGeometry(geom, XkbGeomAllMask(0x3f), TRUE1);
5434 xkb->geom = old;
5435 return status;
5436 }
5437 new_name = (xkb->names->geometry != geom->name);
5438 xkb->names->geometry = geom->name;
5439 if (old)
5440 XkbFreeGeometrySrvXkbFreeGeometry(old, XkbGeomAllMask(0x3f), TRUE1);
5441 if (new_name) {
5442 xkbNamesNotify nn;
5443
5444 memset(&nn, 0, sizeof(xkbNamesNotify))__builtin___memset_chk (&nn, 0, sizeof(xkbNamesNotify), __builtin_object_size
(&nn, 0))
;
5445 nn.changed = XkbGeometryNameMask(1<<1);
5446 XkbSendNamesNotify(dev, &nn);
5447 }
5448 nkn.deviceID = nkn.oldDeviceID = dev->id;
5449 nkn.minKeyCode = nkn.oldMinKeyCode = xkb->min_key_code;
5450 nkn.maxKeyCode = nkn.oldMaxKeyCode = xkb->max_key_code;
5451 nkn.requestMajor = XkbReqCode;
5452 nkn.requestMinor = X_kbSetGeometry20;
5453 nkn.changed = XkbNKN_GeometryMask(1L << 1);
5454 XkbSendNewKeyboardNotify(dev, &nkn);
5455 return Success0;
5456}
5457
5458int
5459ProcXkbSetGeometry(ClientPtr client)
5460{
5461 DeviceIntPtr dev;
5462 int rc;
5463
5464 REQUEST(xkbSetGeometryReq)xkbSetGeometryReq *stuff = (xkbSetGeometryReq *)client->requestBuffer;
5465 REQUEST_AT_LEAST_SIZE(xkbSetGeometryReq)if ((sizeof(xkbSetGeometryReq) >> 2) > client->req_len
) return(16)
;
5466
5467 if (!(client->xkbClientFlags & _XkbClientInitialized(1<<15)))
5468 return BadAccess10;
5469
5470 CHK_KBD_DEVICE(dev, stuff->deviceSpec, client, DixManageAccess){ int why; int tmprc = _XkbLookupKeyboard(&(dev), stuff->
deviceSpec, client, (1<<25), &why); if (tmprc != 0)
{ client->errorValue = ((XID)((((unsigned int)(why))<<
24)|((stuff->deviceSpec)&0xffffff))); return tmprc; }}
;
5471 CHK_ATOM_OR_NONE(stuff->name){ if (((stuff->name)!=0L)&&(!ValidAtom((stuff->
name)))) { (client->errorValue)= (XID)(stuff->name); return
5; }}
;
5472
5473 rc = _XkbSetGeometry(client, dev, stuff);
5474 if (rc != Success0)
5475 return rc;
5476
5477 if (stuff->deviceSpec == XkbUseCoreKbd0x0100) {
5478 DeviceIntPtr other;
5479
5480 for (other = inputInfo.devices; other; other = other->next) {
5481 if ((other != dev) && other->key && !IsMaster(other) &&
5482 GetMaster(other, MASTER_KEYBOARD2) == dev) {
5483 rc = XaceHook(XACE_DEVICE_ACCESS3, client, other,
5484 DixManageAccess(1<<25));
5485 if (rc == Success0)
5486 _XkbSetGeometry(client, other, stuff);
5487 }
5488 }
5489 }
5490
5491 return Success0;
5492}
5493
5494/***====================================================================***/
5495
5496int
5497ProcXkbPerClientFlags(ClientPtr client)
5498{
5499 DeviceIntPtr dev;
5500 xkbPerClientFlagsReply rep;
5501 XkbInterestPtr interest;
5502 Mask access_mode = DixGetAttrAccess(1<<4) | DixSetAttrAccess(1<<5);
5503
5504 REQUEST(xkbPerClientFlagsReq)xkbPerClientFlagsReq *stuff = (xkbPerClientFlagsReq *)client->
requestBuffer
;
5505 REQUEST_SIZE_MATCH(xkbPerClientFlagsReq)if ((sizeof(xkbPerClientFlagsReq) >> 2) != client->req_len
) return(16)
;
5506
5507 if (!(client->xkbClientFlags & _XkbClientInitialized(1<<15)))
5508 return BadAccess10;
5509
5510 CHK_KBD_DEVICE(dev, stuff->deviceSpec, client, access_mode){ int why; int tmprc = _XkbLookupKeyboard(&(dev), stuff->
deviceSpec, client, access_mode, &why); if (tmprc != 0) {
client->errorValue = ((XID)((((unsigned int)(why))<<
24)|((stuff->deviceSpec)&0xffffff))); return tmprc; }}
;
5511 CHK_MASK_LEGAL(0x01, stuff->change, XkbPCF_AllFlagsMask){ if ((stuff->change)&(~((0x1F)))) { (client->errorValue
)= ((XID)((((unsigned int)((0x01)))<<24)|((((stuff->
change)&(~((0x1F)))))&0xffffff))); return 2; }}
;
5512 CHK_MASK_MATCH(0x02, stuff->change, stuff->value){ if ((stuff->value)&(~(stuff->change))) { client->
errorValue= ((XID)((((unsigned int)((0x02)))<<24)|((((stuff
->value)&(~(stuff->change))))&0xffffff))); return
8; }}
;
5513
5514 interest = XkbFindClientResource((DevicePtr) dev, client);
5515 if (stuff->change) {
5516 client->xkbClientFlags &= ~stuff->change;
5517 client->xkbClientFlags |= stuff->value;
5518 }
5519 if (stuff->change & XkbPCF_AutoResetControlsMask(1L << 2)) {
5520 Bool want;
5521
5522 want = stuff->value & XkbPCF_AutoResetControlsMask(1L << 2);
5523 if (interest && !want) {
5524 interest->autoCtrls = interest->autoCtrlValues = 0;
5525 }
5526 else if (want && (!interest)) {
5527 XID id = FakeClientID(client->index);
5528
5529 if (!AddResourceDarwin_X_AddResource(id, RT_XKBCLIENT, dev))
5530 return BadAlloc11;
5531 interest = XkbAddClientResource((DevicePtr) dev, client, id);
5532 if (!interest)
5533 return BadAlloc11;
5534 }
5535 if (interest && want) {
5536 register unsigned affect;
5537
5538 affect = stuff->ctrlsToChange;
5539
5540 CHK_MASK_LEGAL(0x03, affect, XkbAllBooleanCtrlsMask){ if ((affect)&(~((0x00001FFF)))) { (client->errorValue
)= ((XID)((((unsigned int)((0x03)))<<24)|((((affect)&
(~((0x00001FFF)))))&0xffffff))); return 2; }}
;
5541 CHK_MASK_MATCH(0x04, affect, stuff->autoCtrls){ if ((stuff->autoCtrls)&(~(affect))) { client->errorValue
= ((XID)((((unsigned int)((0x04)))<<24)|((((stuff->autoCtrls
)&(~(affect))))&0xffffff))); return 8; }}
;
5542 CHK_MASK_MATCH(0x05, stuff->autoCtrls, stuff->autoCtrlValues){ if ((stuff->autoCtrlValues)&(~(stuff->autoCtrls))
) { client->errorValue= ((XID)((((unsigned int)((0x05)))<<
24)|((((stuff->autoCtrlValues)&(~(stuff->autoCtrls)
)))&0xffffff))); return 8; }}
;
5543
5544 interest->autoCtrls &= ~affect;
5545 interest->autoCtrlValues &= ~affect;
5546 interest->autoCtrls |= stuff->autoCtrls & affect;
5547 interest->autoCtrlValues |= stuff->autoCtrlValues & affect;
5548 }
5549 }
5550
5551 rep = (xkbPerClientFlagsReply) {
5552 .type = X_Reply1,
5553 .sequenceNumber = client->sequence,
5554 .length = 0,
5555 .supported = XkbPCF_AllFlagsMask(0x1F),
5556 .value = client->xkbClientFlags & XkbPCF_AllFlagsMask(0x1F),
5557 .autoCtrls = interest ? interest->autoCtrls : 0,
5558 .autoCtrlValues = interest ? interest->autoCtrlValues : 0,
5559 };
5560 if (client->swapped) {
5561 swaps(&rep.sequenceNumber)do { if (sizeof(*(&rep.sequenceNumber)) != 2) wrong_size(
); if (__builtin_constant_p((uintptr_t)(&rep.sequenceNumber
) & 1) && ((uintptr_t)(&rep.sequenceNumber) &
1) == 0) *(&rep.sequenceNumber) = lswaps(*(&rep.sequenceNumber
)); else swap_uint16((uint16_t *)(&rep.sequenceNumber)); }
while (0)
;
5562 swapl(&rep.supported)do { if (sizeof(*(&rep.supported)) != 4) wrong_size(); if
(__builtin_constant_p((uintptr_t)(&rep.supported) & 3
) && ((uintptr_t)(&rep.supported) & 3) == 0) *
(&rep.supported) = lswapl(*(&rep.supported)); else swap_uint32
((uint32_t *)(&rep.supported)); } while (0)
;
5563 swapl(&rep.value)do { if (sizeof(*(&rep.value)) != 4) wrong_size(); if (__builtin_constant_p
((uintptr_t)(&rep.value) & 3) && ((uintptr_t)
(&rep.value) & 3) == 0) *(&rep.value) = lswapl(*(
&rep.value)); else swap_uint32((uint32_t *)(&rep.value
)); } while (0)
;
5564 swapl(&rep.autoCtrls)do { if (sizeof(*(&rep.autoCtrls)) != 4) wrong_size(); if
(__builtin_constant_p((uintptr_t)(&rep.autoCtrls) & 3
) && ((uintptr_t)(&rep.autoCtrls) & 3) == 0) *
(&rep.autoCtrls) = lswapl(*(&rep.autoCtrls)); else swap_uint32
((uint32_t *)(&rep.autoCtrls)); } while (0)
;
5565 swapl(&rep.autoCtrlValues)do { if (sizeof(*(&rep.autoCtrlValues)) != 4) wrong_size(
); if (__builtin_constant_p((uintptr_t)(&rep.autoCtrlValues
) & 3) && ((uintptr_t)(&rep.autoCtrlValues) &
3) == 0) *(&rep.autoCtrlValues) = lswapl(*(&rep.autoCtrlValues
)); else swap_uint32((uint32_t *)(&rep.autoCtrlValues)); }
while (0)
;
5566 }
5567 WriteToClient(client, SIZEOF(xkbPerClientFlagsReply)32, &rep);
5568 return Success0;
5569}
5570
5571/***====================================================================***/
5572
5573/* all latin-1 alphanumerics, plus parens, minus, underscore, slash */
5574/* and wildcards */
5575static unsigned char componentSpecLegal[] = {
5576 0x00, 0x00, 0x00, 0x00, 0x00, 0xa7, 0xff, 0x87,
5577 0xfe, 0xff, 0xff, 0x87, 0xfe, 0xff, 0xff, 0x07,
5578 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
5579 0xff, 0xff, 0x7f, 0xff, 0xff, 0xff, 0x7f, 0xff
5580};
5581
5582/* same as above but accepts percent, plus and bar too */
5583static unsigned char componentExprLegal[] = {
5584 0x00, 0x00, 0x00, 0x00, 0x20, 0xaf, 0xff, 0x87,
5585 0xfe, 0xff, 0xff, 0x87, 0xfe, 0xff, 0xff, 0x17,
5586 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
5587 0xff, 0xff, 0x7f, 0xff, 0xff, 0xff, 0x7f, 0xff
5588};
5589
5590static char *
5591GetComponentSpec(unsigned char **pWire, Bool allowExpr, int *errRtrn)
5592{
5593 int len;
5594 register int i;
5595 unsigned char *wire, *str, *tmp, *legal;
5596
5597 if (allowExpr)
5598 legal = &componentExprLegal[0];
5599 else
5600 legal = &componentSpecLegal[0];
5601
5602 wire = *pWire;
5603 len = (*(unsigned char *) wire++);
5604 if (len > 0) {
5605 str = calloc(1, len + 1);
5606 if (str) {
5607 tmp = str;
5608 for (i = 0; i < len; i++) {
5609 if (legal[(*wire) / 8] & (1 << ((*wire) % 8)))
5610 *tmp++ = *wire++;
5611 else
5612 wire++;
5613 }
5614 if (tmp != str)
5615 *tmp++ = '\0';
5616 else {
5617 free(str);
5618 str = NULL((void*)0);
5619 }
5620 }
5621 else {
5622 *errRtrn = BadAlloc11;
5623 }
5624 }
5625 else {
5626 str = NULL((void*)0);
5627 }
5628 *pWire = wire;
5629 return (char *) str;
5630}
5631
5632/***====================================================================***/
5633
5634int
5635ProcXkbListComponents(ClientPtr client)
5636{
5637 DeviceIntPtr dev;
5638 xkbListComponentsReply rep;
5639 unsigned len;
5640 unsigned char *str;
5641 uint8_t size;
5642 int i;
5643
5644 REQUEST(xkbListComponentsReq)xkbListComponentsReq *stuff = (xkbListComponentsReq *)client->
requestBuffer
;
5645 REQUEST_AT_LEAST_SIZE(xkbListComponentsReq)if ((sizeof(xkbListComponentsReq) >> 2) > client->
req_len ) return(16)
;
5646
5647 if (!(client->xkbClientFlags & _XkbClientInitialized(1<<15)))
5648 return BadAccess10;
5649
5650 CHK_KBD_DEVICE(dev, stuff->deviceSpec, client, DixGetAttrAccess){ int why; int tmprc = _XkbLookupKeyboard(&(dev), stuff->
deviceSpec, client, (1<<4), &why); if (tmprc != 0) {
client->errorValue = ((XID)((((unsigned int)(why))<<
24)|((stuff->deviceSpec)&0xffffff))); return tmprc; }}
;
5651
5652 /* The request is followed by six Pascal strings (i.e. size in characters
5653 * followed by a string pattern) describing what the client wants us to
5654 * list. We don't care, but might as well check they haven't got the
5655 * length wrong. */
5656 str = (unsigned char *) &stuff[1];
5657 for (i = 0; i < 6; i++) {
5658 size = *((uint8_t *)str);
5659 len = (str + size + 1) - ((unsigned char *) stuff);
5660 if ((XkbPaddedSize(len)((((unsigned int)(len)+3) >> 2) << 2) / 4) > stuff->length)
5661 return BadLength16;
5662 str += (size + 1);
5663 }
5664 if ((XkbPaddedSize(len)((((unsigned int)(len)+3) >> 2) << 2) / 4) != stuff->length)
5665 return BadLength16;
5666 rep = (xkbListComponentsReply) {
5667 .type = X_Reply1,
5668 .deviceID = dev->id,
5669 .sequenceNumber = client->sequence,
5670 .length = 0,
5671 .nKeymaps = 0,
5672 .nKeycodes = 0,
5673 .nTypes = 0,
5674 .nCompatMaps = 0,
5675 .nSymbols = 0,
5676 .nGeometries = 0,
5677 .extra = 0
5678 };
5679 if (client->swapped) {
5680 swaps(&rep.sequenceNumber)do { if (sizeof(*(&rep.sequenceNumber)) != 2) wrong_size(
); if (__builtin_constant_p((uintptr_t)(&rep.sequenceNumber
) & 1) && ((uintptr_t)(&rep.sequenceNumber) &
1) == 0) *(&rep.sequenceNumber) = lswaps(*(&rep.sequenceNumber
)); else swap_uint16((uint16_t *)(&rep.sequenceNumber)); }
while (0)
;
5681 swapl(&rep.length)do { if (sizeof(*(&rep.length)) != 4) wrong_size(); if (__builtin_constant_p
((uintptr_t)(&rep.length) & 3) && ((uintptr_t
)(&rep.length) & 3) == 0) *(&rep.length) = lswapl
(*(&rep.length)); else swap_uint32((uint32_t *)(&rep.
length)); } while (0)
;
5682 swaps(&rep.nKeymaps)do { if (sizeof(*(&rep.nKeymaps)) != 2) wrong_size(); if (
__builtin_constant_p((uintptr_t)(&rep.nKeymaps) & 1) &&
((uintptr_t)(&rep.nKeymaps) & 1) == 0) *(&rep.nKeymaps
) = lswaps(*(&rep.nKeymaps)); else swap_uint16((uint16_t *
)(&rep.nKeymaps)); } while (0)
;
5683 swaps(&rep.nKeycodes)do { if (sizeof(*(&rep.nKeycodes)) != 2) wrong_size(); if
(__builtin_constant_p((uintptr_t)(&rep.nKeycodes) & 1
) && ((uintptr_t)(&rep.nKeycodes) & 1) == 0) *
(&rep.nKeycodes) = lswaps(*(&rep.nKeycodes)); else swap_uint16
((uint16_t *)(&rep.nKeycodes)); } while (0)
;
5684 swaps(&rep.nTypes)do { if (sizeof(*(&rep.nTypes)) != 2) wrong_size(); if (__builtin_constant_p
((uintptr_t)(&rep.nTypes) & 1) && ((uintptr_t
)(&rep.nTypes) & 1) == 0) *(&rep.nTypes) = lswaps
(*(&rep.nTypes)); else swap_uint16((uint16_t *)(&rep.
nTypes)); } while (0)
;
5685 swaps(&rep.nCompatMaps)do { if (sizeof(*(&rep.nCompatMaps)) != 2) wrong_size(); if
(__builtin_constant_p((uintptr_t)(&rep.nCompatMaps) &
1) && ((uintptr_t)(&rep.nCompatMaps) & 1) ==
0) *(&rep.nCompatMaps) = lswaps(*(&rep.nCompatMaps))
; else swap_uint16((uint16_t *)(&rep.nCompatMaps)); } while
(0)
;
5686 swaps(&rep.nSymbols)do { if (sizeof(*(&rep.nSymbols)) != 2) wrong_size(); if (
__builtin_constant_p((uintptr_t)(&rep.nSymbols) & 1) &&
((uintptr_t)(&rep.nSymbols) & 1) == 0) *(&rep.nSymbols
) = lswaps(*(&rep.nSymbols)); else swap_uint16((uint16_t *
)(&rep.nSymbols)); } while (0)
;
5687 swaps(&rep.nGeometries)do { if (sizeof(*(&rep.nGeometries)) != 2) wrong_size(); if
(__builtin_constant_p((uintptr_t)(&rep.nGeometries) &
1) && ((uintptr_t)(&rep.nGeometries) & 1) ==
0) *(&rep.nGeometries) = lswaps(*(&rep.nGeometries))
; else swap_uint16((uint16_t *)(&rep.nGeometries)); } while
(0)
;
5688 swaps(&rep.extra)do { if (sizeof(*(&rep.extra)) != 2) wrong_size(); if (__builtin_constant_p
((uintptr_t)(&rep.extra) & 1) && ((uintptr_t)
(&rep.extra) & 1) == 0) *(&rep.extra) = lswaps(*(
&rep.extra)); else swap_uint16((uint16_t *)(&rep.extra
)); } while (0)
;
5689 }
5690 WriteToClient(client, SIZEOF(xkbListComponentsReply)32, &rep);
5691 return Success0;
5692}
5693
5694/***====================================================================***/
5695int
5696ProcXkbGetKbdByName(ClientPtr client)
5697{
5698 DeviceIntPtr dev;
5699 DeviceIntPtr tmpd;
5700 DeviceIntPtr master;
5701 xkbGetKbdByNameReply rep = { 0 };
5702 xkbGetMapReply mrep = { 0 };
5703 xkbGetCompatMapReply crep = { 0 };
5704 xkbGetIndicatorMapReply irep = { 0 };
5705 xkbGetNamesReply nrep = { 0 };
5706 xkbGetGeometryReply grep = { 0 };
5707 XkbComponentNamesRec names = { 0 };
5708 XkbDescPtr xkb, new;
5709 unsigned char *str;
5710 char mapFile[PATH_MAX1024];
5711 unsigned len;
5712 unsigned fwant, fneed, reported;
5713 int status;
5714 Bool geom_changed;
5715 XkbSrvLedInfoPtr old_sli;
5716 XkbSrvLedInfoPtr sli;
5717 Mask access_mode = DixGetAttrAccess(1<<4) | DixManageAccess(1<<25);
5718
5719 REQUEST(xkbGetKbdByNameReq)xkbGetKbdByNameReq *stuff = (xkbGetKbdByNameReq *)client->
requestBuffer
;
5720 REQUEST_AT_LEAST_SIZE(xkbGetKbdByNameReq)if ((sizeof(xkbGetKbdByNameReq) >> 2) > client->req_len
) return(16)
;
5721
5722 if (!(client->xkbClientFlags & _XkbClientInitialized(1<<15)))
5723 return BadAccess10;
5724
5725 CHK_KBD_DEVICE(dev, stuff->deviceSpec, client, access_mode){ int why; int tmprc = _XkbLookupKeyboard(&(dev), stuff->
deviceSpec, client, access_mode, &why); if (tmprc != 0) {
client->errorValue = ((XID)((((unsigned int)(why))<<
24)|((stuff->deviceSpec)&0xffffff))); return tmprc; }}
;
5726 master = GetMaster(dev, MASTER_KEYBOARD2);
5727
5728 xkb = dev->key->xkbInfo->desc;
5729 status = Success0;
5730 str = (unsigned char *) &stuff[1];
5731 if (GetComponentSpec(&str, TRUE1, &status)) /* keymap, unsupported */
5732 return BadMatch8;
5733 names.keycodes = GetComponentSpec(&str, TRUE1, &status);
5734 names.types = GetComponentSpec(&str, TRUE1, &status);
5735 names.compat = GetComponentSpec(&str, TRUE1, &status);
5736 names.symbols = GetComponentSpec(&str, TRUE1, &status);
5737 names.geometry = GetComponentSpec(&str, TRUE1, &status);
5738 if (status != Success0)
5739 return status;
5740 len = str - ((unsigned char *) stuff);
5741 if ((XkbPaddedSize(len)((((unsigned int)(len)+3) >> 2) << 2) / 4) != stuff->length)
5742 return BadLength16;
5743
5744 CHK_MASK_LEGAL(0x01, stuff->want, XkbGBN_AllComponentsMask){ if ((stuff->want)&(~((0xff)))) { (client->errorValue
)= ((XID)((((unsigned int)((0x01)))<<24)|((((stuff->
want)&(~((0xff)))))&0xffffff))); return 2; }}
;
5745 CHK_MASK_LEGAL(0x02, stuff->need, XkbGBN_AllComponentsMask){ if ((stuff->need)&(~((0xff)))) { (client->errorValue
)= ((XID)((((unsigned int)((0x02)))<<24)|((((stuff->
need)&(~((0xff)))))&0xffffff))); return 2; }}
;
5746
5747 if (stuff->load)
5748 fwant = XkbGBN_AllComponentsMask(0xff);
5749 else
5750 fwant = stuff->want | stuff->need;
5751 if ((!names.compat) &&
5752 (fwant & (XkbGBN_CompatMapMask(1L << 1) | XkbGBN_IndicatorMapMask(1L << 4)))) {
5753 names.compat = Xstrdup("%");
5754 }
5755 if ((!names.types) && (fwant & (XkbGBN_TypesMask(1L << 0)))) {
5756 names.types = Xstrdup("%");
5757 }
5758 if ((!names.symbols) && (fwant & XkbGBN_SymbolsMask((1L << 2)|(1L << 3)))) {
5759 names.symbols = Xstrdup("%");
5760 }
5761 geom_changed = ((names.geometry != NULL((void*)0)) &&
5762 (strcmp(names.geometry, "%") != 0));
5763 if ((!names.geometry) && (fwant & XkbGBN_GeometryMask(1L << 6))) {
5764 names.geometry = Xstrdup("%");
5765 geom_changed = FALSE0;
5766 }
5767
5768 memset(mapFile, 0, PATH_MAX)__builtin___memset_chk (mapFile, 0, 1024, __builtin_object_size
(mapFile, 0))
;
5769 rep.type = X_Reply1;
5770 rep.deviceID = dev->id;
5771 rep.sequenceNumber = client->sequence;
5772 rep.length = 0;
5773 rep.minKeyCode = xkb->min_key_code;
5774 rep.maxKeyCode = xkb->max_key_code;
5775 rep.loaded = FALSE0;
5776 fwant =
5777 XkbConvertGetByNameComponents(TRUE1, stuff->want) | XkmVirtualModsMask(1<<6);
5778 fneed = XkbConvertGetByNameComponents(TRUE1, stuff->need);
5779 rep.reported = XkbConvertGetByNameComponents(FALSE0, fwant | fneed);
5780 if (stuff->load) {
5781 fneed |= XkmKeymapRequired(((1<<1))|((1<<4)|(1<<2)|(1<<0)));
5782 fwant |= XkmKeymapLegal((((1<<1))|((1<<4)|(1<<2)|(1<<0)))|((
((1<<0)|(1<<6)|(1<<3))|((1<<6)|(1<<
5)))&(~(((1<<1))|((1<<4)|(1<<2)|(1<<
0))))))
;
5783 }
5784 if ((fwant | fneed) & XkmSymbolsMask(1<<2)) {
5785 fneed |= XkmKeyNamesIndex4 | XkmTypesIndex0;
5786 fwant |= XkmIndicatorsIndex3;
5787 }
5788
5789 /* We pass dev in here so we can get the old names out if needed. */
5790 rep.found = XkbDDXLoadKeymapByNames(dev, &names, fwant, fneed, &new,
5791 mapFile, PATH_MAX1024);
5792 rep.newKeyboard = FALSE0;
5793 rep.pad1 = rep.pad2 = rep.pad3 = rep.pad4 = 0;
5794
5795 stuff->want |= stuff->need;
5796 if (new == NULL((void*)0))
5797 rep.reported = 0;
5798 else {
5799 if (stuff->load)
5800 rep.loaded = TRUE1;
5801 if (stuff->load ||
5802 ((rep.reported & XkbGBN_SymbolsMask((1L << 2)|(1L << 3))) && (new->compat))) {
5803 XkbChangesRec changes;
5804
5805 memset(&changes, 0, sizeof(changes))__builtin___memset_chk (&changes, 0, sizeof(changes), __builtin_object_size
(&changes, 0))
;
5806 XkbUpdateDescActions(new,
5807 new->min_key_code, XkbNumKeys(new)((new)->max_key_code-(new)->min_key_code+1), &changes);
5808 }
5809
5810 if (new->map == NULL((void*)0))
5811 rep.reported &= ~(XkbGBN_SymbolsMask((1L << 2)|(1L << 3)) | XkbGBN_TypesMask(1L << 0));
5812 else if (rep.reported & (XkbGBN_SymbolsMask((1L << 2)|(1L << 3)) | XkbGBN_TypesMask(1L << 0))) {
5813 mrep.type = X_Reply1;
5814 mrep.deviceID = dev->id;
5815 mrep.sequenceNumber = client->sequence;
5816 mrep.length =
5817 ((SIZEOF(xkbGetMapReply)40 - SIZEOF(xGenericReply)32) >> 2);
5818 mrep.minKeyCode = new->min_key_code;
5819 mrep.maxKeyCode = new->max_key_code;
5820 mrep.present = 0;
5821 mrep.totalSyms = mrep.totalActs =
5822 mrep.totalKeyBehaviors = mrep.totalKeyExplicit =
5823 mrep.totalModMapKeys = mrep.totalVModMapKeys = 0;
5824 if (rep.reported & (XkbGBN_TypesMask(1L << 0) | XkbGBN_ClientSymbolsMask(1L << 2))) {
5825 mrep.present |= XkbKeyTypesMask(1<<0);
5826 mrep.firstType = 0;
5827 mrep.nTypes = mrep.totalTypes = new->map->num_types;
5828 }
5829 else {
5830 mrep.firstType = mrep.nTypes = 0;
5831 mrep.totalTypes = 0;
5832 }
5833 if (rep.reported & XkbGBN_ClientSymbolsMask(1L << 2)) {
5834 mrep.present |= (XkbKeySymsMask(1<<1) | XkbModifierMapMask(1<<2));
5835 mrep.firstKeySym = mrep.firstModMapKey = new->min_key_code;
5836 mrep.nKeySyms = mrep.nModMapKeys = XkbNumKeys(new)((new)->max_key_code-(new)->min_key_code+1);
5837 }
5838 else {
5839 mrep.firstKeySym = mrep.firstModMapKey = 0;
5840 mrep.nKeySyms = mrep.nModMapKeys = 0;
5841 }
5842 if (rep.reported & XkbGBN_ServerSymbolsMask(1L << 3)) {
5843 mrep.present |= XkbAllServerInfoMask((1<<3)|(1<<4)|(1<<5)|(1<<6)|(1<<
7))
;
5844 mrep.virtualMods = ~0;
5845 mrep.firstKeyAct = mrep.firstKeyBehavior =
5846 mrep.firstKeyExplicit = new->min_key_code;
5847 mrep.nKeyActs = mrep.nKeyBehaviors =
5848 mrep.nKeyExplicit = XkbNumKeys(new)((new)->max_key_code-(new)->min_key_code+1);
5849 mrep.firstVModMapKey = new->min_key_code;
5850 mrep.nVModMapKeys = XkbNumKeys(new)((new)->max_key_code-(new)->min_key_code+1);
5851 }
5852 else {
5853 mrep.virtualMods = 0;
5854 mrep.firstKeyAct = mrep.firstKeyBehavior =
5855 mrep.firstKeyExplicit = 0;
5856 mrep.nKeyActs = mrep.nKeyBehaviors = mrep.nKeyExplicit = 0;
5857 }
5858 XkbComputeGetMapReplySize(new, &mrep);
5859 rep.length += SIZEOF(xGenericReply)32 / 4 + mrep.length;
5860 }
5861 if (new->compat == NULL((void*)0))
5862 rep.reported &= ~XkbGBN_CompatMapMask(1L << 1);
5863 else if (rep.reported & XkbGBN_CompatMapMask(1L << 1)) {
5864 crep.type = X_Reply1;
5865 crep.deviceID = dev->id;
5866 crep.sequenceNumber = client->sequence;
5867 crep.length = 0;
5868 crep.groups = XkbAllGroupsMask(0xf);
5869 crep.firstSI = 0;
5870 crep.nSI = crep.nTotalSI = new->compat->num_si;
5871 XkbComputeGetCompatMapReplySize(new->compat, &crep);
5872 rep.length += SIZEOF(xGenericReply)32 / 4 + crep.length;
5873 }
5874 if (new->indicators == NULL((void*)0))
5875 rep.reported &= ~XkbGBN_IndicatorMapMask(1L << 4);
5876 else if (rep.reported & XkbGBN_IndicatorMapMask(1L << 4)) {
5877 irep.type = X_Reply1;
5878 irep.deviceID = dev->id;
5879 irep.sequenceNumber = client->sequence;
5880 irep.length = 0;
5881 irep.which = XkbAllIndicatorsMask(0xffffffff);
5882 XkbComputeGetIndicatorMapReplySize(new->indicators, &irep);
5883 rep.length += SIZEOF(xGenericReply)32 / 4 + irep.length;
5884 }
5885 if (new->names == NULL((void*)0))
5886 rep.reported &= ~(XkbGBN_OtherNamesMask(1L << 7) | XkbGBN_KeyNamesMask(1L << 5));
5887 else if (rep.reported & (XkbGBN_OtherNamesMask(1L << 7) | XkbGBN_KeyNamesMask(1L << 5))) {
5888 nrep.type = X_Reply1;
5889 nrep.deviceID = dev->id;
5890 nrep.sequenceNumber = client->sequence;
5891 nrep.length = 0;
5892 nrep.minKeyCode = new->min_key_code;
5893 nrep.maxKeyCode = new->max_key_code;
5894 if (rep.reported & XkbGBN_OtherNamesMask(1L << 7)) {
5895 nrep.which = XkbAllNamesMask(0x3fff);
5896 if (new->map != NULL((void*)0))
5897 nrep.nTypes = new->map->num_types;
5898 else
5899 nrep.nTypes = 0;
5900 nrep.nKTLevels = 0;
5901 nrep.groupNames = XkbAllGroupsMask(0xf);
5902 nrep.virtualMods = XkbAllVirtualModsMask0xffff;
5903 nrep.indicators = XkbAllIndicatorsMask(0xffffffff);
5904 nrep.nRadioGroups = new->names->num_rg;
5905 }
5906 else {
5907 nrep.which = 0;
5908 nrep.nTypes = 0;
5909 nrep.nKTLevels = 0;
5910 nrep.groupNames = 0;
5911 nrep.virtualMods = 0;
5912 nrep.indicators = 0;
5913 nrep.nRadioGroups = 0;
5914 }
5915 if (rep.reported & XkbGBN_KeyNamesMask(1L << 5)) {
5916 nrep.which |= XkbKeyNamesMask(1<<9);
5917 nrep.firstKey = new->min_key_code;
5918 nrep.nKeys = XkbNumKeys(new)((new)->max_key_code-(new)->min_key_code+1);
5919 nrep.nKeyAliases = new->names->num_key_aliases;
5920 if (nrep.nKeyAliases)
5921 nrep.which |= XkbKeyAliasesMask(1<<10);
5922 }
5923 else {
5924 nrep.which &= ~(XkbKeyNamesMask(1<<9) | XkbKeyAliasesMask(1<<10));
5925 nrep.firstKey = nrep.nKeys = 0;
5926 nrep.nKeyAliases = 0;
5927 }
5928 XkbComputeGetNamesReplySize(new, &nrep);
5929 rep.length += SIZEOF(xGenericReply)32 / 4 + nrep.length;
5930 }
5931 if (new->geom == NULL((void*)0))
5932 rep.reported &= ~XkbGBN_GeometryMask(1L << 6);
5933 else if (rep.reported & XkbGBN_GeometryMask(1L << 6)) {
5934 grep.type = X_Reply1;
5935 grep.deviceID = dev->id;
5936 grep.sequenceNumber = client->sequence;
5937 grep.length = 0;
5938 grep.found = TRUE1;
5939 grep.pad = 0;
5940 grep.widthMM = grep.heightMM = 0;
5941 grep.nProperties = grep.nColors = grep.nShapes = 0;
5942 grep.nSections = grep.nDoodads = 0;
5943 grep.baseColorNdx = grep.labelColorNdx = 0;
5944 XkbComputeGetGeometryReplySize(new->geom, &grep, None0L);
5945 rep.length += SIZEOF(xGenericReply)32 / 4 + grep.length;
5946 }
5947 }
5948
5949 reported = rep.reported;
5950 if (client->swapped) {
5951 swaps(&rep.sequenceNumber)do { if (sizeof(*(&rep.sequenceNumber)) != 2) wrong_size(
); if (__builtin_constant_p((uintptr_t)(&rep.sequenceNumber
) & 1) && ((uintptr_t)(&rep.sequenceNumber) &
1) == 0) *(&rep.sequenceNumber) = lswaps(*(&rep.sequenceNumber
)); else swap_uint16((uint16_t *)(&rep.sequenceNumber)); }
while (0)
;
5952 swapl(&rep.length)do { if (sizeof(*(&rep.length)) != 4) wrong_size(); if (__builtin_constant_p
((uintptr_t)(&rep.length) & 3) && ((uintptr_t
)(&rep.length) & 3) == 0) *(&rep.length) = lswapl
(*(&rep.length)); else swap_uint32((uint32_t *)(&rep.
length)); } while (0)
;
5953 swaps(&rep.found)do { if (sizeof(*(&rep.found)) != 2) wrong_size(); if (__builtin_constant_p
((uintptr_t)(&rep.found) & 1) && ((uintptr_t)
(&rep.found) & 1) == 0) *(&rep.found) = lswaps(*(
&rep.found)); else swap_uint16((uint16_t *)(&rep.found
)); } while (0)
;
5954 swaps(&rep.reported)do { if (sizeof(*(&rep.reported)) != 2) wrong_size(); if (
__builtin_constant_p((uintptr_t)(&rep.reported) & 1) &&
((uintptr_t)(&rep.reported) & 1) == 0) *(&rep.reported
) = lswaps(*(&rep.reported)); else swap_uint16((uint16_t *
)(&rep.reported)); } while (0)
;
5955 }
5956 WriteToClient(client, SIZEOF(xkbGetKbdByNameReply)32, &rep);
5957 if (reported & (XkbGBN_SymbolsMask((1L << 2)|(1L << 3)) | XkbGBN_TypesMask(1L << 0)))
5958 XkbSendMap(client, new, &mrep);
5959 if (reported & XkbGBN_CompatMapMask(1L << 1))
5960 XkbSendCompatMap(client, new->compat, &crep);
5961 if (reported & XkbGBN_IndicatorMapMask(1L << 4))
5962 XkbSendIndicatorMap(client, new->indicators, &irep);
5963 if (reported & (XkbGBN_KeyNamesMask(1L << 5) | XkbGBN_OtherNamesMask(1L << 7)))
5964 XkbSendNames(client, new, &nrep);
5965 if (reported & XkbGBN_GeometryMask(1L << 6))
5966 XkbSendGeometry(client, new->geom, &grep, FALSE0);
5967 if (rep.loaded) {
5968 XkbDescPtr old_xkb;
5969 xkbNewKeyboardNotify nkn;
5970
5971 old_xkb = xkb;
5972 xkb = new;
5973 dev->key->xkbInfo->desc = xkb;
5974 new = old_xkb; /* so it'll get freed automatically */
5975
5976 XkbCopyControls(xkb, old_xkb);
5977
5978 nkn.deviceID = nkn.oldDeviceID = dev->id;
5979 nkn.minKeyCode = new->min_key_code;
5980 nkn.maxKeyCode = new->max_key_code;
5981 nkn.oldMinKeyCode = xkb->min_key_code;
5982 nkn.oldMaxKeyCode = xkb->max_key_code;
5983 nkn.requestMajor = XkbReqCode;
5984 nkn.requestMinor = X_kbGetKbdByName23;
5985 nkn.changed = XkbNKN_KeycodesMask(1L << 0);
5986 if (geom_changed)
5987 nkn.changed |= XkbNKN_GeometryMask(1L << 1);
5988 XkbSendNewKeyboardNotify(dev, &nkn);
5989
5990 /* Update the map and LED info on the device itself, as well as
5991 * any slaves if it's an MD, or its MD if it's an SD and was the
5992 * last device used on that MD. */
5993 for (tmpd = inputInfo.devices; tmpd; tmpd = tmpd->next) {
5994 if (tmpd != dev && GetMaster(tmpd, MASTER_KEYBOARD2) != dev &&
5995 (tmpd != master || dev != master->lastSlave))
5996 continue;
5997
5998 if (tmpd != dev)
5999 XkbDeviceApplyKeymap(tmpd, xkb);
6000
6001 if (tmpd->kbdfeed && tmpd->kbdfeed->xkb_sli) {
6002 old_sli = tmpd->kbdfeed->xkb_sli;
6003 tmpd->kbdfeed->xkb_sli = NULL((void*)0);
6004 sli = XkbAllocSrvLedInfo(tmpd, tmpd->kbdfeed, NULL((void*)0), 0);
6005 if (sli) {
6006 sli->explicitState = old_sli->explicitState;
6007 sli->effectiveState = old_sli->effectiveState;
6008 }
6009 tmpd->kbdfeed->xkb_sli = sli;
6010 XkbFreeSrvLedInfo(old_sli);
6011 }
6012 }
6013 }
6014 if ((new != NULL((void*)0)) && (new != xkb)) {
6015 XkbFreeKeyboardSrvXkbFreeKeyboard(new, XkbAllComponentsMask(0x7f), TRUE1);
6016 new = NULL((void*)0);
6017 }
6018 XkbFreeComponentNames(&names, FALSE0);
6019 XkbUpdateAllDeviceIndicators(NULL((void*)0), NULL((void*)0));
6020
6021 return Success0;
6022}
6023
6024/***====================================================================***/
6025
6026static int
6027ComputeDeviceLedInfoSize(DeviceIntPtr dev,
6028 unsigned int what, XkbSrvLedInfoPtr sli)
6029{
6030 int nNames, nMaps;
6031 register unsigned n, bit;
6032
6033 if (sli == NULL((void*)0))
6034 return 0;
6035 nNames = nMaps = 0;
6036 if ((what & XkbXI_IndicatorNamesMask(1L << 2)) == 0)
6037 sli->namesPresent = 0;
6038 if ((what & XkbXI_IndicatorMapsMask(1L << 3)) == 0)
6039 sli->mapsPresent = 0;
6040
6041 for (n = 0, bit = 1; n < XkbNumIndicators32; n++, bit <<= 1) {
6042 if (sli->names && sli->names[n] != None0L) {
6043 sli->namesPresent |= bit;
6044 nNames++;
6045 }
6046 if (sli->maps && XkbIM_InUse(&sli->maps[n])((&sli->maps[n])->flags || (&sli->maps[n])->
which_groups || (&sli->maps[n])->which_mods || (&
sli->maps[n])->ctrls)
) {
6047 sli->mapsPresent |= bit;
6048 nMaps++;
6049 }
6050 }
6051 return (nNames * 4) + (nMaps * SIZEOF(xkbIndicatorMapWireDesc)12);
6052}
6053
6054static int
6055CheckDeviceLedFBs(DeviceIntPtr dev,
6056 int class,
6057 int id, xkbGetDeviceInfoReply * rep, ClientPtr client)
6058{
6059 int nFBs = 0;
6060 int length = 0;
6061 Bool classOk;
6062
6063 if (class == XkbDfltXIClass0x0300) {
6064 if (dev->kbdfeed)
6065 class = KbdFeedbackClass0;
6066 else if (dev->leds)
6067 class = LedFeedbackClass4;
6068 else {
6069 client->errorValue = _XkbErrCode2(XkbErr_BadClass, class)((XID)((((unsigned int)(0xfe))<<24)|((class)&0xffffff
)))
;
6070 return XkbKeyboardErrorCode;
6071 }
6072 }
6073 classOk = FALSE0;
6074 if ((dev->kbdfeed) &&
6075 ((class == KbdFeedbackClass0) || (class == XkbAllXIClasses0x0500))) {
6076 KbdFeedbackPtr kf;
6077
6078 classOk = TRUE1;
6079 for (kf = dev->kbdfeed; (kf); kf = kf->next) {
6080 if ((id != XkbAllXIIds0x0600) && (id != XkbDfltXIId0x0400) &&
6081 (id != kf->ctrl.id))
6082 continue;
6083 nFBs++;
6084 length += SIZEOF(xkbDeviceLedsWireDesc)20;
6085 if (!kf->xkb_sli)
6086 kf->xkb_sli = XkbAllocSrvLedInfo(dev, kf, NULL((void*)0), 0);
6087 length += ComputeDeviceLedInfoSize(dev, rep->present, kf->xkb_sli);
6088 if (id != XkbAllXIIds0x0600)
6089 break;
6090 }
6091 }
6092 if ((dev->leds) &&
6093 ((class == LedFeedbackClass4) || (class == XkbAllXIClasses0x0500))) {
6094 LedFeedbackPtr lf;
6095
6096 classOk = TRUE1;
6097 for (lf = dev->leds; (lf); lf = lf->next) {
6098 if ((id != XkbAllXIIds0x0600) && (id != XkbDfltXIId0x0400) &&
6099 (id != lf->ctrl.id))
6100 continue;
6101 nFBs++;
6102 length += SIZEOF(xkbDeviceLedsWireDesc)20;
6103 if (!lf->xkb_sli)
6104 lf->xkb_sli = XkbAllocSrvLedInfo(dev, NULL((void*)0), lf, 0);
6105 length += ComputeDeviceLedInfoSize(dev, rep->present, lf->xkb_sli);
6106 if (id != XkbAllXIIds0x0600)
6107 break;
6108 }
6109 }
6110 if (nFBs > 0) {
6111 rep->nDeviceLedFBs = nFBs;
6112 rep->length += (length / 4);
6113 return Success0;
6114 }
6115 if (classOk)
6116 client->errorValue = _XkbErrCode2(XkbErr_BadId, id)((XID)((((unsigned int)(0xfd))<<24)|((id)&0xffffff)
))
;
6117 else
6118 client->errorValue = _XkbErrCode2(XkbErr_BadClass, class)((XID)((((unsigned int)(0xfe))<<24)|((class)&0xffffff
)))
;
6119 return XkbKeyboardErrorCode;
6120}
6121
6122static int
6123SendDeviceLedInfo(XkbSrvLedInfoPtr sli, ClientPtr client)
6124{
6125 xkbDeviceLedsWireDesc wire;
6126 int length;
6127
6128 length = 0;
6129 wire.ledClass = sli->class;
6130 wire.ledID = sli->id;
6131 wire.namesPresent = sli->namesPresent;
6132 wire.mapsPresent = sli->mapsPresent;
6133 wire.physIndicators = sli->physIndicators;
6134 wire.state = sli->effectiveState;
6135 if (client->swapped) {
6136 swaps(&wire.ledClass)do { if (sizeof(*(&wire.ledClass)) != 2) wrong_size(); if
(__builtin_constant_p((uintptr_t)(&wire.ledClass) & 1
) && ((uintptr_t)(&wire.ledClass) & 1) == 0) *
(&wire.ledClass) = lswaps(*(&wire.ledClass)); else swap_uint16
((uint16_t *)(&wire.ledClass)); } while (0)
;
6137 swaps(&wire.ledID)do { if (sizeof(*(&wire.ledID)) != 2) wrong_size(); if (__builtin_constant_p
((uintptr_t)(&wire.ledID) & 1) && ((uintptr_t
)(&wire.ledID) & 1) == 0) *(&wire.ledID) = lswaps
(*(&wire.ledID)); else swap_uint16((uint16_t *)(&wire
.ledID)); } while (0)
;
6138 swapl(&wire.namesPresent)do { if (sizeof(*(&wire.namesPresent)) != 4) wrong_size()
; if (__builtin_constant_p((uintptr_t)(&wire.namesPresent
) & 3) && ((uintptr_t)(&wire.namesPresent) &
3) == 0) *(&wire.namesPresent) = lswapl(*(&wire.namesPresent
)); else swap_uint32((uint32_t *)(&wire.namesPresent)); }
while (0)
;
6139 swapl(&wire.mapsPresent)do { if (sizeof(*(&wire.mapsPresent)) != 4) wrong_size();
if (__builtin_constant_p((uintptr_t)(&wire.mapsPresent) &
3) && ((uintptr_t)(&wire.mapsPresent) & 3) ==
0) *(&wire.mapsPresent) = lswapl(*(&wire.mapsPresent
)); else swap_uint32((uint32_t *)(&wire.mapsPresent)); } while
(0)
;
6140 swapl(&wire.physIndicators)do { if (sizeof(*(&wire.physIndicators)) != 4) wrong_size
(); if (__builtin_constant_p((uintptr_t)(&wire.physIndicators
) & 3) && ((uintptr_t)(&wire.physIndicators) &
3) == 0) *(&wire.physIndicators) = lswapl(*(&wire.physIndicators
)); else swap_uint32((uint32_t *)(&wire.physIndicators));
} while (0)
;
6141 swapl(&wire.state)do { if (sizeof(*(&wire.state)) != 4) wrong_size(); if (__builtin_constant_p
((uintptr_t)(&wire.state) & 3) && ((uintptr_t
)(&wire.state) & 3) == 0) *(&wire.state) = lswapl
(*(&wire.state)); else swap_uint32((uint32_t *)(&wire
.state)); } while (0)
;
6142 }
6143 WriteToClient(client, SIZEOF(xkbDeviceLedsWireDesc)20, &wire);
6144 length += SIZEOF(xkbDeviceLedsWireDesc)20;
6145 if (sli->namesPresent | sli->mapsPresent) {
6146 register unsigned i, bit;
6147
6148 if (sli->namesPresent) {
6149 CARD32 awire;
6150
6151 for (i = 0, bit = 1; i < XkbNumIndicators32; i++, bit <<= 1) {
6152 if (sli->namesPresent & bit) {
6153 awire = (CARD32) sli->names[i];
6154 if (client->swapped) {
6155 swapl(&awire)do { if (sizeof(*(&awire)) != 4) wrong_size(); if (__builtin_constant_p
((uintptr_t)(&awire) & 3) && ((uintptr_t)(&
awire) & 3) == 0) *(&awire) = lswapl(*(&awire)); else
swap_uint32((uint32_t *)(&awire)); } while (0)
;
6156 }
6157 WriteToClient(client, 4, &awire);
6158 length += 4;
6159 }
6160 }
6161 }
6162 if (sli->mapsPresent) {
6163 for (i = 0, bit = 1; i < XkbNumIndicators32; i++, bit <<= 1) {
6164 xkbIndicatorMapWireDesc iwire;
6165
6166 if (sli->mapsPresent & bit) {
6167 iwire.flags = sli->maps[i].flags;
6168 iwire.whichGroups = sli->maps[i].which_groups;
6169 iwire.groups = sli->maps[i].groups;
6170 iwire.whichMods = sli->maps[i].which_mods;
6171 iwire.mods = sli->maps[i].mods.mask;
6172 iwire.realMods = sli->maps[i].mods.real_mods;
6173 iwire.virtualMods = sli->maps[i].mods.vmods;
6174 iwire.ctrls = sli->maps[i].ctrls;
6175 if (client->swapped) {
6176 swaps(&iwire.virtualMods)do { if (sizeof(*(&iwire.virtualMods)) != 2) wrong_size()
; if (__builtin_constant_p((uintptr_t)(&iwire.virtualMods
) & 1) && ((uintptr_t)(&iwire.virtualMods) &
1) == 0) *(&iwire.virtualMods) = lswaps(*(&iwire.virtualMods
)); else swap_uint16((uint16_t *)(&iwire.virtualMods)); }
while (0)
;
6177 swapl(&iwire.ctrls)do { if (sizeof(*(&iwire.ctrls)) != 4) wrong_size(); if (
__builtin_constant_p((uintptr_t)(&iwire.ctrls) & 3) &&
((uintptr_t)(&iwire.ctrls) & 3) == 0) *(&iwire.ctrls
) = lswapl(*(&iwire.ctrls)); else swap_uint32((uint32_t *
)(&iwire.ctrls)); } while (0)
;
6178 }
6179 WriteToClient(client, SIZEOF(xkbIndicatorMapWireDesc)12,
6180 &iwire);
6181 length += SIZEOF(xkbIndicatorMapWireDesc)12;
6182 }
6183 }
6184 }
6185 }
6186 return length;
6187}
6188
6189static int
6190SendDeviceLedFBs(DeviceIntPtr dev,
6191 int class, int id, unsigned wantLength, ClientPtr client)
6192{
6193 int length = 0;
6194
6195 if (class == XkbDfltXIClass0x0300) {
6196 if (dev->kbdfeed)
6197 class = KbdFeedbackClass0;
6198 else if (dev->leds)
6199 class = LedFeedbackClass4;
6200 }
6201 if ((dev->kbdfeed) &&
6202 ((class == KbdFeedbackClass0) || (class == XkbAllXIClasses0x0500))) {
6203 KbdFeedbackPtr kf;
6204
6205 for (kf = dev->kbdfeed; (kf); kf = kf->next) {
6206 if ((id == XkbAllXIIds0x0600) || (id == XkbDfltXIId0x0400) ||
6207 (id == kf->ctrl.id)) {
6208 length += SendDeviceLedInfo(kf->xkb_sli, client);
6209 if (id != XkbAllXIIds0x0600)
6210 break;
6211 }
6212 }
6213 }
6214 if ((dev->leds) &&
6215 ((class == LedFeedbackClass4) || (class == XkbAllXIClasses0x0500))) {
6216 LedFeedbackPtr lf;
6217
6218 for (lf = dev->leds; (lf); lf = lf->next) {
6219 if ((id == XkbAllXIIds0x0600) || (id == XkbDfltXIId0x0400) ||
6220 (id == lf->ctrl.id)) {
6221 length += SendDeviceLedInfo(lf->xkb_sli, client);
6222 if (id != XkbAllXIIds0x0600)
6223 break;
6224 }
6225 }
6226 }
6227 if (length == wantLength)
6228 return Success0;
6229 else
6230 return BadLength16;
6231}
6232
6233int
6234ProcXkbGetDeviceInfo(ClientPtr client)
6235{
6236 DeviceIntPtr dev;
6237 xkbGetDeviceInfoReply rep;
6238 int status, nDeviceLedFBs;
6239 unsigned length, nameLen;
6240 CARD16 ledClass, ledID;
6241 unsigned wanted;
6242 char *str;
6243
6244 REQUEST(xkbGetDeviceInfoReq)xkbGetDeviceInfoReq *stuff = (xkbGetDeviceInfoReq *)client->
requestBuffer
;
6245 REQUEST_SIZE_MATCH(xkbGetDeviceInfoReq)if ((sizeof(xkbGetDeviceInfoReq) >> 2) != client->req_len
) return(16)
;
6246
6247 if (!(client->xkbClientFlags & _XkbClientInitialized(1<<15)))
6248 return BadAccess10;
6249
6250 wanted = stuff->wanted;
6251
6252 CHK_ANY_DEVICE(dev, stuff->deviceSpec, client, DixGetAttrAccess){ int why; int tmprc = _XkbLookupAnyDevice(&(dev), stuff->
deviceSpec, client, (1<<4), &why); if (tmprc != 0) {
client->errorValue = ((XID)((((unsigned int)(why))<<
24)|((stuff->deviceSpec)&0xffffff))); return tmprc; }}
;
6253 CHK_MASK_LEGAL(0x01, wanted, XkbXI_AllDeviceFeaturesMask){ if ((wanted)&(~((0x001e)))) { (client->errorValue)= (
(XID)((((unsigned int)((0x01)))<<24)|((((wanted)&(~
((0x001e)))))&0xffffff))); return 2; }}
;
6254
6255 if ((!dev->button) || ((stuff->nBtns < 1) && (!stuff->allBtns)))
6256 wanted &= ~XkbXI_ButtonActionsMask(1L << 1);
6257 if ((!dev->kbdfeed) && (!dev->leds))
6258 wanted &= ~XkbXI_IndicatorsMask(0x001c);
6259
6260 nameLen = XkbSizeCountedString(dev->name)((dev->name)?((((2+strlen(dev->name))+3)/4)*4):4);
6261 rep = (xkbGetDeviceInfoReply) {
6262 .type = X_Reply1,
6263 .deviceID = dev->id,
6264 .sequenceNumber = client->sequence,
6265 .length = nameLen / 4,
6266 .present = wanted,
6267 .supported = XkbXI_AllDeviceFeaturesMask(0x001e),
6268 .unsupported = 0,
6269 .nDeviceLedFBs = 0,
6270 .firstBtnWanted = 0,
6271 .nBtnsWanted = 0,
6272 .firstBtnRtrn = 0,
6273 .nBtnsRtrn = 0,
6274 .totalBtns = dev->button ? dev->button->numButtons : 0,
6275 .hasOwnState = (dev->key && dev->key->xkbInfo),
6276 .dfltKbdFB = dev->kbdfeed ? dev->kbdfeed->ctrl.id : XkbXINone0xff00,
6277 .dfltLedFB = dev->leds ? dev->leds->ctrl.id : XkbXINone0xff00,
6278 .devType = dev->xinput_type
6279 };
6280
6281 ledClass = stuff->ledClass;
6282 ledID = stuff->ledID;
6283
6284 if (wanted & XkbXI_ButtonActionsMask(1L << 1)) {
6285 if (stuff->allBtns) {
6286 stuff->firstBtn = 0;
6287 stuff->nBtns = dev->button->numButtons;
6288 }
6289
6290 if ((stuff->firstBtn + stuff->nBtns) > dev->button->numButtons) {
6291 client->errorValue = _XkbErrCode4(0x02, dev->button->numButtons,((XID)((((unsigned int)(0x02))<<24)|(((((unsigned int)(
dev->button->numButtons))<<16)|(((((unsigned int)
(stuff->firstBtn))<<8)|(stuff->nBtns))))&0xffffff
)))
6292 stuff->firstBtn, stuff->nBtns)((XID)((((unsigned int)(0x02))<<24)|(((((unsigned int)(
dev->button->numButtons))<<16)|(((((unsigned int)
(stuff->firstBtn))<<8)|(stuff->nBtns))))&0xffffff
)))
;
6293 return BadValue2;
6294 }
6295 else {
6296 rep.firstBtnWanted = stuff->firstBtn;
6297 rep.nBtnsWanted = stuff->nBtns;
6298 if (dev->button->xkb_acts != NULL((void*)0)) {
6299 XkbAction *act;
6300 register int i;
6301
6302 rep.firstBtnRtrn = stuff->firstBtn;
6303 rep.nBtnsRtrn = stuff->nBtns;
6304 act = &dev->button->xkb_acts[rep.firstBtnWanted];
6305 for (i = 0; i < rep.nBtnsRtrn; i++, act++) {
6306 if (act->type != XkbSA_NoAction0x00)
6307 break;
6308 }
6309 rep.firstBtnRtrn += i;
6310 rep.nBtnsRtrn -= i;
6311 act =
6312 &dev->button->xkb_acts[rep.firstBtnRtrn + rep.nBtnsRtrn -
6313 1];
6314 for (i = 0; i < rep.nBtnsRtrn; i++, act--) {
6315 if (act->type != XkbSA_NoAction0x00)
6316 break;
6317 }
6318 rep.nBtnsRtrn -= i;
6319 }
6320 rep.length += (rep.nBtnsRtrn * SIZEOF(xkbActionWireDesc)8) / 4;
6321 }
6322 }
6323
6324 if (wanted & XkbXI_IndicatorsMask(0x001c)) {
6325 status = CheckDeviceLedFBs(dev, ledClass, ledID, &rep, client);
6326 if (status != Success0)
6327 return status;
6328 }
6329 length = rep.length * 4;
6330 nDeviceLedFBs = rep.nDeviceLedFBs;
6331 if (client->swapped) {
6332 swaps(&rep.sequenceNumber)do { if (sizeof(*(&rep.sequenceNumber)) != 2) wrong_size(
); if (__builtin_constant_p((uintptr_t)(&rep.sequenceNumber
) & 1) && ((uintptr_t)(&rep.sequenceNumber) &
1) == 0) *(&rep.sequenceNumber) = lswaps(*(&rep.sequenceNumber
)); else swap_uint16((uint16_t *)(&rep.sequenceNumber)); }
while (0)
;
6333 swapl(&rep.length)do { if (sizeof(*(&rep.length)) != 4) wrong_size(); if (__builtin_constant_p
((uintptr_t)(&rep.length) & 3) && ((uintptr_t
)(&rep.length) & 3) == 0) *(&rep.length) = lswapl
(*(&rep.length)); else swap_uint32((uint32_t *)(&rep.
length)); } while (0)
;
6334 swaps(&rep.present)do { if (sizeof(*(&rep.present)) != 2) wrong_size(); if (
__builtin_constant_p((uintptr_t)(&rep.present) & 1) &&
((uintptr_t)(&rep.present) & 1) == 0) *(&rep.present
) = lswaps(*(&rep.present)); else swap_uint16((uint16_t *
)(&rep.present)); } while (0)
;
6335 swaps(&rep.supported)do { if (sizeof(*(&rep.supported)) != 2) wrong_size(); if
(__builtin_constant_p((uintptr_t)(&rep.supported) & 1
) && ((uintptr_t)(&rep.supported) & 1) == 0) *
(&rep.supported) = lswaps(*(&rep.supported)); else swap_uint16
((uint16_t *)(&rep.supported)); } while (0)
;
6336 swaps(&rep.unsupported)do { if (sizeof(*(&rep.unsupported)) != 2) wrong_size(); if
(__builtin_constant_p((uintptr_t)(&rep.unsupported) &
1) && ((uintptr_t)(&rep.unsupported) & 1) ==
0) *(&rep.unsupported) = lswaps(*(&rep.unsupported))
; else swap_uint16((uint16_t *)(&rep.unsupported)); } while
(0)
;
6337 swaps(&rep.nDeviceLedFBs)do { if (sizeof(*(&rep.nDeviceLedFBs)) != 2) wrong_size()
; if (__builtin_constant_p((uintptr_t)(&rep.nDeviceLedFBs
) & 1) && ((uintptr_t)(&rep.nDeviceLedFBs) &
1) == 0) *(&rep.nDeviceLedFBs) = lswaps(*(&rep.nDeviceLedFBs
)); else swap_uint16((uint16_t *)(&rep.nDeviceLedFBs)); }
while (0)
;
6338 swaps(&rep.dfltKbdFB)do { if (sizeof(*(&rep.dfltKbdFB)) != 2) wrong_size(); if
(__builtin_constant_p((uintptr_t)(&rep.dfltKbdFB) & 1
) && ((uintptr_t)(&rep.dfltKbdFB) & 1) == 0) *
(&rep.dfltKbdFB) = lswaps(*(&rep.dfltKbdFB)); else swap_uint16
((uint16_t *)(&rep.dfltKbdFB)); } while (0)
;
6339 swaps(&rep.dfltLedFB)do { if (sizeof(*(&rep.dfltLedFB)) != 2) wrong_size(); if
(__builtin_constant_p((uintptr_t)(&rep.dfltLedFB) & 1
) && ((uintptr_t)(&rep.dfltLedFB) & 1) == 0) *
(&rep.dfltLedFB) = lswaps(*(&rep.dfltLedFB)); else swap_uint16
((uint16_t *)(&rep.dfltLedFB)); } while (0)
;
6340 swapl(&rep.devType)do { if (sizeof(*(&rep.devType)) != 4) wrong_size(); if (
__builtin_constant_p((uintptr_t)(&rep.devType) & 3) &&
((uintptr_t)(&rep.devType) & 3) == 0) *(&rep.devType
) = lswapl(*(&rep.devType)); else swap_uint32((uint32_t *
)(&rep.devType)); } while (0)
;
6341 }
6342 WriteToClient(client, SIZEOF(xkbGetDeviceInfoReply)32, &rep);
6343
6344 str = malloc(nameLen);
6345 if (!str)
6346 return BadAlloc11;
6347 XkbWriteCountedString(str, dev->name, client->swapped);
6348 WriteToClient(client, nameLen, str);
6349 free(str);
6350 length -= nameLen;
6351
6352 if (rep.nBtnsRtrn > 0) {
6353 int sz;
6354 xkbActionWireDesc *awire;
6355
6356 sz = rep.nBtnsRtrn * SIZEOF(xkbActionWireDesc)8;
6357 awire = (xkbActionWireDesc *) &dev->button->xkb_acts[rep.firstBtnRtrn];
6358 WriteToClient(client, sz, awire);
6359 length -= sz;
6360 }
6361 if (nDeviceLedFBs > 0) {
6362 status = SendDeviceLedFBs(dev, ledClass, ledID, length, client);
6363 if (status != Success0)
6364 return status;
6365 }
6366 else if (length != 0) {
6367 ErrorF("[xkb] Internal Error! BadLength in ProcXkbGetDeviceInfo\n");
6368 ErrorF("[xkb] Wrote %d fewer bytes than expected\n",
6369 length);
6370 return BadLength16;
6371 }
6372 return Success0;
6373}
6374
6375static char *
6376CheckSetDeviceIndicators(char *wire,
6377 DeviceIntPtr dev,
6378 int num, int *status_rtrn, ClientPtr client)
6379{
6380 xkbDeviceLedsWireDesc *ledWire;
6381 int i;
6382 XkbSrvLedInfoPtr sli;
6383
6384 ledWire = (xkbDeviceLedsWireDesc *) wire;
6385 for (i = 0; i < num; i++) {
6386 if (client->swapped) {
6387 swaps(&ledWire->ledClass)do { if (sizeof(*(&ledWire->ledClass)) != 2) wrong_size
(); if (__builtin_constant_p((uintptr_t)(&ledWire->ledClass
) & 1) && ((uintptr_t)(&ledWire->ledClass)
& 1) == 0) *(&ledWire->ledClass) = lswaps(*(&
ledWire->ledClass)); else swap_uint16((uint16_t *)(&ledWire
->ledClass)); } while (0)
;
6388 swaps(&ledWire->ledID)do { if (sizeof(*(&ledWire->ledID)) != 2) wrong_size()
; if (__builtin_constant_p((uintptr_t)(&ledWire->ledID
) & 1) && ((uintptr_t)(&ledWire->ledID) &
1) == 0) *(&ledWire->ledID) = lswaps(*(&ledWire->
ledID)); else swap_uint16((uint16_t *)(&ledWire->ledID
)); } while (0)
;
6389 swapl(&ledWire->namesPresent)do { if (sizeof(*(&ledWire->namesPresent)) != 4) wrong_size
(); if (__builtin_constant_p((uintptr_t)(&ledWire->namesPresent
) & 3) && ((uintptr_t)(&ledWire->namesPresent
) & 3) == 0) *(&ledWire->namesPresent) = lswapl(*(
&ledWire->namesPresent)); else swap_uint32((uint32_t *
)(&ledWire->namesPresent)); } while (0)
;
6390 swapl(&ledWire->mapsPresent)do { if (sizeof(*(&ledWire->mapsPresent)) != 4) wrong_size
(); if (__builtin_constant_p((uintptr_t)(&ledWire->mapsPresent
) & 3) && ((uintptr_t)(&ledWire->mapsPresent
) & 3) == 0) *(&ledWire->mapsPresent) = lswapl(*(&
ledWire->mapsPresent)); else swap_uint32((uint32_t *)(&
ledWire->mapsPresent)); } while (0)
;
6391 swapl(&ledWire->physIndicators)do { if (sizeof(*(&ledWire->physIndicators)) != 4) wrong_size
(); if (__builtin_constant_p((uintptr_t)(&ledWire->physIndicators
) & 3) && ((uintptr_t)(&ledWire->physIndicators
) & 3) == 0) *(&ledWire->physIndicators) = lswapl(
*(&ledWire->physIndicators)); else swap_uint32((uint32_t
*)(&ledWire->physIndicators)); } while (0)
;
6392 }
6393
6394 sli = XkbFindSrvLedInfo(dev, ledWire->ledClass, ledWire->ledID,
6395 XkbXI_IndicatorsMask(0x001c));
6396 if (sli != NULL((void*)0)) {
6397 register int n;
6398 register unsigned bit;
6399 int nMaps, nNames;
6400 CARD32 *atomWire;
6401 xkbIndicatorMapWireDesc *mapWire;
6402
6403 nMaps = nNames = 0;
6404 for (n = 0, bit = 1; n < XkbNumIndicators32; n++, bit <<= 1) {
6405 if (ledWire->namesPresent & bit)
6406 nNames++;
6407 if (ledWire->mapsPresent & bit)
6408 nMaps++;
6409 }
6410 atomWire = (CARD32 *) &ledWire[1];
6411 if (nNames > 0) {
6412 for (n = 0; n < nNames; n++) {
6413 if (client->swapped) {
6414 swapl(atomWire)do { if (sizeof(*(atomWire)) != 4) wrong_size(); if (__builtin_constant_p
((uintptr_t)(atomWire) & 3) && ((uintptr_t)(atomWire
) & 3) == 0) *(atomWire) = lswapl(*(atomWire)); else swap_uint32
((uint32_t *)(atomWire)); } while (0)
;
6415 }
6416 CHK_ATOM_OR_NONE3(((Atom) (*atomWire)), client->errorValue,{ if (((((Atom) (*atomWire)))!=0L)&&(!ValidAtom((((Atom
) (*atomWire)))))) { (client->errorValue)= (XID)(((Atom) (
*atomWire))); (*status_rtrn)= 5; return ((void*)0); }}
6417 *status_rtrn, NULL){ if (((((Atom) (*atomWire)))!=0L)&&(!ValidAtom((((Atom
) (*atomWire)))))) { (client->errorValue)= (XID)(((Atom) (
*atomWire))); (*status_rtrn)= 5; return ((void*)0); }}
;
6418 atomWire++;
6419 }
6420 }
6421 mapWire = (xkbIndicatorMapWireDesc *) atomWire;
6422 if (nMaps > 0) {
6423 for (n = 0; n < nMaps; n++) {
6424 if (client->swapped) {
6425 swaps(&mapWire->virtualMods)do { if (sizeof(*(&mapWire->virtualMods)) != 2) wrong_size
(); if (__builtin_constant_p((uintptr_t)(&mapWire->virtualMods
) & 1) && ((uintptr_t)(&mapWire->virtualMods
) & 1) == 0) *(&mapWire->virtualMods) = lswaps(*(&
mapWire->virtualMods)); else swap_uint16((uint16_t *)(&
mapWire->virtualMods)); } while (0)
;
6426 swapl(&mapWire->ctrls)do { if (sizeof(*(&mapWire->ctrls)) != 4) wrong_size()
; if (__builtin_constant_p((uintptr_t)(&mapWire->ctrls
) & 3) && ((uintptr_t)(&mapWire->ctrls) &
3) == 0) *(&mapWire->ctrls) = lswapl(*(&mapWire->
ctrls)); else swap_uint32((uint32_t *)(&mapWire->ctrls
)); } while (0)
;
6427 }
6428 CHK_MASK_LEGAL3(0x21, mapWire->whichGroups,{ if ((mapWire->whichGroups)&(~(((1L << 0)|(1L <<
1)|(1L << 2) |(1L << 3))))) { (client->errorValue
)= ((XID)((((unsigned int)((0x21)))<<24)|((((mapWire->
whichGroups)&(~(((1L << 0)|(1L << 1)|(1L <<
2) |(1L << 3))))))&0xffffff))); (*status_rtrn)= 2;
return ((void*)0); }}
6429 XkbIM_UseAnyGroup,{ if ((mapWire->whichGroups)&(~(((1L << 0)|(1L <<
1)|(1L << 2) |(1L << 3))))) { (client->errorValue
)= ((XID)((((unsigned int)((0x21)))<<24)|((((mapWire->
whichGroups)&(~(((1L << 0)|(1L << 1)|(1L <<
2) |(1L << 3))))))&0xffffff))); (*status_rtrn)= 2;
return ((void*)0); }}
6430 client->errorValue, *status_rtrn, NULL){ if ((mapWire->whichGroups)&(~(((1L << 0)|(1L <<
1)|(1L << 2) |(1L << 3))))) { (client->errorValue
)= ((XID)((((unsigned int)((0x21)))<<24)|((((mapWire->
whichGroups)&(~(((1L << 0)|(1L << 1)|(1L <<
2) |(1L << 3))))))&0xffffff))); (*status_rtrn)= 2;
return ((void*)0); }}
;
6431 CHK_MASK_LEGAL3(0x22, mapWire->whichMods, XkbIM_UseAnyMods,{ if ((mapWire->whichMods)&(~((((1L << 0)|(1L <<
1)|(1L << 2) |(1L << 3))|(1L << 4))))) { (
client->errorValue)= ((XID)((((unsigned int)((0x22)))<<
24)|((((mapWire->whichMods)&(~((((1L << 0)|(1L <<
1)|(1L << 2) |(1L << 3))|(1L << 4))))))&
0xffffff))); (*status_rtrn)= 2; return ((void*)0); }}
6432 client->errorValue, *status_rtrn, NULL){ if ((mapWire->whichMods)&(~((((1L << 0)|(1L <<
1)|(1L << 2) |(1L << 3))|(1L << 4))))) { (
client->errorValue)= ((XID)((((unsigned int)((0x22)))<<
24)|((((mapWire->whichMods)&(~((((1L << 0)|(1L <<
1)|(1L << 2) |(1L << 3))|(1L << 4))))))&
0xffffff))); (*status_rtrn)= 2; return ((void*)0); }}
;
6433 mapWire++;
6434 }
6435 }
6436 ledWire = (xkbDeviceLedsWireDesc *) mapWire;
6437 }
6438 else {
6439 /* SHOULD NEVER HAPPEN */
6440 return (char *) ledWire;
6441 }
6442 }
6443 return (char *) ledWire;
6444}
6445
6446static char *
6447SetDeviceIndicators(char *wire,
6448 DeviceIntPtr dev,
6449 unsigned changed,
6450 int num,
6451 int *status_rtrn,
6452 ClientPtr client, xkbExtensionDeviceNotify * ev)
6453{
6454 xkbDeviceLedsWireDesc *ledWire;
6455 int i;
6456 XkbEventCauseRec cause;
6457 unsigned namec, mapc, statec;
6458 xkbExtensionDeviceNotify ed;
6459 XkbChangesRec changes;
6460 DeviceIntPtr kbd;
6461
6462 memset((char *) &ed, 0, sizeof(xkbExtensionDeviceNotify))__builtin___memset_chk ((char *) &ed, 0, sizeof(xkbExtensionDeviceNotify
), __builtin_object_size ((char *) &ed, 0))
;
6463 memset((char *) &changes, 0, sizeof(XkbChangesRec))__builtin___memset_chk ((char *) &changes, 0, sizeof(XkbChangesRec
), __builtin_object_size ((char *) &changes, 0))
;
6464 XkbSetCauseXkbReq(&cause, X_kbSetDeviceInfo, client){ (&cause)->kc= (&cause)->event= 0, (&cause
)->mjr= (XkbReqCode),(&cause)->mnr= (25); (&cause
)->client= (client); }
;
6465 ledWire = (xkbDeviceLedsWireDesc *) wire;
6466 for (i = 0; i < num; i++) {
6467 register int n;
6468 register unsigned bit;
6469 CARD32 *atomWire;
6470 xkbIndicatorMapWireDesc *mapWire;
6471 XkbSrvLedInfoPtr sli;
6472
6473 namec = mapc = statec = 0;
6474 sli = XkbFindSrvLedInfo(dev, ledWire->ledClass, ledWire->ledID,
6475 XkbXI_IndicatorMapsMask(1L << 3));
6476 if (!sli) {
6477 /* SHOULD NEVER HAPPEN!! */
6478 return (char *) ledWire;
6479 }
6480
6481 atomWire = (CARD32 *) &ledWire[1];
6482 if (changed & XkbXI_IndicatorNamesMask(1L << 2)) {
6483 namec = sli->namesPresent | ledWire->namesPresent;
6484 memset((char *) sli->names, 0, XkbNumIndicators * sizeof(Atom))__builtin___memset_chk ((char *) sli->names, 0, 32 * sizeof
(Atom), __builtin_object_size ((char *) sli->names, 0))
;
6485 }
6486 if (ledWire->namesPresent) {
6487 sli->namesPresent = ledWire->namesPresent;
6488 memset((char *) sli->names, 0, XkbNumIndicators * sizeof(Atom))__builtin___memset_chk ((char *) sli->names, 0, 32 * sizeof
(Atom), __builtin_object_size ((char *) sli->names, 0))
;
6489 for (n = 0, bit = 1; n < XkbNumIndicators32; n++, bit <<= 1) {
6490 if (ledWire->namesPresent & bit) {
6491 sli->names[n] = (Atom) *atomWire;
6492 if (sli->names[n] == None0L)
6493 ledWire->namesPresent &= ~bit;
6494 atomWire++;
6495 }
6496 }
6497 }
6498 mapWire = (xkbIndicatorMapWireDesc *) atomWire;
6499 if (changed & XkbXI_IndicatorMapsMask(1L << 3)) {
6500 mapc = sli->mapsPresent | ledWire->mapsPresent;
6501 sli->mapsPresent = ledWire->mapsPresent;
6502 memset((char *) sli->maps, 0,__builtin___memset_chk ((char *) sli->maps, 0, 32 * sizeof
(XkbIndicatorMapRec), __builtin_object_size ((char *) sli->
maps, 0))
6503 XkbNumIndicators * sizeof(XkbIndicatorMapRec))__builtin___memset_chk ((char *) sli->maps, 0, 32 * sizeof
(XkbIndicatorMapRec), __builtin_object_size ((char *) sli->
maps, 0))
;
6504 }
6505 if (ledWire->mapsPresent) {
6506 for (n = 0, bit = 1; n < XkbNumIndicators32; n++, bit <<= 1) {
6507 if (ledWire->mapsPresent & bit) {
6508 sli->maps[n].flags = mapWire->flags;
6509 sli->maps[n].which_groups = mapWire->whichGroups;
6510 sli->maps[n].groups = mapWire->groups;
6511 sli->maps[n].which_mods = mapWire->whichMods;
6512 sli->maps[n].mods.mask = mapWire->mods;
6513 sli->maps[n].mods.real_mods = mapWire->realMods;
6514 sli->maps[n].mods.vmods = mapWire->virtualMods;
6515 sli->maps[n].ctrls = mapWire->ctrls;
6516 mapWire++;
6517 }
6518 }
6519 }
6520 if (changed & XkbXI_IndicatorStateMask(1L << 4)) {
6521 statec = sli->effectiveState ^ ledWire->state;
6522 sli->explicitState &= ~statec;
6523 sli->explicitState |= (ledWire->state & statec);
6524 }
6525 if (namec)
6526 XkbApplyLedNameChanges(dev, sli, namec, &ed, &changes, &cause);
6527 if (mapc)
6528 XkbApplyLedMapChanges(dev, sli, mapc, &ed, &changes, &cause);
6529 if (statec)
6530 XkbApplyLedStateChanges(dev, sli, statec, &ed, &changes, &cause);
6531
6532 kbd = dev;
6533 if ((sli->flags & XkbSLI_HasOwnState(1L<<1)) == 0)
6534 kbd = inputInfo.keyboard;
6535
6536 XkbFlushLedEvents(dev, kbd, sli, &ed, &changes, &cause);
6537 ledWire = (xkbDeviceLedsWireDesc *) mapWire;
6538 }
6539 return (char *) ledWire;
6540}
6541
6542static int
6543_XkbSetDeviceInfo(ClientPtr client, DeviceIntPtr dev,
6544 xkbSetDeviceInfoReq * stuff)
6545{
6546 char *wire;
6547
6548 wire = (char *) &stuff[1];
6549 if (stuff->change & XkbXI_ButtonActionsMask(1L << 1)) {
6550 if (!dev->button) {
6551 client->errorValue = _XkbErrCode2(XkbErr_BadClass, ButtonClass)((XID)((((unsigned int)(0xfe))<<24)|((1)&0xffffff))
)
;
6552 return XkbKeyboardErrorCode;
6553 }
6554 if ((stuff->firstBtn + stuff->nBtns) > dev->button->numButtons) {
6555 client->errorValue =
6556 _XkbErrCode4(0x02, stuff->firstBtn, stuff->nBtns,((XID)((((unsigned int)(0x02))<<24)|(((((unsigned int)(
stuff->firstBtn))<<16)|(((((unsigned int)(stuff->
nBtns))<<8)|(dev->button->numButtons))))&0xffffff
)))
6557 dev->button->numButtons)((XID)((((unsigned int)(0x02))<<24)|(((((unsigned int)(
stuff->firstBtn))<<16)|(((((unsigned int)(stuff->
nBtns))<<8)|(dev->button->numButtons))))&0xffffff
)))
;
6558 return BadMatch8;
6559 }
6560 wire += (stuff->nBtns * SIZEOF(xkbActionWireDesc)8);
6561 }
6562 if (stuff->change & XkbXI_IndicatorsMask(0x001c)) {
6563 int status = Success0;
6564
6565 wire = CheckSetDeviceIndicators(wire, dev, stuff->nDeviceLedFBs,
6566 &status, client);
6567 if (status != Success0)
6568 return status;
6569 }
6570 if (((wire - ((char *) stuff)) / 4) != stuff->length)
6571 return BadLength16;
6572
6573 return Success0;
6574}
6575
6576static int
6577_XkbSetDeviceInfoCheck(ClientPtr client, DeviceIntPtr dev,
6578 xkbSetDeviceInfoReq * stuff)
6579{
6580 char *wire;
6581 xkbExtensionDeviceNotify ed;
6582
6583 memset((char *) &ed, 0, SIZEOF(xkbExtensionDeviceNotify))__builtin___memset_chk ((char *) &ed, 0, 32, __builtin_object_size
((char *) &ed, 0))
;
6584 ed.deviceID = dev->id;
6585 wire = (char *) &stuff[1];
6586 if (stuff->change & XkbXI_ButtonActionsMask(1L << 1)) {
6587 int nBtns, sz, i;
6588 XkbAction *acts;
6589 DeviceIntPtr kbd;
6590
6591 nBtns = dev->button->numButtons;
6592 acts = dev->button->xkb_acts;
6593 if (acts == NULL((void*)0)) {
6594 acts = calloc(nBtns, sizeof(XkbAction));
6595 if (!acts)
6596 return BadAlloc11;
6597 dev->button->xkb_acts = acts;
6598 }
6599 sz = stuff->nBtns * SIZEOF(xkbActionWireDesc)8;
6600 memcpy((char *) &acts[stuff->firstBtn], (char *) wire, sz)__builtin___memcpy_chk ((char *) &acts[stuff->firstBtn
], (char *) wire, sz, __builtin_object_size ((char *) &acts
[stuff->firstBtn], 0))
;
6601 wire += sz;
6602 ed.reason |= XkbXI_ButtonActionsMask(1L << 1);
6603 ed.firstBtn = stuff->firstBtn;
6604 ed.nBtns = stuff->nBtns;
6605
6606 if (dev->key)
6607 kbd = dev;
6608 else
6609 kbd = inputInfo.keyboard;
6610 acts = &dev->button->xkb_acts[stuff->firstBtn];
6611 for (i = 0; i < stuff->nBtns; i++, acts++) {
6612 if (acts->type != XkbSA_NoAction0x00)
6613 XkbSetActionKeyMods(kbd->key->xkbInfo->desc, acts, 0);
6614 }
6615 }
6616 if (stuff->change & XkbXI_IndicatorsMask(0x001c)) {
6617 int status = Success0;
6618
6619 wire = SetDeviceIndicators(wire, dev, stuff->change,
6620 stuff->nDeviceLedFBs, &status, client, &ed);
6621 if (status != Success0)
6622 return status;
6623 }
6624 if ((stuff->change) && (ed.reason))
6625 XkbSendExtensionDeviceNotify(dev, client, &ed);
6626 return Success0;
6627}
6628
6629int
6630ProcXkbSetDeviceInfo(ClientPtr client)
6631{
6632 DeviceIntPtr dev;
6633 int rc;
6634
6635 REQUEST(xkbSetDeviceInfoReq)xkbSetDeviceInfoReq *stuff = (xkbSetDeviceInfoReq *)client->
requestBuffer
;
6636 REQUEST_AT_LEAST_SIZE(xkbSetDeviceInfoReq)if ((sizeof(xkbSetDeviceInfoReq) >> 2) > client->
req_len ) return(16)
;
6637
6638 if (!(client->xkbClientFlags & _XkbClientInitialized(1<<15)))
6639 return BadAccess10;
6640
6641 CHK_ANY_DEVICE(dev, stuff->deviceSpec, client, DixManageAccess){ int why; int tmprc = _XkbLookupAnyDevice(&(dev), stuff->
deviceSpec, client, (1<<25), &why); if (tmprc != 0)
{ client->errorValue = ((XID)((((unsigned int)(why))<<
24)|((stuff->deviceSpec)&0xffffff))); return tmprc; }}
;
6642 CHK_MASK_LEGAL(0x01, stuff->change, XkbXI_AllFeaturesMask){ if ((stuff->change)&(~((0x001f)))) { (client->errorValue
)= ((XID)((((unsigned int)((0x01)))<<24)|((((stuff->
change)&(~((0x001f)))))&0xffffff))); return 2; }}
;
6643
6644 rc = _XkbSetDeviceInfoCheck(client, dev, stuff);
6645
6646 if (rc != Success0)
6647 return rc;
6648
6649 if (stuff->deviceSpec == XkbUseCoreKbd0x0100 ||
6650 stuff->deviceSpec == XkbUseCorePtr0x0200) {
6651 DeviceIntPtr other;
6652
6653 for (other = inputInfo.devices; other; other = other->next) {
6654 if (((other != dev) && !IsMaster(other) &&
6655 GetMaster(other, MASTER_KEYBOARD2) == dev) &&
6656 ((stuff->deviceSpec == XkbUseCoreKbd0x0100 && other->key) ||
6657 (stuff->deviceSpec == XkbUseCorePtr0x0200 && other->button))) {
6658 rc = XaceHook(XACE_DEVICE_ACCESS3, client, other,
6659 DixManageAccess(1<<25));
6660 if (rc == Success0) {
6661 rc = _XkbSetDeviceInfoCheck(client, other, stuff);
6662 if (rc != Success0)
6663 return rc;
6664 }
6665 }
6666 }
6667 }
6668
6669 /* checks done, apply */
6670 rc = _XkbSetDeviceInfo(client, dev, stuff);
6671 if (rc != Success0)
6672 return rc;
6673
6674 if (stuff->deviceSpec == XkbUseCoreKbd0x0100 ||
6675 stuff->deviceSpec == XkbUseCorePtr0x0200) {
6676 DeviceIntPtr other;
6677
6678 for (other = inputInfo.devices; other; other = other->next) {
6679 if (((other != dev) && !IsMaster(other) &&
6680 GetMaster(other, MASTER_KEYBOARD2) == dev) &&
6681 ((stuff->deviceSpec == XkbUseCoreKbd0x0100 && other->key) ||
6682 (stuff->deviceSpec == XkbUseCorePtr0x0200 && other->button))) {
6683 rc = XaceHook(XACE_DEVICE_ACCESS3, client, other,
6684 DixManageAccess(1<<25));
6685 if (rc == Success0) {
6686 rc = _XkbSetDeviceInfo(client, other, stuff);
6687 if (rc != Success0)
6688 return rc;
6689 }
6690 }
6691 }
6692 }
6693
6694 return Success0;
6695}
6696
6697/***====================================================================***/
6698
6699int
6700ProcXkbSetDebuggingFlags(ClientPtr client)
6701{
6702 CARD32 newFlags, newCtrls, extraLength;
6703 xkbSetDebuggingFlagsReply rep;
6704 int rc;
6705
6706 REQUEST(xkbSetDebuggingFlagsReq)xkbSetDebuggingFlagsReq *stuff = (xkbSetDebuggingFlagsReq *)client
->requestBuffer
;
6707 REQUEST_AT_LEAST_SIZE(xkbSetDebuggingFlagsReq)if ((sizeof(xkbSetDebuggingFlagsReq) >> 2) > client->
req_len ) return(16)
;
6708
6709 rc = XaceHook(XACE_SERVER_ACCESS9, client, DixDebugAccess(1<<26));
6710 if (rc != Success0)
6711 return rc;
6712
6713 newFlags = xkbDebugFlags & (~stuff->affectFlags);
6714 newFlags |= (stuff->flags & stuff->affectFlags);
6715 newCtrls = xkbDebugCtrls & (~stuff->affectCtrls);
6716 newCtrls |= (stuff->ctrls & stuff->affectCtrls);
6717 if (xkbDebugFlags || newFlags || stuff->msgLength) {
6718 ErrorF("[xkb] XkbDebug: Setting debug flags to 0x%lx\n",
6719 (long) newFlags);
6720 if (newCtrls != xkbDebugCtrls)
6721 ErrorF("[xkb] XkbDebug: Setting debug controls to 0x%lx\n",
6722 (long) newCtrls);
6723 }
6724 extraLength = (stuff->length << 2) - sz_xkbSetDebuggingFlagsReq24;
6725 if (stuff->msgLength > 0) {
6726 char *msg;
6727
6728 if (extraLength < XkbPaddedSize(stuff->msgLength)((((unsigned int)(stuff->msgLength)+3) >> 2) <<
2)
) {
6729 ErrorF
6730 ("[xkb] XkbDebug: msgLength= %d, length= %ld (should be %d)\n",
6731 stuff->msgLength, (long) extraLength,
6732 XkbPaddedSize(stuff->msgLength)((((unsigned int)(stuff->msgLength)+3) >> 2) <<
2)
);
6733 return BadLength16;
6734 }
6735 msg = (char *) &stuff[1];
6736 if (msg[stuff->msgLength - 1] != '\0') {
6737 ErrorF("[xkb] XkbDebug: message not null-terminated\n");
6738 return BadValue2;
6739 }
6740 ErrorF("[xkb] XkbDebug: %s\n", msg);
6741 }
6742 xkbDebugFlags = newFlags;
6743 xkbDebugCtrls = newCtrls;
6744
6745 rep = (xkbSetDebuggingFlagsReply) {
6746 .type = X_Reply1,
6747 .sequenceNumber = client->sequence,
6748 .length = 0,
6749 .currentFlags = newFlags,
6750 .currentCtrls = newCtrls,
6751 .supportedFlags = ~0,
6752 .supportedCtrls = ~0
6753 };
6754 if (client->swapped) {
6755 swaps(&rep.sequenceNumber)do { if (sizeof(*(&rep.sequenceNumber)) != 2) wrong_size(
); if (__builtin_constant_p((uintptr_t)(&rep.sequenceNumber
) & 1) && ((uintptr_t)(&rep.sequenceNumber) &
1) == 0) *(&rep.sequenceNumber) = lswaps(*(&rep.sequenceNumber
)); else swap_uint16((uint16_t *)(&rep.sequenceNumber)); }
while (0)
;
6756 swapl(&rep.currentFlags)do { if (sizeof(*(&rep.currentFlags)) != 4) wrong_size();
if (__builtin_constant_p((uintptr_t)(&rep.currentFlags) &
3) && ((uintptr_t)(&rep.currentFlags) & 3) ==
0) *(&rep.currentFlags) = lswapl(*(&rep.currentFlags
)); else swap_uint32((uint32_t *)(&rep.currentFlags)); } while
(0)
;
6757 swapl(&rep.currentCtrls)do { if (sizeof(*(&rep.currentCtrls)) != 4) wrong_size();
if (__builtin_constant_p((uintptr_t)(&rep.currentCtrls) &
3) && ((uintptr_t)(&rep.currentCtrls) & 3) ==
0) *(&rep.currentCtrls) = lswapl(*(&rep.currentCtrls
)); else swap_uint32((uint32_t *)(&rep.currentCtrls)); } while
(0)
;
6758 swapl(&rep.supportedFlags)do { if (sizeof(*(&rep.supportedFlags)) != 4) wrong_size(
); if (__builtin_constant_p((uintptr_t)(&rep.supportedFlags
) & 3) && ((uintptr_t)(&rep.supportedFlags) &
3) == 0) *(&rep.supportedFlags) = lswapl(*(&rep.supportedFlags
)); else swap_uint32((uint32_t *)(&rep.supportedFlags)); }
while (0)
;
6759 swapl(&rep.supportedCtrls)do { if (sizeof(*(&rep.supportedCtrls)) != 4) wrong_size(
); if (__builtin_constant_p((uintptr_t)(&rep.supportedCtrls
) & 3) && ((uintptr_t)(&rep.supportedCtrls) &
3) == 0) *(&rep.supportedCtrls) = lswapl(*(&rep.supportedCtrls
)); else swap_uint32((uint32_t *)(&rep.supportedCtrls)); }
while (0)
;
6760 }
6761 WriteToClient(client, SIZEOF(xkbSetDebuggingFlagsReply)32, &rep);
6762 return Success0;
6763}
6764
6765/***====================================================================***/
6766
6767static int
6768ProcXkbDispatch(ClientPtr client)
6769{
6770 REQUEST(xReq)xReq *stuff = (xReq *)client->requestBuffer;
6771 switch (stuff->data) {
6772 case X_kbUseExtension0:
6773 return ProcXkbUseExtension(client);
6774 case X_kbSelectEvents1:
6775 return ProcXkbSelectEvents(client);
6776 case X_kbBell3:
6777 return ProcXkbBell(client);
6778 case X_kbGetState4:
6779 return ProcXkbGetState(client);
6780 case X_kbLatchLockState5:
6781 return ProcXkbLatchLockState(client);
6782 case X_kbGetControls6:
6783 return ProcXkbGetControls(client);
6784 case X_kbSetControls7:
6785 return ProcXkbSetControls(client);
6786 case X_kbGetMap8:
6787 return ProcXkbGetMap(client);
6788 case X_kbSetMap9:
6789 return ProcXkbSetMap(client);
6790 case X_kbGetCompatMap10:
6791 return ProcXkbGetCompatMap(client);
6792 case X_kbSetCompatMap11:
6793 return ProcXkbSetCompatMap(client);
6794 case X_kbGetIndicatorState12:
6795 return ProcXkbGetIndicatorState(client);
6796 case X_kbGetIndicatorMap13:
6797 return ProcXkbGetIndicatorMap(client);
6798 case X_kbSetIndicatorMap14:
6799 return ProcXkbSetIndicatorMap(client);
6800 case X_kbGetNamedIndicator15:
6801 return ProcXkbGetNamedIndicator(client);
6802 case X_kbSetNamedIndicator16:
6803 return ProcXkbSetNamedIndicator(client);
6804 case X_kbGetNames17:
6805 return ProcXkbGetNames(client);
6806 case X_kbSetNames18:
6807 return ProcXkbSetNames(client);
6808 case X_kbGetGeometry19:
6809 return ProcXkbGetGeometry(client);
6810 case X_kbSetGeometry20:
6811 return ProcXkbSetGeometry(client);
6812 case X_kbPerClientFlags21:
6813 return ProcXkbPerClientFlags(client);
6814 case X_kbListComponents22:
6815 return ProcXkbListComponents(client);
6816 case X_kbGetKbdByName23:
6817 return ProcXkbGetKbdByName(client);
6818 case X_kbGetDeviceInfo24:
6819 return ProcXkbGetDeviceInfo(client);
6820 case X_kbSetDeviceInfo25:
6821 return ProcXkbSetDeviceInfo(client);
6822 case X_kbSetDebuggingFlags101:
6823 return ProcXkbSetDebuggingFlags(client);
6824 default:
6825 return BadRequest1;
6826 }
6827}
6828
6829static int
6830XkbClientGone(void *data, XID id)
6831{
6832 DevicePtr pXDev = (DevicePtr) data;
6833
6834 if (!XkbRemoveResourceClient(pXDev, id)) {
6835 ErrorF
6836 ("[xkb] Internal Error! bad RemoveResourceClient in XkbClientGone\n");
6837 }
6838 return 1;
6839}
6840
6841void
6842XkbExtensionInit(void)
6843{
6844 ExtensionEntry *extEntry;
6845
6846 RT_XKBCLIENT = CreateNewResourceType(XkbClientGone, "XkbClient");
6847 if (!RT_XKBCLIENT)
6848 return;
6849
6850 if (!XkbInitPrivates())
6851 return;
6852
6853 if ((extEntry = AddExtension(XkbName"XKEYBOARD", XkbNumberEvents(0 +1), XkbNumberErrors1,
6854 ProcXkbDispatch, SProcXkbDispatch,
6855 NULL((void*)0), StandardMinorOpcode))) {
6856 XkbReqCode = (unsigned char) extEntry->base;
6857 XkbEventBase = (unsigned char) extEntry->eventBase;
6858 XkbErrorBase = (unsigned char) extEntry->errorBase;
6859 XkbKeyboardErrorCode = XkbErrorBase + XkbKeyboard0;
6860 }
6861 return;
6862}