← Back to branch summary

~ubuntu-branches/ubuntu/gutsy/vnc4/gutsy

« back to all changes in this revision

Viewing changes to unix/xc/programs/Xserver/xkb/xkbInit.c

  • Committer: Bazaar Package Importer
  • Author(s): Ola Lundqvist
  • Date: 2006-05-15 20:35:17 UTC
  • mfrom: (1.1.2 upstream)
  • Revision ID: james.westby@ubuntu.com-20060515203517-l4lre1ku942mn26k
Tags: 4.1.1+X4.3.0-10
* Correction of critical security issue. Thanks to Martin Kogler
  <e9925248@student.tuwien.ac.at> that informed me about the issue,
  and provided the patch.
  This flaw was originally found by Steve Wiseman of intelliadmin.com.
* Applied patch from Javier Kohen <jkohen@users.sourceforge.net> that
  inform the user that only 8 first characters of the password will
  actually be used when typing more than 8 characters, closes:
  #355619.

Show diffs side-by-side

added added

removed removed

Lines of Context:
unix/xc/programs/Xserver/xkb/xkbInit.c
 
1
/* $Xorg: xkbInit.c,v 1.3 2000/08/17 19:53:47 cpqbld Exp $ */
 
2
/************************************************************
 
3
Copyright (c) 1993 by Silicon Graphics Computer Systems, Inc.
 
4
 
 
5
Permission to use, copy, modify, and distribute this
 
6
software and its documentation for any purpose and without
 
7
fee is hereby granted, provided that the above copyright
 
8
notice appear in all copies and that both that copyright
 
9
notice and this permission notice appear in supporting
 
10
documentation, and that the name of Silicon Graphics not be 
 
11
used in advertising or publicity pertaining to distribution 
 
12
of the software without specific prior written permission.
 
13
Silicon Graphics makes no representation about the suitability 
 
14
of this software for any purpose. It is provided "as is"
 
15
without any express or implied warranty.
 
16
 
 
17
SILICON GRAPHICS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS 
 
18
SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY 
 
19
AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SILICON
 
20
GRAPHICS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL 
 
21
DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, 
 
22
DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE 
 
23
OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION  WITH
 
24
THE USE OR PERFORMANCE OF THIS SOFTWARE.
 
25
 
 
26
********************************************************/
 
27
/* $XFree86: xc/programs/Xserver/xkb/xkbInit.c,v 3.26 2003/02/09 06:29:20 paulo Exp $ */
 
28
 
 
29
#include <stdio.h>
 
30
#include <stdlib.h>
 
31
#include <ctype.h>
 
32
#include <unistd.h>
 
33
#include <math.h>
 
34
#define NEED_EVENTS 1
 
35
#include <X11/X.h>
 
36
#include <X11/Xproto.h>
 
37
#include <X11/keysym.h>
 
38
#include <X11/Xatom.h>
 
39
#include "misc.h"
 
40
#include "inputstr.h"
 
41
#include "opaque.h"
 
42
#include "property.h"
 
43
#define XKBSRV_NEED_FILE_FUNCS
 
44
#include "XKBsrv.h"
 
45
#include "XKBgeom.h"
 
46
#include <X11/extensions/XKMformat.h>
 
47
#include <X11/extensions/XKBfile.h>
 
48
 
 
49
 
 
50
#define CREATE_ATOM(s)  MakeAtom(s,sizeof(s)-1,1)
 
51
 
 
52
#ifdef sgi
 
53
#define LED_CAPS        5
 
54
#define LED_NUM         6
 
55
#define LED_SCROLL      7
 
56
#define PHYS_LEDS       0x7f
 
57
#define LED_COMPOSE     8
 
58
#else
 
59
#if defined(ultrix) || defined(__osf__) || defined(__alpha) || defined(__alpha__)
 
60
#define LED_COMPOSE     2
 
61
#define LED_CAPS        3
 
62
#define LED_SCROLL      4
 
63
#define LED_NUM         5
 
64
#define PHYS_LEDS       0x1f
 
65
#else
 
66
#ifdef sun
 
67
#define LED_NUM         1
 
68
#define LED_SCROLL      2
 
69
#define LED_COMPOSE     3
 
70
#define LED_CAPS        4
 
71
#define PHYS_LEDS       0x0f
 
72
#else
 
73
#define LED_CAPS        1
 
74
#define LED_NUM         2
 
75
#define LED_SCROLL      3
 
76
#define PHYS_LEDS       0x07
 
77
#endif
 
78
#endif
 
79
#endif
 
80
 
 
81
#define MAX_TOC 16
 
82
typedef struct  _SrvXkmInfo {
 
83
        DeviceIntPtr    dev;
 
84
        FILE *          file;
 
85
        XkbFileInfo     xkbinfo;
 
86
} SrvXkmInfo;
 
87
 
 
88
 
 
89
/***====================================================================***/
 
90
 
 
91
#ifndef XKB_BASE_DIRECTORY
 
92
#define XKB_BASE_DIRECTORY      "/usr/lib/X11/xkb"
 
93
#endif
 
94
#ifndef XKB_DFLT_RULES_FILE
 
95
#define XKB_DFLT_RULES_FILE     "rules"
 
96
#endif
 
97
#ifndef XKB_DFLT_KB_LAYOUT
 
98
#define XKB_DFLT_KB_LAYOUT      "us"
 
99
#endif
 
100
#ifndef XKB_DFLT_KB_MODEL
 
101
#define XKB_DFLT_KB_MODEL       "dflt"
 
102
#endif
 
103
#ifndef XKB_DFLT_KB_VARIANT
 
104
#define XKB_DFLT_KB_VARIANT     NULL
 
105
#endif
 
106
#ifndef XKB_DFLT_KB_OPTIONS
 
107
#define XKB_DFLT_KB_OPTIONS     NULL
 
108
#endif
 
109
#ifndef XKB_DFLT_DISABLED
 
110
#define XKB_DFLT_DISABLED       True
 
111
#endif
 
112
#ifndef XKB_DFLT_RULES_PROP
 
113
#define XKB_DFLT_RULES_PROP     True
 
114
#endif
 
115
 
 
116
char    *               XkbBaseDirectory=       XKB_BASE_DIRECTORY;
 
117
char    *               XkbInitialMap=          NULL;
 
118
int                     XkbWantAccessX=         0;      
 
119
static XkbFileInfo *    _XkbInitFileInfo=       NULL;
 
120
char *                  XkbDB=                  NULL;
 
121
int                     XkbAutoLoad=            1;
 
122
 
 
123
static Bool             rulesDefined=           False;
 
124
static char *           XkbRulesFile=           NULL;
 
125
static char *           XkbModelDflt=           NULL;
 
126
static char *           XkbLayoutDflt=          NULL;
 
127
static char *           XkbVariantDflt=         NULL;
 
128
static char *           XkbOptionsDflt=         NULL;
 
129
 
 
130
char *                  XkbModelUsed=   NULL;
 
131
char *                  XkbLayoutUsed=  NULL;
 
132
char *                  XkbVariantUsed= NULL;
 
