← Back to branch summary

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

« back to all changes in this revision

Viewing changes to unix/xc/programs/Xserver/cfb/cfbbres.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/cfb/cfbbres.c
 
1
/* $XFree86: xc/programs/Xserver/cfb/cfbbres.c,v 3.5 2001/12/14 19:59:21 dawes Exp $ */
 
2
/***********************************************************
 
3
 
 
4
Copyright 1987, 1998  The Open Group
 
5
 
 
6
Permission to use, copy, modify, distribute, and sell this software and its
 
7
documentation for any purpose is hereby granted without fee, provided that
 
8
the above copyright notice appear in all copies and that both that
 
9
copyright notice and this permission notice appear in supporting
 
10
documentation.
 
11
 
 
12
The above copyright notice and this permission notice shall be included in
 
13
all copies or substantial portions of the Software.
 
14
 
 
15
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 
16
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 
17
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
 
18
OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
 
19
AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 
20
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
21
 
 
22
Except as contained in this notice, the name of The Open Group shall not be
 
23
used in advertising or otherwise to promote the sale, use or other dealings
 
24
in this Software without prior written authorization from The Open Group.
 
25
 
 
26
 
 
27
Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
 
28
 
 
29
                        All Rights Reserved
 
30
 
 
31
Permission to use, copy, modify, and distribute this software and its 
 
32
documentation for any purpose and without fee is hereby granted, 
 
33
provided that the above copyright notice appear in all copies and that
 
34
both that copyright notice and this permission notice appear in 
 
35
supporting documentation, and that the name of Digital not be
 
36
used in advertising or publicity pertaining to distribution of the
 
37
software without specific, written prior permission.  
 
38
 
 
39
DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
 
40
ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
 
41
DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
 
42
ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
 
43
WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
 
44
ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
 
45
SOFTWARE.
 
46
 
 
47
******************************************************************/
 
48
/* $Xorg: cfbbres.c,v 1.4 2001/02/09 02:04:37 xorgcvs Exp $ */
 
49
#include "X.h"
 
50
#include "misc.h"
 
51
#include "cfb.h"
 
52
#include "cfbmskbits.h"
 
53
#include "servermd.h"
 
54
#include "miline.h"
 
55
 
 
56
/* Solid bresenham line */
 
57
/* NOTES
 
58
   e2 is used less often than e1, so it's not in a register
 
59
*/
 
60
 
 
61
void
 
62
cfbBresS(rop, and, xor, addrl, nlwidth, signdx, signdy, axis, x1, y1, e, e1,
 
63
         e2, len)
 
64
    int             rop;
 
65
    CfbBits   and, xor;
 
66
    CfbBits   *addrl;           /* pointer to base of bitmap */
 
67
    int             nlwidth;            /* width in longwords of bitmap */
 
68
    register int    signdx;
 
69
    int             signdy;             /* signs of directions */
 
70
    int             axis;               /* major axis (Y_AXIS or X_AXIS) */
 
71
    int             x1, y1;             /* initial point */
 
72
    register int    e;                  /* error accumulator */
 
73
    register int    e1;                 /* bresenham increments */
 
74
    int             e2;
 
75
    int             len;                /* length of line */
 
