← Back to branch summary

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

« back to all changes in this revision

Viewing changes to kdm/backend/dpylist.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:
kdm/backend/dpylist.c
41
41
static struct disphist *disphist;
42
42
 
43
43
int
44
 
anyDisplaysLeft( void )
45
 
{
46
 
        return displays != 0;
47
 
}
48
 
 
49
 
int
50
 
anyRunningDisplays( void )
51
 
{
52
 
        struct display *d;
53
 
 
54
 
        for (d = displays; d; d = d->next)
55
 
                switch (d->status) {
56
 
                case notRunning:
57
 
                case textMode:
58
 
                case reserve:
59
 
                        break;
60
 
                default:
61
 
                        return True;
62
 
                }
63
 
        return False;
64
 
}
65
 
 
66
 
int
67
 
anyReserveDisplays( void )
68
 
{
69
 
        struct display *d;
70
 
 
71
 
        for (d = displays; d; d = d->next)
72
 
                if ((d->displayType & d_lifetime) == dReserve)
73
 
                        return True;
74
 
        return False;
75
 
}
76
 
 
77
 
int
78
 
idleReserveDisplays( void )
79
 
{
80
 
        struct display *d;
81
 
        int cnt = 0;
82
 
 
83
 
        for (d = displays; d; d = d->next)
84
 
                if (d->status == reserve)
85
 
                        cnt++;
86
 
        return cnt;
87
 
}
88
 
 
89
 
int
90
 
startReserveDisplay( int lt )
91
 