133
char *                  XkbOptionsUsed= NULL;
 
134
 
 
135
int                     _XkbClientMajor=        XkbMajorVersion;
 
136
int                     _XkbClientMinor=        XkbMinorVersion;
 
137
 
 
138
Bool                    noXkbExtension=         XKB_DFLT_DISABLED;
 
139
Bool                    XkbWantRulesProp=       XKB_DFLT_RULES_PROP;
 
140
 
 
141
/***====================================================================***/
 
142
 
 
143
char *
 
144
#if NeedFunctionPrototypes
 
145
XkbGetRulesDflts(XkbRF_VarDefsPtr defs)
 
146
#else
 
147
XkbGetRulesDflts(defs)
 
148
        XkbRF_VarDefsPtr defs;
 
149
#endif
 
150
{
 
151
    if (XkbModelDflt)   defs->model= XkbModelDflt;
 
152
    else                defs->model= XKB_DFLT_KB_MODEL;
 
153
    if (XkbLayoutDflt)  defs->layout= XkbLayoutDflt;
 
154
    else                defs->layout= XKB_DFLT_KB_LAYOUT;
 
155
    if (XkbVariantDflt) defs->variant= XkbVariantDflt;
 
156
    else                defs->variant= XKB_DFLT_KB_VARIANT;
 
157
    if (XkbOptionsDflt) defs->options= XkbOptionsDflt;
 
158
    else                defs->options= XKB_DFLT_KB_OPTIONS;
 
159
    return (rulesDefined?XkbRulesFile:XKB_DFLT_RULES_FILE);
 
160
}
 
161
 
 
162
Bool
 
163
#if NeedFunctionPrototypes
 
164
XkbWriteRulesProp(ClientPtr client, pointer closure)
 
165
#else
 
166
XkbWriteRulesProp(client, closure)
 
167
    ClientPtr   client;
 
168
    pointer     closure;
 
169
#endif
 
170
{
 
171
int                     len,out;
 
172
Atom                    name;
 
173
char *                  pval;
 
174
 
 
175
    if (rulesDefined && (!XkbRulesFile))
 
176
        return False;
 
177
    len= (XkbRulesFile?strlen(XkbRulesFile):strlen(XKB_DFLT_RULES_FILE));
 
178
    len+= (XkbModelUsed?strlen(XkbModelUsed):0);
 
179
    len+= (XkbLayoutUsed?strlen(XkbLayoutUsed):0);
 
180
    len+= (XkbVariantUsed?strlen(XkbVariantUsed):0);
 
181
    len+= (XkbOptionsUsed?strlen(XkbOptionsUsed):0);
 
182
    if (len<1)
 
183
        return True;
 
184
 
 
185
    len+= 5; /* trailing NULs */
 
186
 
 
187
    name= MakeAtom(_XKB_RF_NAMES_PROP_ATOM,strlen(_XKB_RF_NAMES_PROP_ATOM),1);
 
188
    if (name==None) {
 
189
        ErrorF("Atom error: %s not created\n",_XKB_RF_NAMES_PROP_ATOM);
 
190
        return True;
 
191
    }
 
192
    pval= (char*) ALLOCATE_LOCAL(len);
 
193
    if (!pval) {
 
194
        ErrorF("Allocation error: %s proprerty not created\n",
 
195
                                                _XKB_RF_NAMES_PROP_ATOM);
 
196
        return True;
 
197
    }
 
198
    out= 0;
 
199
    if (XkbRulesFile) {
 
200
        strcpy(&pval[out],XkbRulesFile);
 
201
        out+= strlen(XkbRulesFile);
 
202
    }
 
203
    pval[out++]= '\0';
 
204
    if (XkbModelUsed) {
 
205
        strcpy(&pval[out],XkbModelUsed);
 
206
        out+= strlen(XkbModelUsed);
 
207
    } 
 
208
    pval[out++]= '\0';
 
209
    if (XkbLayoutUsed) {
 
210
        strcpy(&pval[out],XkbLayoutUsed);
 
211
        out+= strlen(XkbLayoutUsed);
 
212
    }
 
213
    pval[out++]= '\0';
 
214
    if (XkbVariantUsed) {
 
215
        strcpy(&pval[out],XkbVariantUsed);
 
216
        out+= strlen(XkbVariantUsed);
 
217
    }
 
218
    pval[out++]= '\0';
 
219
    if (XkbOptionsUsed) {
 
220
        strcpy(&pval[out],XkbOptionsUsed);
 
221
        out+= strlen(XkbOptionsUsed);
 
222
    }
 
223
    pval[out++]= '\0';
 
224
    if (out!=len) {
 
225
        ErrorF("Internal Error! bad size (%d!=%d) for _XKB_RULES_NAMES\n",
 
226
                                                                out,len);
 
227
    }
 
228
    ChangeWindowProperty(WindowTable[0],name,XA_STRING,8,PropModeReplace,
 
229
                                                        len,pval,True);
 
230
    DEALLOCATE_LOCAL(pval);
 
231
    return True;
 
232
}
 
233
 
 
234
void
 
235
#if NeedFunctionPrototypes
 
236
XkbSetRulesUsed(XkbRF_VarDefsPtr defs)
 
237
#else
 
238
XkbSetRulesUsed(defs)
 
239
    XkbRF_VarDefsPtr    defs;
 
240
#endif
 
241
{
 
242
    if (XkbModelUsed)
 
243
        _XkbFree(XkbModelUsed);
 
244
    XkbModelUsed= (defs->model?_XkbDupString(defs->model):NULL);
 
245
    if (XkbLayoutUsed)
 
246
        _XkbFree(XkbLayoutUsed);
 
247
    XkbLayoutUsed= (defs->layout?_XkbDupString(defs->layout):NULL);
 
248
    if (XkbVariantUsed)
 
249
        _XkbFree(XkbVariantUsed);
 
250
    XkbVariantUsed= (defs->variant?_XkbDupString(defs->variant):NULL);
 
251
    if (XkbOptionsUsed)
 
252
        _XkbFree(XkbOptionsUsed);
 
253
    XkbOptionsUsed= (defs->options?_XkbDupString(defs->options):NULL);
 
254
    if (XkbWantRulesProp)
 
255
        QueueWorkProc(XkbWriteRulesProp,NULL,NULL);
 
256
    return;
 
257
}
 
258
 
 
259
void
 
260
#if NeedFunctionPrototypes
 
261
XkbSetRulesDflts(char *rulesFile,char *model,char *layout,
 
262
                                        char *variant,char *options)
 
263
#else
 
264
XkbSetRulesDflts(rulesFile,model,layout,variant,options)
 
265
    char *      rulesFile;
 
266
    char *      model;
 
267
    char *      layout;
 
268
    char *      variant;
 
269
    char *      options;
 
270
#endif
 
