;;; -*- Mode: Common-Lisp; Package: User; Base: 10.; Patch-File: T -*-

;;; Reason: Return vendor release number of 3.
;;;  Fixes SPR #10952.

;;;                           RESTRICTED RIGHTS LEGEND
;;;
;;; Use, duplication, or disclosure by the Government is subject to
;;; restrictions as set forth in subdivision (c)(1)(ii) of the Rights in
;;; Technical Data and Computer Software clause at 52.227-7013.
;;;
;;;   TEXAS INSTRUMENTS INCORPORATED      
;;;   P.O. BOX 2909, M/S 2151             
;;;   AUSTIN, TEXAS 78769                 
;;;
;;; Copyright (C) 1989 Texas Instruments Incorporated.
;;; All rights reserved.

;;; Written 03/30/90 17:28:55 by HAGY,
;;; while running on Zwingli from band LOD1
;;; With SYSTEM 6.25, VIRTUAL-MEMORY 6.2, EH 6.5, MAKE-SYSTEM 6.2, MICRONET 6.0, LOCAL-FILE 6.1,
;;;  BASIC-PATHNAME 6.2, NETWORK-SUPPORT-COLD 6.2, BASIC-NAMESPACE 6.7, NETWORK-NAMESPACE 6.0,
;;;  DISK-IO 6.1, DISK-LABEL 6.0, BASIC-FILE 6.6, MAC-PATHNAME 6.0, NETWORK-PATHNAME 6.0,
;;;  COMPILER 6.14, TV 6.19, DATALINK 6.0, CHAOSNET 6.5, GC 6.3, MEMORY-AUX 6.0, NVRAM 6.2,
;;;  SYSLOG 6.2, STREAMER-TAPE 6.5, UCL 6.0, INPUT-EDITOR 6.0, METER 6.1, ZWEI 6.8,
;;;  DEBUG-TOOLS 6.3, NETWORK-SUPPORT 6.0, NETWORK-SERVICE 6.2, DATALINK-DISPLAYS 6.0,
;;;  FONT-EDITOR 6.1, SERIAL 6.0, PRINTER 6.3, MAC-PRINTER-TYPES 6.1, PRINTER-TYPES 6.2,
;;;  IMAGEN 6.1, SUGGESTIONS 6.1, MAIL-DAEMON 6.3, MAIL-READER 6.6, TELNET 6.0, VT100 6.0,
;;;  NAMESPACE-EDITOR 6.4, PROFILE 6.2, VISIDOC 6.5, TI-CLOS 6.26, CLEH 6.5, IP 3.56,
;;;  Experimental CLX 6.9, CLUE 6.86, X11M 6.20, Experimental BUG 11.17, Experimental CLIO 1.0,
;;;   microcode 430, Band Name: REL 6.0 + SLE 11/28

#!C
; From file DEFS.LISP#> X11M.SERVER; Hotel:
#10R X11#:
(COMPILER-LET ((*PACKAGE* (FIND-PACKAGE "X11"))
                          (SI:*LISP-MODE* :COMMON-LISP)
                          (*READTABLE* SYS:COMMON-LISP-READTABLE)
                          (SI:*READER-SYMBOL-SUBSTITUTIONS* SYS::*COMMON-LISP-SYMBOL-SUBSTITUTIONS*))
  (COMPILER#:PATCH-SOURCE-FILE "SYS: X11M.SERVER; DEFS.#"


(DEFCONSTANT VENDOR-RELEASE-NUMBER 3)
))

