![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to extension.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv9 / X11 / src / X.V11R1 / server / dix|
Return to extension.c CVS log | Up to [Research Unix] / researchv9 / X11 / src / X.V11R1 / server / dix |
1.1 root 1: /***********************************************************
2: Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts,
3: and the Massachusetts Institute of Technology, Cambridge, Massachusetts.
4:
5: All Rights Reserved
6:
7: Permission to use, copy, modify, and distribute this software and its
8: documentation for any purpose and without fee is hereby granted,
9: provided that the above copyright notice appear in all copies and that
10: both that copyright notice and this permission notice appear in
11: supporting documentation, and that the names of Digital or MIT not be
12: used in advertising or publicity pertaining to distribution of the
13: software without specific, written prior permission.
14:
15: DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
16: ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
17: DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
18: ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
19: WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
20: ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
21: SOFTWARE.
22:
23: ******************************************************************/
24: /* $Header: extension.c,v 1.36 87/09/09 13:16:05 rws Exp $ */
25:
26: #include "X.h"
27: #define NEED_REPLIES
28: #include "Xproto.h"
29: #include "misc.h"
30: #include "dixstruct.h"
31: #include "extnsionst.h"
32: #include "gcstruct.h"
33: #include "scrnintstr.h"
34:
35: #define EXTENSION_BASE 128
36: #define EXTENSION_EVENT_BASE 64
37: #define LAST_EVENT 128
38: #define LAST_ERROR 255
39:
40: ScreenProcEntry AuxillaryScreenProcs[MAXSCREENS];
41:
42: static ExtensionEntry **extensions = (ExtensionEntry **)NULL;
43: extern int (* ProcVector[]) ();
44: extern int (* SwappedProcVector[]) ();
45: extern int (* ReplySwapVector[256]) ();
46:
47: int lastEvent = EXTENSION_EVENT_BASE;
48: static int lastError = FirstExtensionError;
49: static int NumExtensions = 0;
50:
51: ExtensionEntry *AddExtension(name, NumEvents, NumErrors, MainProc,
52: SwappedMainProc, CloseDownProc)
53: char *name;
54: int NumEvents;
55: int NumErrors;
56: int (* MainProc)();
57: int (* SwappedMainProc)();
58: void (* CloseDownProc)();
59: {
60: int i;
61:
62: if (!MainProc || !SwappedMainProc || !CloseDownProc)
63: return((ExtensionEntry *) NULL);
64: if ((lastEvent + NumEvents > LAST_EVENT) ||
65: (unsigned)(lastError + NumErrors > LAST_ERROR))
66: return((ExtensionEntry *) NULL);
67:
68: i = NumExtensions;
69: NumExtensions += 1;
70: extensions = (ExtensionEntry **) Xrealloc(extensions,
71: NumExtensions * sizeof(ExtensionEntry *));
72: extensions[i] = (ExtensionEntry *) Xalloc(sizeof(ExtensionEntry));
73: extensions[i]->name = (char *)Xalloc(strlen(name) + 1);
74: strcpy(extensions[i]->name, name);
75: extensions[i]->index = i;
76: extensions[i]->base = i + EXTENSION_BASE;
77: extensions[i]->CloseDown = CloseDownProc;
78: ProcVector[i + EXTENSION_BASE] = MainProc;
79: SwappedProcVector[i + EXTENSION_BASE] = SwappedMainProc;
80: if (NumEvents)
81: {
82: extensions[i]->eventBase = lastEvent;
83: extensions[i]->eventLast = lastEvent + NumEvents;
84: lastEvent += NumEvents;
85: }
86: else
87: {
88: extensions[i]->eventBase = 0;
89: extensions[i]->eventLast = 0;
90: }
91: if (NumErrors)
92: {
93: extensions[i]->errorBase = lastError;
94: extensions[i]->errorLast = lastError + NumErrors;
95: lastError += NumErrors;
96: }
97: else
98: {
99: extensions[i]->errorBase = 0;
100: extensions[i]->errorLast = 0;
101: }
102: return(extensions[i]);
103: }
104:
105: CloseDownExtensions()
106: {
107: register int i;
108:
109: for (i = 0; i < NumExtensions; i++)
110: {
111: (* extensions[i]->CloseDown)(extensions[i]);
112: Xfree(extensions[i]->name);
113: Xfree(extensions[i]);
114: }
115: Xfree(extensions);
116: NumExtensions = 0;
117: extensions = (ExtensionEntry **)NULL;
118: lastEvent = EXTENSION_EVENT_BASE;
119: lastError = FirstExtensionError;
120: }
121:
122:
123:
124: int
125: ProcQueryExtension(client)
126: ClientPtr client;
127: {
128: xQueryExtensionReply reply;
129: int i;
130: REQUEST(xQueryExtensionReq);
131:
132: REQUEST_AT_LEAST_SIZE(xQueryExtensionReq);
133:
134: reply.type = X_Reply;
135: reply.length = 0;
136: reply.major_opcode = 0;
137: reply.sequenceNumber = client->sequence;
138:
139: if ( ! NumExtensions )
140: reply.present = xFalse;
141: else
142: {
143: for (i=0; i<NumExtensions; i++)
144: {
145: if ((strlen(extensions[i]->name) == stuff->nbytes) &&
146: !strncmp(&stuff[1], extensions[i]->name, stuff->nbytes))
147: break;
148: }
149: if (i == NumExtensions)
150: reply.present = xFalse;
151: else
152: {
153: reply.present = xTrue;
154: reply.major_opcode = extensions[i]->base;
155: reply.first_event = extensions[i]->eventBase;
156: reply.first_error = extensions[i]->errorBase;
157: }
158: }
159: WriteReplyToClient(client, sizeof(xQueryExtensionReply), &reply);
160: return(client->noClientException);
161: }
162:
163: int
164: ProcListExtensions(client)
165: ClientPtr client;
166: {
167: xListExtensionsReply reply;
168: char *bufptr, *buffer;
169: int total_length = 0;
170:
171: REQUEST(xReq);
172: REQUEST_SIZE_MATCH(xReq);
173:
174: reply.type = X_Reply;
175: reply.nExtensions = NumExtensions;
176: reply.length = 0;
177: reply.sequenceNumber = client->sequence;
178: buffer = NULL;
179:
180: if ( NumExtensions )
181: {
182: register int i;
183:
184: for (i=0; i<NumExtensions; i++)
185: total_length += strlen(extensions[i]->name) + 1;
186:
187: reply.length = (total_length + 3) >> 2;
188: buffer = bufptr = (char *)ALLOCATE_LOCAL(total_length);
189: for (i=0; i<NumExtensions; i++)
190: {
191: int len;
192: *bufptr++ = len = strlen(extensions[i]->name);
193: bcopy(extensions[i]->name, bufptr, len);
194: bufptr += len;
195: }
196: }
197: WriteReplyToClient(client, sizeof(xListExtensionsReply), &reply);
198: if (reply.length)
199: {
200: WriteToClient(client, total_length, buffer);
201: DEALLOCATE_LOCAL(buffer);
202: }
203: return(client->noClientException);
204: }
205:
206:
207: ExtensionLookupProc
208: LookupProc(name, pGC)
209: char *name;
210: GCPtr pGC;
211: {
212: register int i;
213: ScreenProcEntry spentry;
214: spentry = AuxillaryScreenProcs[pGC->pScreen->myNum];
215: if (spentry.num)
216: {
217: for (i = 0; i < spentry.num; i++)
218: if (strcmp(name, spentry.procList[i].name) == 0)
219: return(spentry.procList[i].proc);
220: }
221: return (ExtensionLookupProc)NULL;
222: }
223:
224: void
225: RegisterProc(name, pGC, proc)
226: char *name;
227: GC *pGC;
228: ExtensionLookupProc proc;
229: {
230: RegisterScreenProc(name, pGC->pScreen, proc);
231: }
232:
233: void
234: RegisterScreenProc(name, pScreen, proc)
235: char *name;
236: ScreenPtr pScreen;
237: ExtensionLookupProc proc;
238: {
239: ScreenProcEntry *spentry;
240: ProcEntryPtr procEntry = (ProcEntryPtr)NULL;
241: int i;
242:
243: spentry = &AuxillaryScreenProcs[pScreen->myNum];
244: /* first replace duplicates */
245: if (spentry->num)
246: {
247: for (i = 0; i < spentry->num; i++)
248: if (strcmp(name, spentry->procList[i].name) == 0)
249: {
250: procEntry = &spentry->procList[i];
251: break;
252: }
253: }
254: if (procEntry)
255: procEntry->proc = proc;
256: else
257: {
258: if (spentry->num)
259: spentry->procList = (ProcEntryPtr)
260: Xrealloc(spentry->procList,
261: sizeof(ProcEntryRec) * (spentry->num+1));
262: else
263: spentry->procList = (ProcEntryPtr)
264: Xalloc(sizeof(ProcEntryRec));
265: procEntry = &spentry->procList[spentry->num];
266: procEntry->name = (char *)Xalloc(strlen(name)+1);
267: strcpy(procEntry->name, name);
268: procEntry->proc = proc;
269: spentry->num++;
270: }
271: }
272:
273:
274: /*****************
275: * SendErrorToClient
276: * Send an Error back to the client.
277: *****************/
278:
279: SendErrorToClient (client, reqCode, minorCode, resId, status)
280: ClientPtr client;
281: char reqCode, minorCode, status;
282: XID resId;
283: {
284: xError rep;
285:
286: rep.type = X_Error;
287: rep.sequenceNumber = client->sequence;
288: rep.errorCode = status;
289: rep.majorCode = reqCode;
290: rep.minorCode = minorCode;
291: rep.resourceID = resId;
292:
293: #ifdef notdef
294: ErrorF("SendErrorToClient %x\n", client->index);
295: ErrorF(" sequenceNumber = %d\n", rep.sequenceNumber);
296: ErrorF(" rep.errorCode= %d\n", rep.errorCode);
297: ErrorF(" rep.majorCode = %d\n", rep.majorCode);
298: ErrorF(" rep.resourceID = %x\n", rep.resourceID);
299: #endif
300:
301: WriteEventsToClient (client, 1, (pointer) &rep);
302: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.