271
{
 
272
    if (XkbRulesFile)
 
273
        _XkbFree(XkbRulesFile);
 
274
    XkbRulesFile= _XkbDupString(rulesFile);
 
275
    rulesDefined= True;
 
276
    if (model) {
 
277
        if (XkbModelDflt)
 
278
            _XkbFree(XkbModelDflt);
 
279
        XkbModelDflt= _XkbDupString(model);
 
280
    }
 
281
    if (layout) {
 
282
        if (XkbLayoutDflt)
 
283
            _XkbFree(XkbLayoutDflt);
 
284
        XkbLayoutDflt= _XkbDupString(layout);
 
285
    }
 
286
    if (variant) {
 
287
        if (XkbVariantDflt)
 
288
            _XkbFree(XkbVariantDflt);
 
289
        XkbVariantDflt= _XkbDupString(variant);
 
290
    }
 
291
    if (options) {
 
292
        if (XkbOptionsDflt)
 
293
            _XkbFree(XkbOptionsDflt);
 
294
        XkbOptionsDflt= _XkbDupString(options);
 
295
    }
 
296
    return;
 
297
}
 
298
 
 
299
/***====================================================================***/
 
300
 
 
301
#if defined(luna)
 
302
#define XKB_DDX_PERMANENT_LOCK  1
 
303
#endif
 
304
 
 
305
#include "xkbDflts.h"
 
306
 
 
307
/* A dummy to keep the compiler quiet */
 
308
pointer xkbBogus = &indicators;
 
309
 
 
310
static Bool
 
311
#if NeedFunctionPrototypes
 
312
XkbInitKeyTypes(XkbDescPtr xkb,SrvXkmInfo *file)
 
313
#else
 
314
XkbInitKeyTypes(xkb,file)
 
315
    XkbDescPtr          xkb;
 
316
    SrvXkmInfo *        file;
 
317
#endif
 
318
{
 
319
    if (file->xkbinfo.defined&XkmTypesMask)
 
320
        return True;
 
321
    initTypeNames(NULL);
 
322
    if (XkbAllocClientMap(xkb,XkbKeyTypesMask,num_dflt_types)!=Success)
 
323
        return False;
 
324
    if (XkbCopyKeyTypes(dflt_types,xkb->map->types,num_dflt_types)!=
 
325
                                                                 Success) {
 
326
        return False;
 
327
    }
 
328
    xkb->map->size_types= xkb->map->num_types= num_dflt_types;
 
329
    return True;
 
330
}
 
331
 
 
332
static void
 
333
#if NeedFunctionPrototypes
 
334
XkbInitRadioGroups(XkbSrvInfoPtr xkbi,SrvXkmInfo *file)
 
335
#else
 
336
XkbInitRadioGroups(xkbi,file)
 
337
    XkbSrvInfoPtr       xkbi;
 
338
    SrvXkmInfo *        file;
 
339
#endif
 
340
{
 
341
    xkbi->nRadioGroups = 0;
 
342
    xkbi->radioGroups = NULL;
 
343
    return;
 
344
}
 
345
 
 
346
 
 
347
static Status
 
348
#if NeedFunctionPrototypes
 
349
XkbInitCompatStructs(XkbDescPtr xkb,SrvXkmInfo *file)
 
350
#else
 
351
XkbInitCompatStructs(xkb,file)
 
352
    XkbDescPtr          xkb;
 
353
    SrvXkmInfo *        file;
 
354
#endif
 
355
{
 
356
register int    i;
 
357
XkbCompatMapPtr compat;
 
358
 
 
359
    if (file->xkbinfo.defined&XkmCompatMapMask)
 
360
        return Success;
 
361
    if (XkbAllocCompatMap(xkb,XkbAllCompatMask,num_dfltSI)!=Success)
 
362
        return BadAlloc;
 
363
    compat = xkb->compat;
 
364
    if (compat->sym_interpret) {
 
365
        compat->num_si = num_dfltSI;
 
366
        memcpy((char *)compat->sym_interpret,(char *)dfltSI,sizeof(dfltSI));
 
367
    }
 
368
    for (i=0;i<XkbNumKbdGroups;i++) {
 
369
        compat->groups[i]= compatMap.groups[i];
 
370
        if (compat->groups[i].vmods!=0) {
 
371
            unsigned mask;
 
372
            mask= XkbMaskForVMask(xkb,compat->groups[i].vmods);
 
373
            compat->groups[i].mask= compat->groups[i].real_mods|mask;
 
374
        }
 
375
        else compat->groups[i].mask= compat->groups[i].real_mods;
 
376
    }
 
377
    return Success;
 
378
}
 
379
 
 
380
static void
 
381
#if NeedFunctionPrototypes
 
382
XkbInitSemantics(XkbDescPtr xkb,SrvXkmInfo *file)
 
383
#else
 
384
XkbInitSemantics(xkb,file)
 
385
    XkbDescPtr          xkb;
 
386
    SrvXkmInfo *        file;
 
387
#endif
 
388
{
 
389
    XkbInitKeyTypes(xkb,file);
 
390
    XkbInitCompatStructs(xkb,file);
 
391
    return;
 
392
}
 
393
 
 
394
/***====================================================================***/
 
395
 
 
396
static Status
 
397
#if NeedFunctionPrototypes
 
398
XkbInitNames(XkbSrvInfoPtr xkbi,SrvXkmInfo *file)
 
399
#else
 
400
XkbInitNames(xkbi,file)
 
401
    XkbSrvInfoPtr       xkbi;
 
402
    SrvXkmInfo *        file;
 
403
#endif
 
404
{
 
405
XkbDescPtr      xkb;
 
406
XkbNamesPtr     names;
 
407
Status          rtrn;
 
408
Atom            unknown;
 
409
 
 
410
    xkb= xkbi->desc;
 
411
    if ((rtrn=XkbAllocNames(xkb,XkbAllNamesMask,0,0))!=Success)
 
412
        return rtrn;
 
413
    unknown= CREATE_ATOM("unknown");
 
414
    names = xkb->names;
 
415
    if (names->keycodes==None)          names->keycodes= unknown;
 
416
    if (names->geometry==None)          names->geometry= unknown;
 
417
    if (names->phys_symbols==None)      names->phys_symbols= unknown;
 
418
    if (names->symbols==None)           names->symbols= unknown;
 
419
    if (names->types==None)             names->types= unknown;
 
420
    if (names->compat==None)            names->compat= unknown;
 
421
    if ((file->xkbinfo.defined&XkmVirtualModsMask)==0) {
 
422
        if (names->vmods[vmod_NumLock]==None)
 
423
            names->vmods[vmod_NumLock]= CREATE_ATOM("NumLock");
 
424
        if (names->vmods[vmod_Alt]==None)
 
425
            names->vmods[vmod_Alt]= CREATE_ATOM("Alt");
 
426
        if (names->vmods[vmod_AltGr]==None)
 
427
            names->vmods[vmod_AltGr]= CREATE_ATOM("ModeSwitch");
 
428
    }
 
429
 
 
430
    if (((file->xkbinfo.defined&XkmIndicatorsMask)==0)||
 
431
        ((file->xkbinfo.defined&XkmGeometryMask)==0)) {
 
432
        initIndicatorNames(NULL,xkb);
 
433
        if (names->indicators[LED_CAPS-1]==None)
 
434
            names->indicators[LED_CAPS-1] = CREATE_ATOM("Caps Lock");
 
435
        if (names->indicators[LED_NUM-1]==None)
 
436
            names->indicators[LED_NUM-1] = CREATE_ATOM("Num Lock");
 
437
        if (names->indicators[LED_SCROLL-1]==None)
 
438
            names->indicators[LED_SCROLL-1] = CREATE_ATOM("Scroll Lock");
 
439
#ifdef LED_COMPOSE
 
440
        if (names->indicators[LED_COMPOSE-1]==None)
 
441
            names->indicators[LED_COMPOSE-1] = CREATE_ATOM("Compose");
 
442
#endif
 
443
    }
 
444
#ifdef DEBUG_RADIO_GROUPS
 
445
    if (names->num_rg<1) {
 
446
        names->radio_groups= (Atom *)_XkbCalloc(RG_COUNT, sizeof(Atom));
 
447
        if (names->radio_groups) {
 
448
            names->num_rg = RG_COUNT;
 
449
            names->radio_groups[RG_BOGUS_FUNCTION_GROUP]= CREATE_ATOM("BOGUS");
 
450
        }
 
451
    }
 
452
#endif
 
453
    if (xkb->geom!=NULL)
 
454
         names->geometry= xkb->geom->name;
 
455
    else names->geometry= unknown;
 
456
    return Success;
 
457
}
 
