workspace/kdm/backend/server.c

   1 /*
   2
   3 Copyright 1988, 1998  The Open Group
   4 Copyright 2001,2003,2005 Oswald Buddenhagen <ossi@kde.org>
   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
  13 in all copies or substantial portions of the Software.
  14
  15 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  16 OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  17 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  18 IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
  19 OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  20 ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  21 OTHER DEALINGS IN THE SOFTWARE.
  22
  23 Except as contained in this notice, the name of a copyright holder shall
  24 not be used in advertising or otherwise to promote the sale, use or
  25 other dealings in this Software without prior written authorization
  26 from the copyright holder.
  27
  28 */
  29
  30 /*
  31  * xdm - display manager daemon
  32  * Author: Keith Packard, MIT X Consortium
  33  *
  34  * server.c - manage the X server
  35  */
  36
  37 #include "dm.h"
  38 #include "dm_error.h"
  39 #include "dm_socket.h"
  40
  41 #include <X11/Xlib.h>
  42
  43 #include <stdio.h>
  44 #include <signal.h>
  45
  46
  47 struct display *startingServer;
  48 time_t serverTimeout = TO_INF;
  49
  50 char **
  51 prepareServerArgv( struct display *d, const char *args )
  52 {
  53         char **argv;
  54 #ifdef HAVE_VTS
  55         char vtstr[8];
  56 #endif
  57
  58         if (!(argv = parseArgs( 0, d->serverCmd )) ||
  59             !(argv = parseArgs( argv, args )) ||
  60             !(argv = addStrArr( argv, d->name, -1 )))
  61                 exit( 47 );
  62 #ifdef HAVE_VTS
  63         if (d->serverVT &&
  64             !(argv = addStrArr( argv, vtstr,
  65                                 sprintf( vtstr, "vt%d", d->serverVT ) )))
  66                 exit( 47 );
  67 #endif
  68         return argv;
  69 }
  70
  71 static void
  72 startServerOnce( void )
  73 {
  74         struct display *d = startingServer;
  75         char **argv;
  76
  77         debug( "startServerOnce for %s, try %d\n", d->name, ++d->startTries );
  78         d->serverStatus = starting;
  79         switch (Fork( &d->serverPid )) {
  80         case 0:
  81                 argv = prepareServerArgv( d, d->serverArgsLocal );
  82                 if (d->authFile) {
  83                         if (!(argv = addStrArr( argv, "-auth", 5 )) ||
  84                             !(argv = addStrArr( argv, d->authFile, -1 )))
  85                                 exit( 47 );
  86                 }
  87                 debug( "exec %\"[s\n", argv );
  88                 /*
  89                  * give the server SIGUSR1 ignored,
  90                  * it will notice that and send SIGUSR1
  91                  * when ready
  92                  */
  93                 (void)Signal( SIGUSR1, SIG_IGN );
  94                 (void)execv( argv[0], argv );
  95                 logError( "X server %\"s cannot be executed\n", argv[0] );
  96                 exit( 47 );
  97         case -1:
  98                 logError( "X server fork failed\n" );
  99                 startServerFailed();
 100                 break;
 101         default:
 102                 debug( "X server forked, pid %d\n", d->serverPid );
 103                 serverTimeout = d->serverTimeout + now;
 104                 break;
 105         }
 106 }
 107
 108 void
 109 startServer( struct display *d )
 110 {
 111         startingServer = d;
 112         d->startTries = 0;
 113         startServerOnce();
 114 }
 115
 116 void
 117 abortStartServer( struct display *d )
 118 {
 119         if (startingServer == d)
 120         {
 121                 if (d->serverStatus != ignore)
 122                 {
 123                         d->serverStatus = ignore;
 124                         serverTimeout = TO_INF;
 125                         debug( "aborting X server start\n" );
 126                 }
 127                 startingServer = 0;
 128         }
 129 }
 130
 131 void
 132 startServerSuccess()
 133 {
 134         struct display *d = startingServer;
 135         d->serverStatus = ignore;
 136         serverTimeout = TO_INF;
 137         debug( "X server ready, starting session\n" );
 138         startDisplayP2( d );
 139 }
 140
 141 void
 142 startServerFailed()
 143 {
 144         struct display *d = startingServer;
 145         if (!d->serverAttempts || d->startTries < d->serverAttempts) {
 146                 d->serverStatus = pausing;
 147                 serverTimeout = d->openDelay + now;
 148         } else {
 149                 d->serverStatus = ignore;
 150                 serverTimeout = TO_INF;
 151                 startingServer = 0;
 152                 logError( "X server for display %s cannot be started,"
 153                           " session disabled\n", d->name );
 154                 stopDisplay( d );
 155         }
 156 }
 157
 158 void
 159 startServerTimeout()
 160 {
 161         struct display *d = startingServer;
 162         switch (d->serverStatus) {
 163         case ignore:
 164         case awaiting:
 165                 break; /* cannot happen */
 166         case starting:
 167                 logError( "X server startup timeout, terminating\n" );
 168                 kill( d->serverPid, d->termSignal );
 169                 d->serverStatus = d->termSignal == SIGKILL ? killed : terminated;
 170                 serverTimeout = d->serverTimeout + now;
 171                 break;
 172         case terminated:
 173                 logInfo( "X server termination timeout, killing\n" );
 174                 kill( d->serverPid, SIGKILL );
 175                 d->serverStatus = killed;
 176                 serverTimeout = 10 + now;
 177                 break;
 178         case killed:
 179                 logInfo( "X server is stuck in D state; leaving it alone\n" );
 180                 startServerFailed();
 181                 break;
 182         case pausing:
 183                 startServerOnce();
 184                 break;
 185         }
 186 }
 187
 188
 189 Display *dpy;
 190
 191 /*
 192  * this code is complicated by some TCP failings.  On
 193  * many systems, the connect will occasionally hang forever,
 194  * this trouble is avoided by setting up a timeout to Longjmp
 195  * out of the connect (possibly leaving piles of garbage around
 196  * inside Xlib) and give up, terminating the server.
 197  */
 198
 199 static Jmp_buf openAbort;
 200
 201 /* ARGSUSED */
 202 static void
 203 abortOpen( int n ATTR_UNUSED )
 204 {
 205         Longjmp( openAbort, 1 );
 206 }
 207
 208 #ifdef XDMCP
 209
 210 #ifdef STREAMSCONN
 211 # include <tiuser.h>
 212 #endif
 213
 214 static void
 215 getRemoteAddress( struct display *d, int fd )
 216 {
 217         char buf[512];
 218         int len = sizeof(buf);
 219 #ifdef STREAMSCONN
 220         struct netbuf netb;
 221 #endif
 222
 223         XdmcpDisposeARRAY8( &d->peer );
 224 #ifdef STREAMSCONN
 225         netb.maxlen = sizeof(buf);
 226         netb.buf = buf;
 227         t_getname( fd, &netb, REMOTENAME );
 228         len = 8;
 229         /* lucky for us, t_getname returns something that looks like a sockaddr */
 230 #else
 231         getpeername( fd, (struct sockaddr *)buf, (void *)&len );
 232 #endif
 233         if (len && XdmcpAllocARRAY8( &d->peer, len ))
 234                 memmove( (char *)d->peer.data, buf, len );
 235         debug( "got remote address %s %d\n", d->name, d->peer.length );
 236 }
 237
 238 #endif /* XDMCP */
 239
 240 static int
 241 openErrorHandler( Display *dspl ATTR_UNUSED )
 242 {
 243         logError( "IO Error in XOpenDisplay\n" );
 244         exit( EX_OPENFAILED_DPY );
 245         /*NOTREACHED*/
 246         return (0);
 247 }
 248
 249 void
 250 waitForServer( struct display *d )
 251 {
 252         volatile int i;
 253         /* static int i; */
 254
 255         i = 0;
 256         do {
 257                 (void)Signal( SIGALRM, abortOpen );
 258                 (void)alarm( (unsigned)d->openTimeout );
 259                 if (!Setjmp( openAbort )) {
 260                         debug( "before XOpenDisplay(%s)\n", d->name );
 261                         errno = 0;
 262                         (void)XSetIOErrorHandler( openErrorHandler );
 263                         dpy = XOpenDisplay( d->name );
 264 #ifdef STREAMSCONN
 265                         {
 266                                 /* For some reason, the next XOpenDisplay we do is
 267                                    going to fail, so we might as well get that out
 268                                    of the way.  There is something broken here. */
 269                                 Display *bogusDpy = XOpenDisplay( d->name );
 270                                 debug( "bogus XOpenDisplay %s\n",
 271                                        bogusDpy ? "succeeded" : "failed" );
 272                                 if (bogusDpy) XCloseDisplay( bogusDpy ); /* just in case */
 273                         }
 274 #endif
 275                         (void)alarm( (unsigned)0 );
 276                         (void)Signal( SIGALRM, SIG_DFL );
 277                         (void)XSetIOErrorHandler( (int (*)( Display * )) 0 );
 278                         debug( "after XOpenDisplay(%s)\n", d->name );
 279                         if (dpy) {
 280 #ifdef XDMCP
 281                                 if ((d->displayType & d_location) == dForeign)
 282                                         getRemoteAddress( d, ConnectionNumber( dpy ) );
 283 #endif
 284                                 registerCloseOnFork( ConnectionNumber( dpy ) );
 285                                 return;
 286                         }
 287                         debug( "OpenDisplay(%s) attempt %d failed: %m\n", d->name, i + 1 );
 288                         sleep( (unsigned)d->openDelay );
 289                 } else {
 290                         logError( "Hung in XOpenDisplay(%s), aborting\n", d->name );
 291                         (void)Signal( SIGALRM, SIG_DFL );
 292                         break;
 293                 }
 294         } while (++i < d->openRepeat);
 295         logError( "Cannot connect to %s, giving up\n", d->name );
 296         exit( EX_OPENFAILED_DPY );
 297 }
 298
 299
 300 void
 301 resetServer( struct display *d )
 302 {
 303         if (dpy && (d->displayType & d_origin) != dFromXDMCP)
 304                 pseudoReset();
 305 }
 306
 307
 308 static Jmp_buf pingTime;
 309
 310 static void
 311 pingLost( void )
 312 {
 313         Longjmp( pingTime, 1 );
 314 }
 315
 316 /* ARGSUSED */
 317 static int
 318 pingLostIOErr( Display *dspl ATTR_UNUSED )
 319 {
 320         pingLost();
 321         return 0;
 322 }
 323
 324 /* ARGSUSED */
 325 static void
 326 pingLostSig( int n ATTR_UNUSED )
 327 {
 328         pingLost();
 329 }
 330
 331 int
 332 pingServer( struct display *d )
 333 {
 334         int (*oldError)( Display * );
 335         void (*oldSig)( int );
 336         int oldAlarm;
 337
 338         oldError = XSetIOErrorHandler( pingLostIOErr );
 339         oldAlarm = alarm( 0 );
 340         oldSig = Signal( SIGALRM, pingLostSig );
 341         (void)alarm( d->pingTimeout * 60 );
 342         if (!Setjmp( pingTime )) {
 343                 debug( "ping X server\n" );
 344                 XSync( dpy, 0 );
 345         } else {
 346                 debug( "X server dead\n" );
 347                 (void)alarm( 0 );
 348                 (void)Signal( SIGALRM, SIG_DFL );
 349                 XSetIOErrorHandler( oldError );
 350                 return False;
 351         }
 352         (void)alarm( 0 );
 353         (void)Signal( SIGALRM, oldSig );
 354         (void)alarm( oldAlarm );
 355         debug( "X server alive\n" );
 356         XSetIOErrorHandler( oldError );
 357         return True;
 358 }