{
92
 
        struct display *d, *rd;
93
 
 
94
 
        for (rd = 0, d = displays; d; d = d->next)
95
 
                if (d->status == reserve)
96
 
                        rd = d;
97
 
        if (rd) {
98
 
                rd->idleTimeout = lt;
99
 
                rd->status = notRunning;
100
 
                return True;
101
 
        }
102
 
        return False;
 
44
anyDisplaysLeft(void)
 
45
{
 
46
    return displays != 0;
 
47
}
 
48
 
 
49
int
 
50
anyRunningDisplays(void)
 
51
{
 
52
    struct display *d;
 
53
 
 
54
    for (d = displays; d; d = d->next)
 
55
        switch (d->status) {
 
56
        case notRunning:
 
57
        case textMode:
 
58
        case reserve:
 
59
            break;
 
60
        default:
 
61
            return True;
 
62
        }
 
63
    return False;
 
64
}
 
65
 
 
66
int
 
67
anyReserveDisplays(void)
 
68
{
 
69
    struct display *d;
 
70
 
 
71
    for (d = displays; d; d = d->next)
 
72
        if ((d->displayType & d_lifetime) == dReserve)
 
73
            return True;
 
74
    return False;
 
75
}
 
76
 
 
77
int
 
78
idleReserveDisplays(void)
 
79
{
 
80
    struct display *d;
 
81
    int cnt = 0;
 
82
 
 
83
    for (d = displays; d; d = d->next)
 
84
        if (d->status == reserve)
 
85
            cnt++;
 
86
    return cnt;
 
87
}
 
88
 
 
89
int
 
90
startReserveDisplay(int lt)
 
91
{
 
92
    struct display *d, *rd;
 
93
 
 
94
    for (rd = 0, d = displays; d; d = d->next)
 
95
        if (d->status == reserve)
 
96
            rd = d;
 
97
    if (rd) {
 
98
        rd->idleTimeout = lt;
 
99
        rd->status = notRunning;
 
100
        return True;
 
101
    }
 
102
    return False;
103
103
}
104
104
 
105
105
void
106
 
forEachDisplay( void (*f)( struct display * ) )
 
106
forEachDisplay(void (*f)(struct display *))
107
107
{
108
 
        struct display *d, *next;
 
108
    struct display *d, *next;
109
109
 
110
 
        for (d = displays; d; d = next) {
111
 
                next = d->next;
112
 
                (*f)( d );
113
 
        }
 
110
    for (d = displays; d; d = next) {
 
111
        next = d->next;
 
112
        (*f)(d);
 
113
    }
114
114
}
115
115
 
116
116
#ifdef HAVE_VTS
117
117
static void
118
 
_forEachDisplayRev( struct display *d, void (*f)( struct display * ) )
 
118
_forEachDisplayRev(struct display *d, void (*f)(struct display *))
119
119
{
120
 
        if (d) {
121
 
                if (d->next)
122
 
                        _forEachDisplayRev( d->next, f );
123
 
                (*f)( d );
124
 
        }
 
120
    if (d) {
 
121
        if (d->next)
 
122
            _forEachDisplayRev(d->next, f);
 
123
        (*f)(d);
 
124
    }
125
125
}
126
126
 
127
127
void
128
 
forEachDisplayRev( void (*f)( struct display * ) )
 
128
forEachDisplayRev(void (*f)(struct display *))
129
129
{
130
 
        _forEachDisplayRev( displays, f );
 
130
    _forEachDisplayRev(displays, f);
131
131
}
132
132
#endif
133
133
 
134
134
struct display *
135
 
findDisplayByName( const char *name )
136
 
{
137
 
        struct display *d;
138
 
 
139
 
        for (d = displays; d; d = d->next)
140
 
                if (!strcmp( name, d->name ))
141
 
                        return d;
142
 
        return 0;
143
 
}
144
 
 
145
 
struct display *
146
 
findDisplayByPid( int pid )
147
 
{
148
 
        struct display *d;
149
 
 
150
 
        for (d = displays; d; d = d->next)
151
 
                if (pid == d->pid)
152
 
                        return d;
153
 
        return 0;
154
 
}
155
 
 
156
 
struct display *
157
 
findDisplayByServerPid( int serverPid )
158
 
{
159
 
        struct display *d;
160
 
 
161
 
        for (d = displays; d; d = d->next)
162
 
                if (serverPid == d->serverPid)
163
 
                        return d;
164
 
        return 0;
 
135
findDisplayByName(const char *name)
 
136
{
 
137
    struct display *d;
 
138
 
 
139
    for (d = displays; d; d = d->next)
 
140
        if (!strcmp(name, d->name))
 
141
            return d;
 
142
    return 0;
 
143
}
 
144
 
 
145
struct display *
 
146
findDisplayByPid(int pid)
 
147
{
 
148
    struct display *d;
 
149
 
 
150
    for (d = displays; d; d = d->next)
 
151
        if (pid == d->pid)
 
152
            return d;
 
153
    return 0;
 
154
}
 
155
 
 
156
struct display *
 
157
findDisplayByServerPid(int serverPid)
 
158
{
 
159
    struct display *d;
 
160
 
 
161
    for (d = displays; d; d = d->next)
 
162
        if (serverPid == d->serverPid)
 
163
            return d;
 
164
    return 0;
165
165
}
166
166
 
167
167
#ifdef XDMCP
168
168
 
169
169
struct display *
170
 
findDisplayBySessionID( CARD32 sessionID )
 
170
findDisplayBySessionID(CARD32 sessionID)
171
171
{
172
 
        struct display *d;
 
172
    struct display *d;
173
173
 
174
 
        for (d = displays; d; d = d->next)
175
 
                if (sessionID == d->sessionID)
176
 
                        return d;
177
 
        return 0;
 
174
    for (d = displays; d; d = d->next)
 
175
        if (sessionID == d->sessionID)
 
176
            return d;
 
177
    return 0;
178
178
}
179
179
 
180
180
struct display *
181
 
findDisplayByAddress( XdmcpNetaddr addr, int addrlen, CARD16 displayNumber )
 
181
findDisplayByAddress(XdmcpNetaddr addr, int addrlen, CARD16 displayNumber)
182
182
{
183
 
        struct display *d;
 
183
    struct display *d;
184
184
 
185
 
        for (d = displays; d; d = d->next)
186
 
                if ((d->displayType & d_origin) == dFromXDMCP &&
187
 
                    d->displayNumber == displayNumber &&
188
 
                    addressEqual( (XdmcpNetaddr)d->from.data, d->from.length,
189
 
                                  addr, addrlen ))
190
 
                        return d;
191
 
        return 0;
 
185
    for (d = displays; d; d = d->next)
 
186
        if ((d->displayType & d_origin) == dFromXDMCP &&
 
187
            d->displayNumber == displayNumber &&
 
188
            addressEqual((XdmcpNetaddr)d->from.data, d->from.length,
 
189
                         addr, addrlen))
 
190
            return d;
 
191
    return 0;
192
192
}
193
193
 
194
194
#endif /* XDMCP */
195
195
 
196
196
void
197
 
removeDisplay( struct display *old )
 
197
removeDisplay(struct display *old)
198
198
{
199
 
        struct display *d, **dp;
200
 
        int i;
 
199
    struct display *d, **dp;
 
200
    int i;
201
201
 
202
 
        for (dp = &displays; (d = *dp); dp = &(*dp)->next) {
203
 
                if (d == old) {
204
 
                        debug( "Removing display %s\n", d->name );
205
 
                        *dp = d->next;
206
 
                        free( d->class2 );
207
 
                        free( d->cfg.data );
208
 
                        delStr( d->cfg.dep.name );
209
 
#ifdef XDMCP
210
 
                        free( d->remoteHost );
211
 
#endif
212
 
                        if (d->authorizations) {
213
 
                                for (i = 0; i < d->authNum; i++)
214
 
                                        XauDisposeAuth( d->authorizations[i] );
215
 
                                free( d->authorizations );
216
 
                        }
217
 
                        if (d->authFile) {
218
 
                                (void)unlink( d->authFile );
219
 
                                free( d->authFile );
220
 
                        }
221
 
                        if (d->greeterAuthFile) {
222
 
                                (void)unlink( d->greeterAuthFile );
223
 
                                free( d->greeterAuthFile );
224
 
                        }
225
 
#ifdef XDMCP
226
 
                        XdmcpDisposeARRAY8( &d->peer );
227
 
                        XdmcpDisposeARRAY8( &d->from );
228
 
                        XdmcpDisposeARRAY8( &d->clientAddr );
229
 
#endif
230
 
                        free( d );
231
 
                        break;
232
 
                }
233
 
        }
 
202
    for (dp = &displays; (d = *dp); dp = &(*dp)->next) {
 
203
        if (d == old) {
 
204
            debug("Removing display %s\n", d->name);
 
205
            *dp = d->next;
 
206
            free(d->class2);
 
207
            free(d->cfg.data);
 
208
            delStr(d->cfg.dep.name);
 
209
#ifdef XDMCP
 
210
            free(d->remoteHost);
 
211
#endif
 
212
            if (d->authorizations) {
 
213
                for (i = 0; i < d->authNum; i++)
 
214
                    XauDisposeAuth(d->authorizations[i]);
 
215
                free(d->authorizations);
 
216
            }
 
217
            if (d->authFile) {
 
218
                (void)unlink(d->authFile);
 
219
                free(d->authFile);
 
220
            }
 
221
            if (d->greeterAuthFile) {
 
222
                (void)unlink(d->greeterAuthFile);
 
223
                free(d->greeterAuthFile);
 
224
            }
 
225
#ifdef XDMCP
 
226
            XdmcpDisposeARRAY8(&d->peer);
 
227
            XdmcpDisposeARRAY8(&d->from);
 
228
            XdmcpDisposeARRAY8(&d->clientAddr);
 
229
#endif
 
230
            free(d);
 
231
            break;
 
232
        }
 
233
    }
234
234
}
235
235
 
236
236
static struct disphist *
237
 
findHist( const char *name )
 
237
findHist(const char *name)
238
238
{
239
 
        struct disphist *hstent;
 
239
    struct disphist *hstent;
240
240
 
241
 
        for (hstent = disphist; hstent; hstent = hstent->next)
242
 
                if (!strcmp( hstent->name, name ))
243
 
                        return hstent;
244
 
        return 0;
 
241
    for (hstent = disphist; hstent; hstent = hstent->next)
 
242
        if (!strcmp(hstent->name, name))
 
243
            return hstent;
 
244
    return 0;
245
245
}
246
246
 
247
247
struct display *
248
 
newDisplay( const char *name )
 
248
newDisplay(const char *name)
249
249
{
250
 
        struct display *d;
251
 
        struct disphist *hstent;
252
 
 
253
 
        if (!(hstent = findHist( name ))) {
254
 
                if (!(hstent = Calloc( 1, sizeof(*hstent) )))
255
 
                        return 0;
256
 
                if (!strDup( &hstent->name, name )) {
257
 
                        free( hstent );
258
 
                        return 0;
259
 
                }
260
 
                hstent->next = disphist; disphist = hstent;
261
 
        }
262
 
 
263
 
        if (!(d = Calloc( 1, sizeof(*d) )))
264
 
                return 0;
265
 
        d->next = displays;
266
 
        d->hstent = hstent;
267
 
        d->name = hstent->name;
268
 
        /* initialize fields (others are 0) */
269
 
        d->pid = -1;
270
 
        d->serverPid = -1;
271
 
        d->ctrl.fd = -1;
272
 
        d->pipe.fd.r = -1;
273
 
        d->gpipe.fd.r = -1;
 
250
    struct display *d;
 
251
    struct disphist *hstent;
 
252
 
 
253
    if (!(hstent = findHist(name))) {
 
254
        if (!(hstent = Calloc(1, sizeof(*hstent))))
 
255
            return 0;
 
256
        if (!strDup(&hstent->name, name)) {
 
257
            free(hstent);
 
258
            return 0;
 
259
        }
 
260
        hstent->next = disphist;
 
261
        disphist = hstent;
 
262
    }
 
263
 
 
264
    if (!(d = Calloc(1, sizeof(*d))))
 
265
        return 0;
 
266
    d->next = displays;
 
267
    d->hstent = hstent;
 
268
    d->name = hstent->name;
 
269
    /* initialize fields (others are 0) */
 
270
    d->pid = -1;
 
271
    d->serverPid = -1;
 
272
    d->ctrl.fd = -1;
 
273
    d->pipe.fd.r = -1;
 
274
    d->gpipe.fd.r = -1;
274
275
#ifndef SINGLE_PIPE
275
 
        d->pipe.fd.w = -1;
276
 
        d->gpipe.fd.w = -1;
 
276
    d->pipe.fd.w = -1;
 
277
    d->gpipe.fd.w = -1;
277
278
#endif
278
 
        d->userSess = -1;
 
279
    d->userSess = -1;
279
280
#ifdef XDMCP
280
 
        d->xdmcpFd = -1;
 
281
    d->xdmcpFd = -1;
281
282
#endif
282
 
        displays = d;
283
 
        debug( "created new display %s\n", d->name );
284
 
        return d;
 
283
    displays = d;
 
284
    debug("created new display %s\n", d->name);
 
285
    return d;
285
286
}
286
287
 
287
288
const char *
288
 
displayName( struct display *d )
 
289
displayName(struct display *d)
289
290
{
290
 
        return memcmp( d->name, "localhost:", 10 ) ? d->name : d->name + 9;
 
291
    return memcmp(d->name, "localhost:", 10) ? d->name : d->name + 9;
291
292
}