458
 
 
459
static Status
 
460
#if NeedFunctionPrototypes
 
461
XkbInitIndicatorMap(XkbSrvInfoPtr xkbi,SrvXkmInfo *file)
 
462
#else
 
463
XkbInitIndicatorMap(xkbi,file)
 
464
    XkbSrvInfoPtr       xkbi;
 
465
    SrvXkmInfo *        file;
 
466
#endif
 
467
{
 
468
XkbDescPtr              xkb;
 
469
XkbIndicatorPtr         map;
 
470
XkbSrvLedInfoPtr        sli;
 
471
 
 
472
    xkb= xkbi->desc;
 
473
    if (XkbAllocIndicatorMaps(xkb)!=Success)
 
474
        return BadAlloc;
 
475
    if ((file->xkbinfo.defined&XkmIndicatorsMask)==0) {
 
476
        map= xkb->indicators;
 
477
        map->phys_indicators = PHYS_LEDS;
 
478
        map->maps[LED_CAPS-1].flags= XkbIM_NoExplicit;
 
479
        map->maps[LED_CAPS-1].which_mods= XkbIM_UseLocked;
 
480
        map->maps[LED_CAPS-1].mods.mask= LockMask;
 
481
        map->maps[LED_CAPS-1].mods.real_mods= LockMask;
 
482
 
 
483
        map->maps[LED_NUM-1].flags= XkbIM_NoExplicit;
 
484
        map->maps[LED_NUM-1].which_mods= XkbIM_UseLocked;
 
485
        map->maps[LED_NUM-1].mods.mask= 0;
 
486
        map->maps[LED_NUM-1].mods.real_mods= 0;
 
487
        map->maps[LED_NUM-1].mods.vmods= vmod_NumLockMask;
 
488
 
 
489
/* Metro Link */
 
490
        map->maps[LED_SCROLL-1].flags= XkbIM_NoExplicit;
 
491
        map->maps[LED_SCROLL-1].which_mods= XkbIM_UseLocked;
 
492
        map->maps[LED_SCROLL-1].mods.mask= Mod3Mask;
 
493
        map->maps[LED_SCROLL-1].mods.real_mods= Mod3Mask;
 
494
/* Metro Link */
 
495
    }
 
496
    sli= XkbFindSrvLedInfo(xkbi->device,XkbDfltXIClass,XkbDfltXIId,0);
 
497
    if (sli)
 
498
        XkbCheckIndicatorMaps(xkbi->device,sli,XkbAllIndicatorsMask);
 
499
    return Success;
 
500
}
 
501
 
 
502
static Status
 
503
#if NeedFunctionPrototypes
 
504
XkbInitControls(DeviceIntPtr pXDev,XkbSrvInfoPtr xkbi,SrvXkmInfo *file)
 
505
#else
 
506
XkbInitControls(pXDev,xkbi,file)
 
507
    DeviceIntPtr        pXDev;
 
508
    XkbSrvInfoPtr       xkbi;
 
509
    SrvXkmInfo *        file;
 
510
#endif
 
511
{
 
512
XkbDescPtr      xkb;
 
513
XkbControlsPtr  ctrls;
 
514
 
 
515
    xkb= xkbi->desc;
 
516
    /* 12/31/94 (ef) -- XXX! Should check if controls loaded from file */
 
517
    if (XkbAllocControls(xkb,XkbAllControlsMask)!=Success)
 
518
        FatalError("Couldn't allocate keyboard controls\n");
 
519
    ctrls= xkb->ctrls;
 
520
    if ((file->xkbinfo.defined&XkmSymbolsMask)==0)
 
521
        ctrls->num_groups = 1;
 
522
    ctrls->groups_wrap = XkbSetGroupInfo(1,XkbWrapIntoRange,0);
 
523
    ctrls->internal.mask = 0;
 
524
    ctrls->internal.real_mods = 0;
 
525
    ctrls->internal.vmods = 0;
 
526
    ctrls->ignore_lock.mask = 0;
 
527
    ctrls->ignore_lock.real_mods = 0;
 
528
    ctrls->ignore_lock.vmods = 0;
 
529
    ctrls->enabled_ctrls = XkbAccessXTimeoutMask|XkbRepeatKeysMask|
 
530
                                XkbMouseKeysAccelMask|XkbAudibleBellMask|
 
531
                                XkbIgnoreGroupLockMask;
 
532
    if (XkbWantAccessX)
 
533
        ctrls->enabled_ctrls|= XkbAccessXKeysMask;
 
534
    AccessXInit(pXDev);
 
535
    return Success;
 
536
}
 
537
 
 
538
void
 
539
#if NeedFunctionPrototypes
 
540
XkbInitDevice(DeviceIntPtr pXDev)
 
541
#else
 
542
XkbInitDevice(pXDev)
 
543
    DeviceIntPtr pXDev;
 
544
#endif
 
