← Back to branch summary

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

« back to all changes in this revision

Viewing changes to unix/xc/programs/xkbevd/utils.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/xkbevd/utils.c
 
1
 
 
2
  /*\
 
3
   * $XFree86: xc/programs/xkbevd/utils.c,v 3.6 2002/01/14 18:30:11 dawes Exp $
 
4
   *
 
5
   *                          COPYRIGHT 1990
 
6
   *                    DIGITAL EQUIPMENT CORPORATION
 
7
   *                       MAYNARD, MASSACHUSETTS
 
8
   *                        ALL RIGHTS RESERVED.
 
9
   *
 
10
   * THE INFORMATION IN THIS SOFTWARE IS SUBJECT TO CHANGE WITHOUT NOTICE AND
 
11
   * SHOULD NOT BE CONSTRUED AS A COMMITMENT BY DIGITAL EQUIPMENT CORPORATION.
 
12
   * DIGITAL MAKES NO REPRESENTATIONS ABOUT THE SUITABILITY OF THIS SOFTWARE 
 
13
   * FOR ANY PURPOSE.  IT IS SUPPLIED "AS IS" WITHOUT EXPRESS OR IMPLIED 
 
14
   * WARRANTY.
 
15
   *
 
16
   * IF THE SOFTWARE IS MODIFIED IN A MANNER CREATING DERIVATIVE COPYRIGHT
 
17
   * RIGHTS, APPROPRIATE LEGENDS MAY BE PLACED ON THE DERIVATIVE WORK IN
 
18
   * ADDITION TO THAT SET FORTH ABOVE.
 
19
   *
 
20
   * Permission to use, copy, modify, and distribute this software and its
 
21
   * documentation for any purpose and without fee is hereby granted, provided
 
22
   * that the above copyright notice appear in all copies and that both that
 
23
   * copyright notice and this permission notice appear in supporting
 
24
   * documentation, and that the name of Digital Equipment Corporation not be
 
25
   * used in advertising or publicity pertaining to distribution of the 
 
26
   * software without specific, written prior permission.
 
27
  \*/
 
28
/* $Xorg: utils.c,v 1.5 2000/08/17 19:54:49 cpqbld Exp $ */
 
29
 
 
30
#define DEBUG_VAR_LOCAL
 
31
#include        "utils.h"
 
32
#include        <ctype.h>
 
33
#include        <stdlib.h>
 
34
 
 
35
/***====================================================================***/
 
36
 
 
37
Opaque
 
38
uAlloc(size)
 
39
    unsigned    size;
 
40
{
 
41
    return((Opaque)malloc(size));
 
42
}
 
43
 
 
44
/***====================================================================***/
 
45
 
 
46
Opaque
 
47
uCalloc(n,size)
 
48
    unsigned    n;
 
49
    unsigned    size;
 
50
{
 
51
    return((Opaque)calloc(n,size));
 
52
}
 
53
 
 
54
/***====================================================================***/
 
55
 
 
56
Opaque
 
57
uRealloc(old,newSize)
 
58
    Opaque      old;
 
59
    unsigned    newSize;
 
60
{
 
61
    if (old==NULL)
 
62
         return((Opaque)malloc(newSize));
 
63
    else return((Opaque)realloc((char *)old,newSize));
 
64
}
 
65
 
 
66
/***====================================================================***/
 
67
 
 
68
Opaque
 
69
uRecalloc(old,nOld,nNew,itemSize)
 
70
    Opaque      old;
 
71
    unsigned    nOld;
 
72
    unsigned    nNew;
 
73
    unsigned    itemSize;
 
74
{
 
75
char *rtrn;
 
76
 
 
77
    if (old==NULL)
 
78
         rtrn= (char *)calloc(nNew,itemSize);
 
79
    else {
 
80
        rtrn= (char *)realloc((char *)old,nNew*itemSize);
 
81
        if ((rtrn)&&(nNew>nOld)) {
 
82
            bzero(&rtrn[nOld*itemSize],(nNew-nOld)*itemSize);
 
83
        }
 
84
    }
 
85
    return (Opaque)rtrn;
 
86
}
 
87
 
 
88
/***====================================================================***/
 
89
 
 
90
void
 
91
uFree(ptr)
 
92
    Opaque ptr;
 
93
{
 
94
    if (ptr!=(Opaque)NULL)
 
95
        free((char *)ptr);
 
96
    return;
 
97
}
 
98
 
 
99
/***====================================================================***/
 
100
/***                  FUNCTION ENTRY TRACKING                           ***/
 
101
/***====================================================================***/
 