76
{
 
77
    register int        e3 = e2-e1;
 
78
#if PSZ == 24
 
79
    CfbBits piQxelXor[3],piQxelAnd[3];
 
80
    char *addrb;
 
81
    int nlwidth3, signdx3;
 
82
#endif
 
83
#ifdef PIXEL_ADDR
 
84
    register PixelType  *addrp;         /* Pixel pointer */
 
85
 
 
86
    if (len == 0)
 
87
        return;
 
88
    /* point to first point */
 
89
    nlwidth <<= PWSH;
 
90
#if PSZ == 24
 
91
    addrp = (PixelType *)(addrl) + (y1 * nlwidth);
 
92
    addrb = (char *)addrp + x1 * 3;
 
93
 
 
94
    piQxelXor[0] = (xor << 24) | xor;
 
95
    piQxelXor[1] = (xor << 16)| (xor >> 8);
 
96
    piQxelXor[2] = (xor << 8) | (xor >> 16);
 
97
    piQxelAnd[0] = (and << 24) | and;
 
98
    piQxelAnd[1] = (and << 16)| (and >> 8);
 
99
    piQxelAnd[2] = (and << 8) | (and >> 16);
 
100
#else
 
101
    addrp = (PixelType *)(addrl) + (y1 * nlwidth) + x1;
 
102
#endif
 
103
    if (signdy < 0)
 
104
        nlwidth = -nlwidth;
 
105
    e = e-e1;                   /* to make looping easier */
 
106
#if PSZ == 24
 
107
    nlwidth3 = nlwidth * sizeof (CfbBits);
 
108
    signdx3 = signdx * 3;
 
109
#endif
 
110
    
 
111
    if (axis == Y_AXIS)
 
112
    {
 
113
        int     t;
 
114
 
 
115
        t = nlwidth;
 
116
        nlwidth = signdx;
 
117
        signdx = t;
 
118
#if PSZ == 24
 
119
        t = nlwidth3;
 
120
        nlwidth3 = signdx3;
 
121
        signdx3 = t;
 
122
#endif
 
123
    }
 
124
    if (rop == GXcopy)
 
125
    {
 
126
        --len;
 
127
#if PSZ == 24
 
128
#define body_copy \
 
129
            addrp = (PixelType *)((unsigned long)addrb & ~0x03); \
 
130
            switch((unsigned long)addrb & 3){ \
 
131
            case 0: \
 
132
              *addrp = ((*addrp)&0xFF000000)|(piQxelXor[0] & 0xFFFFFF); \
 
133
              break; \
 
134
            case 1: \
 
135
              *addrp = ((*addrp)&0xFF)|(piQxelXor[2] & 0xFFFFFF00); \
 
136
              break; \
 
137
            case 3: \
 
138
              *addrp = ((*addrp)&0xFFFFFF)|(piQxelXor[0] & 0xFF000000); \
 
139
              *(addrp+1) = ((*(addrp+1))&0xFFFF0000)|(piQxelXor[1] & 0xFFFF); \
 
140
              break; \
 
141
            case 2: \
 
142
              *addrp = ((*addrp)&0xFFFF)|(piQxelXor[1] & 0xFFFF0000); \
 
143
              *(addrp+1) = ((*(addrp+1))&0xFFFFFF00)|(piQxelXor[2] & 0xFF); \
 
144
              break; \
 
145
            }
 
146
#define body {\
 
147
            body_copy \
 
148
            addrb += signdx3; \
 
149
            e += e1; \
 
150
            if (e >= 0) \
 
151
            { \
 
152
                addrb += nlwidth3; \
 
153
                e += e3; \
 
154
             } \
 
155
            }
 
156
#else /* PSZ == 24 */
 
157
#define body {\
 
158
            *addrp = xor; \
 
159
            addrp += signdx; \
 
160
            e += e1; \
 
161
            if (e >= 0) \
 
162
            { \
 
163
                addrp += nlwidth; \
 
164
                e += e3; \
 
165
            } \
 
166
        }
 
167
#endif /* PSZ == 24 */
 
168
        while (len >= 4)
 
169
        {
 
170
            body body body body
 
171
            len -= 4;
 
172
        }
 
173
        switch (len)
 
174
        {
 
175
        case  3: body case  2: body case  1: body
 
176
        }
 
177
#undef body
 
178
#if PSZ == 24
 
179
        body_copy
 
180
# undef body_copy
 
181
#else
 
182
        *addrp = xor;
 
183
#endif
 
184
    }
 
185
    else /* not GXcopy */
 
186
    {
 
187
        while(len--)
 
188
        { 
 
189
#if PSZ == 24
 
190
            addrp = (PixelType *)((unsigned long)addrb & ~0x03);
 
191
            switch((unsigned long)addrb & 3){
 
192
            case 0:
 
193
              *addrp = (*addrp & (piQxelAnd[0]|0xFF000000))
 
194
                        ^ (piQxelXor[0] & 0xFFFFFF);
 
195
              break;
 
196
            case 1:
 
197
              *addrp = (*addrp & (piQxelAnd[2]|0xFF))
 
198
                        ^ (piQxelXor[2] & 0xFFFFFF00);
 
199
              break;
 
200
            case 3:
 
201
              *addrp = (*addrp & (piQxelAnd[0]|0xFFFFFF))
 
202
                        ^ (piQxelXor[0] & 0xFF000000);
 
203
              *(addrp+1) = (*(addrp+1) & (piQxelAnd[1]|0xFFFF0000))
 
204
                        ^ (piQxelXor[1] & 0xFFFF);
 
205
              break;
 
206
            case 2:
 
207
              *addrp = (*addrp & (piQxelAnd[1]|0xFFFF))
 
208
                        ^ (piQxelXor[1] & 0xFFFF0000);
 
209
              *(addrp+1) = (*(addrp+1) & (piQxelAnd[2]|0xFFFFFF00))
 
210
                        ^ (piQxelXor[2] & 0xFF);
 
211
              break;
 
212
            }
 
213
            e += e1;
 
214
            if (e >= 0)
 
215
            {
 
216
                addrb += nlwidth3;
 
217
                e += e3;
 
218
            }
 
219
            addrb += signdx3;
 
220
#else /* PSZ == 24 */
 
221
            *addrp = DoRRop (*addrp, and, xor);
 
222
            e += e1;
 
223
            if (e >= 0)
 
224
            {
 
225
                addrp += nlwidth;
 
226
                e += e3;
 
227
            }
 
228
            addrp += signdx;
 
229
#endif /* PSZ == 24 */
 
230
        }
 
231
    }
 