545
{
 
546
int                     i;
 
547
XkbSrvInfoPtr           xkbi;
 
548
XkbChangesRec           changes;
 
549
SrvXkmInfo              file;
 
550
unsigned                check;
 
551
XkbEventCauseRec        cause;
 
552
 
 
553
    file.dev= pXDev;
 
554
    file.file=NULL;
 
555
    bzero(&file.xkbinfo,sizeof(XkbFileInfo));
 
556
    bzero(&changes,sizeof(XkbChangesRec));
 
557
    if (XkbAutoLoad && (XkbInitialMap!=NULL)) {
 
558
        if ((file.file=XkbDDXOpenConfigFile(XkbInitialMap,NULL,0))!=NULL) {
 
559
            XkmReadFile(file.file,0,XkmKeymapLegal,&file.xkbinfo);
 
560
            if (file.xkbinfo.xkb==NULL) {
 
561
                ErrorF("Error loading keymap file %s (%s in %s)\n",
 
562
                                XkbInitialMap, _XkbErrMessages[_XkbErrCode],
 
563
                                (_XkbErrLocation?_XkbErrLocation:"unknown"));
 
564
                ErrorF("      reverting to defaults\n");
 
565
                fclose(file.file);
 
566
                file.file= NULL;
 
567
                bzero(&file.xkbinfo,sizeof(XkbFileInfo));
 
568
            }
 
569
            else {
 
570
                if (_XkbInitFileInfo!=NULL) {
 
571
                    XkbDescPtr  tmp;
 
572
                    if ((tmp=_XkbInitFileInfo->xkb)!=NULL) {
 
573
                        XkbFreeKeyboard(tmp,XkbAllComponentsMask,True);
 
574
                        _XkbInitFileInfo->xkb= NULL;
 
575
                    }
 
576
                }
 
577
                _XkbInitFileInfo= &file.xkbinfo;
 
578
            }
 
579
        }
 
580
        else {
 
581
            ErrorF("Error opening keymap file %s, reverting to defaults\n",
 
582
                                                                XkbInitialMap);
 
583
        }
 
584
    }
 
585
    pXDev->key->xkbInfo= xkbi= _XkbTypedCalloc(1,XkbSrvInfoRec);
 
586
    if ( xkbi ) {
 
587
        XkbDescPtr      xkb;
 
588
        if ((_XkbInitFileInfo!=NULL)&&(_XkbInitFileInfo->xkb!=NULL)) {
 
589
            file.xkbinfo= *_XkbInitFileInfo;
 
590
            xkbi->desc= _XkbInitFileInfo->xkb;
 
591
            _XkbInitFileInfo= NULL;
 
592
        }
 
593
        else {
 
594
            xkbi->desc= XkbAllocKeyboard();
 
595
            if (!xkbi->desc)
 
596
                FatalError("Couldn't allocate keyboard description\n");
 
597
            xkbi->desc->min_key_code = pXDev->key->curKeySyms.minKeyCode;
 
598
            xkbi->desc->max_key_code = pXDev->key->curKeySyms.maxKeyCode;
 
599
        }
 
600
        xkb= xkbi->desc;
 
601
        if (xkb->min_key_code == 0)
 
602
            xkb->min_key_code = pXDev->key->curKeySyms.minKeyCode;
 
603
        if (xkb->max_key_code == 0)
 
604
            xkb->max_key_code = pXDev->key->curKeySyms.maxKeyCode;
 
605
        if ((pXDev->key->curKeySyms.minKeyCode!=xkbi->desc->min_key_code)||
 
606
            (pXDev->key->curKeySyms.maxKeyCode!=xkbi->desc->max_key_code)) {
 
607
            /* 12/9/95 (ef) -- XXX! Maybe we should try to fix up one or */
 
608
            /*                 the other here, but for now just complain */
 
609
            /*                 can't just update the core range without */
 
610
            /*                 reallocating the KeySymsRec (pain)       */
 
611
            ErrorF("Internal Error!! XKB and core keymap have different range\n");
 
612
        }
 
613
        if (XkbAllocClientMap(xkb,XkbAllClientInfoMask,0)!=Success)
 
614
            FatalError("Couldn't allocate client map in XkbInitDevice\n");
 
615
        i= XkbNumKeys(xkb)/3+1;
 
616
        if (XkbAllocServerMap(xkb,XkbAllServerInfoMask,i)!=Success)
 
617
            FatalError("Couldn't allocate server map in XkbInitDevice\n");
 
618
 
 
619
        xkbi->dfltPtrDelta=1;
 
620
        xkbi->device = pXDev;
 
621
 
 
622
        file.xkbinfo.xkb= xkb;
 
623
        XkbInitSemantics(xkb,&file);
 
624
        XkbInitNames(xkbi,&file);
 
625
        XkbInitRadioGroups(xkbi,&file);
 
626
 
 
627
        /* 12/31/94 (ef) -- XXX! Should check if state loaded from file */
 
628
        bzero(&xkbi->state,sizeof(XkbStateRec));
 
629
 
 
630
        XkbInitControls(pXDev,xkbi,&file);
 
631
 
 
632
        if (file.xkbinfo.defined&XkmSymbolsMask)
 
633
           memcpy(pXDev->key->modifierMap,xkb->map->modmap,xkb->max_key_code+1);
 
634
        else
 
635
           memcpy(xkb->map->modmap,pXDev->key->modifierMap,xkb->max_key_code+1);
 
636
 
 
637
        XkbInitIndicatorMap(xkbi,&file);
 
638
 
 
639
        XkbDDXInitDevice(pXDev);
 
640
 
 
641
        if (!(file.xkbinfo.defined&XkmSymbolsMask)) {
 
642
            XkbUpdateKeyTypesFromCore(pXDev,xkb->min_key_code,XkbNumKeys(xkb),
 
643
                                                                &changes);
 
644
        }
 
645
        else {
 
646
            XkbUpdateCoreDescription(pXDev,True);
 
647
        }
 
648
        XkbSetCauseUnknown(&cause);
 
649
        XkbUpdateActions(pXDev,xkb->min_key_code, XkbNumKeys(xkb),&changes,
 
650
                                                                &check,&cause);
 
651
        /* For sanity.  The first time the connection
 
652
         * is opened, the client side min and max are set
 
653
         * using QueryMinMaxKeyCodes() which grabs them 
 
654
         * from pXDev.
 
655
         */
 
656
        pXDev->key->curKeySyms.minKeyCode = xkb->min_key_code;
 
657
        pXDev->key->curKeySyms.maxKeyCode = xkb->max_key_code;
 
658
    }
 
659
    if (file.file!=NULL)
 
660
        fclose(file.file);
 
661
    return;
 
662
}
 
663
 
 
664
#if MAP_LENGTH > XkbMaxKeyCount
 
665
#undef  XkbMaxKeyCount
 
666
#define XkbMaxKeyCount MAP_LENGTH
 
667
#endif
 
668
 
 
669
Bool
 
670
#if NeedFunctionPrototypes
 
671
XkbInitKeyboardDeviceStruct(    DeviceIntPtr            dev,
 
672
                                XkbComponentNamesPtr    names,
 
673
                                KeySymsPtr              pSymsIn,
 
674
                                CARD8                   pModsIn[],
 
675
                                void                    (*bellProc)(),
 
676
                                void                    (*ctrlProc)())
 
677
#else
 
678
XkbInitKeyboardDeviceStruct( dev,names,pSymsIn,pModsIn,bellProc,ctrlProc )
 
679
    DeviceIntPtr                  dev;
 
680
    XkbComponentNamesPtr          names;
 
681
    KeySymsPtr                    pSymsIn;
 
682
    CARD8                         pModsIn[];
 
683
    void                        (*bellProc)();
 
684
    void                        (*ctrlProc)();
 
685
#endif
 
