![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to main.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 main.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: main.c,v 1.124 87/09/07 18:17:41 toddb Exp $ */
25:
26: #include "X.h"
27: #include "Xproto.h"
28: #include "input.h"
29: #include "scrnintstr.h"
30: #include "misc.h"
31: #include "os.h"
32: #include "windowstr.h"
33: #include "resource.h"
34: #include "dixstruct.h"
35: #include "gcstruct.h"
36: #include "extension.h"
37: #include "colormap.h"
38: #include "cursorstr.h"
39: #include "opaque.h"
40: #include "servermd.h"
41:
42: extern long defaultScreenSaverTime;
43: extern long defaultScreenSaverInterval;
44: extern int defaultScreenSaverBlanking;
45: extern int defaultScreenSaverAllowExposures;
46:
47: extern char *display;
48: char *ConnectionInfo;
49: xConnSetupPrefix connSetupPrefix;
50:
51: extern WindowRec WindowTable[];
52: extern xColorItem screenWhite, screenBlack;
53: extern FontPtr defaultFont;
54:
55: extern void SetInputCheck();
56: extern void AbortServer();
57:
58: PaddingInfo PixmapWidthPaddingInfo[33];
59: int connBlockScreenStart;
60:
61: unsigned char *minfree;
62:
63: static int restart = 0;
64:
65: int
66: NotImplemented()
67: {
68: FatalError("Not implemented");
69: }
70:
71: /*
72: * This array encodes the answer to the question "what is the log base 2
73: * of the number of pixels that fit in a scanline pad unit?"
74: * Note that ~0 is an invalid entry (mostly for the benefit of the reader).
75: */
76: static int answer[6][3] = {
77: /* pad pad pad */
78: /* 8 16 32 */
79:
80: { 3, 4, 5 }, /* 1 bit per pixel */
81: { 1, 2, 3 }, /* 4 bits per pixel */
82: { 0, 1, 2 }, /* 8 bits per pixel */
83: { ~0, 0, 1 }, /* 16 bits per pixel */
84: { ~0, ~0, 0 }, /* 24 bits per pixel */
85: { ~0, ~0, 0 } /* 32 bits per pixel */
86: };
87:
88: /*
89: * This array gives the answer to the question "what is the first index for
90: * the answer array above given the number of bits per pixel?"
91: * Note that ~0 is an invalid entry (mostly for the benefit of the reader).
92: */
93: static int indexForBitsPerPixel[ 33 ] = {
94: ~0, 0, ~0, ~0, /* 1 bit per pixel */
95: 1, ~0, ~0, ~0, /* 4 bits per pixel */
96: 2, ~0, ~0, ~0, /* 8 bits per pixel */
97: ~0,~0, ~0, ~0,
98: 3, ~0, ~0, ~0, /* 16 bits per pixel */
99: ~0,~0, ~0, ~0,
100: 4, ~0, ~0, ~0, /* 24 bits per pixel */
101: ~0,~0, ~0, ~0,
102: 5 /* 32 bits per pixel */
103: };
104:
105: /*
106: * This array gives the answer to the question "what is the second index for
107: * the answer array above given the number of bits per scanline pad unit?"
108: * Note that ~0 is an invalid entry (mostly for the benefit of the reader).
109: */
110: static int indexForScanlinePad[ 33 ] = {
111: ~0, ~0, ~0, ~0,
112: ~0, ~0, ~0, ~0,
113: 0, ~0, ~0, ~0, /* 8 bits per scanline pad unit */
114: ~0, ~0, ~0, ~0,
115: 1, ~0, ~0, ~0, /* 16 bits per scanline pad unit */
116: ~0, ~0, ~0, ~0,
117: ~0, ~0, ~0, ~0,
118: ~0, ~0, ~0, ~0,
119: 2 /* 32 bits per scanline pad unit */
120: };
121:
122: main(argc, argv)
123: int argc;
124: char *argv[];
125: {
126: int i, j, k, looping;
127: int alwaysCheckForInput[2];
128:
129: /* Notice if we're restart. Probably this is because we jumped through
130: * uninitialized pointer */
131: minfree = (unsigned char *)sbrk(0); /* FOR DEBUG XXX */
132: if (restart)
133: FatalError("server restarted. Jumped through uninitialized pointer?\n");
134: else
135: restart = 1;
136: /* These are needed by some routines which are called from interrupt
137: * handlers, thus have no direct calling path back to main and thus
138: * can't be passed argc, argv as parameters */
139: argcGlobal = argc;
140: argvGlobal = argv;
141: display = "0";
142: ProcessCommandLine(argc, argv);
143:
144: alwaysCheckForInput[0] = 0;
145: alwaysCheckForInput[1] = 1;
146: looping = 0;
147: while(1)
148: {
149: ScreenSaverTime = defaultScreenSaverTime;
150: ScreenSaverInterval = defaultScreenSaverInterval;
151: ScreenSaverBlanking = defaultScreenSaverBlanking;
152: ScreenSaverAllowExposures = defaultScreenSaverAllowExposures;
153:
154: /* Perform any operating system dependent initializations you'd like */
155: OsInit();
156: if(!looping)
157: {
158: CreateWellKnownSockets();
159: InitProcVectors();
160: serverClient = (ClientPtr)Xalloc(sizeof(ClientRec));
161: serverClient->sequence = 0;
162: serverClient->closeDownMode = RetainPermanent;
163: serverClient->clientGone = FALSE;
164: serverClient->lastDrawable = (DrawablePtr)NULL;
165: serverClient->lastDrawableID = INVALID;
166: serverClient->lastGC = (GCPtr)NULL;
167: serverClient->lastGCID = None;
168: serverClient->numSaved = None;
169: serverClient->saveSet = (pointer *)NULL;
170: serverClient->index = 0;
171: }
172: currentMaxClients = 10;
173: clients = (ClientPtr *)Xalloc(currentMaxClients * sizeof(ClientPtr));
174: for (i=1; i<currentMaxClients; i++)
175: clients[i] = NullClient;
176: clients[0] = serverClient;
177:
178: InitClientResources(serverClient); /* for root resources */
179:
180: SetInputCheck(&alwaysCheckForInput[0], &alwaysCheckForInput[1]);
181: screenInfo.arraySize = 0;
182: screenInfo.numScreens = 0;
183: screenInfo.screen = (ScreenPtr)NULL;
184: /*
185: * Just in case the ddx doesnt supply a format for depth 1 (like qvss).
186: */
187: j = indexForBitsPerPixel[ 1 ];
188: k = indexForScanlinePad[ BITMAP_SCANLINE_PAD ];
189: PixmapWidthPaddingInfo[1].scanlinePad = BITMAP_SCANLINE_PAD-1;
190: PixmapWidthPaddingInfo[1].bitmapPadLog2 = answer[j][k];
191:
192: InitAtoms();
193: InitExtensions();
194: InitOutput(&screenInfo, argc, argv);
195: if (screenInfo.numScreens < 1)
196: FatalError("no screens found\n");
197: InitEvents();
198: InitInput(argc, argv);
199: InitAndStartDevices(argc, argv);
200:
201: SetDefaultFontPath(defaultFontPath); /* default path has no nulls */
202: if ( ! SetDefaultFont(defaultTextFont))
203: ErrorF( "main: Could not open default font '%s'\n",
204: defaultTextFont);
205: if ( ! (rootCursor = CreateRootCursor(defaultCursorFont, 0)))
206: ErrorF( "main: Could not open default cursor font '%s'\n",
207: defaultCursorFont);
208:
209: for (i=0; i<screenInfo.numScreens; i++)
210: {
211: CreateRootWindow(i);
212: }
213: DefineInitialRootWindow(&WindowTable[0]);
214: if(!looping)
215: {
216: CreateConnectionBlock();
217: }
218:
219: Dispatch();
220:
221: /* Now free up whatever must be freed */
222: CloseDownExtensions();
223: FreeAllResources();
224: for ( i = 0; i < screenInfo.numScreens; i++)
225: {
226: FreeGCperDepth(i);
227: FreeDefaultStipple(i);
228: }
229: CloseDownDevices(argc, argv);
230: for (i = 0; i < screenInfo.numScreens; i++)
231: (* screenInfo.screen[i].CloseScreen)(i, &screenInfo.screen[i]);
232: Xfree(screenInfo.screen);
233:
234: CloseFont(defaultFont);
235: defaultFont = (FontPtr)NULL;
236:
237: ResetHosts(display);
238: Xfree(clients);
239:
240: looping = 1;
241: }
242: }
243:
244: static int padlength[4] = {0, 3, 2, 1};
245:
246: CreateConnectionBlock()
247: {
248: xConnSetup setup;
249: xWindowRoot root;
250: xDepth depth;
251: xVisualType visual;
252: xPixmapFormat format;
253: int i, j, k, vid,
254: lenofblock=0,
255: sizesofar = 0;
256: char *pBuf;
257:
258:
259: /* Leave off the ridBase and ridMask, these must be sent with
260: connection */
261:
262: setup.release = VENDOR_RELEASE;
263: /*
264: * per-server image and bitmap parameters are defined in Xmd.h
265: */
266: setup.imageByteOrder = screenInfo.imageByteOrder;
267: setup.bitmapScanlineUnit = screenInfo.bitmapScanlineUnit;
268: setup.bitmapScanlinePad = screenInfo.bitmapScanlinePad;
269: setup.bitmapBitOrder = screenInfo.bitmapBitOrder;
270: setup.motionBufferSize = NumMotionEvents();
271: setup.numRoots = screenInfo.numScreens;
272: setup.nbytesVendor = strlen(VENDOR_STRING);
273: setup.numFormats = screenInfo.numPixmapFormats;
274: setup.maxRequestSize = MAX_REQUEST_SIZE;
275: QueryMinMaxKeyCodes(&setup.minKeyCode, &setup.maxKeyCode);
276:
277: lenofblock = sizeof(xConnSetup) +
278: ((setup.nbytesVendor + 3) & ~3) +
279: (setup.numFormats * sizeof(xPixmapFormat)) +
280: (setup.numRoots * sizeof(xWindowRoot));
281: ConnectionInfo = (char *) Xalloc(lenofblock);
282:
283: bcopy((char *)&setup, ConnectionInfo, sizeof(xConnSetup));
284: sizesofar = sizeof(xConnSetup);
285: pBuf = ConnectionInfo + sizeof(xConnSetup);
286:
287: bcopy(VENDOR_STRING, pBuf, setup.nbytesVendor);
288: sizesofar += setup.nbytesVendor;
289: pBuf += setup.nbytesVendor;
290: i = padlength[setup.nbytesVendor & 3];
291: if (i)
292: {
293: char pad[4];
294: bcopy(pad, pBuf, i);
295: pBuf += i;
296: sizesofar += i;
297: }
298:
299: for (i=0; i<screenInfo.numPixmapFormats; i++)
300: {
301: format.depth = screenInfo.formats[i].depth;
302: format.bitsPerPixel = screenInfo.formats[i].bitsPerPixel;
303: format.scanLinePad = screenInfo.formats[i].scanlinePad;;
304: bcopy((char *)&format, pBuf, sizeof(xPixmapFormat));
305: pBuf += sizeof(xPixmapFormat);
306: sizesofar += sizeof(xPixmapFormat);
307: }
308:
309: connBlockScreenStart = sizesofar;
310: for (i=0; i<screenInfo.numScreens; i++)
311: {
312: ScreenPtr pScreen;
313: DepthPtr pDepth;
314: VisualPtr pVisual;
315:
316: pScreen = &(screenInfo.screen[i]);
317: root.windowId = WindowTable[i].wid;
318: root.defaultColormap = pScreen->defColormap;
319: root.whitePixel = pScreen->whitePixel;
320: root.blackPixel = pScreen->blackPixel;
321: root.currentInputMask = 0; /* filled in when sent */
322: root.pixWidth = pScreen->width;
323: root.pixHeight = pScreen->height;
324: root.mmWidth = pScreen->mmWidth;
325: root.mmHeight = pScreen->mmHeight;
326: root.minInstalledMaps = pScreen->minInstalledCmaps;
327: root.maxInstalledMaps = pScreen->maxInstalledCmaps;
328: root.rootVisualID = pScreen->rootVisual;
329: root.backingStore = pScreen->backingStoreSupport;
330: root.saveUnders = pScreen->saveUnderSupport;
331: root.rootDepth = pScreen->rootDepth;
332: root.nDepths = pScreen->numDepths;
333: bcopy((char *)&root, pBuf, sizeof(xWindowRoot));
334: sizesofar += sizeof(xWindowRoot);
335: pBuf += sizeof(xWindowRoot);
336:
337: pDepth = pScreen->allowedDepths;
338: for(j = 0; j < pScreen->numDepths; j++, pDepth++)
339: {
340: lenofblock += sizeof(xDepth) +
341: (pDepth->numVids * sizeof(xVisualType));
342: ConnectionInfo = (char *)Xrealloc(ConnectionInfo, lenofblock);
343: pBuf = ConnectionInfo + sizesofar;
344: depth.depth = pDepth->depth;
345: depth.nVisuals = pDepth->numVids;
346: bcopy((char *)&depth, pBuf, sizeof(xDepth));
347: pBuf += sizeof(xDepth);
348: sizesofar += sizeof(xDepth);
349: for(k = 0; k < pDepth->numVids; k++)
350: {
351: vid = pDepth->vids[k];
352: pVisual = (VisualPtr) LookupID(vid, RT_VISUALID, RC_CORE);
353: visual.visualID = pVisual->vid;
354: visual.class = pVisual->class;
355: visual.bitsPerRGB = pVisual->bitsPerRGBValue;
356: visual.colormapEntries = pVisual->ColormapEntries;
357: visual.redMask = pVisual->redMask;
358: visual.greenMask = pVisual->greenMask;
359: visual.blueMask = pVisual->blueMask;
360: bcopy((char *)&visual, pBuf, sizeof(xVisualType));
361: pBuf += sizeof(xVisualType);
362: sizesofar += sizeof(xVisualType);
363: }
364: }
365: }
366: connSetupPrefix.success = xTrue;
367: connSetupPrefix.length = lenofblock/4;
368: connSetupPrefix.majorVersion = X_PROTOCOL;
369: connSetupPrefix.minorVersion = X_PROTOCOL_REVISION;
370: }
371:
372:
373: /* VARARGS */
374: FatalError (msg, v0, v1, v2, v3, v4, v5, v6, v7, v8)
375: char *msg;
376: int v0, v1, v2, v3, v4, v5, v6, v7, v8;
377: {
378: ErrorF("\nFatal server bug!\n");
379: ErrorF(msg, v0, v1, v2, v3, v4, v5, v6, v7, v8);
380: ErrorF("\n");
381: AbortServer();
382: }
383:
384: /*
385: grow the array of screenRecs if necessary.
386: call the device-supplied initialization procedure
387: with its screen number, a pointer to its ScreenRec, argc, and argv.
388: return the number of successfully installed screens.
389:
390: */
391:
392: AddScreen(pfnInit, argc, argv)
393: Bool (* pfnInit)();
394: int argc;
395: char **argv;
396: {
397:
398: int i = screenInfo.numScreens;
399: int scanlinepad, format, bitsPerPixel, j, k;
400: #ifdef DEBUG
401: void (**jNI) ();
402: #endif /* DEBUG */
403:
404: if (screenInfo.numScreens == screenInfo.arraySize)
405: {
406: screenInfo.arraySize += 5;
407: screenInfo.screen = (ScreenPtr)Xrealloc(
408: screenInfo.screen,
409: screenInfo.arraySize * sizeof(ScreenRec));
410: }
411:
412: #ifdef DEBUG
413: for (jNI = &screenInfo.screen[i].QueryBestSize;
414: jNI < (void (**) ()) &screenInfo.screen[i].RegionExtents;
415: jNI++)
416: *jNI = (void (*) ())NotImplemented;
417: #endif /* DEBUG */
418:
419:
420: /*
421: * This loop gets run once for every Screen that gets added,
422: * but thats ok. If the ddx layer initializes the formats
423: * one at a time calling AddScreen() after each, then each
424: * iteration will make it a little more accurate. Worst case
425: * we do this loop N * numPixmapFormats where N is # of screens.
426: * Anyway, this must be called after InitOutput and before the
427: * screen init routine is called.
428: */
429: for (format=0; format<screenInfo.numPixmapFormats; format++)
430: {
431: bitsPerPixel = screenInfo.formats[format].bitsPerPixel;
432: scanlinepad = screenInfo.formats[format].scanlinePad;
433: j = indexForBitsPerPixel[ bitsPerPixel ];
434: k = indexForScanlinePad[ scanlinepad ];
435: PixmapWidthPaddingInfo[ bitsPerPixel ].bitmapPadLog2 = answer[j][k];
436: PixmapWidthPaddingInfo[ bitsPerPixel ].scanlinePad =
437: (scanlinepad/bitsPerPixel) - 1;
438: }
439:
440: /* This is where screen specific stuff gets initialized. Load the
441: screen structure, call the hardware, whatever.
442: This is also where the default colormap should be allocated and
443: also pixel values for blackPixel, whitePixel, and the cursor
444: Note that InitScreen is NOT allowed to modify argc, argv, or
445: any of the strings pointed to by argv. They may be passed to
446: multiple screens.
447: */
448: screenInfo.screen[i].rgf = ~0; /* there are no scratch GCs yet*/
449: screenInfo.screen[i].myNum = i;
450: if ((*pfnInit)(i, &screenInfo.screen[i], argc, argv))
451: {
452: screenInfo.numScreens++;
453: CreateGCperDepthArray(i);
454: CreateDefaultStipple(i);
455: }
456: else
457: ErrorF("screen %d failed initialization\n", i);
458:
459: return screenInfo.numScreens;
460: }
461:
462:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.