Bug Summary

File:src/xkb/XKBGetMap.c
Location:line 44, column 13
Description:Value stored to 'n' 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#define NEED_MAP_READERS
28#ifdef HAVE_CONFIG_H1
29#include <config.h>
30#endif
31#include "Xlibint.h"
32#include <X11/extensions/XKBproto.h>
33#include "XKBlibint.h"
34
35static Statusint
36_XkbReadKeyTypes(XkbReadBufferPtr buf, XkbDescPtr xkb, xkbGetMapReply *rep)
37{
38 int i, n, lastMapCount;
39 XkbKeyTypePtr type;
40
41 if (rep->nTypes > 0) {
42 n = rep->firstType + rep->nTypes;
43 if (xkb->map->num_types >= n)
44 n = xkb->map->num_types;
Value stored to 'n' is never read
45 else if (XkbAllocClientMap(xkb, XkbKeyTypesMask(1<<0), n) != Success0)
46 return BadAlloc11;
47
48 type = &xkb->map->types[rep->firstType];
49 for (i = 0; i < (int) rep->nTypes; i++, type++) {
50 xkbKeyTypeWireDesc *desc;
51 register int ndx;
52
53 ndx = i + rep->firstType;
54 if (ndx >= xkb->map->num_types)
55 xkb->map->num_types = ndx + 1;
56
57 desc = (xkbKeyTypeWireDesc *)
58 _XkbGetReadBufferPtr(buf, SIZEOF(xkbKeyTypeWireDesc)8);
59 if (desc == NULL((void*)0))
60 return BadLength16;
61
62 lastMapCount = type->map_count;
63 if (desc->nMapEntries > 0) {
64 if ((type->map == NULL((void*)0)) ||
65 (desc->nMapEntries > type->map_count)) {
66 XkbKTMapEntryRec *prev_map = type->map;
67
68 type->map = _XkbTypedRealloc(type->map, desc->nMapEntries,((type->map) ? (XkbKTMapEntryRec *)realloc(((type->map)
), (((desc->nMapEntries)*sizeof(XkbKTMapEntryRec)) == 0 ? 1
: ((desc->nMapEntries)*sizeof(XkbKTMapEntryRec)))) : ((XkbKTMapEntryRec
*)calloc((((desc->nMapEntries)) == 0 ? 1 : ((desc->nMapEntries
))), (sizeof(XkbKTMapEntryRec)))))
69 XkbKTMapEntryRec)((type->map) ? (XkbKTMapEntryRec *)realloc(((type->map)
), (((desc->nMapEntries)*sizeof(XkbKTMapEntryRec)) == 0 ? 1
: ((desc->nMapEntries)*sizeof(XkbKTMapEntryRec)))) : ((XkbKTMapEntryRec
*)calloc((((desc->nMapEntries)) == 0 ? 1 : ((desc->nMapEntries
))), (sizeof(XkbKTMapEntryRec)))))
;
70 if (type->map == NULL((void*)0)) {
71 _XkbFree(prev_map)free((prev_map));
72 return BadAlloc11;
73 }
74 }
75 }
76 else if (type->map != NULL((void*)0)) {
77 Xfree(type->map)free((type->map));
78 type->map_count = 0;
79 type->map = NULL((void*)0);
80 }
81
82 if (desc->preserve && (desc->nMapEntries > 0)) {
83 if ((!type->preserve) || (desc->nMapEntries > lastMapCount)) {
84 XkbModsRec *prev_preserve = type->preserve;
85
86 type->preserve = _XkbTypedRealloc(type->preserve,((type->preserve) ? (XkbModsRec *)realloc(((type->preserve
)), (((desc->nMapEntries)*sizeof(XkbModsRec)) == 0 ? 1 : (
(desc->nMapEntries)*sizeof(XkbModsRec)))) : ((XkbModsRec *
)calloc((((desc->nMapEntries)) == 0 ? 1 : ((desc->nMapEntries
))), (sizeof(XkbModsRec)))))
87 desc->nMapEntries,((type->preserve) ? (XkbModsRec *)realloc(((type->preserve
)), (((desc->nMapEntries)*sizeof(XkbModsRec)) == 0 ? 1 : (
(desc->nMapEntries)*sizeof(XkbModsRec)))) : ((XkbModsRec *
)calloc((((desc->nMapEntries)) == 0 ? 1 : ((desc->nMapEntries
))), (sizeof(XkbModsRec)))))
88 XkbModsRec)((type->preserve) ? (XkbModsRec *)realloc(((type->preserve
)), (((desc->nMapEntries)*sizeof(XkbModsRec)) == 0 ? 1 : (
(desc->nMapEntries)*sizeof(XkbModsRec)))) : ((XkbModsRec *
)calloc((((desc->nMapEntries)) == 0 ? 1 : ((desc->nMapEntries
))), (sizeof(XkbModsRec)))))
;
89 if (type->preserve == NULL((void*)0)) {
90 _XkbFree(prev_preserve)free((prev_preserve));
91 return BadAlloc11;
92 }
93 }
94 }
95 else if (type->preserve != NULL((void*)0)) {
96 Xfree(type->preserve)free((type->preserve));
97 type->preserve = NULL((void*)0);
98 }
99
100 type->mods.mask = desc->mask;
101 type->mods.real_mods = desc->realMods;
102 type->mods.vmods = desc->virtualMods;
103 type->num_levels = desc->numLevels;
104 type->map_count = desc->nMapEntries;
105 if (desc->nMapEntries > 0) {
106 register xkbKTMapEntryWireDesc *wire;
107 register XkbKTMapEntryPtr entry;
108 register int size;
109
110 size = type->map_count * SIZEOF(xkbKTMapEntryWireDesc)8;
111 wire =
112 (xkbKTMapEntryWireDesc *) _XkbGetReadBufferPtr(buf, size);
113 if (wire == NULL((void*)0))
114 return BadLength16;
115 entry = type->map;
116 for (n = 0; n < type->map_count; n++, wire++, entry++) {
117 entry->active = wire->active;
118 entry->level = wire->level;
119 entry->mods.mask = wire->mask;
120 entry->mods.real_mods = wire->realMods;
121 entry->mods.vmods = wire->virtualMods;
122 }
123
124 if (desc->preserve) {
125 register xkbModsWireDesc *pwire;
126 register XkbModsPtr preserve;
127 register int sz;
128
129 sz = desc->nMapEntries * SIZEOF(xkbModsWireDesc)4;
130 pwire = (xkbModsWireDesc *) _XkbGetReadBufferPtr(buf, sz);
131 if (pwire == NULL((void*)0))
132 return BadLength16;
133 preserve = type->preserve;
134 for (n = 0; n < desc->nMapEntries; n++, pwire++, preserve++) {
135 preserve->mask = pwire->mask;
136 preserve->vmods = pwire->virtualMods;
137 preserve->real_mods = pwire->realMods;
138 }
139 }
140 }
141 }
142 }
143 return Success0;
144}
145
146static Statusint
147_XkbReadKeySyms(XkbReadBufferPtr buf, XkbDescPtr xkb, xkbGetMapReply *rep)
148{
149 register int i;
150 XkbClientMapPtr map;
151 int size = xkb->max_key_code + 1;
152
153 if (((unsigned short) rep->firstKeySym + rep->nKeySyms) > size)
154 return BadLength16;
155
156 map = xkb->map;
157 if (map->key_sym_map == NULL((void*)0)) {
158 register int offset;
159 XkbSymMapPtr oldMap;
160 xkbSymMapWireDesc *newMap;
161
162 map->key_sym_map = _XkbTypedCalloc(size, XkbSymMapRec)((XkbSymMapRec *)calloc((((size)) == 0 ? 1 : ((size))), (sizeof
(XkbSymMapRec))))
;
163 if (map->key_sym_map == NULL((void*)0))
164 return BadAlloc11;
165 if (map->syms == NULL((void*)0)) {
166 int sz;
167
168 sz = (rep->totalSyms * 12) / 10;
169 sz = ((sz + (unsigned) 128) / 128) * 128;
170 map->syms = _XkbTypedCalloc(sz, KeySym)((KeySym *)calloc((((sz)) == 0 ? 1 : ((sz))), (sizeof(KeySym)
)))
;
171 if (map->syms == NULL((void*)0))
172 return BadAlloc11;
173 map->size_syms = sz;
174 }
175 offset = 1;
176 oldMap = &map->key_sym_map[rep->firstKeySym];
177 for (i = 0; i < (int) rep->nKeySyms; i++, oldMap++) {
178 newMap = (xkbSymMapWireDesc *)
179 _XkbGetReadBufferPtr(buf, SIZEOF(xkbSymMapWireDesc)8);
180 if (newMap == NULL((void*)0))
181 return BadLength16;
182 oldMap->kt_index[0] = newMap->ktIndex[0];
183 oldMap->kt_index[1] = newMap->ktIndex[1];
184 oldMap->kt_index[2] = newMap->ktIndex[2];
185 oldMap->kt_index[3] = newMap->ktIndex[3];
186 oldMap->group_info = newMap->groupInfo;
187 oldMap->width = newMap->width;
188 oldMap->offset = offset;
189 if (offset + newMap->nSyms >= map->size_syms) {
190 register int sz;
191 KeySym *prev_syms = map->syms;
192
193 sz = map->size_syms + 128;
194 map->syms = _XkbTypedRealloc(map->syms, sz, KeySym)((map->syms) ? (KeySym *)realloc(((map->syms)), (((sz)*
sizeof(KeySym)) == 0 ? 1 : ((sz)*sizeof(KeySym)))) : ((KeySym
*)calloc((((sz)) == 0 ? 1 : ((sz))), (sizeof(KeySym)))))
;
195 if (map->syms == NULL((void*)0)) {
196 _XkbFree(prev_syms)free((prev_syms));
197 map->size_syms = 0;
198 return BadAlloc11;
199 }
200 map->size_syms = sz;
201 }
202 if (newMap->nSyms > 0) {
203 _XkbReadBufferCopyKeySyms(buf, (KeySym *) &map->syms[offset],
204 newMap->nSyms);
205 offset += newMap->nSyms;
206 }
207 else {
208 map->syms[offset] = 0;
209 }
210 }
211 map->num_syms = offset;
212 }
213 else {
214 XkbSymMapPtr oldMap = &map->key_sym_map[rep->firstKeySym];
215
216 for (i = 0; i < (int) rep->nKeySyms; i++, oldMap++) {
217 xkbSymMapWireDesc *newMap;
218 KeySym *newSyms;
219 int tmp;
220
221 newMap = (xkbSymMapWireDesc *)
222 _XkbGetReadBufferPtr(buf, SIZEOF(xkbSymMapWireDesc)8);
223 if (newMap == NULL((void*)0))
224 return BadLength16;
225
226 if (newMap->nSyms > 0)
227 tmp = newMap->nSyms;
228 else
229 tmp = 0;
230
231 newSyms = XkbResizeKeySyms(xkb, i + rep->firstKeySym, tmp);
232 if (newSyms == NULL((void*)0))
233 return BadAlloc11;
234 if (newMap->nSyms > 0)
235 _XkbReadBufferCopyKeySyms(buf, newSyms, newMap->nSyms);
236 else
237 newSyms[0] = NoSymbol0L;
238 oldMap->kt_index[0] = newMap->ktIndex[0];
239 oldMap->kt_index[1] = newMap->ktIndex[1];
240 oldMap->kt_index[2] = newMap->ktIndex[2];
241 oldMap->kt_index[3] = newMap->ktIndex[3];
242 oldMap->group_info = newMap->groupInfo;
243 oldMap->width = newMap->width;
244 }
245 }
246 return Success0;
247}
248
249static Statusint
250_XkbReadKeyActions(XkbReadBufferPtr buf, XkbDescPtr info, xkbGetMapReply *rep)
251{
252 int i;
253 CARD8 numDescBuf[248];
254 CARD8 *numDesc = NULL((void*)0);
255 register int nKeyActs;
256 Statusint ret = Success0;
257
258 if ((nKeyActs = rep->nKeyActs) > 0) {
259 XkbSymMapPtr symMap;
260
261 if (nKeyActs < sizeof numDescBuf)
262 numDesc = numDescBuf;
263 else
264 numDesc = Xmalloc(nKeyActs * sizeof(CARD8))malloc(((nKeyActs * sizeof(CARD8)) == 0 ? 1 : (nKeyActs * sizeof
(CARD8))))
;
265
266 if (!_XkbCopyFromReadBuffer(buf, (char *) numDesc, nKeyActs)) {
267 ret = BadLength16;
268 goto done;
269 }
270 i = XkbPaddedSize(nKeyActs)((((unsigned int)(nKeyActs)+3) >> 2) << 2) - nKeyActs;
271 if ((i > 0) && (!_XkbSkipReadBufferData(buf, i))) {
272 ret = BadLength16;
273 goto done;
274 }
275 symMap = &info->map->key_sym_map[rep->firstKeyAct];
276 for (i = 0; i < (int) rep->nKeyActs; i++, symMap++) {
277 if (numDesc[i] == 0) {
278 if ((i + rep->firstKeyAct) > (info->max_key_code + 1)) {
279 ret = BadLength16;
280 goto done;
281 }
282 info->server->key_acts[i + rep->firstKeyAct] = 0;
283 }
284 else {
285 XkbAction *newActs;
286
287 /* 8/16/93 (ef) -- XXX! Verify size here (numdesc must be */
288 /* either zero or XkbKeyNumSyms(info,key) */
289 newActs = XkbResizeKeyActions(info, i + rep->firstKeyAct,
290 numDesc[i]);
291 if (newActs == NULL((void*)0)) {
292 ret = BadAlloc11;
293 goto done;
294 }
295 if (!_XkbCopyFromReadBuffer(buf, (char *) newActs,
296 (int) (numDesc[i] * sizeof(XkbAction)))) {
297 ret = BadLength16;
298 goto done;
299 }
300 }
301 }
302 }
303 done:
304 if (numDesc != NULL((void*)0) && numDesc != numDescBuf)
305 Xfree(numDesc)free((numDesc));
306 return ret;
307}
308
309static Statusint
310_XkbReadKeyBehaviors(XkbReadBufferPtr buf, XkbDescPtr xkb, xkbGetMapReply *rep)
311{
312 register int i;
313
314 if (rep->totalKeyBehaviors > 0) {
315 int size = xkb->max_key_code + 1;
316
317 if (((int) rep->firstKeyBehavior + rep->nKeyBehaviors) > size)
318 return BadLength16;
319 if (xkb->server->behaviors == NULL((void*)0)) {
320 xkb->server->behaviors = _XkbTypedCalloc(size, XkbBehavior)((XkbBehavior *)calloc((((size)) == 0 ? 1 : ((size))), (sizeof
(XkbBehavior))))
;
321 if (xkb->server->behaviors == NULL((void*)0))
322 return BadAlloc11;
323 }
324 else {
325 bzero(&xkb->server->behaviors[rep->firstKeyBehavior],__builtin___memset_chk (&xkb->server->behaviors[rep
->firstKeyBehavior], 0, (rep->nKeyBehaviors * sizeof(XkbBehavior
)), __builtin_object_size (&xkb->server->behaviors[
rep->firstKeyBehavior], 0))
326 (rep->nKeyBehaviors * sizeof(XkbBehavior)))__builtin___memset_chk (&xkb->server->behaviors[rep
->firstKeyBehavior], 0, (rep->nKeyBehaviors * sizeof(XkbBehavior
)), __builtin_object_size (&xkb->server->behaviors[
rep->firstKeyBehavior], 0))
;
327 }
328 for (i = 0; i < rep->totalKeyBehaviors; i++) {
329 xkbBehaviorWireDesc *wire;
330
331 wire = (xkbBehaviorWireDesc *) _XkbGetReadBufferPtr(buf,
332 SIZEOF(xkbBehaviorWireDesc)4);
333 if (wire == NULL((void*)0) || wire->key >= size)
334 return BadLength16;
335 xkb->server->behaviors[wire->key].type = wire->type;
336 xkb->server->behaviors[wire->key].data = wire->data;
337 }
338 }
339 return Success0;
340}
341
342static Statusint
343_XkbReadVirtualMods(XkbReadBufferPtr buf, XkbDescPtr xkb, xkbGetMapReply *rep)
344{
345 if (rep->virtualMods) {
346 register int i, bit, nVMods;
347 register char *data;
348
349 for (i = nVMods = 0, bit = 1; i < XkbNumVirtualMods16; i++, bit <<= 1) {
350 if (rep->virtualMods & bit)
351 nVMods++;
352 }
353 data = _XkbGetReadBufferPtr(buf, XkbPaddedSize(nVMods)((((unsigned int)(nVMods)+3) >> 2) << 2));
354 if (data == NULL((void*)0))
355 return BadLength16;
356 for (i = 0, bit = 1; (i < XkbNumVirtualMods16) && (nVMods > 0);
357 i++, bit <<= 1) {
358 if (rep->virtualMods & bit) {
359 xkb->server->vmods[i] = *data++;
360 nVMods--;
361 }
362 }
363 }
364 return Success0;
365}
366
367static Statusint
368_XkbReadExplicitComponents(XkbReadBufferPtr buf,
369 XkbDescPtr xkb,
370 xkbGetMapReply *rep)
371{
372 register int i;
373 unsigned char *wire;
374
375 if (rep->totalKeyExplicit > 0) {
376 int size = xkb->max_key_code + 1;
377
378 if (((int) rep->firstKeyExplicit + rep->nKeyExplicit) > size)
379 return BadLength16;
380 if (xkb->server->explicit == NULL((void*)0)) {
381 xkb->server->explicit = _XkbTypedCalloc(size, unsigned char)((unsigned char *)calloc((((size)) == 0 ? 1 : ((size))), (sizeof
(unsigned char))))
;
382
383 if (xkb->server->explicit == NULL((void*)0))
384 return BadAlloc11;
385 }
386 else {
387 bzero(&xkb->server->explicit[rep->firstKeyExplicit],__builtin___memset_chk (&xkb->server->explicit[rep->
firstKeyExplicit], 0, rep->nKeyExplicit, __builtin_object_size
(&xkb->server->explicit[rep->firstKeyExplicit],
0))
388 rep->nKeyExplicit)__builtin___memset_chk (&xkb->server->explicit[rep->
firstKeyExplicit], 0, rep->nKeyExplicit, __builtin_object_size
(&xkb->server->explicit[rep->firstKeyExplicit],
0))
;
389 }
390 i = XkbPaddedSize(2 * rep->totalKeyExplicit)((((unsigned int)(2 * rep->totalKeyExplicit)+3) >> 2
) << 2)
;
391 wire = (unsigned char *) _XkbGetReadBufferPtr(buf, i);
392 if (!wire)
393 return BadLength16;
394 for (i = 0; i < rep->totalKeyExplicit; i++, wire += 2) {
395 if (wire[0] > xkb->max_key_code || wire[1] > xkb->max_key_code)
396 return BadLength16;
397 xkb->server->explicit[wire[0]] = wire[1];
398 }
399 }
400 return Success0;
401}
402
403static Statusint
404_XkbReadModifierMap(XkbReadBufferPtr buf, XkbDescPtr xkb, xkbGetMapReply *rep)
405{
406 register int i;
407 unsigned char *wire;
408
409 if (rep->totalModMapKeys > 0) {
410 if (((int) rep->firstModMapKey + rep->nModMapKeys) >
411 (xkb->max_key_code + 1))
412 return BadLength16;
413 if ((xkb->map->modmap == NULL((void*)0)) &&
414 (XkbAllocClientMap(xkb, XkbModifierMapMask(1<<2), 0) != Success0)) {
415 return BadAlloc11;
416 }
417 else {
418 bzero(&xkb->map->modmap[rep->firstModMapKey], rep->nModMapKeys)__builtin___memset_chk (&xkb->map->modmap[rep->firstModMapKey
], 0, rep->nModMapKeys, __builtin_object_size (&xkb->
map->modmap[rep->firstModMapKey], 0))
;
419 }
420 i = XkbPaddedSize(2 * rep->totalModMapKeys)((((unsigned int)(2 * rep->totalModMapKeys)+3) >> 2)
<< 2)
;
421 wire = (unsigned char *) _XkbGetReadBufferPtr(buf, i);
422 if (!wire)
423 return BadLength16;
424 for (i = 0; i < rep->totalModMapKeys; i++, wire += 2) {
425 if (wire[0] > xkb->max_key_code || wire[1] > xkb->max_key_code)
426 return BadLength16;
427 xkb->map->modmap[wire[0]] = wire[1];
428 }
429 }
430 return Success0;
431}
432
433static Statusint
434_XkbReadVirtualModMap(XkbReadBufferPtr buf,
435 XkbDescPtr xkb,
436 xkbGetMapReply *rep)
437{
438 register int i;
439 xkbVModMapWireDesc *wire;
440 XkbServerMapPtr srv;
441
442 if (rep->totalVModMapKeys > 0) {
443 if (((int) rep->firstVModMapKey + rep->nVModMapKeys)
444 > xkb->max_key_code + 1)
445 return BadLength16;
446 if (((xkb->server == NULL((void*)0)) || (xkb->server->vmodmap == NULL((void*)0))) &&
447 (XkbAllocServerMap(xkb, XkbVirtualModMapMask(1<<7), 0) != Success0)) {
448 return BadAlloc11;
449 }
450 else {
451 srv = xkb->server;
452 if (rep->nVModMapKeys > rep->firstVModMapKey)
453 bzero((char *) &srv->vmodmap[rep->firstVModMapKey],__builtin___memset_chk ((char *) &srv->vmodmap[rep->
firstVModMapKey], 0, (rep->nVModMapKeys - rep->firstVModMapKey
) * sizeof(unsigned short), __builtin_object_size ((char *) &
srv->vmodmap[rep->firstVModMapKey], 0))
454 (rep->nVModMapKeys - rep->firstVModMapKey) *__builtin___memset_chk ((char *) &srv->vmodmap[rep->
firstVModMapKey], 0, (rep->nVModMapKeys - rep->firstVModMapKey
) * sizeof(unsigned short), __builtin_object_size ((char *) &
srv->vmodmap[rep->firstVModMapKey], 0))
455 sizeof(unsigned short))__builtin___memset_chk ((char *) &srv->vmodmap[rep->
firstVModMapKey], 0, (rep->nVModMapKeys - rep->firstVModMapKey
) * sizeof(unsigned short), __builtin_object_size ((char *) &
srv->vmodmap[rep->firstVModMapKey], 0))
;
456 }
457 srv = xkb->server;
458 i = rep->totalVModMapKeys * SIZEOF(xkbVModMapWireDesc)4;
459 wire = (xkbVModMapWireDesc *) _XkbGetReadBufferPtr(buf, i);
460 if (!wire)
461 return BadLength16;
462 for (i = 0; i < rep->totalVModMapKeys; i++, wire++) {
463 if ((wire->key >= xkb->min_key_code) &&
464 (wire->key <= xkb->max_key_code))
465 srv->vmodmap[wire->key] = wire->vmods;
466 }
467 }
468 return Success0;
469}
470
471static xkbGetMapReq *
472_XkbGetGetMapReq(Display *dpy, XkbDescPtr xkb)
473{
474 xkbGetMapReq *req;
475
476 GetReq(kbGetMap, req)req = (xkbGetMapReq *) _XGetRequest(dpy, 8, 28);
477 req->reqType = dpy->xkb_info->codes->major_opcode;
478 req->xkbReqType = X_kbGetMap8;
479 req->deviceSpec = xkb->device_spec;
480 req->full = req->partial = 0;
481 req->firstType = req->nTypes = 0;
482 req->firstKeySym = req->nKeySyms = 0;
483 req->firstKeyAct = req->nKeyActs = 0;
484 req->firstKeyBehavior = req->nKeyBehaviors = 0;
485 req->virtualMods = 0;
486 req->firstKeyExplicit = req->nKeyExplicit = 0;
487 req->firstModMapKey = req->nModMapKeys = 0;
488 req->firstVModMapKey = req->nVModMapKeys = 0;
489 return req;
490}
491
492Statusint
493_XkbReadGetMapReply(Display *dpy,
494 xkbGetMapReply *rep,
495 XkbDescPtr xkb,
496 int *nread_rtrn)
497{
498 int extraData;
499 unsigned mask;
500
501 if (xkb->device_spec == XkbUseCoreKbd0x0100)
502 xkb->device_spec = rep->deviceID;
503 if (rep->maxKeyCode < rep->minKeyCode)
504 return BadImplementation17;
505 xkb->min_key_code = rep->minKeyCode;
506 xkb->max_key_code = rep->maxKeyCode;
507
508 if (!xkb->map) {
509 mask = rep->present & XkbAllClientInfoMask((1<<0)|(1<<1)|(1<<2));
510 if (mask && (XkbAllocClientMap(xkb, mask, rep->nTypes) != Success0))
511 return BadAlloc11;
512 }
513 if (!xkb->server) {
514 mask = rep->present & XkbAllServerInfoMask((1<<3)|(1<<4)|(1<<5)|(1<<6)|(1<<
7))
;
515 if (mask && (XkbAllocServerMap(xkb, mask, rep->totalActs) != Success0))
516 return BadAlloc11;
517 }
518 extraData = (int) (rep->length * 4);
519 extraData -= (SIZEOF(xkbGetMapReply)40 - SIZEOF(xGenericReply)32);
520 if (rep->length) {
521 XkbReadBufferRec buf;
522 int left;
523
524 if (_XkbInitReadBuffer(dpy, &buf, extraData)) {
525 Statusint status = Success0;
526
527 if (nread_rtrn != NULL((void*)0))
528 *nread_rtrn = extraData;
529 if (status == Success0)
530 status = _XkbReadKeyTypes(&buf, xkb, rep);
531 if (status == Success0)
532 status = _XkbReadKeySyms(&buf, xkb, rep);
533 if (status == Success0)
534 status = _XkbReadKeyActions(&buf, xkb, rep);
535 if (status == Success0)
536 status = _XkbReadKeyBehaviors(&buf, xkb, rep);
537 if (status == Success0)
538 status = _XkbReadVirtualMods(&buf, xkb, rep);
539 if (status == Success0)
540 status = _XkbReadExplicitComponents(&buf, xkb, rep);
541 if (status == Success0)
542 status = _XkbReadModifierMap(&buf, xkb, rep);
543 if (status == Success0)
544 status = _XkbReadVirtualModMap(&buf, xkb, rep);
545 left = _XkbFreeReadBuffer(&buf);
546 if (status != Success0)
547 return status;
548 else if (left || buf.error)
549 return BadLength16;
550 }
551 else
552 return BadAlloc11;
553 }
554 return Success0;
555}
556
557static Statusint
558_XkbHandleGetMapReply(Display *dpy, XkbDescPtr xkb)
559{
560 xkbGetMapReply rep;
561
562 if (!_XReply(dpy, (xReply *) &rep,
563 ((SIZEOF(xkbGetMapReply)40 - SIZEOF(xGenericReply)32) >> 2),
564 xFalse0)) {
565 return BadImplementation17;
566 }
567 return _XkbReadGetMapReply(dpy, &rep, xkb, NULL((void*)0));
568}
569
570Statusint
571XkbGetUpdatedMap(Display *dpy, unsigned which, XkbDescPtr xkb)
572{
573 if ((dpy->flags & XlibDisplayNoXkb(1L << 2)) ||
574 (!dpy->xkb_info && !XkbUseExtension(dpy, NULL((void*)0), NULL((void*)0))))
575 return BadAccess10;
576 if (which) {
577 register xkbGetMapReq *req;
578 Statusint status;
579
580 LockDisplay(dpy)if ((dpy)->lock_fns) (*(dpy)->lock_fns->lock_display
)(dpy)
;
581
582 req = _XkbGetGetMapReq(dpy, xkb);
583 req->full = which;
584 status = _XkbHandleGetMapReply(dpy, xkb);
585
586 UnlockDisplay(dpy)if ((dpy)->lock_fns) (*(dpy)->lock_fns->unlock_display
)(dpy)
;
587 SyncHandle()if (dpy->synchandler) (*dpy->synchandler)(dpy);
588 return status;
589 }
590 return Success0;
591}
592
593XkbDescPtr
594XkbGetMap(Display *dpy, unsigned which, unsigned deviceSpec)
595{
596 XkbDescPtr xkb;
597
598 xkb = _XkbTypedCalloc(1, XkbDescRec)((XkbDescRec *)calloc((((1)) == 0 ? 1 : ((1))), (sizeof(XkbDescRec
))))
;
599 if (xkb) {
600 xkb->device_spec = deviceSpec;
601 xkb->map = _XkbTypedCalloc(1, XkbClientMapRec)((XkbClientMapRec *)calloc((((1)) == 0 ? 1 : ((1))), (sizeof(
XkbClientMapRec))))
;
602 if ((xkb->map == NULL((void*)0)) ||
603 ((which) && (XkbGetUpdatedMap(dpy, which, xkb) != Success0))) {
604 if (xkb->map) {
605 Xfree(xkb->map)free((xkb->map));
606 xkb->map = NULL((void*)0);
607 }
608 Xfree(xkb)free((xkb));
609 return NULL((void*)0);
610 }
611 xkb->dpy = dpy;
612 }
613 return xkb;
614}
615
616Statusint
617XkbGetKeyTypes(Display *dpy, unsigned first, unsigned num, XkbDescPtr xkb)
618{
619 register xkbGetMapReq *req;
620 Statusint status;
621
622 if ((dpy->flags & XlibDisplayNoXkb(1L << 2)) ||
623 (!dpy->xkb_info && !XkbUseExtension(dpy, NULL((void*)0), NULL((void*)0))))
624 return BadAccess10;
625 if ((num < 1) || (num > XkbMaxKeyTypes255))
626 return BadValue2;
627
628 LockDisplay(dpy)if ((dpy)->lock_fns) (*(dpy)->lock_fns->lock_display
)(dpy)
;
629
630 req = _XkbGetGetMapReq(dpy, xkb);
631 req->firstType = first;
632 req->nTypes = num;
633 status = _XkbHandleGetMapReply(dpy, xkb);
634
635 UnlockDisplay(dpy)if ((dpy)->lock_fns) (*(dpy)->lock_fns->unlock_display
)(dpy)
;
636 SyncHandle()if (dpy->synchandler) (*dpy->synchandler)(dpy);
637 return status;
638}
639
640Statusint
641XkbGetKeyActions(Display *dpy, unsigned first, unsigned num, XkbDescPtr xkb)
642{
643 register xkbGetMapReq *req;
644 Statusint status;
645
646 if ((dpy->flags & XlibDisplayNoXkb(1L << 2)) ||
647 (!dpy->xkb_info && !XkbUseExtension(dpy, NULL((void*)0), NULL((void*)0))))
648 return BadAccess10;
649
650 if ((num < 1) || (num > XkbMaxKeyCount(255 -8 +1)))
651 return BadValue2;
652
653 LockDisplay(dpy)if ((dpy)->lock_fns) (*(dpy)->lock_fns->lock_display
)(dpy)
;
654
655 req = _XkbGetGetMapReq(dpy, xkb);
656 req->firstKeyAct = first;
657 req->nKeyActs = num;
658 status = _XkbHandleGetMapReply(dpy, xkb);
659
660 UnlockDisplay(dpy)if ((dpy)->lock_fns) (*(dpy)->lock_fns->unlock_display
)(dpy)
;
661 SyncHandle()if (dpy->synchandler) (*dpy->synchandler)(dpy);
662 return status;
663}
664
665Statusint
666XkbGetKeySyms(Display *dpy, unsigned first, unsigned num, XkbDescPtr xkb)
667{
668 register xkbGetMapReq *req;
669 Statusint status;
670
671 if ((dpy->flags & XlibDisplayNoXkb(1L << 2)) ||
672 (!dpy->xkb_info && !XkbUseExtension(dpy, NULL((void*)0), NULL((void*)0))))
673 return BadAccess10;
674
675 if ((num < 1) || (num > XkbMaxKeyCount(255 -8 +1)))
676 return BadValue2;
677
678 LockDisplay(dpy)if ((dpy)->lock_fns) (*(dpy)->lock_fns->lock_display
)(dpy)
;
679
680 req = _XkbGetGetMapReq(dpy, xkb);
681 req->firstKeySym = first;
682 req->nKeySyms = num;
683 status = _XkbHandleGetMapReply(dpy, xkb);
684
685 UnlockDisplay(dpy)if ((dpy)->lock_fns) (*(dpy)->lock_fns->unlock_display
)(dpy)
;
686 SyncHandle()if (dpy->synchandler) (*dpy->synchandler)(dpy);
687
688 return status;
689}
690
691Statusint
692XkbGetKeyBehaviors(Display *dpy, unsigned first, unsigned num, XkbDescPtr xkb)
693{
694 register xkbGetMapReq *req;
695 Statusint status;
696
697 if ((dpy->flags & XlibDisplayNoXkb(1L << 2)) ||
698 (!dpy->xkb_info && !XkbUseExtension(dpy, NULL((void*)0), NULL((void*)0))))
699 return BadAccess10;
700
701 if ((num < 1) || (num > XkbMaxKeyCount(255 -8 +1)))
702 return BadValue2;
703
704 LockDisplay(dpy)if ((dpy)->lock_fns) (*(dpy)->lock_fns->lock_display
)(dpy)
;
705
706 req = _XkbGetGetMapReq(dpy, xkb);
707 req->firstKeyBehavior = first;
708 req->nKeyBehaviors = num;
709 status = _XkbHandleGetMapReply(dpy, xkb);
710
711 UnlockDisplay(dpy)if ((dpy)->lock_fns) (*(dpy)->lock_fns->unlock_display
)(dpy)
;
712 SyncHandle()if (dpy->synchandler) (*dpy->synchandler)(dpy);
713 return status;
714}
715
716Statusint
717XkbGetVirtualMods(Display *dpy, unsigned which, XkbDescPtr xkb)
718{
719 register xkbGetMapReq *req;
720 Statusint status;
721
722 if ((dpy->flags & XlibDisplayNoXkb(1L << 2)) ||
723 (!dpy->xkb_info && !XkbUseExtension(dpy, NULL((void*)0), NULL((void*)0))))
724 return BadAccess10;
725
726 LockDisplay(dpy)if ((dpy)->lock_fns) (*(dpy)->lock_fns->lock_display
)(dpy)
;
727
728 req = _XkbGetGetMapReq(dpy, xkb);
729 req->virtualMods = which;
730 status = _XkbHandleGetMapReply(dpy, xkb);
731
732 UnlockDisplay(dpy)if ((dpy)->lock_fns) (*(dpy)->lock_fns->unlock_display
)(dpy)
;
733 SyncHandle()if (dpy->synchandler) (*dpy->synchandler)(dpy);
734 return status;
735}
736
737Statusint
738XkbGetKeyExplicitComponents(Display *dpy,
739 unsigned first,
740 unsigned num,
741 XkbDescPtr xkb)
742{
743 register xkbGetMapReq *req;
744 Statusint status;
745
746 if ((dpy->flags & XlibDisplayNoXkb(1L << 2)) ||
747 (!dpy->xkb_info && !XkbUseExtension(dpy, NULL((void*)0), NULL((void*)0))))
748 return BadAccess10;
749
750 if ((num < 1) || (num > XkbMaxKeyCount(255 -8 +1)))
751 return BadValue2;
752
753 LockDisplay(dpy)if ((dpy)->lock_fns) (*(dpy)->lock_fns->lock_display
)(dpy)
;
754
755 req = _XkbGetGetMapReq(dpy, xkb);
756 req->firstKeyExplicit = first;
757 req->nKeyExplicit = num;
758 if ((xkb != NULL((void*)0)) && (xkb->server != NULL((void*)0)) &&
759 (xkb->server->explicit != NULL((void*)0))) {
760 if ((num > 0) && (first >= xkb->min_key_code) &&
761 (first + num <= xkb->max_key_code))
762 bzero(&xkb->server->explicit[first], num)__builtin___memset_chk (&xkb->server->explicit[first
], 0, num, __builtin_object_size (&xkb->server->explicit
[first], 0))
;
763 }
764 if (xkb)
765 status = _XkbHandleGetMapReply(dpy, xkb);
766 else
767 status = BadMatch8;
768
769 UnlockDisplay(dpy)if ((dpy)->lock_fns) (*(dpy)->lock_fns->unlock_display
)(dpy)
;
770 SyncHandle()if (dpy->synchandler) (*dpy->synchandler)(dpy);
771 return status;
772}
773
774Statusint
775XkbGetKeyModifierMap(Display *dpy,
776 unsigned first,
777 unsigned num,
778 XkbDescPtr xkb)
779{
780 register xkbGetMapReq *req;
781 Statusint status;
782
783 if ((dpy->flags & XlibDisplayNoXkb(1L << 2)) ||
784 (!dpy->xkb_info && !XkbUseExtension(dpy, NULL((void*)0), NULL((void*)0))))
785 return BadAccess10;
786
787 if ((num < 1) || (num > XkbMaxKeyCount(255 -8 +1)))
788 return BadValue2;
789
790 LockDisplay(dpy)if ((dpy)->lock_fns) (*(dpy)->lock_fns->lock_display
)(dpy)
;
791
792 req = _XkbGetGetMapReq(dpy, xkb);
793 req->firstModMapKey = first;
794 req->nModMapKeys = num;
795 if ((xkb != NULL((void*)0)) && (xkb->map != NULL((void*)0)) && (xkb->map->modmap != NULL((void*)0))) {
796 if ((num > 0) && (first >= xkb->min_key_code) &&
797 (first + num <= xkb->max_key_code))
798 bzero(&xkb->map->modmap[first], num)__builtin___memset_chk (&xkb->map->modmap[first], 0
, num, __builtin_object_size (&xkb->map->modmap[first
], 0))
;
799 }
800 if (xkb)
801 status = _XkbHandleGetMapReply(dpy, xkb);
802 else
803 status = BadMatch8;
804
805 UnlockDisplay(dpy)if ((dpy)->lock_fns) (*(dpy)->lock_fns->unlock_display
)(dpy)
;
806 SyncHandle()if (dpy->synchandler) (*dpy->synchandler)(dpy);
807 return status;
808}
809
810Statusint
811XkbGetKeyVirtualModMap(Display *dpy, unsigned first, unsigned num,
812 XkbDescPtr xkb)
813{
814 register xkbGetMapReq *req;
815 Statusint status;
816
817 if ((dpy->flags & XlibDisplayNoXkb(1L << 2)) ||
818 (!dpy->xkb_info && !XkbUseExtension(dpy, NULL((void*)0), NULL((void*)0))))
819 return BadAccess10;
820
821 if ((num < 1) || (num > XkbMaxKeyCount(255 -8 +1)))
822 return BadValue2;
823
824 LockDisplay(dpy)if ((dpy)->lock_fns) (*(dpy)->lock_fns->lock_display
)(dpy)
;
825
826 req = _XkbGetGetMapReq(dpy, xkb);
827 req->firstVModMapKey = first;
828 req->nVModMapKeys = num;
829 if ((xkb != NULL((void*)0)) && (xkb->map != NULL((void*)0)) && (xkb->map->modmap != NULL((void*)0))) {
830 if ((num > 0) && (first >= xkb->min_key_code) &&
831 (first + num <= xkb->max_key_code))
832 bzero(&xkb->server->vmodmap[first], num * sizeof(unsigned short))__builtin___memset_chk (&xkb->server->vmodmap[first
], 0, num * sizeof(unsigned short), __builtin_object_size (&
xkb->server->vmodmap[first], 0))
;
833 }
834
835 if (xkb)
836 status = _XkbHandleGetMapReply(dpy, xkb);
837 else
838 status = BadMatch8;
839
840 UnlockDisplay(dpy)if ((dpy)->lock_fns) (*(dpy)->lock_fns->unlock_display
)(dpy)
;
841 SyncHandle()if (dpy->synchandler) (*dpy->synchandler)(dpy);
842 return status;
843}
844
845Statusint
846XkbGetMapChanges(Display *dpy, XkbDescPtr xkb, XkbMapChangesPtr changes)
847{
848 xkbGetMapReq *req;
849
850 if ((dpy->flags & XlibDisplayNoXkb(1L << 2)) ||
851 (!dpy->xkb_info && !XkbUseExtension(dpy, NULL((void*)0), NULL((void*)0))))
852 return BadAccess10;
853 LockDisplay(dpy)if ((dpy)->lock_fns) (*(dpy)->lock_fns->lock_display
)(dpy)
;
854 if (changes->changed) {
855 Statusint status = Success0;
856
857 req = _XkbGetGetMapReq(dpy, xkb);
858 req->full = 0;
859 req->partial = changes->changed;
860 req->firstType = changes->first_type;
861 req->nTypes = changes->num_types;
862 req->firstKeySym = changes->first_key_sym;
863 req->nKeySyms = changes->num_key_syms;
864 req->firstKeyAct = changes->first_key_act;
865 req->nKeyActs = changes->num_key_acts;
866 req->firstKeyBehavior = changes->first_key_behavior;
867 req->nKeyBehaviors = changes->num_key_behaviors;
868 req->virtualMods = changes->vmods;
869 req->firstKeyExplicit = changes->first_key_explicit;
870 req->nKeyExplicit = changes->num_key_explicit;
871 req->firstModMapKey = changes->first_modmap_key;
872 req->nModMapKeys = changes->num_modmap_keys;
873 req->firstVModMapKey = changes->first_vmodmap_key;
874 req->nVModMapKeys = changes->num_vmodmap_keys;
875 status = _XkbHandleGetMapReply(dpy, xkb);
876 UnlockDisplay(dpy)if ((dpy)->lock_fns) (*(dpy)->lock_fns->unlock_display
)(dpy)
;
877 SyncHandle()if (dpy->synchandler) (*dpy->synchandler)(dpy);
878 return status;
879 }
880 UnlockDisplay(dpy)if ((dpy)->lock_fns) (*(dpy)->lock_fns->unlock_display
)(dpy)
;
881 return Success0;
882}