686
{
 
687
XkbFileInfo             finfo;
 
688
KeySymsRec              tmpSyms,*pSyms;
 
689
CARD8                   tmpMods[XkbMaxLegalKeyCode+1],*pMods;
 
690
char                    name[PATH_MAX],*rules;
 
691
Bool                    ok=False;
 
692
XPointer                config;
 
693
XkbComponentNamesRec    cfgNames;
 
694
XkbRF_VarDefsRec        defs;
 
695
 
 
696
    if ((dev->key!=NULL)||(dev->kbdfeed!=NULL))
 
697
        return False;
 
698
    pSyms= pSymsIn;
 
699
    pMods= pModsIn;
 
700
    bzero(&defs,sizeof(XkbRF_VarDefsRec));
 
701
    bzero(&cfgNames,sizeof(XkbComponentNamesRec));
 
702
    rules= XkbGetRulesDflts(&defs);
 
703
    config= XkbDDXPreloadConfig(&rules,&defs,&cfgNames,dev);
 
704
 
 
705
    /*
 
706
     * The strings are duplicated because it is not guaranteed that
 
707
     * they are allocated, or that they are allocated for every server
 
708
     * generation. Eventually they will be freed at the end of this
 
709
     * function.
 
710
     */
 
711
    if (names->keymap) names->keymap = _XkbDupString(names->keymap);
 
712
    if (names->keycodes) names->keycodes = _XkbDupString(names->keycodes);
 
713
    if (names->types) names->types = _XkbDupString(names->types);
 
714
    if (names->compat) names->compat = _XkbDupString(names->compat);
 
715
    if (names->geometry) names->geometry = _XkbDupString(names->geometry);
 
716
    if (names->symbols) names->geometry = _XkbDupString(names->symbols);
 
717
 
 
718
    if (defs.model && defs.layout && rules) {
 
719
        XkbComponentNamesRec    rNames;
 
720
        bzero(&rNames,sizeof(XkbComponentNamesRec));
 
721
        if (XkbDDXNamesFromRules(dev,rules,&defs,&rNames)) {
 
722
            if (rNames.keymap) {
 
723
                if (!names->keymap)
 
724
                    names->keymap = rNames.keymap;
 
725
                else _XkbFree(rNames.keymap);
 
726
            }
 
727
            if (rNames.keycodes) {
 
728
                if (!names->keycodes)
 
729
                    names->keycodes =  rNames.keycodes;
 
730
                else
 
731
                    _XkbFree(rNames.keycodes);
 
732
            }
 
733
            if (rNames.types) {
 
734
                if (!names->types)
 
735
                    names->types = rNames.types;
 
736
                else  _XkbFree(rNames.types);
 
737
            }
 
738
            if (rNames.compat) {
 
739
                if (!names->compat) 
 
740
                    names->compat =  rNames.compat;
 
741
                else  _XkbFree(rNames.compat);
 
742
            }
 
743
            if (rNames.symbols) {
 
744
                if (!names->symbols)
 
745
                    names->symbols =  rNames.symbols;
 
746
                else _XkbFree(rNames.symbols);
 
747
            }
 
748
            if (rNames.geometry) {
 
749
                if (!names->geometry)
 
750
                    names->geometry = rNames.geometry;
 
751
                else _XkbFree(rNames.geometry);
 
752
            }
 
753
            XkbSetRulesUsed(&defs);
 
754
        }
 
755
    }
 
756
    if (cfgNames.keymap){
 
757
        if (names->keymap) _XkbFree(names->keymap);
 
758
        names->keymap= cfgNames.keymap;
 
759
    }
 
760
    if (cfgNames.keycodes){
 
761
        if (names->keycodes) _XkbFree(names->keycodes); 
 
762
        names->keycodes= cfgNames.keycodes;
 
763
    }
 
764
    if (cfgNames.types) {
 
765
        if (names->types) _XkbFree(names->types);       
 
766
        names->types= cfgNames.types;
 
767
    }
 
768
    if (cfgNames.compat) {
 
769
        if (names->compat) _XkbFree(names->compat);     
 
770
        names->compat= cfgNames.compat;
 
771
    }
 
772
    if (cfgNames.symbols){
 
773
        if (names->symbols) _XkbFree(names->symbols);   
 
774
        names->symbols= cfgNames.symbols;
 
775
    }
 
776
    if (cfgNames.geometry) {
 
777
        if (names->geometry) _XkbFree(names->geometry);
 
778
        names->geometry= cfgNames.geometry;
 
779
    }
 
780
 
 
781
    if (names->keymap) {
 
782
        XkbComponentNamesRec    tmpNames;
 
783
        bzero(&tmpNames,sizeof(XkbComponentNamesRec));
 
784
        tmpNames.keymap = names->keymap;
 
785
        ok = (Bool) XkbDDXLoadKeymapByNames(dev,&tmpNames,XkmAllIndicesMask,0,
 
786
                                            &finfo,name,PATH_MAX);
 
787
    }
 
788
    if (!(ok && (finfo.xkb!=NULL)))
 
789
        ok = (Bool) XkbDDXLoadKeymapByNames(dev,names,XkmAllIndicesMask,0,
 
790
                                            &finfo,name,PATH_MAX);
 
791
 
 
792
    if (ok && (finfo.xkb!=NULL)) {
 
793
        XkbDescPtr      xkb;
 
794
        int             minKC,maxKC;
 
795
 
 
796
        xkb= finfo.xkb;
 
797
        minKC= xkb->min_key_code;
 
798
        maxKC= xkb->max_key_code;
 
799
        if (XkbIsLegalKeycode(minKC)&&XkbIsLegalKeycode(maxKC)&&(minKC<=maxKC)&&
 
800
            ((minKC!=pSyms->minKeyCode)||(maxKC!=pSyms->maxKeyCode))) {
 
801
            if (xkb->map!=NULL) {
 
802
                KeySym  *inSym,*outSym;
 
803
                int     width= pSymsIn->mapWidth;
 
804
 
 
805
                tmpSyms.minKeyCode= minKC;
 
806
                tmpSyms.maxKeyCode= maxKC;
 
807
 
 
808
                if (minKC<pSymsIn->minKeyCode)
 
809
                    minKC= pSymsIn->minKeyCode;
 
810
                if (maxKC>pSymsIn->maxKeyCode)
 
811
                    maxKC= pSymsIn->maxKeyCode;
 
812
 
 
813
                tmpSyms.mapWidth= width;
 
814
                tmpSyms.map= _XkbTypedCalloc(width*XkbNumKeys(xkb),KeySym);
 
815
                inSym= &pSymsIn->map[(minKC-pSymsIn->minKeyCode)*width];
 
816
                outSym= &tmpSyms.map[(minKC-tmpSyms.minKeyCode)*width];
 
817
                memcpy(outSym,inSym,((maxKC-minKC+1)*width)*sizeof(KeySym));
 
818
                pSyms= &tmpSyms;
 
819
            }
 
820
            if ((xkb->map!=NULL)&&(xkb->map->modmap!=NULL)) {
 
821
                bzero(tmpMods,XkbMaxKeyCount);
 
822
                memcpy(tmpMods,xkb->map->modmap,maxKC+1);
 
823
                pMods= tmpMods;
 
824
            }
 
825
        }
 
826
        _XkbInitFileInfo= &finfo;
 
827
    }
 
828
    else {
 
829
        ErrorF("Couldn't load XKB keymap, falling back to pre-XKB keymap\n");
 
830
    }
 
831
    ok= InitKeyboardDeviceStruct((DevicePtr)dev,pSyms,pMods,bellProc,ctrlProc);
 
832
    if ((config!=NULL)&&(dev && dev->key && dev->key->xkbInfo))
 
833
        XkbDDXApplyConfig(config,dev->key->xkbInfo);
 
834
    _XkbInitFileInfo= NULL;
 
835
    if ((pSyms==&tmpSyms)&&(pSyms->map!=NULL)) {
 
836
        _XkbFree(pSyms->map);
 
837
        pSyms->map= NULL;
 
838
    }
 
839
 
 
840
    if (names->keymap) _XkbFree(names->keymap);
 
841
    names->keymap = NULL;
 
842
    if (names->keycodes) _XkbFree(names->keycodes);
 
843
    names->keycodes = NULL;
 
844
    if (names->types) _XkbFree(names->types);
 
845
    names->types = NULL;
 
846
    if (names->compat) _XkbFree(names->compat);
 
847
    names->compat = NULL;
 
848
    if (names->geometry) _XkbFree(names->geometry);
 
849
    names->geometry = NULL;
 
850
    if (names->symbols) _XkbFree(names->symbols);
 
851
    names->symbols = NULL;
 
852
 
 
853
    return ok;
 
854
}
 
