← Back to branch summary

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

« back to all changes in this revision

Viewing changes to unix/xc/programs/Xserver/PEX5/dipex/objects/pexRndrPick.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/PEX5/dipex/objects/pexRndrPick.c
 
1
/* $Xorg: pexRndrPick.c,v 1.4 2001/02/09 02:04:14 xorgcvs Exp $ */
 
2
 
 
3
/************************************************************
 
4
 
 
5
Copyright 1992, 1998  The Open Group
 
6
 
 
7
Permission to use, copy, modify, distribute, and sell this software and its
 
8
documentation for any purpose is hereby granted without fee, provided that
 
9
the above copyright notice appear in all copies and that both that
 
10
copyright notice and this permission notice appear in supporting
 
11
documentation.
 
12
 
 
13
The above copyright notice and this permission notice shall be included in
 
14
all copies or substantial portions of the Software.
 
15
 
 
16
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 
17
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 
18
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
 
19
OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
 
20
AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 
21
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
22
 
 
23
Except as contained in this notice, the name of The Open Group shall not be
 
24
used in advertising or otherwise to promote the sale, use or other dealings
 
25
in this Software without prior written authorization from The Open Group.
 
26
 
 
27
******************************************************************/
 
28
 
 
29
 
 
30
 
 
31
/*++
 
32
 *  --- Renderer Picking ---
 
33
 *      PEXBeginPickOne
 
34
 *      PEXEndPickOne
 
35
 *      PEXPickOne
 
36
 *      PEXBeginPickAll
 
37
 *      PEXEndPickAll
 
38
 *      PEXPickAll
 
39
 --*/
 
40
 
 
41
#include "X.h"
 
42
#define NEED_EVENTS
 
43
#include "Xproto.h"
 
44
#include "pexError.h"
 
45
#include "dipex.h"
 
46
#include "PEXprotost.h"
 
47
#include "pex_site.h"
 
48
#include "ddpex3.h"
 
49
#include "ddpex4.h"
 
50
#include "pexLookup.h"
 
51
 
 
52
#ifdef min
 
53
#undef min
 
54
#endif
 
55
 
 
56
#ifdef max
 
57
#undef max
 
58
#endif
 
59
 
 
60
 
 
61
/*++  Renderer Picking ++*/
 
62
 
 
63
ErrorCode
 
64
PEXBeginPickOne( cntxtPtr, strmPtr )
 
65
pexContext              *cntxtPtr;
 
66
pexBeginPickOneReq      *strmPtr;
 
67
{
 
68
    ErrorCode err = Success;
 
69
    ddRendererStr *prend = 0;
 
70
    pexPickRecord *pr = (pexPickRecord *)(strmPtr+1);
 
71
    ddPickPath    *sIDpp;
 
72
 
 
73
    LU_RENDERER(strmPtr->rdr, prend);
 
74
    LU_DRAWABLE(strmPtr->drawable, prend->pDrawable);
 
75
    prend->drawableId = strmPtr->drawable;
 
76
    /* this is evil but necessary, use the pickid field of the
 
77
       sIDlist to store the structure ID that corresponds to the 
 
78
       top level fake structure
 
79
    */
 
80
    sIDpp = (ddPickPath *)(prend->pickstr.sIDlist)->pList;
 
81
    sIDpp->pickid = strmPtr->sid;
 
82
 
 
83
    prend->pickstr.pick_method = strmPtr->method;
 
84
    prend->pickstr.state = DD_PICK_ONE;
 
85
    prend->pickstr.server = DD_CLIENT;
 
86
 
 
87
    err = ChangePseudoPickMeasure (prend, pr);
 
88
    if (err) PEX_ERR_EXIT(err,0,cntxtPtr);
 
89
 
 
90
    /* This is set up to use this instead of defining a BeginPickOne */
 
91
    err = BeginPicking(prend, prend->pickstr.pseudoPM);
 
92
    if (err) PEX_ERR_EXIT(err,0,cntxtPtr);
 
93
 
 
94
    return( err );
 
95
} /* end-PEXBeginPickOne() */
 
96
 
 
97
ErrorCode
 
98
PEXEndPickOne( cntxtPtr, strmPtr )
 
99
pexContext              *cntxtPtr;
 
100
pexEndPickOneReq        *strmPtr;
 
