← Back to branch summary

~ubuntu-branches/ubuntu/maverick/kdebase-workspace/maverick-proposed

« back to all changes in this revision

Viewing changes to .pc/kubuntu_34_kdm_plymouth_transition.diff/kdm/backend/server.c

  • Committer: Bazaar Package Importer
  • Author(s): Alessandro Ghersi
  • Date: 2010-07-08 01:11:52 UTC
  • mfrom: (1.1.43 upstream)
  • Revision ID: james.westby@ubuntu.com-20100708011152-z0h26httnjr91mmy
Tags: 4:4.4.92-0ubuntu1
* New upstream rc release:
  - Bump kde-sc-dev-latest to 4.4.92
  - Refresh patches
  - Update symbols
  - plasma-widgets-workspace replaces/conflicts plasma-widget-logout

Show diffs side-by-side

added added

removed removed

Lines of Context:
.pc/kubuntu_34_kdm_plymouth_transition.diff/kdm/backend/server.c
49
49
time_t serverTimeout = TO_INF;
50
50
 
51
51
char **
52
 
prepareServerArgv( struct display *d, const char *args )
 
52
prepareServerArgv(struct display *d, const char *args)
53
53
{
54
 
        char **argv;
55
 
#ifdef HAVE_VTS
56
 
        char vtstr[8];
57
 
#endif
58
 
 
59
 
        if (!(argv = parseArgs( 0, d->serverCmd )) ||
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
 
        if (!(argv = parseArgs( argv, args )))
69
 
                exit( 47 );
70
 
 
71
 
        if (!changeUser( d->serverUID, d->authFile ))
72
 
                exit( 47 );
73
 
 
74
 
        return argv;
 
54
    char **argv;
 
55
#ifdef HAVE_VTS
 
56
    char vtstr[8];
 
57
#endif
 
58
 
 
59
    if (!(argv = parseArgs(0, d->serverCmd)) ||
 
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
    if (!(argv = parseArgs(argv, args)))
 
69
        exit(47);
 
70
 
 
71
    if (!changeUser(d->serverUID, d->authFile))
 
72
        exit(47);
 
73
 
 
74
    return argv;
75
75
}
76
76
 
77
77
static void
78
 
startServerOnce( void )
79
 
{
80
 
        struct display *d = startingServer;
81
 
        char **argv;
82
 
 
83
 
        debug( "startServerOnce for %s, try %d\n", d->name, ++d->startTries );
84
 
        d->serverStatus = starting;
85
 
        switch (Fork( &d->serverPid )) {
86
 
        case 0:
87
 
                argv = prepareServerArgv( d, d->serverArgsLocal );
88
 
                if (d->authFile) {
89
 
                        if (!(argv = addStrArr( argv, "-auth", 5 )) ||
90
 
                            !(argv = addStrArr( argv, d->authFile, -1 )))
91
 
                                exit( 47 );
92
 
                }
93
 
                debug( "exec %\"[s\n", argv );
94
 
                /*
95
 
                 * give the server SIGUSR1 ignored,
96
 
                 * it will notice that and send SIGUSR1
97
 
                 * when ready
98
 
                 */
99
 
                (void)Signal( SIGUSR1, SIG_IGN );
100
 
                (void)execv( argv[0], argv );
101
 
 
102
 
                /* Let's try again with a standard path */
103
 
                argv[0] = (char *)realloc(argv[0], strlen("/usr/bin/X") + 1);
104
 
                if (argv[0] != NULL) {
105
 
                        argv[0] = "/usr/bin/X";
106
 
                        debug( "exec %\"[s\n", argv );
107
 
                        (void)execv( argv[0], argv );
108
 
                        logError( "X server %\"s cannot be executed\n", argv[0] );
109
 
                }
110
 
 
111
 
                logError( "X server %\"s cannot be executed\n", argv[0] );
112
 
                exit( 47 );
113
 
        case -1:
114
 
                logError( "X server fork failed\n" );
115
 
                startServerFailed();
116
 
                break;
117
 
        default:
118
 
                debug( "X server forked, pid %d\n", d->serverPid );
119
 
                serverTimeout = d->serverTimeout + now;
120
 
                break;
121
 
        }
122
 
}
123
 
 
124
 
void
125
 
startServer( struct display *d )
126
 
{
127
 
        startingServer = d;
128
 
        d->startTries = 0;
129
 
        startServerOnce();
130
 
}
131
 
 
132
 
void
133
 
abortStartServer( struct display *d )
134
 
{
135
 
        if (startingServer == d)
136
 
        {
137
 
                if (d->serverStatus != ignore)
138
 
                {
139
 
                        d->serverStatus = ignore;
140
 
                        serverTimeout = TO_INF;
141
 
                        debug( "aborting X server start\n" );
142
 
                }
143
 
                startingServer = 0;
144
 
        }
 
78
startServerOnce(void)
 
79
{
 
80
    struct display *d = startingServer;
 
81
    char **argv;
 
82
 
 
83
    debug("startServerOnce for %s, try %d\n", d->name, ++d->startTries);
 
84
    d->serverStatus = starting;
 
85
    switch (Fork(&d->serverPid)) {
 
86
    case 0:
 
87
        argv = prepareServerArgv(d, d->serverArgsLocal);
 
88
        if (d->authFile) {
 
89
            if (!(argv = addStrArr(argv, "-auth", 5)) ||
 
90
                !(argv = addStrArr(argv, d->authFile, -1)))
 
91
                exit(47);
 
92
        }
 
93
        debug("exec %\"[s\n", argv);
 
94
        /*
 
95
         * give the server SIGUSR1 ignored,
 
96
         * it will notice that and send SIGUSR1
 
97
         * when ready
 
98
         */
 
99
        (void)Signal(SIGUSR1, SIG_IGN);
 
100
        (void)execv(argv[0], argv);
 
101
 
 
102
                /* Let's try again with a standard path */
 
103
                argv[0] = (char *)realloc(argv[0], strlen("/usr/bin/X") + 1);
 
104
                if (argv[0] != NULL) {
 
105
                        argv[0] = "/usr/bin/X";
 
106
                        debug( "exec %\"[s\n", argv );
 
107
                        (void)execv( argv[0], argv );
 
108
                        logError( "X server %\"s cannot be executed\n", argv[0] );
 
109
                }
 
110
 
 
111
        logError("X server %\"s cannot be executed\n", argv[0]);
 
112
        exit(47);
 
113
    case -1:
 
114
        logError("X server fork failed\n");
 
115
        startServerFailed();
 
116
        break;
 
117
    default:
 
118
        debug("X server forked, pid %d\n", d->serverPid);
 
119
        serverTimeout = d->serverTimeout + now;
 
120
        break;
 
121
    }
 
122
}
 
123
 
 
124
void
 
125
startServer(struct display *d)
 
126
{
 
127
    startingServer = d;
 
128
    d->startTries = 0;
 
129
    startServerOnce();
 
130
}
 
131
 
 
132
void
 
133
abortStartServer(struct display *d)
 
134
{
 
135
    if (startingServer == d) {
 
136
        if (d->serverStatus != ignore) {
 
137
            d->serverStatus = ignore;
 
138
            serverTimeout = TO_INF;
 
139
            debug("aborting X server start\n");
 
140
        }
 
141
        startingServer = 0;
 
142
    }
145
143
}
146
144
 
147
145
void
148
146
startServerSuccess()
149
147
{
150
 
        struct display *d = startingServer;
151
 
        d->serverStatus = ignore;
152
 
        serverTimeout = TO_INF;
153
 
        debug( "X server ready, starting session\n" );
154
 
        startDisplayP2( d );
 
148
    struct display *d = startingServer;
 
149
    d->serverStatus = ignore;
 
150
    serverTimeout = TO_INF;
 
151
    debug("X server ready, starting session\n");
 
152
    startDisplayP2(d);
155
153
}
156
154
 
157
155
void
158
156
startServerFailed()
159
157
{
160
 
        struct display *d = startingServer;
161
 
        if (!d->serverAttempts || d->startTries < d->serverAttempts) {
162
 
                d->serverStatus = pausing;
163
 
                serverTimeout = d->openDelay + now;
164
 
        } else {
165
 
                d->serverStatus = ignore;
166
 
                serverTimeout = TO_INF;
167
 
                startingServer = 0;
168
 
                logError( "X server for display %s cannot be started,"
169
 
                          " session disabled\n", d->name );
170
 
                stopDisplay( d );
171
 
        }
 
158
    struct display *d = startingServer;
 
159
    if (!d->serverAttempts || d->startTries < d->serverAttempts) {
 
160
        d->serverStatus = pausing;
 
161
        serverTimeout = d->openDelay + now;
 
162
    } else {
 
163
        d->serverStatus = ignore;
 
164
        serverTimeout = TO_INF;
 
165
        startingServer = 0;
 
166
        logError("X server for display %s cannot be started,"
 
167
                 " session disabled\n", d->name);
 
168
        stopDisplay(d);
 
169
    }
172
170
}
173
171
 
174
172
void
175
173
startServerTimeout()
176
174
{
177
 
        struct display *d = startingServer;
178
 
        switch (d->serverStatus) {
179
 
        case ignore:
180
 
        case awaiting:
181
 
                break; /* cannot happen */
182
 
        case starting:
183
 
                logError( "X server startup timeout, terminating\n" );
184
 
                kill( d->serverPid, d->termSignal );
185
 
                d->serverStatus = d->termSignal == SIGKILL ? killed : terminated;
186
 
                serverTimeout = d->serverTimeout + now;
187
 
                break;
188
 
        case terminated:
189
 
                logInfo( "X server termination timeout, killing\n" );
190
 
                kill( d->serverPid, SIGKILL );
191
 
                d->serverStatus = killed;
192
 
                serverTimeout = 10 + now;
193
 
                break;
194
 
        case killed:
195
 
                logInfo( "X server is stuck in D state; leaving it alone\n" );
196
 
                startServerFailed();
197
 
                break;
198
 
        case pausing:
199
 
                startServerOnce();
200
 
                break;
201
 
        }
 
175
    struct display *d = startingServer;
 
176
    switch (d->serverStatus) {
 
177
    case ignore:
 
178
    case awaiting:
 
179
        break; /* cannot happen */
 
180
    case starting:
 
181
        logError("X server startup timeout, terminating\n");
 
182
        kill(d->serverPid, d->termSignal);
 
183
        d->serverStatus = d->termSignal == SIGKILL ? killed : terminated;
 
184
        serverTimeout = d->serverTimeout + now;
 
185
        break;
 
186
    case terminated:
 
187
        logInfo("X server termination timeout, killing\n");
 
188
        kill(d->serverPid, SIGKILL);
 
189
        d->serverStatus = killed;
 
190
        serverTimeout = 10 + now;
 
191
        break;
 
192
    case killed:
 
193
        logInfo("X server is stuck in D state; leaving it alone\n");
 
194
        startServerFailed();
 
195
        break;
 
196
    case pausing:
 
197
        startServerOnce();
 
198
        break;
 
199
    }
202
200
}
203
201
 
204
202
 
216
214
 
217
215
/* ARGSUSED */
218
216
static void
219
 
abortOpen( int n ATTR_UNUSED )
 
217
abortOpen(int n ATTR_UNUSED)
220
218
{
221
 
        Longjmp( openAbort, 1 );
 
219
    Longjmp(openAbort, 1);
222
220
}
223
221
 
224
222
#ifdef XDMCP
228
226
#endif
229
227
 
230
228
static void
231
 
getRemoteAddress( struct display *d, int fd )
 
229
getRemoteAddress(struct display *d, int fd)
232
230
{
233
 
        char buf[512];
234
 
        int len = sizeof(buf);
 
231
    char buf[512];
 
232
    int len = sizeof(buf);
235
233
#ifdef STREAMSCONN
236
 
        struct netbuf netb;
 
234
    struct netbuf netb;
237
235
#endif
238
236
 
239
 
        XdmcpDisposeARRAY8( &d->peer );
 
237
    XdmcpDisposeARRAY8(&d->peer);
240
238
#ifdef STREAMSCONN
241
 
        netb.maxlen = sizeof(buf);
242
 
        netb.buf = buf;
243
 
        t_getname( fd, &netb, REMOTENAME );
244
 
        len = 8;
245
 
        /* lucky for us, t_getname returns something that looks like a sockaddr */
 
239
    netb.maxlen = sizeof(buf);
 
240
    netb.buf = buf;
 
241
    t_getname(fd, &netb, REMOTENAME);
 
242
    len = 8;
 
243
    /* lucky for us, t_getname returns something that looks like a sockaddr */
246
244
#else
247
 
        getpeername( fd, (struct sockaddr *)buf, (void *)&len );
 
245
    getpeername(fd, (struct sockaddr *)buf, (void *)&len);
248
246
#endif
249
 
        if (len && XdmcpAllocARRAY8( &d->peer, len ))
250
 
                memmove( d->peer.data, buf, len );
251
 
        debug( "got remote address %s %d\n", d->name, d->peer.length );
 
247
    if (len && XdmcpAllocARRAY8(&d->peer, len))
 
248
        memmove(d->peer.data, buf, len);
 
249
    debug("got remote address %s %d\n", d->name, d->peer.length);
252
250
}
253
251
 
254
252
#endif /* XDMCP */
255
253
 
256
254
static int
257
 
openErrorHandler( Display *dspl ATTR_UNUSED )
 
255
openErrorHandler(Display *dspl ATTR_UNUSED)
258
256
{
259
 
        logError( "IO Error in XOpenDisplay\n" );
260
 
        exit( EX_OPENFAILED_DPY );
261
 
        /*NOTREACHED*/
262
 
        return (0);
 
257
    logError("IO Error in XOpenDisplay\n");
 
258
    exit(EX_OPENFAILED_DPY);
 
259
    /*NOTREACHED*/
 
260
    return (0);
263
261
}
264
262
 
265
263
void
266
 
waitForServer( struct display *d )
 
264
waitForServer(struct display *d)
267
265
{
268
 
        volatile int i;
269
 
        /* static int i; */
 
266
    volatile int i;
 
267
    /* static int i; */
270
268
 
271
 
        i = 0;
272
 
        do {
273
 
                (void)Signal( SIGALRM, abortOpen );
274
 
                (void)alarm( (unsigned)d->openTimeout );
275
 
                if (!Setjmp( openAbort )) {
276
 
                        debug( "before XOpenDisplay(%s)\n", d->name );
277
 
                        errno = 0;
278
 
                        (void)XSetIOErrorHandler( openErrorHandler );
279
 
                        dpy = XOpenDisplay( d->name );
 
269
    i = 0;
 
270
    do {
 
271
        (void)Signal(SIGALRM, abortOpen);
 
272
        (void)alarm((unsigned)d->openTimeout);
 
273
        if (!Setjmp(openAbort)) {
 
274
            debug("before XOpenDisplay(%s)\n", d->name);
 
275
            errno = 0;
 
276
            (void)XSetIOErrorHandler(openErrorHandler);
 
277
            dpy = XOpenDisplay(d->name);
280
278
#ifdef STREAMSCONN
281
 
                        {
282
 
                                /* For some reason, the next XOpenDisplay we do is
283
 
                                   going to fail, so we might as well get that out
284
 
                                   of the way.  There is something broken here. */
285
 
                                Display *bogusDpy = XOpenDisplay( d->name );
286
 
                                debug( "bogus XOpenDisplay %s\n",
287
 
                                       bogusDpy ? "succeeded" : "failed" );
288
 
                                if (bogusDpy) XCloseDisplay( bogusDpy ); /* just in case */
289
 
                        }
 
279
            {
 
280
                /* For some reason, the next XOpenDisplay we do is
 
281
                   going to fail, so we might as well get that out
 
282
                   of the way.  There is something broken here. */
 
283
                Display *bogusDpy = XOpenDisplay(d->name);
 
284
                debug("bogus XOpenDisplay %s\n",
 
285
                      bogusDpy ? "succeeded" : "failed");
 
286
                if (bogusDpy)
 
287
                    XCloseDisplay(bogusDpy);    /* just in case */
 
288
            }
290
289
#endif
291
 
                        (void)alarm( (unsigned)0 );
292
 
                        (void)Signal( SIGALRM, SIG_DFL );
293
 
                        (void)XSetIOErrorHandler( (int (*)( Display * )) 0 );
294
 
                        debug( "after XOpenDisplay(%s)\n", d->name );
295
 
                        if (dpy) {
 
290
            (void)alarm((unsigned)0);
 
291
            (void)Signal(SIGALRM, SIG_DFL);
 
292
            (void)XSetIOErrorHandler((int (*)(Display *)) 0);
 
293
            debug("after XOpenDisplay(%s)\n", d->name);
 
294
            if (dpy) {
296
295
#ifdef XDMCP
297
 
                                if ((d->displayType & d_location) == dForeign)
298
 
                                        getRemoteAddress( d, ConnectionNumber( dpy ) );
 
296
                if ((d->displayType & d_location) == dForeign)
 
297
                    getRemoteAddress(d, ConnectionNumber(dpy));
299
298
#endif
300
 
                                registerCloseOnFork( ConnectionNumber( dpy ) );
301
 
                                return;
302
 
                        }
303
 
                        debug( "OpenDisplay(%s) attempt %d failed: %m\n", d->name, i + 1 );
304
 
                        sleep( (unsigned)d->openDelay );
305
 
                } else {
306
 
                        logError( "Hung in XOpenDisplay(%s), aborting\n", d->name );
307
 
                        (void)Signal( SIGALRM, SIG_DFL );
308
 
                        break;
309
 
                }
310
 
        } while (++i < d->openRepeat);
311
 
        logError( "Cannot connect to %s, giving up\n", d->name );
312
 
        exit( EX_OPENFAILED_DPY );
 
299
                registerCloseOnFork(ConnectionNumber(dpy));
 
300
                return;
 
301
            }
 
302
            debug("OpenDisplay(%s) attempt %d failed: %m\n", d->name, i + 1);
 
303
            sleep((unsigned)d->openDelay);
 
304
        } else {
 
305
            logError("Hung in XOpenDisplay(%s), aborting\n", d->name);
 
306
            (void)Signal(SIGALRM, SIG_DFL);
 
307
            break;
 
308
        }
 
309
    } while (++i < d->openRepeat);
 
310
    logError("Cannot connect to %s, giving up\n", d->name);
 
311
    exit(EX_OPENFAILED_DPY);
313
312
}
314
313
 
315
314
 
316
315
void
317
 
resetServer( struct display *d )
 
316
resetServer(struct display *d)
318
317
{
319
 
        if (dpy && (d->displayType & d_origin) != dFromXDMCP)
320
 
                pseudoReset();
 
318
    if (dpy && (d->displayType & d_origin) != dFromXDMCP)
 
319
        pseudoReset();
321
320
}
322
321
 
323
322
 
324
323
static Jmp_buf pingTime;
325
324
 
326
325
static void
327
 
pingLost( void )
 
326
pingLost(void)
328
327
{
329
 
        Longjmp( pingTime, 1 );
 
328
    Longjmp(pingTime, 1);
330
329
}
331
330
 
332
331
/* ARGSUSED */
333
332
static int
334
 
pingLostIOErr( Display *dspl ATTR_UNUSED )
 
333
pingLostIOErr(Display *dspl ATTR_UNUSED)
335
334
{
336
 
        pingLost();
337
 
        return 0;
 
335
    pingLost();
 
336
    return 0;
338
337
}
339
338
 
340
339
/* ARGSUSED */
341
340
static void
342
 
pingLostSig( int n ATTR_UNUSED )
 
341
pingLostSig(int n ATTR_UNUSED)
343
342
{
344
 
        pingLost();
 
343
    pingLost();
345
344
}
346
345
 
347
346
int
348
 
pingServer( struct display *d )
 
347
pingServer(struct display *d)
349
348
{
350
 
        int (*oldError)( Display * );
351
 
        void (*oldSig)( int );
352
 
        int oldAlarm;
 
349
    int (*oldError)(Display *);
 
350
    void (*oldSig)(int);
 
351
    int oldAlarm;
353
352
 
354
 
        oldError = XSetIOErrorHandler( pingLostIOErr );
355
 
        oldAlarm = alarm( 0 );
356
 
        oldSig = Signal( SIGALRM, pingLostSig );
357
 
        (void)alarm( d->pingTimeout * 60 );
358
 
        if (!Setjmp( pingTime )) {
359
 
                debug( "ping X server\n" );
360
 
                XSync( dpy, 0 );
361
 
        } else {
362
 
                debug( "X server dead\n" );
363
 
                (void)alarm( 0 );
364
 
                (void)Signal( SIGALRM, SIG_DFL );
365
 
                XSetIOErrorHandler( oldError );
366
 
                return False;
367
 
        }
368
 
        (void)alarm( 0 );
369
 
        (void)Signal( SIGALRM, oldSig );
370
 
        (void)alarm( oldAlarm );
371
 
        debug( "X server alive\n" );
372
 
        XSetIOErrorHandler( oldError );
373
 
        return True;
 
353
    oldError = XSetIOErrorHandler(pingLostIOErr);
 
354
    oldAlarm = alarm(0);
 
355
    oldSig = Signal(SIGALRM, pingLostSig);
 
356
    (void)alarm(d->pingTimeout * 60);
 
357
    if (!Setjmp(pingTime)) {
 
358
        debug("ping X server\n");
 
359
        XSync(dpy, 0);
 
360
    } else {
 
361
        debug("X server dead\n");
 
362
        (void)alarm(0);
 
363
        (void)Signal(SIGALRM, SIG_DFL);
 
364
        XSetIOErrorHandler(oldError);
 
365
        return False;
 
366
    }
 
367
    (void)alarm(0);
 
368
    (void)Signal(SIGALRM, oldSig);
 
369
    (void)alarm(oldAlarm);
 
370
    debug("X server alive\n");
 
371
    XSetIOErrorHandler(oldError);
 
372
    return True;
374
373
}