#!C
; From file SERVER.LISP#> X11M.SERVER; Hotel:
#10R X11#:
(COMPILER-LET ((*PACKAGE* (FIND-PACKAGE "X11"))
                          (SI:*LISP-MODE* :COMMON-LISP)
                          (*READTABLE* SYS:COMMON-LISP-READTABLE)
                          (SI:*READER-SYMBOL-SUBSTITUTIONS* SYS::*COMMON-LISP-SYMBOL-SUBSTITUTIONS*))
  (COMPILER#:PATCH-SOURCE-FILE "SYS: X11M.SERVER; SERVER.#"
;;;
;;; NOTE: This patch does not change PROCESS-CLIENT-CONNECTION, it just
;;;        has to be re-compiled since we changed the constant VENDOR-RELEASE-NUMBER
;;;
(DEFUN PROCESS-CLIENT-CONNECTION (STATE)
  "Read in the bytes from the client requesting a connection, and reply appropriately."
  (LET ((BYTES (STATE.BYTES STATE))
        (SUCCESS 1)
        OUTPUT-BUFFER-INDEX
        MAJOR-VERSION MINOR-VERSION LENGTH-AUTHORIZATION-NAME LENGTH-AUTHORIZATION-DATA
        AUTHORIZATION-NAME AUTHORIZATION-DATA)
    (FLET ()
      ;; First byte is trash.
      (SERVER-TYI STATE)
      (SETQ MAJOR-VERSION (READ-INT16)
            MINOR-VERSION (READ-INT16)
            LENGTH-AUTHORIZATION-NAME (READ-INT16)
            LENGTH-AUTHORIZATION-DATA (READ-INT16)
            AUTHORIZATION-NAME (PROGN
                                 (READ-INT16)     ; Trash
                                 (LOOP WITH STRING = (MAKE-ARRAY 0 :ELEMENT-TYPE :STRING-CHAR
                                                                 :FILL-POINTER 0)
                                       FOR INDEX FROM 0 BELOW (ROUND-UP-TO-NEAREST
                                                                LENGTH-AUTHORIZATION-NAME 4)
                                       FOR CHAR = (SERVER-TYI STATE)
                                       DO (WHEN (< INDEX LENGTH-AUTHORIZATION-NAME)
                                            (VECTOR-PUSH-EXTEND CHAR STRING))
                                       FINALLY (RETURN STRING)))
            AUTHORIZATION-DATA (LOOP WITH STRING = (MAKE-ARRAY 0 :ELEMENT-TYPE :STRING-CHAR
                                                               :FILL-POINTER 0)
                                     FOR INDEX FROM 0 BELOW (ROUND-UP-TO-NEAREST
                                                              LENGTH-AUTHORIZATION-DATA 4)
                                     FOR CHAR = (SERVER-TYI STATE)
                                     DO (WHEN (< INDEX LENGTH-AUTHORIZATION-DATA)
                                          (VECTOR-PUSH-EXTEND CHAR STRING))
                                     FINALLY (RETURN STRING)))
      ;; Note that we have read in all of this data, but we don't do much with it for now.
      ;; Later on we may want to check the authorization name (e.g. a user-id) and the
      ;; authorization data (e.g. a password).
      (WHEN (OR (NOT (= MAJOR-VERSION X-MAJOR-VERSION-NUMBER))
		(NOT (= MINOR-VERSION X-MINOR-VERSION-NUMBER)))
        (SETQ SUCCESS 0))
      (IF (PLUSP SUCCESS)
          ;; Return a success packet to the client, along with
          ;; a description of the screen's capabilities.
          (progn
            (SETF (AREF BYTES 0) 1)    ; Succuss
            (SETQ OUTPUT-BUFFER-INDEX 2)
            (WRITE-16 X-MAJOR-VERSION-NUMBER)
            (WRITE-16 X-MINOR-VERSION-NUMBER)
            (WRITE-16 (+ 8
                         (* 2 *MAX-PIXMAP-FORMATS*)
                         (CEILING VENDOR-STRING-LENGTH 4)
                         (* 18 *MAX-SCREENS*)))
            (WRITE-32 VENDOR-RELEASE-NUMBER)
            ;; Make the id base be based on the connection number.
            (SETF (STATE.ID-BASE STATE) (CONNECTION-NUMBER-TO-ID-MASK
                                          (ALLOCATE-CONNECTION-NUMBER)))
            (WRITE-32 (STATE.ID-BASE STATE))
            (WRITE-32 *RESOURCE-ID-MASK*)
            (WRITE-32 *MAX-MOTION-EVENTS*)
            (WRITE-16 (LENGTH VENDOR-STRING))
            (WRITE-16 *DEFAULT-BUFFER-SIZE*)   ; Maximum request length.
            (WRITE-8 *MAX-SCREENS*)
            (WRITE-8 *MAX-PIXMAP-FORMATS*)
            (WRITE-8 *IMAGE-BYTE-ORDER*)
            (WRITE-8 *BITMAP-FORMAT-BIT-ORDER*)
            (WRITE-8 *BITMAP-FORMAT-SCANLINE-UNIT*)
            (WRITE-8 *BITMAP-FORMAT-SCANLINE-PAD*)
            (WRITE-8 (key-syms-record.min-key-code current-key-syms))
            (WRITE-8 (key-syms-record.max-key-code current-key-syms))
            (WRITE-32 0)               ; Trash
            (WRITE-STRING8 VENDOR-STRING)
            (LOOP FOR PIXMAP-FORMAT-INDEX FROM 1 TO *MAX-PIXMAP-FORMATS*
                  FOR DEPTH IN *PIXMAP-FORMAT-DEPTHS*
                  FOR BITS-PER-PIXEL IN *PIXMAP-FORMAT-BITS-PER-PIXELS*
                  FOR PAD IN *PIXMAP-FORMAT-SCANLINE-PADS*
                  DO (PROGN
                       (WRITE-8 DEPTH)
                       (WRITE-8 BITS-PER-PIXEL)
                       (WRITE-8 PAD)
                       ;; 5 bytes of pad.
                       (LOOP FOR TRASH FROM 1 TO 5
                             DO (WRITE-8 0))))
            (LOOP FOR SCREEN FROM 0 BELOW *MAX-SCREENS*
                  FOR SCREEN-ROOT IN *SCREEN-ROOTS*
                  FOR WINDOW-ROOT IN *WINDOW-ROOTS*
                  FOR WHITE-PIXEL IN *SCREEN-WHITE-PIXELS*
                  FOR BLACK-PIXEL IN *SCREEN-BLACK-PIXELS*
                  FOR INPUT-EVENT IN *SCREEN-INPUT-EVENTS*
                  FOR PIXEL-WIDTH IN *SCREEN-WIDTHS-IN-PIXELS*
                  FOR PIXEL-HEIGHT IN *SCREEN-HEIGHTS-IN-PIXELS*
                  FOR MILLIMETER-WIDTH IN *SCREEN-WIDTHS-IN-MILLIMETERS*
                  FOR MILLIMETER-HEIGHT IN *SCREEN-HEIGHTS-IN-MILLIMETERS*
                  FOR MAX-INSTALLED-MAPS IN *SCREEN-MAX-INSTALLED-MAPS*
                  FOR MIN-INSTALLED-MAPS IN *SCREEN-MIN-INSTALLED-MAPS*
                  FOR ROOT-VISUAL IN *SCREEN-ROOT-VISUALS*
                  FOR BACKING-STORES IN *SCREEN-BACKING-STORES*
                  FOR SAVE-UNDERS IN *SCREEN-SAVE-UNDERS*
                  FOR ROOT-DEPTH IN *SCREEN-ROOT-DEPTHS*
                  FOR (ALLOWED-DEPTH VISUAL-TYPE-COUNT VISUAL-TYPES) IN *SCREEN-ALLOWED-DEPTHS*
                  FOR SCREEN-ROOT-INSTANCE IN (SCREEN-INFO.SCREENS SCREEN-INFO)
                  FOR WINDOW-ROOT-INSTANCE IN (SCREEN-INFO.WINDOWS SCREEN-INFO)
                  DO (PROGN
                       (WRITE-32 WINDOW-ROOT)
                       ;; Note: this is hopefully correct for the multiple-client
                       ;; case.  I think it is. (I leave it as an exercise for the
                       ;; reader to prove this wrong.)   (TWE)
                       (SETF (WINDOW.CLIENT WINDOW-ROOT-INSTANCE) STATE)
                       ;; Be certain to have a place to draw on.
                       (SETF (SCREEN.DEV-PRIVATE SCREEN-ROOT-INSTANCE)
                             (LET ((SERVER-WINDOW (FIND-FREE-X-SERVER-WINDOW)))
                               (WHEN (NULL SERVER-WINDOW)
                                 (SETQ SERVER-WINDOW (MAKE-SERVER-WINDOW)))
                               SERVER-WINDOW))
                       (STORE-RESOURCE SCREEN-ROOT SCREEN-ROOT-INSTANCE)
                       (STORE-RESOURCE WINDOW-ROOT WINDOW-ROOT-INSTANCE)
                       (LET ((*STATE* STATE))
                         (EVENT-SELECT-FOR-WINDOW WINDOW-ROOT-INSTANCE *STATE* 0))
                       (LET ((COLORMAP-INSTANCE (WINDOW.COLORMAP WINDOW-ROOT-INSTANCE)))
                         (STORE-RESOURCE (COLORMAP.ID COLORMAP-INSTANCE) COLORMAP-INSTANCE)
                         (WRITE-32 (COLORMAP.ID COLORMAP-INSTANCE)))
                       (WRITE-32 WHITE-PIXEL)
                       (WRITE-32 BLACK-PIXEL)
                       (WRITE-32 INPUT-EVENT)
                       (WRITE-16 PIXEL-WIDTH)
                       (WRITE-16 PIXEL-HEIGHT)
                       (WRITE-16 MILLIMETER-WIDTH)
                       (WRITE-16 MILLIMETER-HEIGHT)
                       (WRITE-16 MAX-INSTALLED-MAPS)
                       (WRITE-16 MIN-INSTALLED-MAPS)
                       (WRITE-32 ROOT-VISUAL)
                       (WRITE-8 BACKING-STORES)
                       (WRITE-8 SAVE-UNDERS)
                       (WRITE-8 ROOT-DEPTH)
                       (WRITE-8 (LENGTH *SCREEN-ALLOWED-DEPTHS*))
                       (WRITE-8 ALLOWED-DEPTH)
                       (WRITE-8 0)     ; Trash
                       (WRITE-16 (LENGTH VISUAL-TYPES))
                       (WRITE-32 0)    ; Trash
                       (LOOP FOR VISUAL-TYPE IN VISUAL-TYPES
                             DO (PROGN
                                  (STORE-RESOURCE (VISUAL.VID VISUAL-TYPE)   VISUAL-TYPE)
                                  (WRITE-32 (VISUAL.VID                      VISUAL-TYPE))
                                  (WRITE-8  (VISUAL.CLASS                    VISUAL-TYPE))
                                  (WRITE-8  (VISUAL.BITS-PER-RGB-VALUE       VISUAL-TYPE))
                                  (WRITE-16 (LENGTH (VISUAL.COLORMAP-ENTRIES VISUAL-TYPE)))
                                  (WRITE-32 (VISUAL.RED-MASK                 VISUAL-TYPE))
                                  (WRITE-32 (VISUAL.GREEN-MASK               VISUAL-TYPE))
                                  (WRITE-32 (VISUAL.BLUE-MASK                VISUAL-TYPE))
                                  (WRITE-32 0))))) ; Trash
	    ;; Moved to server initialization - \/\/
            ;;(SETQ root-cursor (create-root-cursor *default-cursor-font* 0))
	    )
          ;;ELSE
          ;; Return a failure packet to the client.
          (LET ((FAILURE-REASON "Mismatched version number"))
            (SETF (AREF BYTES 0) 0)    ; Failure
            (SETQ OUTPUT-BUFFER-INDEX 2)
            (WRITE-16 X-MAJOR-VERSION-NUMBER)
            (WRITE-16 X-MINOR-VERSION-NUMBER)
            (WRITE-16 (CEILING (LENGTH FAILURE-REASON) 4))
            (WRITE-STRING8 FAILURE-REASON)))
      (SERVER-STRING-OUT STATE BYTES OUTPUT-BUFFER-INDEX)
      (SERVER-PUSH STATE)
      (server-flush state))))
))