← Back to branch summary

~ubuntu-branches/ubuntu/precise/libfs/precise-security

« back to all changes in this revision

Viewing changes to src/FSOpenServ.c

  • Committer: Bazaar Package Importer
  • Author(s): Daniel Stone
  • Date: 2005-07-23 00:15:32 UTC
  • Revision ID: james.westby@ubuntu.com-20050723001532-1n80puvkrct21vfl
Tags: upstream-3.0.0
Import upstream version 3.0.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/FSOpenServ.c
 
1
/* $Xorg: FSOpenServ.c,v 1.4 2001/02/09 02:03:25 xorgcvs Exp $ */
 
2
 
 
3
/* @(#)FSOpenServ.c     4.1     91/05/02
 
4
 * Copyright 1990 Network Computing Devices;
 
5
 * Portions Copyright 1987 by Digital Equipment Corporation
 
6
 *
 
7
 * Permission to use, copy, modify, distribute, and sell this software 
 
8
 * and its documentation for any purpose is hereby granted without fee, 
 
9
 * provided that the above copyright notice appear in all copies and 
 
10
 * that both that copyright notice and this permission notice appear 
 
11
 * in supporting documentation, and that the names of Network Computing 
 
12
 * Devices or Digital not be used in advertising or publicity pertaining 
 
13
 * to distribution of the software without specific, written prior 
 
14
 * permission. Network Computing Devices or Digital make no representations 
 
15
 * about the suitability of this software for any purpose.  It is provided 
 
16
 * "as is" without express or implied warranty.
 
17
 *
 
18
 * NETWORK COMPUTING DEVICES AND  DIGITAL DISCLAIM ALL WARRANTIES WITH
 
19
 * REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF 
 
20
 * MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL NETWORK COMPUTING DEVICES
 
21
 * OR DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES 
 
22
 * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, 
 
23
 * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, 
 
24
 * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS 
 
25
 * SOFTWARE.
 
26
 */
 
27
/* $XFree86: xc/lib/FS/FSOpenServ.c,v 1.8tsi Exp $ */
 
28
 
 
29
/*
 
30
 
 
31
Copyright 1987, 1994, 1998  The Open Group
 
32
 
 
33
Permission to use, copy, modify, distribute, and sell this software and its
 
34
documentation for any purpose is hereby granted without fee, provided that
 
35
the above copyright notice appear in all copies and that both that
 
36
copyright notice and this permission notice appear in supporting
 
37
documentation.
 
38
 
 
39
The above copyright notice and this permission notice shall be included in
 
40
all copies or substantial portions of the Software.
 
41
 
 
42
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 
43
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 
44
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
 
45
OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
 
46
AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 
47
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
48
 
 
49
Except as contained in this notice, the name of The Open Group shall not be
 
50
used in advertising or otherwise to promote the sale, use or other dealings
 
51
in this Software without prior written authorization from The Open Group.
 
52
 
 
53
*/
 
54
 
 
55
/*
 
56
 * does initial handshake w/ font server
 
57
 */
 
58
 
 
59
#ifdef HAVE_CONFIG_H
 
60
#include <config.h>
 
61
#endif
 
62
#include        <stdio.h>
 
63
#include        "FSlibint.h"
 
64
#include        <X11/Xtrans/Xtrans.h>
 
65
 
 
66
int         _FSdebug = 0;
 
67
 
 
68
static fsReq _dummy_request = {
 
69
    0, 0, 0
 
70
};
 
71
 
 
72
static void OutOfMemory ( FSServer *svr, char *setup );
 
73
 
 
74
FSServer   *_FSHeadOfServerList = NULL;
 
75
 
 
76
void _FSFreeServerStructure(svr)
 
77
    FSServer   *svr;
 
78
{
 
79
    if (svr->server_name)
 
80
        FSfree(svr->server_name);
 
81
    if (svr->vendor)
 
82
        FSfree(svr->vendor);
 
83
 
 
84
    if (svr->buffer)
 
85
        FSfree(svr->buffer);
 
86
 
 
87
    FSfree((char *) svr);
 
88
}
 
89
 
 
90
static
 
91
void OutOfMemory(svr, setup)
 
92
    FSServer   *svr;
 
93
    char       *setup;
 