855
 
 
856
/***====================================================================***/
 
857
 
 
858
        /*
 
859
         * InitKeyClassDeviceStruct initializes the key class before it
 
860
         * initializes the keyboard feedback class for a device. 
 
861
         * UpdateActions can't set up the correct autorepeat for keyboard 
 
862
         * initialization because the keyboard feedback isn't created yet.   
 
863
         * Instead, UpdateActions notes the "correct" autorepeat in the 
 
864
         * SrvInfo structure and InitKbdFeedbackClass calls UpdateAutoRepeat 
 
865
         * to apply the computed autorepeat once the feedback class exists.
 
866
         *
 
867
         * DIX will apply the changed autorepeat, so there's no need to
 
868
         * do so here.   This function returns True if both RepeatKeys and
 
869
         * the core protocol autorepeat ctrls are set (i.e. should use 
 
870
         * software autorepeat), false otherwise.
 
871
         *
 
872
         * This function also computes the autorepeat accelerators for the
 
873
         * default indicator feedback.
 
874
         */
 
875
int
 
876
#if NeedFunctionPrototypes
 
877
XkbFinishDeviceInit(DeviceIntPtr pXDev)
 
878
#else
 
879
XkbFinishDeviceInit(pXDev)
 
880
    DeviceIntPtr pXDev;
 
881
#endif
 
882
{
 
883
XkbSrvInfoPtr           xkbi;
 
884
XkbDescPtr              xkb;
 
885
int                     softRepeat;
 
886
XkbSrvLedInfoPtr        sli;
 
887
 
 
888
    xkbi = NULL;
 
889
    if (pXDev && pXDev->key && pXDev->key->xkbInfo && pXDev->kbdfeed) {
 
890
        xkbi= pXDev->key->xkbInfo;
 
891
        xkb= xkbi->desc;
 
892
        if (pXDev->kbdfeed) {
 
893
            xkbi->kbdProc= pXDev->kbdfeed->CtrlProc;
 
894
            pXDev->kbdfeed->CtrlProc= XkbDDXKeybdCtrlProc;
 
895
        }
 
896
        if (pXDev->kbdfeed->ctrl.autoRepeat)
 
897
            xkb->ctrls->enabled_ctrls|= XkbRepeatKeysMask;
 
898
        softRepeat= (xkb->ctrls->enabled_ctrls&XkbRepeatKeysMask)!=0;
 
899
        if (pXDev->kbdfeed) {
 
900
            memcpy(pXDev->kbdfeed->ctrl.autoRepeats,
 
901
                   xkb->ctrls->per_key_repeat,XkbPerKeyBitArraySize);
 
902
            softRepeat= softRepeat&&pXDev->kbdfeed->ctrl.autoRepeat;
 
903
        }
 
904
    }
 
905
    else softRepeat= 0;
 
906
    sli= XkbFindSrvLedInfo(pXDev,XkbDfltXIClass,XkbDfltXIId,0);
 
907
    if (sli && xkbi)
 
908
        XkbCheckIndicatorMaps(xkbi->device,sli,XkbAllIndicatorsMask);
 
909
#ifdef DEBUG
 
910
    else ErrorF("No indicator feedback in XkbFinishInit (shouldn't happen)!\n");
 
911
#endif
 
912
    return softRepeat;
 
913
}
 
914
 
 
915
        /*
 
916
         * Be very careful about what does and doesn't get freed by this 
 
917
         * function.  To reduce fragmentation, XkbInitDevice allocates a 
 
918
         * single huge block per device and divides it up into most of the 
 
919
         * fixed-size structures for the device.   Don't free anything that
 
920
         * is part of this larger block.
 
921
         */
 
922
void
 
923
#if NeedFunctionPrototypes
 
924
XkbFreeInfo(XkbSrvInfoPtr xkbi)
 
925
#else
 
926
XkbFreeInfo(xkbi)
 
927
    XkbSrvInfoPtr       xkbi;
 
928
#endif
 
929
{
 
930
    if (xkbi->radioGroups) {
 
931
        _XkbFree(xkbi->radioGroups);
 
932
        xkbi->radioGroups= NULL;
 
933
    }
 
934
    if (xkbi->mouseKeyTimer) {
 
935
        TimerFree(xkbi->mouseKeyTimer);
 
936
        xkbi->mouseKeyTimer= NULL;
 
937
    }
 
938
    if (xkbi->slowKeysTimer) {
 
939
        TimerFree(xkbi->slowKeysTimer);
 
940
        xkbi->slowKeysTimer= NULL;
 
941
    }
 
942
    if (xkbi->bounceKeysTimer) {
 
943
        TimerFree(xkbi->bounceKeysTimer);
 
944
        xkbi->bounceKeysTimer= NULL;
 
945
    }
 
946
    if (xkbi->repeatKeyTimer) {
 
947
        TimerFree(xkbi->repeatKeyTimer);
 
948
        xkbi->repeatKeyTimer= NULL;
 
949
    }
 
950
    if (xkbi->krgTimer) {
 
951
        TimerFree(xkbi->krgTimer);
 
952
        xkbi->krgTimer= NULL;
 
953
    }
 
954
    xkbi->beepType= _BEEP_NONE;
 
955
    if (xkbi->beepTimer) {
 
956
        TimerFree(xkbi->beepTimer);
 
957
        xkbi->beepTimer= NULL;
 
958
    }
 
959
    if (xkbi->desc) {
 
960
        XkbFreeKeyboard(xkbi->desc,XkbAllComponentsMask,True);
 
961
        xkbi->desc= NULL;
 
962
    }
 
963
    _XkbFree(xkbi);
 
964
    return;
 
965
}
 