101
{
 
102
    ErrorCode err = Success;
 
103
    ddRendererStr *prend = 0;
 
104
    extern ddBufferPtr pPEXBuffer;
 
105
    pexEndPickOneReply *reply = (pexEndPickOneReply*)(pPEXBuffer->pHead);
 
106
 
 
107
    LU_RENDERER(strmPtr->rdr, prend);
 
108
 
 
109
    if (prend->pickstr.state != DD_PICK_ONE)
 
110
        PEX_ERR_EXIT(PEX_ERROR_CODE(PEXRendererStateError),0,cntxtPtr);
 
111
 
 
112
    SETUP_INQ(pexEndPickOneReply);
 
113
 
 
114
    err = EndPickOne(prend, pPEXBuffer, &(reply->numPickElRefs),
 
115
                     &(reply->pickStatus), &(reply->betterPick));
 
116
    if (err) PEX_ERR_EXIT(err,0,cntxtPtr);
 
117
 
 
118
    err = EndPicking(prend);
 
119
    if (err) PEX_ERR_EXIT(err,0,cntxtPtr);
 
120
 
 
121
    {
 
122
        reply->length = LWORDS(pPEXBuffer->dataSize);
 
123
        WritePEXBufferReply(pexEndPickOneReply);
 
124
 
 
125
    }
 
126
    return( err );
 
127
} /* end-PEXEndPickOne() */
 
128
 
 
129
ErrorCode
 
130
PEXPickOne( cntxtPtr, strmPtr )
 
131
pexContext              *cntxtPtr;
 
132
pexPickOneReq           *strmPtr;
 
133
{
 
134
    ErrorCode err = Success;
 
135
    extern ddBufferPtr pPEXBuffer;
 
136
    ddRendererStr *prend = 0;
 
137
    pexPickRecord *pr = (pexPickRecord *)(strmPtr+1);
 
138
    pexPickOneReply *reply = (pexPickOneReply*)(pPEXBuffer->pHead);
 
139
 
 
140
    /* do stuff same as BeginPickOne */
 
141
    LU_RENDERER(strmPtr->rdr, prend);
 
142
    LU_DRAWABLE(strmPtr->drawable, prend->pDrawable);
 
143
    prend->drawableId = strmPtr->drawable;
 
144
    LU_STRUCTURE(strmPtr->sid, prend->pickstr.strHandle);
 
145
 
 
146
    prend->pickstr.pick_method = strmPtr->method;
 
147
    prend->pickstr.state = DD_PICK_ONE;
 
148
    prend->pickstr.server = DD_SERVER;
 
149
 
 
150
    err = ChangePseudoPickMeasure (prend, pr);
 
151
    if (err) PEX_ERR_EXIT(err,0,cntxtPtr);
 
152
 
 
153
    err = BeginPicking(prend, prend->pickstr.pseudoPM);
 
154
    if (err) PEX_ERR_EXIT(err,0,cntxtPtr);
 
155
 
 
156
    /* now call PickOne which does set up and calls the traverser */
 
157
    err = PickOne(prend);
 
158
 
 
159
    /* now do stuff same as EndPickOne */
 
160
    SETUP_INQ(pexPickOneReply);
 
161
 
 
162
    err = EndPickOne(prend, pPEXBuffer, &(reply->numPickElRefs),
 
163
                     &(reply->pickStatus), &(reply->betterPick));
 
164
    if (err) PEX_ERR_EXIT(err,0,cntxtPtr);
 
165
 
 
166
    err = EndPicking(prend);
 
167
    if (err) PEX_ERR_EXIT(err,0,cntxtPtr);
 
168
 
 
169
    {
 
170
        reply->length = LWORDS(pPEXBuffer->dataSize);
 
171
        WritePEXBufferReply(pexPickOneReply);
 
172
    }
 
173
    return( err );
 
174
} /* end-PEXPickOne() */
 
175
 
 
176
ErrorCode
 
177
PEXBeginPickAll( cntxtPtr, strmPtr )
 
178
pexContext              *cntxtPtr;
 
179
pexBeginPickAllReq      *strmPtr;
 
180
{
 
181
    ErrorCode err = Success;
 
182
    ddRendererStr *prend = 0;
 
183
    pexPickRecord *pr = (pexPickRecord *)(strmPtr+1);
 
184
    ddPickPath    *sIDpp;
 
185
 
 
186
    LU_RENDERER(strmPtr->rdr, prend);
 
187
    LU_DRAWABLE(strmPtr->drawable, prend->pDrawable);
 
188
    prend->drawableId = strmPtr->drawable;
 
189
    /* this is evil but necessary, use the pickid field of the
 
190
       sIDlist to store the structure ID that corresponds to the 
 
191
       top level fake structure
 
192
    */
 
193
    sIDpp = (ddPickPath *)(prend->pickstr.sIDlist)->pList;
 
194
    sIDpp->pickid = strmPtr->sid;
 
195
 
 
196
    prend->pickstr.pick_method = strmPtr->method;
 
197
    prend->pickstr.state = DD_PICK_ALL;
 
198
    prend->pickstr.server = DD_CLIENT;
 
199
    prend->pickstr.send_event = strmPtr->sendEvent;
 
200
    prend->pickstr.max_hits = strmPtr->pickMaxHits;
 
201
    prend->pickstr.client = cntxtPtr->client;
 
202
 
 
203
    err = ChangePseudoPickMeasure (prend, pr);
 
204
    if (err) PEX_ERR_EXIT(err,0,cntxtPtr);
 
205
 
 
206
    /* This is set up to use this instead of defining a BeginPickOne */
 
207
    err = BeginPicking(prend, prend->pickstr.pseudoPM);
 
208
    if (err) PEX_ERR_EXIT(err,0,cntxtPtr);
 
209
 
 
210
 
 
211
    if (err) PEX_ERR_EXIT(err,0,cntxtPtr);
 
212
    return( err );
 
213
} /* end-PEXBeginPickAll() */
 