232
#else /* !PIXEL_ADDR */
 
233
    register CfbBits   tmp, bit;
 
234
    CfbBits leftbit, rightbit;
 
235
 
 
236
    /* point to longword containing first point */
 
237
#if PSZ == 24
 
238
    addrl = (addrl + (y1 * nlwidth) + ((x1 * 3) >>2);
 
239
#else
 
240
    addrl = (addrl + (y1 * nlwidth) + (x1 >> PWSH));
 
241
#endif
 
242
    if (signdy < 0)
 
243
            nlwidth = -nlwidth;
 
244
    e = e-e1;                   /* to make looping easier */
 
245
 
 
246
    leftbit = cfbmask[0];
 
247
#if PSZ == 24
 
248
    rightbit = cfbmask[(PPW-1)<<1];
 
249
    bit = cfbmask[(x1 & 3)<<1];
 
250
#else
 
251
    rightbit = cfbmask[PPW-1];
 
252
    bit = cfbmask[x1 & PIM];
 
253
#endif
 
254
 
 
255
    if (axis == X_AXIS)
 
256
    {
 
257
        if (signdx > 0)
 
258
        {
 
259
            while (len--)
 
260
            { 
 
261
                *addrl = DoMaskRRop (*addrl, and, xor, bit);
 
262
                bit = SCRRIGHT(bit,1);
 
263
                e += e1;
 
264
                if (e >= 0)
 
265
                {
 
266
                    addrl += nlwidth;
 
267
                    e += e3;
 
268
                }
 
269
                if (!bit)
 
270
                {
 
271
                    bit = leftbit;
 
272
                    addrl++;
 
273
                }
 
274
            }
 
275
        }
 
276
        else
 
277
        {
 
278
            while (len--)
 
279
            { 
 
280
                *addrl = DoMaskRRop (*addrl, and, xor, bit);
 
281
                e += e1;
 
282
                bit = SCRLEFT(bit,1);
 
283
                if (e >= 0)
 
284
                {
 
285
                    addrl += nlwidth;
 
286
                    e += e3;
 
287
                }
 
288
                if (!bit)
 
289
                {
 
290
                    bit = rightbit;
 
291
                    addrl--;
 
292
                }
 
293
            }
 
294
        }
 
295
    } /* if X_AXIS */
 
296
    else
 
297
    {
 
298
        if (signdx > 0)
 
299
        {
 
300
            while(len--)
 
301
            {
 
302
                *addrl = DoMaskRRop (*addrl, and, xor, bit);
 
303
                e += e1;
 
304
                if (e >= 0)
 
305
                {
 
306
                    bit = SCRRIGHT(bit,1);
 
307
                    if (!bit)
 
308
                    {
 
309
                        bit = leftbit;
 
310
                        addrl++;
 
311
                    }
 
312
                    e += e3;
 
313
                }
 
314
                addrl += nlwidth;
 
315
            }
 
316
        }
 
317
        else
 
318
        {
 
319
            while(len--)
 
320
            {
 
321
                *addrl = DoMaskRRop (*addrl, and, xor, bit);
 
322
                e += e1;
 
323
                if (e >= 0)
 
324
                {
 
325
                    bit = SCRLEFT(bit,1);
 
326
                    if (!bit)
 
327
                    {
 
328
                        bit = rightbit;
 
329
                        addrl--;
 
330
                    }
 
331
                    e += e3;
 
332
                }
 
333
                addrl += nlwidth;
 
334
            }
 
335
        }
 
336
    } /* else Y_AXIS */
 
337
#endif
 
338
}