966
 
 
967
/***====================================================================***/
 
968
 
 
969
extern int      XkbDfltRepeatDelay;
 
970
extern int      XkbDfltRepeatInterval;
 
971
 
 
972
extern unsigned short   XkbDfltAccessXTimeout;
 
973
extern unsigned int     XkbDfltAccessXTimeoutMask;
 
974
extern unsigned int     XkbDfltAccessXFeedback;
 
975
extern unsigned char    XkbDfltAccessXOptions;
 
976
 
 
977
int
 
978
#if NeedFunctionPrototypes
 
979
XkbProcessArguments(int argc,char *argv[],int i)
 
980
#else
 
981
XkbProcessArguments(argc,argv,i)
 
982
    int         argc;
 
983
    char *      argv[];
 
984
    int         i;
 
985
#endif
 
986
{
 
987
    if (strcmp(argv[i],"-kb")==0) {
 
988
        noXkbExtension= True;
 
989
        return 1;
 
990
    }
 
991
    else if (strcmp(argv[i],"+kb")==0) {
 
992
        noXkbExtension= False;
 
993
        return 1;
 
994
    }
 
995
    else if (strncmp(argv[i], "-xkbdir", 7) == 0) {
 
996
        if(++i < argc) {
 
997
#if !defined(WIN32) && !defined(__UNIXOS2__) && !defined(__CYGWIN__)
 
998
            if (getuid() != geteuid()) {
 
999
                ErrorF("-xkbdir is not available for setuid X servers\n");
 
1000
                return -1;
 
1001
            } else
 
1002
#endif
 
1003
            {
 
1004
                if (strlen(argv[i]) < PATH_MAX) {
 
1005
                    XkbBaseDirectory= argv[i];
 
1006
                    return 2;
 
1007
                } else {
 
1008
                    ErrorF("-xkbdir pathname too long\n");
 
1009
                    return -1;
 
1010
                }
 
1011
            }
 
1012
        }
 
1013
        else {
 
1014
            return -1;
 
1015
        }
 
1016
    }
 
1017
    else if (strncmp(argv[i], "-xkbmap", 7) == 0) {
 
1018
        if(++i < argc) {
 
1019
            if (strlen(argv[i]) < PATH_MAX) {
 
1020
                XkbInitialMap= argv[i];
 
1021
                return 2;
 
1022
            } else {
 
1023
                ErrorF("-xkbmap pathname too long\n");
 
1024
                return -1;
 
1025
            }
 
1026
        }
 
1027
        else {
 
1028
            return -1;
 
1029
        }
 
1030
    }
 
1031
    else if (strncmp(argv[i], "-xkbdb", 7) == 0) {
 
1032
        if(++i < argc) {
 
1033
            if (strlen(argv[i]) < PATH_MAX) {
 
1034
                XkbDB= argv[i];
 
1035
                return 2;
 
1036
            } else {
 
1037
                ErrorF("-xkbdb pathname too long\n");
 
1038
                return -1;
 
1039
            }
 
1040
        }
 
1041
        else {
 
1042
            return -1;
 
1043
        }
 
1044
    }
 
1045
    else if (strncmp(argv[i], "-noloadxkb", 7) == 0) {
 
1046
        XkbAutoLoad= 0;
 
1047
        return 1;
 
1048
    }
 
1049
    else if ((strncmp(argv[i],"-accessx",8)==0)||
 
1050
                 (strncmp(argv[i],"+accessx",8)==0)) {
 
1051
        int j=1;            
 
1052
        if (argv[i][0]=='-')        
 
1053
            XkbWantAccessX= 0;
 
1054
        else {
 
1055
            XkbWantAccessX= 1;
 
1056
            
 
1057
            if ( ((i+1)<argc) && (isdigit(argv[i+1][0])) ) {
 
1058
                XkbDfltAccessXTimeout = atoi(argv[++i]);
 
1059
                j++;
 
1060
 
 
1061
                if ( ((i+1)<argc) && (isdigit(argv[i+1][0])) ) {
 
1062
                    /*
 
1063
                     * presumption that the reasonably useful range of
 
1064
                     * values fits in 0..MAXINT since SunOS 4 doesn't
 
1065
                     * have strtoul.
 
1066
                     */
 
1067
                    XkbDfltAccessXTimeoutMask=(unsigned int)
 
1068
                                              strtol(argv[++i],NULL,16); 
 
1069
                    j++;
 
1070
                }
 
1071
                if ( ((i+1)<argc) && (isdigit(argv[i+1][0])) ) {
 
1072
                    if (argv[++i][0] == '1' ) 
 
1073
                        XkbDfltAccessXFeedback=XkbAccessXFeedbackMask;
 
1074
                    else
 
1075
                        XkbDfltAccessXFeedback=0;
 
1076
                    j++;
 
1077
                }
 
1078
                if ( ((i+1)<argc) && (isdigit(argv[i+1][0])) ) {
 
1079
                    XkbDfltAccessXOptions=(unsigned char)
 
1080
                                           strtol(argv[++i],NULL,16);
 
1081
                    j++;
 
1082
                }
 
1083
            }
 
1084
        }
 
1085
        return j;
 
1086
    }
 
1087
    if (strcmp (argv[i], "-ar1") == 0) {        /* -ar1 int */
 
1088
        if (++i >= argc) UseMsg ();
 
1089
        XkbDfltRepeatDelay = (long)atoi(argv[i]);
 
1090
        return 2;
 
1091
    }
 
1092
    if (strcmp (argv[i], "-ar2") == 0) {        /* -ar2 int */
 
1093
        if (++i >= argc) UseMsg ();
 
1094
        XkbDfltRepeatInterval = (long)atoi(argv[i]);
 
1095
        return 2;
 
1096
    }
 
1097
    return 0;
 
1098
}
 
1099
 
 
1100
void
 
1101
#if NeedFunctionPrototypes
 
1102
XkbUseMsg(void)
 
1103
#else
 
1104
XkbUseMsg()
 
1105
#endif
 
1106
{
 
1107
    ErrorF("The X Keyboard Extension adds the following arguments:\n");
 
1108
    ErrorF("-kb                    disable the X Keyboard Extension\n");
 
1109
    ErrorF("+kb                    enable the X Keyboard Extension\n");
 
1110
    ErrorF("[+-]accessx [ timeout [ timeout_mask [ feedback [ options_mask] ] ] ]\n");
 
1111
    ErrorF("                       enable/disable accessx key sequences\n");
 
1112
    ErrorF("-ar1                   set XKB autorepeat delay\n");
 
1113
    ErrorF("-ar2                   set XKB autorepeat interval\n");
 
1114
    ErrorF("-noloadxkb             don't load XKB keymap description\n");
 
1115
    ErrorF("-xkbdb                 file that contains default XKB keymaps\n");
 
1116
    ErrorF("-xkbmap                XKB keyboard description to load on startup\n");
 
1117
}