214
 
 
215
ErrorCode
 
216
PEXEndPickAll( cntxtPtr, strmPtr )
 
217
pexContext              *cntxtPtr;
 
218
pexEndPickAllReq        *strmPtr;
 
219
{
 
220
    ErrorCode err = Success;
 
221
    extern ddBufferPtr pPEXBuffer;
 
222
    ddRendererStr *prend = 0;
 
223
 
 
224
    LU_RENDERER(strmPtr->rdr, prend);
 
225
 
 
226
    if (prend->pickstr.state != DD_PICK_ALL)
 
227
        PEX_ERR_EXIT(err,0,cntxtPtr);
 
228
 
 
229
    SETUP_INQ(pexEndPickAllReply);
 
230
 
 
231
    err = EndPickAll(prend, pPEXBuffer);
 
232
    if (err) PEX_ERR_EXIT(err,0,cntxtPtr);
 
233
 
 
234
    err = EndPicking(prend);
 
235
    if (err) PEX_ERR_EXIT(err,0,cntxtPtr);
 
236
 
 
237
    {
 
238
        SETUP_VAR_REPLY(pexEndPickAllReply);
 
239
        WritePEXBufferReply(pexEndPickAllReply);
 
240
    }
 
241
    return( err );
 
242
} /* end-PEXEndPickAll() */
 
243
 
 
244
ErrorCode
 
245
PEXPickAll( cntxtPtr, strmPtr )
 
246
pexContext              *cntxtPtr;
 
247
pexPickAllReq           *strmPtr;
 
248
{
 
249
    ErrorCode err = Success;
 
250
    extern ddBufferPtr pPEXBuffer;
 
251
    ddRendererStr *prend = 0;
 
252
    pexPickRecord *pr = (pexPickRecord *)(strmPtr+1);
 
253
 
 
254
    /* do stuff same as BeginPickAll */
 
255
    LU_RENDERER(strmPtr->rdr, prend);
 
256
    LU_DRAWABLE(strmPtr->drawable, prend->pDrawable);
 
257
    prend->drawableId = strmPtr->drawable;
 
258
 
 
259
    prend->pickstr.pick_method = strmPtr->method;
 
260
    prend->pickstr.state = DD_PICK_ALL;
 
261
    prend->pickstr.server = DD_SERVER;
 
262
    prend->pickstr.max_hits = strmPtr->pickMaxHits;
 
263
 
 
264
    err = ChangePseudoPickMeasure (prend, pr);
 
265
    if (err) PEX_ERR_EXIT(err,0,cntxtPtr);
 
266
 
 
267
    err = BeginPicking(prend, prend->pickstr.pseudoPM);
 
268
    if (err) PEX_ERR_EXIT(err,0,cntxtPtr);
 
269
 
 
270
    /* now call PickAll which does set up and calls RenderElements */
 
271
    err = PickAll(prend);
 
272
 
 
273
    /* now do stuff same as EndPickOne */
 
274
    SETUP_INQ(pexPickAllReply);
 
275
 
 
276
    err = EndPickAll(prend, pPEXBuffer);
 
277
    if (err) PEX_ERR_EXIT(err,0,cntxtPtr);
 
278
 
 
279
    err = EndPicking(prend);
 
280
    if (err) PEX_ERR_EXIT(err,0,cntxtPtr);
 
281
 
 
282
    {
 
283
        SETUP_VAR_REPLY(pexPickAllReply);
 
284
 
 
285
        WritePEXBufferReply(pexPickAllReply);
 
286
    }
 
287
    return( err );
 
288
} /* end-PEXPickAll() */
 
289
 
 
290
 
 
291
/**** Renderer Pick Events ****/
 
292
 
 
293
ErrorCode
 
294
PEXMaxHitsReachedNotify(client, rendId)
 
295
ClientPtr           client;
 
296
ddULONG             rendId;
 
297
{
 
298
    pexMaxHitsReachedEvent mhre;
 
299
 
 
300
    mhre.type = PexEventBase + PEXMaxHitsReached; 
 
301
    mhre.sequenceNumber = client->sequence;
 
302
    mhre.rdr = rendId;
 
303
 
 
304
    WriteEventsToClient (client, 1, (xEvent *) &mhre);
 
305
    return(client->noClientException);
 
306
}
 
307
/*++
 
308
 *
 
309
 *      End of File
 
310
 *
 
311
 --*/