94
{
 
95
 
 
96
    _FSDisconnectServer(svr->trans_conn);
 
97
    _FSFreeServerStructure(svr);
 
98
    FSfree(setup);
 
99
    errno = ENOMEM;
 
100
}
 
101
 
 
102
/*
 
103
 * connects to a server, makes a FSServer object and returns a pointer
 
104
 * to it
 
105
 */
 
106
 
 
107
FSServer   *
 
108
FSOpenServer(server)
 
109
    char       *server;
 
110
{
 
111
    FSServer   *svr;
 
112
    int         i;
 
113
    int         endian;
 
114
    fsConnClientPrefix client;
 
115
    fsConnSetup prefix;
 
116
    char       *setup;
 
117
    fsConnSetupAccept conn;
 
118
    char       *auth_data;
 
119
    char       *alt_data,
 
120
               *ad;
 
121
    AlternateServer *alts;
 
122
    int         altlen;
 
123
    char       *vendor_string;
 
124
    unsigned long        setuplength;
 
125
 
 
126
    if (server == NULL || *server == '\0') {
 
127
        if ((server = getenv("FONTSERVER")) == NULL) {
 
128
            return (FSServer *) NULL;
 
129
        }
 
130
    }
 
131
 
 
132
    if ((svr = (FSServer *) FScalloc(1, sizeof(FSServer))) == NULL) {
 
133
        errno = ENOMEM;
 
134
        return (FSServer *) NULL;
 
135
    }
 
136
    if ((svr->trans_conn = _FSConnectServer(server)) == NULL) {
 
137
        FSfree((char *) svr);
 
138
        return (FSServer *) NULL;
 
139
    }
 
140
 
 
141
    svr->fd = _FSTransGetConnectionNumber (svr->trans_conn);
 
142
 
 
143
    endian = 1;
 
144
    if (*(char *) &endian)
 
145
        client.byteOrder = 'l';
 
146
    else
 
147
        client.byteOrder = 'B';
 
148
    client.major_version = FS_PROTOCOL;
 
149
    client.minor_version = FS_PROTOCOL_MINOR;
 
150
/* XXX -- fix this when we have some auths */
 
151
    client.num_auths = 0;
 
152
    client.auth_len = 0;
 
153
    _FSSendClientPrefix(svr, &client);
 
154
 
 
155
/* see if connection was accepted */
 
156
    _FSRead(svr, (char *) &prefix, (long) SIZEOF(fsConnSetup));
 
157
 
 
158
    setuplength = prefix.alternate_len << 2;
 
159
    if (setuplength > (SIZE_MAX>>2)
 
160
        || (alt_data = (char *)
 
161
         (setup = FSmalloc((unsigned) setuplength))) == NULL) {
 
162
        errno = ENOMEM;
 
163
        FSfree((char *) svr);
 
164
        return (FSServer *) NULL;
 
165
    }
 
166
    _FSRead(svr, (char *) alt_data, setuplength);
 
167
    ad = alt_data;
 
168
 
 
169
#if SIZE_MAX <= UINT_MAX
 
170
    if (prefix.num_alternates > SIZE_MAX / sizeof(AlternateServer)) {
 
171
        errno = ENOMEM;
 
172
        FSfree((char *) alt_data);
 
173
        FSfree((char *) svr);
 
174
        return (FSServer *) 0;
 
175
    }
 
176
#endif
 
177
 
 
178
    alts = (AlternateServer *)
 
179
        FSmalloc(sizeof(AlternateServer) * prefix.num_alternates);
 
180
    if (!alts) {
 
181
        errno = ENOMEM;
 
182
        FSfree((char *) alt_data);
 
183
        FSfree((char *) svr);
 
184
        return (FSServer *) 0;
 
185
    }
 
186
    for (i = 0; i < prefix.num_alternates; i++) {
 
187
        alts[i].subset = (Bool) *ad++;
 
188
        altlen = (int) *ad++;
 
189
        alts[i].name = (char *) FSmalloc(altlen + 1);
 
190
        if (!alts[i].name) {
 
191
            while (--i) {
 
192
                FSfree((char *) alts[i].name);
 
193
            }
 
194
            FSfree((char *) alts);
 
195
            FSfree((char *) alt_data);
 
196
            FSfree((char *) svr);
 
197
            errno = ENOMEM;
 
198
            return (FSServer *) 0;
 
199
        }
 
200
        bcopy(ad, alts[i].name, altlen);
 
201
        alts[i].name[altlen] = '\0';
 
202
        ad += altlen + ((4 - (altlen + 2)) & 3);
 
203
    }
 
204
    FSfree((char *) alt_data);
 
205
 
 
206
    svr->alternate_servers = alts;
 
207
    svr->num_alternates = prefix.num_alternates;
 
208
 
 
209
    setuplength = prefix.auth_len << 2;
 
210
    if (setuplength > (SIZE_MAX>>2) 
 
211
        || (auth_data = (char *)
 
212
         (setup = FSmalloc((unsigned) setuplength))) == NULL) {
 
213
        errno = ENOMEM;
 
214
        FSfree((char *) alts);
 
215
        FSfree((char *) svr);
 
216
        return (FSServer *) NULL;
 
217
    }
 
218
    _FSRead(svr, (char *) auth_data, setuplength);
 
219
 
 
220
    if (prefix.status != AuthSuccess) {
 
221
        fprintf(stderr, "%s: connection to \"%s\" refused by server\r\n%s: ",
 
222
                "FSlib", server, "FSlib");
 
223
        FSfree((char *) alts);
 
224
        FSfree((char *) svr);
 
225
        FSfree(setup);
 
226
        return (FSServer *) NULL;
 
227
    }
 
228
    /* get rest */
 
229
    _FSRead(svr, (char *) &conn, (long) SIZEOF(fsConnSetupAccept));
 
230
 
 
231
    if ((vendor_string = (char *)
 
232
         FSmalloc((unsigned) conn.vendor_len + 1)) == NULL) {
 
233
        errno = ENOMEM;
 
234
        FSfree((char *) auth_data);
 
235
        FSfree((char *) alts);
 
236
        FSfree((char *) svr);
 
237
        return (FSServer *) NULL;
 
238
    }
 
239
    _FSReadPad(svr, (char *) vendor_string, conn.vendor_len);
 
240
 
 
241
    /* move the data into the FSServer struct */
 
242
    svr->next = (FSServer *) NULL;
 
243
    svr->proto_version = prefix.major_version;
 
244
    svr->release = conn.release_number;
 
245
    svr->max_request_size = conn.max_request_len;
 
246
 
 
247
    svr->event_vec[FS_Error] = _FSUnknownWireEvent;
 
248
    svr->event_vec[FS_Reply] = _FSUnknownWireEvent;
 
249
    svr->wire_vec[FS_Error] = _FSUnknownNativeEvent;
 
250
    svr->wire_vec[FS_Reply] = _FSUnknownNativeEvent;
 
251
    for (i = FSLASTEvent; i < 128; i++) {
 
252
        svr->event_vec[i] = _FSUnknownWireEvent;
 
253
        svr->wire_vec[i] = _FSUnknownNativeEvent;
 
254
    }
 
255
    svr->resource_id = 1;
 
256
 
 
257
    svr->vendor = vendor_string;
 
258
    svr->vendor[conn.vendor_len] = '\0';
 
259
 
 
260
    svr->vnumber = FS_PROTOCOL;
 
261
    svr->request = 0;
 
262
    svr->last_request_read = 0;
 
263
    svr->last_req = (char *) &_dummy_request;
 
264
 
 
265
    if ((svr->server_name = FSmalloc((unsigned) (strlen(server) + 1)))
 
266
            == NULL) {
 
267
        OutOfMemory(svr, setup);
 
268
        return (FSServer *) NULL;
 
269
    }
 
270
    (void) strcpy(svr->server_name, server);
 
271
 
 
272
    /* setup the output buffers */
 
273
    if ((svr->bufptr = svr->buffer = FSmalloc(BUFSIZE)) == NULL) {
 
274
        OutOfMemory(svr, setup);
 
275
        return (FSServer *) NULL;
 
276
    }
 
277
    svr->bufmax = svr->buffer + BUFSIZE;
 
278
 
 
279
    /* set up input event queue */
 
280
    svr->head = svr->tail = NULL;
 
281
    svr->qlen = 0;
 
282
 
 
283
    FSfree(setup);
 
284
 
 
285
    (void) FSSynchronize(svr, _FSdebug);
 
286
 
 
287
    svr->next = _FSHeadOfServerList;
 
288
    _FSHeadOfServerList = svr;
 
289
 
 
290
    return (svr);
 
291
}