102
 
 
103
static  FILE    *entryFile=     NULL;
 
104
        int      uEntryLevel;
 
105
 
 
106
Boolean
 
107
uSetEntryFile(name)
 
108
    char *name;
 
109
{
 
110
    if ((entryFile!=NULL)&&(entryFile!=stderr)) {
 
111
        fprintf(entryFile,"switching to %s\n",name?name:"stderr");
 
112
        fclose(entryFile);
 
113
    }
 
114
    if (name!=NullString)       entryFile=      fopen(name,"w");
 
115
    else                        entryFile=      stderr;
 
116
    if (entryFile==NULL) {
 
117
        entryFile=      stderr;
 
118
        return(False);
 
119
    }
 
120
    return(True);
 
121
}
 
122
 
 
123
void
 
124
uEntry(int l, char *s,...)
 
125
{
 
126
int     i;
 
127
va_list ap;
 
128
 
 
129
    va_start(ap, s);
 
130
    for (i=0;i<uEntryLevel;i++) {
 
131
        putc(' ',entryFile);
 
132
    }
 
133
    vfprintf(entryFile,s,ap);
 
134
    uEntryLevel+= l;
 
135
    va_end(ap);
 
136
    return;
 
137
}
 
138
 
 
139
void
 
140
uExit(l,rtVal)
 
141
    int         l;
 
142
    char *      rtVal;
 
143
{
 
144
int     i;
 
145
 
 
146
    uEntryLevel-= l;
 
147
    if (uEntryLevel<0)  uEntryLevel=    0;
 
148
    for (i=0;i<uEntryLevel;i++) {
 
149
        putc(' ',entryFile);
 
150
    }
 
151
    fprintf(entryFile,"---> 0x%p\n",rtVal);
 
152
    return;
 
153
}
 
154
 
 
155
/***====================================================================***/
 
156
/***                    PRINT FUNCTIONS                                 ***/
 
157
/***====================================================================***/
 
158
 
 
159
        FILE    *uDebugFile=            NULL;
 
160
        int      uDebugIndentLevel=     0;
 
161
        int      uDebugIndentSize=      4;
 
162
 
 
163
Boolean
 
164
uSetDebugFile(name)
 
165
    char *name;
 
166
{
 
167
    if ((uDebugFile!=NULL)&&(uDebugFile!=stderr)) {
 
168
        fprintf(uDebugFile,"switching to %s\n",name?name:"stderr");
 
169
        fclose(uDebugFile);
 
170
    }
 
171
    if (name!=NullString)       uDebugFile=     fopen(name,"w");
 
172
    else                        uDebugFile=     stderr;
 
173
    if (uDebugFile==NULL) {
 
174
        uDebugFile=     stderr;
 
175
        return(False);
 
176
    }
 
177
    return(True);
 
178
}
 
179
 
 
180
void
 
181
uDebug(char *s,...)
 
182
{
 
183
int     i;
 
184
va_list ap;
 
185
 
 
186
    va_start(ap, s);
 
187
    for (i=(uDebugIndentLevel*uDebugIndentSize);i>0;i--) {
 
188
        putc(' ',uDebugFile);
 
189
    }
 
190
    vfprintf(uDebugFile,s,ap);
 
191
    fflush(uDebugFile);
 
192
    va_end(ap);
 
193
    return;
 
194
}
 
195
 
 
196
void
 
197
uDebugNOI(char *s,...)
 
198
{
 
199
va_list ap;
 
200
 
 
201
    va_start(ap, s);
 
202
    vfprintf(uDebugFile,s,ap);
 
203
    fflush(uDebugFile);
 
204
    va_end(ap);
 
205
    return;
 
206
}
 
207
 
 
208
/***====================================================================***/
 
209
 
 
210
static  FILE    *errorFile=     NULL;
 
211
 
 
212
Boolean
 
213
uSetErrorFile(char *name)
 
214
{
 
215
    if ((errorFile!=NULL)&&(errorFile!=stderr)) {
 
216
        fprintf(errorFile,"switching to %s\n",name?name:"stderr");
 
217
        fclose(errorFile);
 
218
    }
 
219
    if (name!=NullString)       errorFile=      fopen(name,"w");
 
220
    else                        errorFile=      stderr;
 
221
    if (errorFile==NULL) {
 
222
        errorFile=      stderr;
 
223
        return(False);
 
224
    }
 
225
    return(True);
 
226
}
 
227
 
 
228
void
 
229
uInformation(char *s,...)
 
230
{
 
231
    va_list ap;
 
232
 
 
233
    va_start(ap, s);
 
234
    vfprintf(errorFile,s,ap);
 
235
    fflush(errorFile);
 
236
    va_end(ap);
 
237
    return;
 
238
}
 
239
 
 
240
/***====================================================================***/
 
241
 
 
242
void
 
243
uAction(char *s,...)
 
244
{
 
245
    va_list ap;
 
246
 
 
247
    va_start(ap, s);
 
248
    fprintf(errorFile,"                  ");
 
249
    vfprintf(errorFile,s,ap);
 
250
    fflush(errorFile);
 
251
    va_end(ap);
 
252
    return;
 
253
}
 
254
 
 
255
/***====================================================================***/
 
256
 
 
257
void
 
258
uWarning(char *s,...)
 
259
{
 
260
    va_list ap;
 
261
 
 
262
    va_start(ap, s);
 
263
    fprintf(errorFile,"Warning:          ");
 
264
    vfprintf(errorFile,s,ap);
 
265
    fflush(errorFile);
 
266
    va_end(ap);
 
267
    return;
 
268
}
 
269
 
 
270
/***====================================================================***/
 
271
 
 
272
void
 
273
uError(char *s,...)
 
274
{
 
275
    va_list ap;
 
276
 
 
277
    va_start(ap, s);
 
278
    fprintf(errorFile,"Error:            ");
 
279
    vfprintf(errorFile,s,ap);
 
280
    fflush(errorFile);
 
281
    va_end(ap);
 
282
    return;
 
283
}
 
284
 
 
285
/***====================================================================***/
 
286
 
 
287
void
 
288
uFatalError(char *s,...)
 
289
{
 
290
    va_list ap;
 
291
 
 
292
    va_start(ap, s);
 
293
    fprintf(errorFile,"Fatal Error:      ");
 
294
    vfprintf(errorFile,s,ap);
 
295
    fprintf(errorFile,"                  Exiting\n");
 
296
    fflush(errorFile);
 
297
    va_end(ap);
 
298
    exit(1);
 
299
    /* NOTREACHED */
 
300
}
 
301
 
 
302
/***====================================================================***/
 
303
 
 
304
void
 
305
uInternalError(char *s,...)
 
306
{
 
307
    va_list ap;
 
308
 
 
309
    va_start(ap, s);
 
310
    fprintf(errorFile,"Internal error:   ");
 
311
    vfprintf(errorFile,s,ap);
 
312
    fflush(errorFile);
 
313
    va_end(ap);
 
314
    return;
 
315
}
 
316
 
 
317
/***====================================================================***/
 
318
 
 
319
#ifndef HAVE_STRDUP
 
320
char *
 
321
uStringDup(str)
 
322
    char *str;
 
323
{
 
324
char *rtrn;
 
325
 
 
326
    if (str==NULL)
 
327
        return NULL;
 
328
    rtrn= (char *)uAlloc(strlen(str)+1);
 
329
    strcpy(rtrn,str);
 
330
    return rtrn;
 
331
}
 
332
#endif
 
333
 
 
334
#ifndef HAVE_STRCASECMP
 
335
int
 
336
uStrCaseCmp(str1, str2)
 
337
    char *str1, *str2;
 
338
{
 
339
    char buf1[512],buf2[512];
 
340
    char c, *s;
 
341
    register int n;
 
342
 
 
343
    for (n=0, s = buf1; (c = *str1++); n++) {
 
344
        if (isupper(c))
 
345
            c = tolower(c);
 
346
        if (n>510)
 
347
            break;
 
348
        *s++ = c;
 
349
    }
 
350
    *s = '\0';
 
351
    for (n=0, s = buf2; (c = *str2++); n++) {
 
352
        if (isupper(c))
 
353
            c = tolower(c);
 
354
        if (n>510)
 
355
            break;
 
356
        *s++ = c;
 
357
    }
 
358
    *s = '\0';
 
359
    return (strcmp(buf1, buf2));
 
360
}
 
361
 
 
362
int
 
363
uStrCasePrefix(prefix, str)
 
364
    char *prefix, *str;
 
365
{
 
366
    char c1;
 
367
    char c2;
 
368
    while (((c1=*prefix)!='\0')&&((c2=*str)!='\0')) {
 
369
        if (isupper(c1))        c1= tolower(c1);
 
370
        if (isupper(c2))        c2= tolower(c2);
 
371
        if (c1!=c2)
 
372
            return 0;
 
373
        prefix++; str++;
 
374
    }
 
375
    if (c1!='\0')
 
376
        return 0;
 
377
    return 1;
 
378
}
 
379
 
 
380
#endif