fserve.c

Bug Summary

File:	fc/fserve.c
Location:	line 861, column 5
Description:	Value stored to 'buf' is never read

Annotated Source Code

1	/*
2
3	Copyright 1990, 1998 The Open Group
4
5	Permission to use, copy, modify, distribute, and sell this software and its
6	documentation for any purpose is hereby granted without fee, provided that
7	the above copyright notice appear in all copies and that both that
8	copyright notice and this permission notice appear in supporting
9	documentation.
10
11	The above copyright notice and this permission notice shall be included in
12	all copies or substantial portions of the Software.
13
14	THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15	IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16	FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
17	OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
18	AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
19	CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
20
21	Except as contained in this notice, the name of The Open Group shall not be
22	used in advertising or otherwise to promote the sale, use or other dealings
23	in this Software without prior written authorization from The Open Group.
24
25	*/
26
27	/*
28	* Copyright 1990 Network Computing Devices
29	*
30	* Permission to use, copy, modify, distribute, and sell this software and
31	* its documentation for any purpose is hereby granted without fee, provided
32	* that the above copyright notice appear in all copies and that both that
33	* copyright notice and this permission notice appear in supporting
34	* documentation, and that the names of Network Computing Devices, or Digital
35	* not be used in advertising or publicity pertaining to distribution
36	* of the software without specific, written prior permission.
37	*
38	* NETWORK COMPUTING DEVICES, AND DIGITAL AND DISCLAIM ALL WARRANTIES WITH
39	* REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF
40	* MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL NETWORK COMPUTING DEVICES,
41	* OR DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
42	* DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
43	* PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
44	* ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
45	* THIS SOFTWARE.
46	*
47	* Author: Dave Lemke, Network Computing Devices, Inc
48	*/
49	/*
50	* font server specific font access
51	*/
52
53	#ifdef HAVE_CONFIG_H1
54	#include <config.h>
55	#endif
56
57	#ifdef WIN32
58	#define _WILLWINSOCK_
59	#endif
60	#define FONT_t
61	#define TRANS_CLIENT
62	#include "X11/Xtrans/Xtrans.h"
63	#include "X11/Xpoll.h"
64	#include <X11/fonts/FS.h>
65	#include <X11/fonts/FSproto.h>
66	#include <X11/X.h>
67	#include <X11/Xos.h>
68	#include <X11/fonts/fontmisc.h>
69	#include <X11/fonts/fontstruct.h>
70	#include "fservestr.h"
71	#include <X11/fonts/fontutil.h>
72	#include <errno(*__errno_location ()).h>
73
74	#include <time.h>
75	#define Time_ttime_t time_t
76
77	#ifdef NCD
78	#include <ncd/nvram.h>
79	#endif
80
81	#include <stddef.h>
82
83	#ifndef MIN
84	#define MIN(a,b)((a)<(b)?(a):(b)) ((a)<(b)?(a):(b))
85	#endif
86	#define TimeCmp(a,c,b)((int) ((a) - (b)) c 0) ((int) ((a) - (b)) c 0)
87
88	#define NONZEROMETRICS(pci)((pci)->leftSideBearing \|\| (pci)->rightSideBearing \|\| ( pci)->ascent \|\| (pci)->descent \|\| (pci)->characterWidth ) ((pci)->leftSideBearing \|\| \
89	(pci)->rightSideBearing \|\| \
90	(pci)->ascent \|\| \
91	(pci)->descent \|\| \
92	(pci)->characterWidth)
93
94	extern void ErrorF(const char *f, ...);
95
96	static int fs_read_glyphs ( FontPathElementPtr fpe, FSBlockDataPtr blockrec );
97	static int fs_read_list ( FontPathElementPtr fpe, FSBlockDataPtr blockrec );
98	static int fs_read_list_info ( FontPathElementPtr fpe,
99	FSBlockDataPtr blockrec );
100
101	extern fd_set _fs_fd_mask;
102
103	static void fs_block_handler ( pointer data, OSTimePtr wt,
104	pointer LastSelectMask );
105	static int fs_wakeup ( FontPathElementPtr fpe, unsigned long *mask );
106
107	/*
108	* List of all FPEs
109	*/
110	static FSFpePtr fs_fpes;
111	/*
112	* Union of all FPE blockStates
113	*/
114	static CARD32 fs_blockState;
115
116	static int _fs_restart_connection ( FSFpePtr conn );
117	static void fs_send_query_bitmaps ( FontPathElementPtr fpe,
118	FSBlockDataPtr blockrec );
119	static int fs_send_close_font ( FontPathElementPtr fpe, Font id );
120	static void fs_client_died ( pointer client, FontPathElementPtr fpe );
121	static void _fs_client_access ( FSFpePtr conn, pointer client, Bool sync );
122	static void _fs_client_resolution ( FSFpePtr conn );
123	static fsGenericReply fs_get_reply (FSFpePtr conn, int error);
124	static int fs_await_reply (FSFpePtr conn);
125	static void _fs_do_blocked (FSFpePtr conn);
126	static void fs_cleanup_bfont (FSBlockedFontPtr bfont);
127
128	char _fs_glyph_undefined;
129	char _fs_glyph_requested;
130	static char _fs_glyph_zero_length;
131
132	static int generationCount;
133
134	static int FontServerRequestTimeout = 30 * 1000;
135
136	static void
137	_fs_close_server (FSFpePtr conn);
138
139	static FSFpePtr
140	_fs_init_conn (char *servername);
141
142	static int
143	_fs_wait_connect (FSFpePtr conn);
144
145	static int
146	_fs_send_init_packets (FSFpePtr conn);
147
148	static void
149	_fs_check_reconnect (FSFpePtr conn);
150
151	static void
152	_fs_start_reconnect (FSFpePtr conn);
153
154	static void
155	_fs_free_conn (FSFpePtr conn);
156
157	static int
158	fs_free_fpe(FontPathElementPtr fpe);
159
160	/*
161	* Font server access
162	*
163	* the basic idea for the non-blocking access is to have the function
164	* called multiple times until the actual data is returned, instead
165	* of ClientBlocked.
166	*
167	* the first call to the function will cause the request to be sent to
168	* the font server, and a block record to be stored in the fpe's list
169	* of outstanding requests. the FS block handler also sticks the
170	* proper set of fd's into the select mask. when data is ready to be
171	* read in, the FS wakup handler will be hit. this will read the
172	* data off the wire into the proper block record, and then signal the
173	* client that caused the block so that it can restart. it will then
174	* call the access function again, which will realize that the data has
175	* arrived and return it.
176	*/
177
178
179	#ifdef DEBUG
180	static void
181	_fs_add_req_log(FSFpePtr conn, int opcode)((FSFpePtr conn)->current_seq++)
182	{
183	conn->current_seq++;
184	fprintf (stderrstderr, "\t\tRequest: %5d Opcode: %2d\n",
185	conn->current_seq, opcode);
186	conn->reqbuffer[conn->reqindex].opcode = opcode;
187	conn->reqbuffer[conn->reqindex].sequence = conn->current_seq;
188	conn->reqindex++;
189	if (conn->reqindex == REQUEST_LOG_SIZE100)
190	conn->reqindex = 0;
191	}
192
193	static void
194	_fs_add_rep_log (FSFpePtr conn, fsGenericReply *rep)
195	{
196	int i;
197
198	for (i = 0; i < REQUEST_LOG_SIZE100; i++)
199	if (conn->reqbuffer[i].sequence == rep->sequenceNumber)
200	break;
201	if (i == REQUEST_LOG_SIZE100)
202	fprintf (stderrstderr, "\t\t\t\t\tReply: %5d Opcode: unknown\n",
203	rep->sequenceNumber);
204	else
205	fprintf (stderrstderr, "\t\t\t\t\tReply: %5d Opcode: %d\n",
206	rep->sequenceNumber,
207	conn->reqbuffer[i].opcode);
208	}
209	#else
210	#define _fs_add_req_log(conn,op)((conn)->current_seq++) ((conn)->current_seq++)
211	#define _fs_add_rep_log(conn,rep)
212	#endif
213
214	static Bool
215	fs_name_check(char *name)
216	{
217	/* Just make sure there is a protocol/ prefix */
218	return (name && *name != '/' && strchr(name, '/'));
219	}
220
221	static void
222	_fs_client_resolution(FSFpePtr conn)
223	{
224	fsSetResolutionReq srreq;
225	int num_res;
226	FontResolutionPtr res;
227
228	res = GetClientResolutions(&num_res);
229
230	if (num_res) {
231	srreq.reqType = FS_SetResolution11;
232	srreq.num_resolutions = num_res;
233	srreq.length = (SIZEOF(fsSetResolutionReq)4 +
234	(num_res * SIZEOF(fsResolution)6) + 3) >> 2;
235
236	_fs_add_req_log(conn, FS_SetResolution)((conn)->current_seq++);
237	if (_fs_write(conn, (char *) &srreq, SIZEOF(fsSetResolutionReq)4) != -1)
238	(void)_fs_write_pad(conn, (char *) res,
239	(num_res * SIZEOF(fsResolution)6));
240	}
241	}
242
243	/*
244	* close font server and remove any state associated with
245	* this connection - this includes any client records.
246	*/
247
248	static void
249	fs_close_conn(FSFpePtr conn)
250	{
251	FSClientPtr client, nclient;
252
253	_fs_close_server (conn);
254
255	for (client = conn->clients; client; client = nclient)
256	{
257	nclient = client->next;
258	free (client);
259	}
260	conn->clients = NULL((void*)0);
261	}
262
263	/*
264	* the wakeup handlers have to be set when the FPE is open, and not
265	* removed until it is freed, in order to handle unexpected data, like
266	* events
267	*/
268	/* ARGSUSED */
269	static int
270	fs_init_fpe(FontPathElementPtr fpe)
271	{
272	FSFpePtr conn;
273	char *name;
274	int err;
275	int ret;
276
277	/* open font server */
278	/* create FS specific fpe info */
279	name = fpe->name;
280
281	/* hack for old style names */
282	if (*name == ':')
283	name++; /* skip ':' */
284
285	conn = _fs_init_conn (name);
286	if (!conn)
287	err = AllocError80;
288	else
289	{
290	err = init_fs_handlers (fpe, fs_block_handler);
291	if (err != Successful85)
292	{
293	_fs_free_conn (conn);
294	err = AllocError80;
295	}
296	else
297	{
298	fpe->private = conn;
299	conn->next = fs_fpes;
300	fs_fpes = conn;
301	ret = _fs_wait_connect (conn);
302	if (ret != FSIO_READY1)
303	{
304	fs_free_fpe (fpe);
305	err = BadFontPath86;
306	}
307	else
308	err = Successful85;
309	}
310	}
311
312	if (err == Successful85)
313	{
314	#ifdef NCD
315	if (configData.ExtendedFontDiags)
316	printf("Connected to font server \"%s\"\n", name);
317	#endif
318	#ifdef DEBUG
319	fprintf (stderrstderr, "connected to FS \"%s\"\n", name);
320	#endif
321	}
322	else
323	{
324	#ifdef DEBUG
325	fprintf(stderrstderr, "failed to connect to FS \"%s\" %d\n", name, err);
326	#endif
327	#ifdef NCD
328	if (configData.ExtendedFontDiags)
329	printf("Failed to connect to font server \"%s\"\n", name);
330	#endif
331	;
332	}
333	return err;
334	}
335
336	static int
337	fs_reset_fpe(FontPathElementPtr fpe)
338	{
339	(void) _fs_send_init_packets((FSFpePtr) fpe->private);
340	return Successful85;
341	}
342
343	/*
344	* this shouldn't be called till all refs to the FPE are gone
345	*/
346
347	static int
348	fs_free_fpe(FontPathElementPtr fpe)
349	{
350	FSFpePtr conn = (FSFpePtr) fpe->private, *prev;
351
352	/* unhook from chain of all font servers */
353	for (prev = &fs_fpes; prev; prev = &(prev)->next)
354	{
355	if (*prev == conn)
356	{
357	*prev = conn->next;
358	break;
359	}
360	}
361	_fs_unmark_block (conn, conn->blockState);
362	fs_close_conn(conn);
363	remove_fs_handlers(fpe, fs_block_handler, fs_fpes == 0);
364	_fs_free_conn (conn);
365	fpe->private = (pointer) 0;
366
367	#ifdef NCD
368	if (configData.ExtendedFontDiags)
369	printf("Disconnected from font server \"%s\"\n", fpe->name);
370	#endif
371	#ifdef DEBUG
372	fprintf (stderrstderr, "disconnect from FS \"%s\"\n", fpe->name);
373	#endif
374
375	return Successful85;
376	}
377
378	static FSBlockDataPtr
379	fs_new_block_rec(FontPathElementPtr fpe, pointer client, int type)
380	{
381	FSBlockDataPtr blockrec,
382	*prev;
383	FSFpePtr conn = (FSFpePtr) fpe->private;
384	int size;
385
386	switch (type) {
387	case FS_OPEN_FONT1:
388	size = sizeof(FSBlockedFontRec);
389	break;
390	case FS_LOAD_GLYPHS2:
391	size = sizeof(FSBlockedGlyphRec);
392	break;
393	case FS_LIST_FONTS3:
394	size = sizeof(FSBlockedListRec);
395	break;
396	case FS_LIST_WITH_INFO4:
397	size = sizeof(FSBlockedListInfoRec);
398	break;
399	default:
400	size = 0;
401	break;
402	}
403	blockrec = malloc(sizeof(FSBlockDataRec) + size);
404	if (!blockrec)
405	return (FSBlockDataPtr) 0;
406	blockrec->data = (pointer) (blockrec + 1);
407	blockrec->client = client;
408	blockrec->sequenceNumber = -1;
409	blockrec->errcode = StillWorking81;
410	blockrec->type = type;
411	blockrec->depending = 0;
412	blockrec->next = (FSBlockDataPtr) 0;
413
414	/* stick it on the end of the list (since its expected last) */
415	for (prev = &conn->blockedRequests; prev; prev = &(prev)->next)
416	;
417	*prev = blockrec;
418
419	return blockrec;
420	}
421
422	static void
423	_fs_set_pending_reply (FSFpePtr conn)
424	{
425	FSBlockDataPtr blockrec;
426
427	for (blockrec = conn->blockedRequests; blockrec; blockrec = blockrec->next)
428	if (blockrec->errcode == StillWorking81)
429	break;
430	if (blockrec)
431	{
432	conn->blockedReplyTime = GetTimeInMillis () + FontServerRequestTimeout;
433	_fs_mark_block (conn, FS_PENDING_REPLY0x08);
434	}
435	else
436	_fs_unmark_block (conn, FS_PENDING_REPLY0x08);
437	}
438
439	static void
440	_fs_remove_block_rec(FSFpePtr conn, FSBlockDataPtr blockrec)
441	{
442	FSBlockDataPtr *prev;
443
444	for (prev = &conn->blockedRequests; prev; prev = &(prev)->next)
445	if (*prev == blockrec)
446	{
447	*prev = blockrec->next;
448	break;
449	}
450	if (blockrec->type == FS_LOAD_GLYPHS2)
451	{
452	FSBlockedGlyphPtr bglyph = (FSBlockedGlyphPtr)blockrec->data;
453	if (bglyph->num_expected_ranges)
454	free(bglyph->expected_ranges);
455	}
456	free(blockrec);
457	_fs_set_pending_reply (conn);
458	}
459
460	static void
461	_fs_signal_clients_depending(FSClientsDependingPtr *clients_depending)
462	{
463	FSClientsDependingPtr p;
464
465	while ((p = *clients_depending))
466	{
467	*clients_depending = p->next;
468	ClientSignal(p->client);
469	free(p);
470	}
471	}
472
473	static int
474	_fs_add_clients_depending(FSClientsDependingPtr *clients_depending, pointer client)
475	{
476	FSClientsDependingPtr new, cd;
477
478	for (; (cd = *clients_depending);
479	clients_depending = &(*clients_depending)->next)
480	{
481	if (cd->client == client)
482	return Suspended84;
483	}
484
485	new = malloc (sizeof (FSClientsDependingRec));
486	if (!new)
487	return BadAlloc11;
488
489	new->client = client;
490	new->next = 0;
491	*clients_depending = new;
492	return Suspended84;
493	}
494
495	/*
496	* When a request is aborted due to a font server failure,
497	* signal any depending clients to restart their dependant
498	* requests
499	*/
500	static void
501	_fs_clean_aborted_blockrec(FSFpePtr conn, FSBlockDataPtr blockrec)
502	{
503	switch(blockrec->type) {
504	case FS_OPEN_FONT1: {
505	FSBlockedFontPtr bfont = (FSBlockedFontPtr)blockrec->data;
506
507	fs_cleanup_bfont (bfont);
508	_fs_signal_clients_depending(&bfont->clients_depending);
509	break;
510	}
511	case FS_LOAD_GLYPHS2: {
512	FSBlockedGlyphPtr bglyph = (FSBlockedGlyphPtr)blockrec->data;
513
514	_fs_clean_aborted_loadglyphs(bglyph->pfont,
515	bglyph->num_expected_ranges,
516	bglyph->expected_ranges);
517	_fs_signal_clients_depending(&bglyph->clients_depending);
518	break;
519	}
520	case FS_LIST_FONTS3:
521	break;
522	case FS_LIST_WITH_INFO4: {
523	FSBlockedListInfoPtr binfo;
524	binfo = (FSBlockedListInfoPtr) blockrec->data;
525	if (binfo->status == FS_LFWI_REPLY1)
526	FD_SET(conn->fs_fd, &_fs_fd_mask)((void) (((&_fs_fd_mask)->fds_bits)[((conn->fs_fd) / (8 * (int) sizeof (__fd_mask)))] \|= ((__fd_mask) 1 << ( (conn->fs_fd) % (8 * (int) sizeof (__fd_mask))))));
527	_fs_free_props (&binfo->info);
528	}
529	default:
530	break;
531	}
532	}
533
534	static void
535	fs_abort_blockrec(FSFpePtr conn, FSBlockDataPtr blockrec)
536	{
537	_fs_clean_aborted_blockrec (conn, blockrec);
538	_fs_remove_block_rec (conn, blockrec);
539	}
540
541	/*
542	* Tell the font server we've failed to complete an open and
543	* then unload the partially created font
544	*/
545	static void
546	fs_cleanup_bfont (FSBlockedFontPtr bfont)
547	{
548	FSFontDataRec *fsd;
549
550	if (bfont->pfont)
551	{
552	fsd = (FSFontDataRec *) bfont->pfont->fpePrivate;
553
554	/* make sure the FS knows we choked on it */
555	fs_send_close_font(bfont->pfont->fpe, bfont->fontid);
556
557	/*
558	* Either unload the font if it's being opened for
559	* the first time, or smash the generation field to
560	* mark this font as an orphan
561	*/
562	if (!(bfont->flags & FontReopen0x0020))
563	{
564	if (bfont->freeFont)
565	(*bfont->pfont->unload_font) (bfont->pfont);
566	#ifdef DEBUG
567	else
568	fprintf (stderrstderr, "Not freeing other font in cleanup_bfont\n");
569	#endif
570	bfont->pfont = 0;
571	}
572	else
573	fsd->generation = -1;
574	}
575	}
576
577	/*
578	* Check to see if a complete reply is waiting
579	*/
580	static fsGenericReply *
581	fs_get_reply (FSFpePtr conn, int *error)
582	{
583	char *buf;
584	fsGenericReply *rep;
585	int ret;
586
587	/* block if the connection is down or paused in lfwi */
588	if (conn->fs_fd == -1 \|\| !FD_ISSET (conn->fs_fd, &_fs_fd_mask)((((&_fs_fd_mask)->fds_bits)[((conn->fs_fd) / (8 * ( int) sizeof (__fd_mask)))] & ((__fd_mask) 1 << ((conn ->fs_fd) % (8 * (int) sizeof (__fd_mask))))) != 0))
589	{
590	*error = FSIO_BLOCK0;
591	return 0;
592	}
593
594	ret = _fs_start_read (conn, sizeof (fsGenericReply), &buf);
595	if (ret != FSIO_READY1)
596	{
597	*error = FSIO_BLOCK0;
598	return 0;
599	}
600
601	rep = (fsGenericReply *) buf;
602
603	ret = _fs_start_read (conn, rep->length << 2, &buf);
604	if (ret != FSIO_READY1)
605	{
606	*error = FSIO_BLOCK0;
607	return 0;
608	}
609
610	*error = FSIO_READY1;
611
612	return (fsGenericReply *) buf;
613	}
614
615	static Bool
616	fs_reply_ready (FSFpePtr conn)
617	{
618	fsGenericReply *rep;
619
620	if (conn->fs_fd == -1 \|\| !FD_ISSET (conn->fs_fd, &_fs_fd_mask)((((&_fs_fd_mask)->fds_bits)[((conn->fs_fd) / (8 * ( int) sizeof (__fd_mask)))] & ((__fd_mask) 1 << ((conn ->fs_fd) % (8 * (int) sizeof (__fd_mask))))) != 0))
621	return FALSE0;
622	if (fs_data_read (conn)((conn)->inBuf.insert - (conn)->inBuf.remove) < sizeof (fsGenericReply))
623	return FALSE0;
624	rep = (fsGenericReply *) (conn->inBuf.buf + conn->inBuf.remove);
625	if (fs_data_read (conn)((conn)->inBuf.insert - (conn)->inBuf.remove) < rep->length << 2)
626	return FALSE0;
627	return TRUE1;
628	}
629
630	static void
631	_fs_pending_reply (FSFpePtr conn)
632	{
633	if (!(conn->blockState & FS_PENDING_REPLY0x08))
634	{
635	_fs_mark_block (conn, FS_PENDING_REPLY0x08);
636	conn->blockedReplyTime = GetTimeInMillis () + FontServerRequestTimeout;
637	}
638	}
639
640	static void
641	_fs_prepare_for_reply (FSFpePtr conn)
642	{
643	_fs_pending_reply (conn);
644	_fs_flush (conn);
645	}
646
647	/*
648	* Block (for a while) awaiting a complete reply
649	*/
650	static int
651	fs_await_reply (FSFpePtr conn)
652	{
653	int ret;
654
655	if (conn->blockState & FS_COMPLETE_REPLY0x20)
656	return FSIO_READY1;
657
658	while (!fs_get_reply (conn, &ret))
659	{
660	if (ret != FSIO_BLOCK0)
661	return ret;
662	if (_fs_wait_for_readable (conn, FontServerRequestTimeout) != FSIO_READY1)
663	{
664	_fs_connection_died (conn);
665	return FSIO_ERROR-1;
666	}
667	}
668	return FSIO_READY1;
669	}
670
671	/*
672	* Process the reply to an OpenBitmapFont request
673	*/
674	static int
675	fs_read_open_font(FontPathElementPtr fpe, FSBlockDataPtr blockrec)
676	{
677	FSFpePtr conn = (FSFpePtr) fpe->private;
678	FSBlockedFontPtr bfont = (FSBlockedFontPtr) blockrec->data;
679	fsOpenBitmapFontReply *rep;
680	FSBlockDataPtr blockOrig;
681	FSBlockedFontPtr origBfont;
682	int ret;
683
684	rep = (fsOpenBitmapFontReply *) fs_get_reply (conn, &ret);
685	if (!rep \|\| rep->type == FS_Error1)
686	{
687	if (ret == FSIO_BLOCK0)
688	return StillWorking81;
689	if (rep)
690	_fs_done_read (conn, rep->length << 2);
691	fs_cleanup_bfont (bfont);
692	return BadFontName83;
693	}
694
695	/* If we're not reopening a font and FS detected a duplicate font
696	open request, replace our reference to the new font with a
697	reference to an existing font (possibly one not finished
698	opening). If this is a reopen, keep the new font reference...
699	it's got the metrics and extents we read when the font was opened
700	before. This also gives us the freedom to easily close the font
701	if we we decide (in fs_read_query_info()) that we don't like what
702	we got. */
703
704	if (rep->otherid && !(bfont->flags & FontReopen0x0020))
705	{
706	fs_cleanup_bfont (bfont);
707
708	/* Find old font if we're completely done getting it from server. */
709	bfont->pfont = find_old_font(rep->otherid);
710	bfont->freeFont = FALSE0;
711	bfont->fontid = rep->otherid;
712	bfont->state = FS_DONE_REPLY4;
713	/*
714	* look for a blocked request to open the same font
715	*/
716	for (blockOrig = conn->blockedRequests;
717	blockOrig;
718	blockOrig = blockOrig->next)
719	{
720	if (blockOrig != blockrec && blockOrig->type == FS_OPEN_FONT1)
721	{
722	origBfont = (FSBlockedFontPtr) blockOrig->data;
723	if (origBfont->fontid == rep->otherid)
724	{
725	blockrec->depending = blockOrig->depending;
726	blockOrig->depending = blockrec;
727	bfont->state = FS_DEPENDING5;
728	bfont->pfont = origBfont->pfont;
729	break;
730	}
731	}
732	}
733	if (bfont->pfont == NULL((void*)0))
734	{
735	/* XXX - something nasty happened */
736	ret = BadFontName83;
737	}
738	else
739	ret = AccessDone0x400;
740	}
741	else
742	{
743	bfont->pfont->info.cachable = rep->cachable != 0;
744	bfont->state = FS_INFO_REPLY1;
745	/*
746	* Reset the blockrec for the next reply
747	*/
748	blockrec->sequenceNumber = bfont->queryInfoSequence;
749	conn->blockedReplyTime = GetTimeInMillis () + FontServerRequestTimeout;
750	ret = StillWorking81;
751	}
752	_fs_done_read (conn, rep->length << 2);
753	return ret;
754	}
755
756	static Bool
757	fs_fonts_match (FontInfoPtr pInfo1, FontInfoPtr pInfo2)
758	{
759	int i;
760
761	if (pInfo1->firstCol != pInfo2->firstCol \|\|
762	pInfo1->lastCol != pInfo2->lastCol \|\|
763	pInfo1->firstRow != pInfo2->firstRow \|\|
764	pInfo1->lastRow != pInfo2->lastRow \|\|
765	pInfo1->defaultCh != pInfo2->defaultCh \|\|
766	pInfo1->noOverlap != pInfo2->noOverlap \|\|
767	pInfo1->terminalFont != pInfo2->terminalFont \|\|
768	pInfo1->constantMetrics != pInfo2->constantMetrics \|\|
769	pInfo1->constantWidth != pInfo2->constantWidth \|\|
770	pInfo1->inkInside != pInfo2->inkInside \|\|
771	pInfo1->inkMetrics != pInfo2->inkMetrics \|\|
772	pInfo1->allExist != pInfo2->allExist \|\|
773	pInfo1->drawDirection != pInfo2->drawDirection \|\|
774	pInfo1->cachable != pInfo2->cachable \|\|
775	pInfo1->anamorphic != pInfo2->anamorphic \|\|
776	pInfo1->maxOverlap != pInfo2->maxOverlap \|\|
777	pInfo1->fontAscent != pInfo2->fontAscent \|\|
778	pInfo1->fontDescent != pInfo2->fontDescent \|\|
779	pInfo1->nprops != pInfo2->nprops)
780	return FALSE0;
781
782	#define MATCH(xci1, xci2) \
783	(((xci1).leftSideBearing == (xci2).leftSideBearing) && \
784	((xci1).rightSideBearing == (xci2).rightSideBearing) && \
785	((xci1).characterWidth == (xci2).characterWidth) && \
786	((xci1).ascent == (xci2).ascent) && \
787	((xci1).descent == (xci2).descent) && \
788	((xci1).attributes == (xci2).attributes))
789
790	if (!MATCH(pInfo1->maxbounds, pInfo2->maxbounds) \|\|
791	!MATCH(pInfo1->minbounds, pInfo2->minbounds) \|\|
792	!MATCH(pInfo1->ink_maxbounds, pInfo2->ink_maxbounds) \|\|
793	!MATCH(pInfo1->ink_minbounds, pInfo2->ink_minbounds))
794	return FALSE0;
795
796	#undef MATCH
797
798	for (i = 0; i < pInfo1->nprops; i++)
799	if (pInfo1->isStringProp[i] !=
800	pInfo2->isStringProp[i] \|\|
801	pInfo1->props[i].name !=
802	pInfo2->props[i].name \|\|
803	pInfo1->props[i].value !=
804	pInfo2->props[i].value)
805	{
806	return FALSE0;
807	}
808	return TRUE1;
809	}
810
811	static int
812	fs_read_query_info(FontPathElementPtr fpe, FSBlockDataPtr blockrec)
813	{
814	FSBlockedFontPtr bfont = (FSBlockedFontPtr) blockrec->data;
815	FSFpePtr conn = (FSFpePtr) fpe->private;
816	fsQueryXInfoReply *rep;
817	char *buf;
818	fsPropInfo *pi;
819	fsPropOffset *po;
820	pointer pd;
821	FontInfoPtr pInfo;
822	FontInfoRec tempInfo;
823	int err;
824	int ret;
825
826	rep = (fsQueryXInfoReply *) fs_get_reply (conn, &ret);
827	if (!rep \|\| rep->type == FS_Error1)
828	{
829	if (ret == FSIO_BLOCK0)
830	return StillWorking81;
831	if (rep)
832	_fs_done_read (conn, rep->length << 2);
833	fs_cleanup_bfont (bfont);
834	return BadFontName83;
835	}
836
837	/* If this is a reopen, accumulate the query info into a dummy
838	font and compare to our original data. */
839	if (bfont->flags & FontReopen0x0020)
840	pInfo = &tempInfo;
841	else
842	pInfo = &bfont->pfont->info;
843
844	buf = (char *) rep;
845	buf += SIZEOF(fsQueryXInfoReply)(8 + 40);
846
847	/* move the data over */
848	fsUnpack_XFontInfoHeader(rep, pInfo)(pInfo)->allExist = ((rep)->font_header_flags & (1L << 0)) != 0; (pInfo)->drawDirection = ((rep)->font_header_draw_direction == 0) ? 0 : 1; (pInfo)->inkInside = ((rep)->font_header_flags & (1L << 1)) != 0; (pInfo)->firstRow = (rep)-> font_hdr_char_range_min_char_high; (pInfo)->firstCol = (rep )->font_hdr_char_range_min_char_low; (pInfo)->lastRow = (rep)->font_hdr_char_range_max_char_high; (pInfo)->lastCol = (rep)->font_hdr_char_range_max_char_low; (pInfo)->defaultCh = (rep)->font_header_default_char_low + ((rep)->font_header_default_char_high << 8); (pInfo)->fontDescent = (rep)->font_header_font_descent ; (pInfo)->fontAscent = (rep)->font_header_font_ascent; (&(pInfo)->minbounds)->leftSideBearing = (rep)-> font_header_min_bounds_left; (&(pInfo)->minbounds)-> rightSideBearing = (rep)->font_header_min_bounds_right; (& (pInfo)->minbounds)->characterWidth = (rep)->font_header_min_bounds_width ; (&(pInfo)->minbounds)->ascent = (rep)->font_header_min_bounds_ascent ; (&(pInfo)->minbounds)->descent = (rep)->font_header_min_bounds_descent ; (&(pInfo)->minbounds)->attributes = (rep)->font_header_min_bounds_attributes ; (&(pInfo)->ink_minbounds)->leftSideBearing = (rep )->font_header_min_bounds_left; (&(pInfo)->ink_minbounds )->rightSideBearing = (rep)->font_header_min_bounds_right ; (&(pInfo)->ink_minbounds)->characterWidth = (rep) ->font_header_min_bounds_width; (&(pInfo)->ink_minbounds )->ascent = (rep)->font_header_min_bounds_ascent; (& (pInfo)->ink_minbounds)->descent = (rep)->font_header_min_bounds_descent ; (&(pInfo)->ink_minbounds)->attributes = (rep)-> font_header_min_bounds_attributes; (&(pInfo)->maxbounds )->leftSideBearing = (rep)->font_header_max_bounds_left ; (&(pInfo)->maxbounds)->rightSideBearing = (rep)-> font_header_max_bounds_right; (&(pInfo)->maxbounds)-> characterWidth = (rep)->font_header_max_bounds_width; (& (pInfo)->maxbounds)->ascent = (rep)->font_header_max_bounds_ascent ; (&(pInfo)->maxbounds)->descent = (rep)->font_header_max_bounds_descent ; (&(pInfo)->maxbounds)->attributes = (rep)->font_header_max_bounds_attributes ; (&(pInfo)->ink_maxbounds)->leftSideBearing = (rep )->font_header_max_bounds_left; (&(pInfo)->ink_maxbounds )->rightSideBearing = (rep)->font_header_max_bounds_right ; (&(pInfo)->ink_maxbounds)->characterWidth = (rep) ->font_header_max_bounds_width; (&(pInfo)->ink_maxbounds )->ascent = (rep)->font_header_max_bounds_ascent; (& (pInfo)->ink_maxbounds)->descent = (rep)->font_header_max_bounds_descent ; (&(pInfo)->ink_maxbounds)->attributes = (rep)-> font_header_max_bounds_attributes;
849
850	/* compute accelerators */
851	_fs_init_fontinfo(conn, pInfo);
852
853	/* Compute offsets into the reply */
854	pi = (fsPropInfo *) buf;
855	buf += SIZEOF (fsPropInfo)8;
856
857	po = (fsPropOffset *) buf;
858	buf += pi->num_offsets * SIZEOF(fsPropOffset)20;
859
860	pd = (pointer) buf;
861	buf += pi->data_len;
	Value stored to 'buf' is never read
862
863	/* convert the properties and step over the reply */
864	ret = _fs_convert_props(pi, po, pd, pInfo);
865	_fs_done_read (conn, rep->length << 2);
866
867	if (ret == -1)
868	{
869	fs_cleanup_bfont (bfont);
870	return AllocError80;
871	}
872
873	if (bfont->flags & FontReopen0x0020)
874	{
875	/* We're reopening a font that we lost because of a downed
876	connection. In the interest of avoiding corruption from
877	opening a different font than the old one (we already have
878	its metrics, extents, and probably some of its glyphs),
879	verify that the metrics and properties all match. */
880
881	if (fs_fonts_match (pInfo, &bfont->pfont->info))
882	{
883	err = Successful85;
884	bfont->state = FS_DONE_REPLY4;
885	}
886	else
887	{
888	fs_cleanup_bfont (bfont);
889	err = BadFontName83;
890	}
891	_fs_free_props (pInfo);
892
893	return err;
894	}
895
896	/*
897	* Ask for terminal format fonts if possible
898	*/
899	if (bfont->pfont->info.terminalFont)
900	bfont->format = ((bfont->format & ~ (BitmapFormatImageRectMask(3L << 2))) \|
901	BitmapFormatImageRectMax(2L << 2));
902
903	/*
904	* Figure out if the whole font should get loaded right now.
905	*/
906	if (glyphCachingMode == CACHING_OFF0 \|\|
907	(glyphCachingMode == CACHE_16_BIT_GLYPHS1
908	&& !bfont->pfont->info.lastRow))
909	{
910	bfont->flags \|= FontLoadAll0x000f;
911	}
912
913	/*
914	* Ready to send the query bitmaps; the terminal font bit has
915	* been computed and glyphCaching has been considered
916	*/
917	if (bfont->flags & FontLoadBitmaps0x0008)
918	{
919	fs_send_query_bitmaps (fpe, blockrec);
920	_fs_flush (conn);
921	}
922
923	bfont->state = FS_EXTENT_REPLY2;
924
925	/*
926	* Reset the blockrec for the next reply
927	*/
928	blockrec->sequenceNumber = bfont->queryExtentsSequence;
929	conn->blockedReplyTime = GetTimeInMillis () + FontServerRequestTimeout;
930
931	return StillWorking81;
932	}
933
934	static int
935	fs_read_extent_info(FontPathElementPtr fpe, FSBlockDataPtr blockrec)
936	{
937	FSFpePtr conn = (FSFpePtr) fpe->private;
938	FSBlockedFontPtr bfont = (FSBlockedFontPtr) blockrec->data;
939	FSFontDataPtr fsd = (FSFontDataPtr) bfont->pfont->fpePrivate;
940	FSFontPtr fsfont = (FSFontPtr) bfont->pfont->fontPrivate;
941	fsQueryXExtents16Reply *rep;
942	char *buf;
943	int i;
944	int numExtents;
945	int numInfos;
946	int ret;
947	Bool haveInk = FALSE0; /* need separate ink metrics? */
948	CharInfoPtr ci, pCI;
949	char *fsci;
950	fsXCharInfo fscilocal;
951	FontInfoRec *fi = &bfont->pfont->info;
952
953	rep = (fsQueryXExtents16Reply *) fs_get_reply (conn, &ret);
954	if (!rep \|\| rep->type == FS_Error1)
955	{
956	if (ret == FSIO_BLOCK0)
957	return StillWorking81;
958	if (rep)
959	_fs_done_read (conn, rep->length << 2);
960	fs_cleanup_bfont (bfont);
961	return BadFontName83;
962	}
963
964	/* move the data over */
965	/* need separate inkMetrics for fixed font server protocol version */
966	numExtents = rep->num_extents;
967	numInfos = numExtents;
968	if (bfont->pfont->info.terminalFont && conn->fsMajorVersion > 1)
969	{
970	numInfos *= 2;
971	haveInk = TRUE1;
972	}
973	ci = pCI = malloc(sizeof(CharInfoRec) * numInfos);
974
975	if (!pCI)
976	{
977	_fs_done_read (conn, rep->length << 2);
978	fs_cleanup_bfont(bfont);
979	return AllocError80;
980	}
981	fsfont->encoding = pCI;
982	if (haveInk)
983	fsfont->inkMetrics = pCI + numExtents;
984	else
985	fsfont->inkMetrics = pCI;
986
987	buf = (char *) rep;
988	buf += SIZEOF (fsQueryXExtents16Reply)12;
989	fsci = buf;
990
991	fsd->glyphs_to_get = 0;
992	ci = fsfont->inkMetrics;
993	for (i = 0; i < numExtents; i++)
994	{
995	memcpy(&fscilocal, fsci, SIZEOF(fsXCharInfo)12); /* align it */
996	_fs_convert_char_info(&fscilocal, &ci->metrics);
997	/* Bounds check. */
998	if (ci->metrics.ascent > fi->maxbounds.ascent)
999	{
1000	ErrorF("fserve: warning: %s %s ascent (%d) > maxascent (%d)\n",
1001	fpe->name, fsd->name,
1002	ci->metrics.ascent, fi->maxbounds.ascent);
1003	ci->metrics.ascent = fi->maxbounds.ascent;
1004	}
1005	if (ci->metrics.descent > fi->maxbounds.descent)
1006	{
1007	ErrorF("fserve: warning: %s %s descent (%d) > maxdescent (%d)\n",
1008	fpe->name, fsd->name,
1009	ci->metrics.descent, fi->maxbounds.descent);
1010	ci->metrics.descent = fi->maxbounds.descent;
1011	}
1012	fsci = fsci + SIZEOF(fsXCharInfo)12;
1013	/* Initialize the bits field for later glyph-caching use */
1014	if (NONZEROMETRICS(&ci->metrics)((&ci->metrics)->leftSideBearing \|\| (&ci->metrics )->rightSideBearing \|\| (&ci->metrics)->ascent \|\| (&ci->metrics)->descent \|\| (&ci->metrics)-> characterWidth))
1015	{
1016	if (!haveInk &&
1017	(ci->metrics.leftSideBearing == ci->metrics.rightSideBearing \|\|
1018	ci->metrics.ascent == -ci->metrics.descent))
1019	pCI[i].bits = &_fs_glyph_zero_length;
1020	else
1021	{
1022	pCI[i].bits = &_fs_glyph_undefined;
1023	fsd->glyphs_to_get++;
1024	}
1025	}
1026	else
1027	pCI[i].bits = (char *)0;
1028	ci++;
1029	}
1030
1031	/* Done with reply */
1032	_fs_done_read (conn, rep->length << 2);
1033
1034	/* build bitmap metrics, ImageRectMax style */
1035	if (haveInk)
1036	{
1037	CharInfoPtr ii;
1038
1039	ci = fsfont->encoding;
1040	ii = fsfont->inkMetrics;
1041	for (i = 0; i < numExtents; i++, ci++, ii++)
1042	{
1043	if (NONZEROMETRICS(&ii->metrics)((&ii->metrics)->leftSideBearing \|\| (&ii->metrics )->rightSideBearing \|\| (&ii->metrics)->ascent \|\| (&ii->metrics)->descent \|\| (&ii->metrics)-> characterWidth))
1044	{
1045	ci->metrics.leftSideBearing = FONT_MIN_LEFT(fi)((fi)->ink_minbounds.leftSideBearing < 0 ? (fi)->ink_minbounds .leftSideBearing : 0);
1046	ci->metrics.rightSideBearing = FONT_MAX_RIGHT(fi)((fi)->ink_maxbounds.rightSideBearing > (fi)->ink_maxbounds .characterWidth ? (fi)->ink_maxbounds.rightSideBearing : ( fi)->ink_maxbounds.characterWidth);
1047	ci->metrics.ascent = FONT_MAX_ASCENT(fi)((fi)->fontAscent > (fi)->ink_maxbounds.ascent ? (fi )->fontAscent : (fi)->ink_maxbounds.ascent);
1048	ci->metrics.descent = FONT_MAX_DESCENT(fi)((fi)->fontDescent > (fi)->ink_maxbounds.descent ? ( fi)->fontDescent : (fi)->ink_maxbounds.descent);
1049	ci->metrics.characterWidth = FONT_MAX_WIDTH(fi)(((fi)->ink_maxbounds.rightSideBearing > (fi)->ink_maxbounds .characterWidth ? (fi)->ink_maxbounds.rightSideBearing : ( fi)->ink_maxbounds.characterWidth) - ((fi)->ink_minbounds .leftSideBearing < 0 ? (fi)->ink_minbounds.leftSideBearing : 0));
1050	ci->metrics.attributes = ii->metrics.attributes;
1051	}
1052	else
1053	{
1054	ci->metrics = ii->metrics;
1055	}
1056	/* Bounds check. */
1057	if (ci->metrics.ascent > fi->maxbounds.ascent)
1058	{
1059	ErrorF("fserve: warning: %s %s ascent (%d) "
1060	"> maxascent (%d)\n",
1061	fpe->name, fsd->name,
1062	ci->metrics.ascent, fi->maxbounds.ascent);
1063	ci->metrics.ascent = fi->maxbounds.ascent;
1064	}
1065	if (ci->metrics.descent > fi->maxbounds.descent)
1066	{
1067	ErrorF("fserve: warning: %s %s descent (%d) "
1068	"> maxdescent (%d)\n",
1069	fpe->name, fsd->name,
1070	ci->metrics.descent, fi->maxbounds.descent);
1071	ci->metrics.descent = fi->maxbounds.descent;
1072	}
1073	}
1074	}
1075	{
1076	unsigned int r, c, numCols, firstCol;
1077
1078	firstCol = bfont->pfont->info.firstCol;
1079	numCols = bfont->pfont->info.lastCol - firstCol + 1;
1080	c = bfont->pfont->info.defaultCh;
1081	fsfont->pDefault = 0;
1082	if (bfont->pfont->info.lastRow)
1083	{
1084	r = c >> 8;
1085	r -= bfont->pfont->info.firstRow;
1086	c &= 0xff;
1087	c -= firstCol;
1088	if (r < bfont->pfont->info.lastRow-bfont->pfont->info.firstRow+1 &&
1089	c < numCols)
1090	fsfont->pDefault = &pCI[r * numCols + c];
1091	}
1092	else
1093	{
1094	c -= firstCol;
1095	if (c < numCols)
1096	fsfont->pDefault = &pCI[c];
1097	}
1098	}
1099	bfont->state = FS_GLYPHS_REPLY3;
1100
1101	if (bfont->flags & FontLoadBitmaps0x0008)
1102	{
1103	/*
1104	* Reset the blockrec for the next reply
1105	*/
1106	blockrec->sequenceNumber = bfont->queryBitmapsSequence;
1107	conn->blockedReplyTime = GetTimeInMillis () + FontServerRequestTimeout;
1108	return StillWorking81;
1109	}
1110	return Successful85;
1111	}
1112
1113	#ifdef DEBUG
1114	static char *fs_open_states[] = {
1115	"OPEN_REPLY ",
1116	"INFO_REPLY ",
1117	"EXTENT_REPLY",
1118	"GLYPHS_REPLY",
1119	"DONE_REPLY ",
1120	"DEPENDING ",
1121	};
1122	#endif
1123
1124	static int
1125	fs_do_open_font(FontPathElementPtr fpe, FSBlockDataPtr blockrec)
1126	{
1127	FSBlockedFontPtr bfont = (FSBlockedFontPtr) blockrec->data;
1128	int err;
1129
1130	#ifdef DEBUG
1131	fprintf (stderrstderr, "fs_do_open_font state %s %s\n",
1132	fs_open_states[bfont->state],
1133	((FSFontDataPtr) (bfont->pfont->fpePrivate))->name);
1134	#endif
1135	err = BadFontName83;
1136	switch (bfont->state) {
1137	case FS_OPEN_REPLY0:
1138	err = fs_read_open_font(fpe, blockrec);
1139	if (err != StillWorking81) { /* already loaded, or error */
1140	/* if font's already loaded, massage error code */
1141	switch (bfont->state) {
1142	case FS_DONE_REPLY4:
1143	err = Successful85;
1144	break;
1145	case FS_DEPENDING5:
1146	err = StillWorking81;
1147	break;
1148	}
1149	}
1150	break;
1151	case FS_INFO_REPLY1:
1152	err = fs_read_query_info(fpe, blockrec);
1153	break;
1154	case FS_EXTENT_REPLY2:
1155	err = fs_read_extent_info(fpe, blockrec);
1156	break;
1157	case FS_GLYPHS_REPLY3:
1158	if (bfont->flags & FontLoadBitmaps0x0008)
1159	err = fs_read_glyphs(fpe, blockrec);
1160	break;
1161	case FS_DEPENDING5: /* can't happen */
1162	default:
1163	break;
1164	}
1165	#ifdef DEBUG
1166	fprintf (stderrstderr, "fs_do_open_font err %d\n", err);
1167	#endif
1168	if (err != StillWorking81)
1169	{
1170	bfont->state = FS_DONE_REPLY4; /* for _fs_load_glyphs() */
1171	while ((blockrec = blockrec->depending))
1172	{
1173	bfont = (FSBlockedFontPtr) blockrec->data;
1174	bfont->state = FS_DONE_REPLY4; /* for _fs_load_glyphs() */
1175	}
1176	}
1177	return err;
1178	}
1179
1180	void
1181	_fs_mark_block (FSFpePtr conn, CARD32 mask)
1182	{
1183	conn->blockState \|= mask;
1184	fs_blockState \|= mask;
1185	}
1186
1187	void
1188	_fs_unmark_block (FSFpePtr conn, CARD32 mask)
1189	{
1190	FSFpePtr c;
1191
1192	if (conn->blockState & mask)
1193	{
1194	conn->blockState &= ~mask;
1195	fs_blockState = 0;
1196	for (c = fs_fpes; c; c = c->next)
1197	fs_blockState \|= c->blockState;
1198	}
1199	}
1200
1201	/* ARGSUSED */
1202	static void
1203	fs_block_handler(pointer data, OSTimePtr wt, pointer LastSelectMask)
1204	{
1205	static struct timeval block_timeout;
1206	CARD32 now, earliest, wakeup;
1207	int soonest;
1208	FSFpePtr conn;
1209
1210	XFD_ORSET((fd_set )LastSelectMask, (fd_set )LastSelectMask,{ int __i__; for (__i__ = 0; __i__ < (((1024)+(((8 * (int) sizeof (__fd_mask)))-1))/((8 * (int) sizeof (__fd_mask)))); __i__ ++) (((((fd_set )LastSelectMask))->fds_bits))[__i__] = (( (((((fd_set )LastSelectMask))->fds_bits))[__i__]) \| ((((( &_fs_fd_mask))->fds_bits))[__i__])); }
1211	&_fs_fd_mask){ int __i__; for (__i__ = 0; __i__ < (((1024)+(((8 * (int) sizeof (__fd_mask)))-1))/((8 * (int) sizeof (__fd_mask)))); __i__ ++) (((((fd_set )LastSelectMask))->fds_bits))[__i__] = (( (((((fd_set )LastSelectMask))->fds_bits))[__i__]) \| ((((( &_fs_fd_mask))->fds_bits))[__i__])); };
1212	/*
1213	* Flush all pending output
1214	*/
1215	if (fs_blockState & FS_PENDING_WRITE0x01)
1216	for (conn = fs_fpes; conn; conn = conn->next)
1217	if (conn->blockState & FS_PENDING_WRITE0x01)
1218	_fs_flush (conn);
1219	/*
1220	* Check for any fpe with a complete reply, set sleep time to zero
1221	*/
1222	if (fs_blockState & FS_COMPLETE_REPLY0x20)
1223	{
1224	block_timeout.tv_sec = 0;
1225	block_timeout.tv_usec = 0;
1226	if (wt == NULL((void)0))
1227	*wt = &block_timeout;
1228	else
1229	**wt = block_timeout;
1230	}
1231	/*
1232	* Walk through fpe list computing sleep time
1233	*/
1234	else if (fs_blockState & (FS_BROKEN_WRITE0x02\|
1235	FS_BROKEN_CONNECTION0x04\|
1236	FS_PENDING_REPLY0x08\|
1237	FS_RECONNECTING0x40))
1238	{
1239	now = GetTimeInMillis ();
1240	earliest = now + 10000000;
1241	for (conn = fs_fpes; conn; conn = conn->next)
1242	{
1243	if (conn->blockState & FS_RECONNECTING0x40)
1244	{
1245	wakeup = conn->blockedConnectTime;
1246	if (TimeCmp (wakeup, <, earliest)((int) ((wakeup) - (earliest)) < 0))
1247	earliest = wakeup;
1248	}
1249	if (conn->blockState & FS_BROKEN_CONNECTION0x04)
1250	{
1251	wakeup = conn->brokenConnectionTime;
1252	if (TimeCmp (wakeup, <, earliest)((int) ((wakeup) - (earliest)) < 0))
1253	earliest = wakeup;
1254	}
1255	if (conn->blockState & FS_BROKEN_WRITE0x02)
1256	{
1257	wakeup = conn->brokenWriteTime;
1258	if (TimeCmp (wakeup, <, earliest)((int) ((wakeup) - (earliest)) < 0))
1259	earliest = wakeup;
1260	}
1261	if (conn->blockState & FS_PENDING_REPLY0x08)
1262	{
1263	wakeup = conn->blockedReplyTime;
1264	if (TimeCmp (wakeup, <, earliest)((int) ((wakeup) - (earliest)) < 0))
1265	earliest = wakeup;
1266	}
1267	}
1268	soonest = earliest - now;
1269	if (soonest < 0)
1270	soonest = 0;
1271	block_timeout.tv_sec = soonest / 1000;
1272	block_timeout.tv_usec = (soonest % 1000) * 1000;
1273	if (wt == NULL((void)0))
1274	*wt = &block_timeout;
1275	else if (soonest < (wt)->tv_sec 1000 + (*wt)->tv_usec / 1000)
1276	**wt = block_timeout;
1277	}
1278	}
1279
1280	static void
1281	fs_handle_unexpected(FSFpePtr conn, fsGenericReply *rep)
1282	{
1283	if (rep->type == FS_Event2 && rep->data1 == KeepAlive0)
1284	{
1285	fsNoopReq req;
1286
1287	/* ping it back */
1288	req.reqType = FS_Noop0;
1289	req.length = SIZEOF(fsNoopReq)4 >> 2;
1290	_fs_add_req_log(conn, FS_Noop)((conn)->current_seq++);
1291	_fs_write(conn, (char *) &req, SIZEOF(fsNoopReq)4);
1292	}
1293	/* this should suck up unexpected replies and events */
1294	_fs_done_read (conn, rep->length << 2);
1295	}
1296
1297	static void
1298	fs_read_reply (FontPathElementPtr fpe, pointer client)
1299	{
1300	FSFpePtr conn = (FSFpePtr) fpe->private;
1301	FSBlockDataPtr blockrec;
1302	int ret;
1303	int err;
1304	fsGenericReply *rep;
1305
1306	if ((rep = fs_get_reply (conn, &ret)))
1307	{
1308	_fs_add_rep_log (conn, rep);
1309	for (blockrec = conn->blockedRequests;
1310	blockrec;
1311	blockrec = blockrec->next)
1312	{
1313	if (blockrec->sequenceNumber == rep->sequenceNumber)
1314	break;
1315	}
1316	err = Successful85;
1317	if (!blockrec)
1318	{
1319	fs_handle_unexpected(conn, rep);
1320	}
1321	else
1322	{
1323	/*
1324	* go read it, and if we're done,
1325	* wake up the appropriate client
1326	*/
1327	switch (blockrec->type) {
1328	case FS_OPEN_FONT1:
1329	blockrec->errcode = fs_do_open_font(fpe, blockrec);
1330	break;
1331	case FS_LOAD_GLYPHS2:
1332	blockrec->errcode = fs_read_glyphs(fpe, blockrec);
1333	break;
1334	case FS_LIST_FONTS3:
1335	blockrec->errcode = fs_read_list(fpe, blockrec);
1336	break;
1337	case FS_LIST_WITH_INFO4:
1338	blockrec->errcode = fs_read_list_info(fpe, blockrec);
1339	break;
1340	default:
1341	break;
1342	}
1343	err = blockrec->errcode;
1344	if (err != StillWorking81)
1345	{
1346	while (blockrec)
1347	{
1348	blockrec->errcode = err;
1349	if (client != blockrec->client)
1350	ClientSignal(blockrec->client);
1351	blockrec = blockrec->depending;
1352	}
1353	_fs_unmark_block (conn, FS_PENDING_REPLY0x08);
1354	}
1355	}
1356	if (fs_reply_ready (conn))
1357	_fs_mark_block (conn, FS_COMPLETE_REPLY0x20);
1358	else
1359	_fs_unmark_block (conn, FS_COMPLETE_REPLY0x20);
1360	}
1361	}
1362
1363	static int
1364	fs_wakeup(FontPathElementPtr fpe, unsigned long *mask)
1365	{
1366	fd_set LastSelectMask = (fd_set ) mask;
1367	FSFpePtr conn = (FSFpePtr) fpe->private;
1368
1369	/*
1370	* Don't continue if the fd is -1 (which will be true when the
1371	* font server terminates
1372	*/
1373	if ((conn->blockState & FS_RECONNECTING0x40))
1374	_fs_check_reconnect (conn);
1375	else if ((conn->blockState & FS_COMPLETE_REPLY0x20) \|\|
1376	(conn->fs_fd != -1 && FD_ISSET(conn->fs_fd, LastSelectMask)((((LastSelectMask)->fds_bits)[((conn->fs_fd) / (8 * (int ) sizeof (__fd_mask)))] & ((__fd_mask) 1 << ((conn-> fs_fd) % (8 * (int) sizeof (__fd_mask))))) != 0)))
1377	fs_read_reply (fpe, 0);
1378	if (conn->blockState & (FS_PENDING_REPLY0x08\|FS_BROKEN_CONNECTION0x04\|FS_BROKEN_WRITE0x02))
1379	_fs_do_blocked (conn);
1380	#ifdef DEBUG
1381	{
1382	FSBlockDataPtr blockrec;
1383	FSBlockedFontPtr bfont;
1384	FSBlockedListPtr blist;
1385	static CARD32 lastState;
1386	static FSBlockDataPtr lastBlock;
1387
1388	if (conn->blockState \|\| conn->blockedRequests \|\| lastState \|\| lastBlock)
1389	{
1390	fprintf (stderrstderr, " Block State 0x%x\n", (int) conn->blockState);
1391	lastState = conn->blockState;
1392	lastBlock = conn->blockedRequests;
1393	}
1394	for (blockrec = conn->blockedRequests; blockrec; blockrec = blockrec->next)
1395	{
1396	switch (blockrec->type) {
1397	case FS_OPEN_FONT1:
1398	bfont = (FSBlockedFontPtr) blockrec->data;
1399	fprintf (stderrstderr, " Blocked font errcode %d sequence %d state %s %s\n",
1400	blockrec->errcode,
1401	blockrec->sequenceNumber,
1402	fs_open_states[bfont->state],
1403	bfont->pfont ?
1404	((FSFontDataPtr) (bfont->pfont->fpePrivate))->name :
1405	"<freed>");
1406	break;
1407	case FS_LIST_FONTS3:
1408	blist = (FSBlockedListPtr) blockrec->data;
1409	fprintf (stderrstderr, " Blocked list errcode %d sequence %d\n",
1410	blockrec->errcode, blockrec->sequenceNumber);
1411	break;
1412	default:
1413	fprintf (stderrstderr, " Blocked type %d errcode %d sequence %d\n",
1414	blockrec->type,
1415	blockrec->errcode,
1416	blockrec->sequenceNumber);
1417	break;
1418	}
1419	}
1420	}
1421	#endif
1422	return FALSE0;
1423	}
1424
1425	/*
1426	* Notice a dead connection and prepare for reconnect
1427	*/
1428
1429	void
1430	_fs_connection_died(FSFpePtr conn)
1431	{
1432	if (conn->blockState & FS_BROKEN_CONNECTION0x04)
1433	return;
1434	fs_close_conn(conn);
1435	conn->brokenConnectionTime = GetTimeInMillis ();
1436	_fs_mark_block (conn, FS_BROKEN_CONNECTION0x04);
1437	_fs_unmark_block (conn, FS_BROKEN_WRITE0x02\|FS_PENDING_WRITE0x01\|FS_RECONNECTING0x40);
1438	}
1439
1440	/*
1441	* Signal clients that the connection has come back up
1442	*/
1443	static int
1444	_fs_restart_connection(FSFpePtr conn)
1445	{
1446	FSBlockDataPtr block;
1447
1448	_fs_unmark_block (conn, FS_GIVE_UP0x10);
1449	while ((block = (FSBlockDataPtr) conn->blockedRequests))
1450	{
1451	if (block->errcode == StillWorking81)
1452	{
1453	ClientSignal(block->client);
1454	fs_abort_blockrec(conn, block);
1455	}
1456	}
1457	return TRUE1;
1458	}
1459
1460	/*
1461	* Declare this font server connection useless
1462	*/
1463	static void
1464	_fs_giveup (FSFpePtr conn)
1465	{
1466	FSBlockDataPtr block;
1467
1468	if (conn->blockState & FS_GIVE_UP0x10)
1469	return;
1470	#ifdef DEBUG
1471	fprintf (stderrstderr, "give up on FS \"%s\"\n", conn->servername);
1472	#endif
1473	_fs_mark_block (conn, FS_GIVE_UP0x10);
1474	while ((block = (FSBlockDataPtr) conn->blockedRequests))
1475	{
1476	if (block->errcode == StillWorking81)
1477	{
1478	ClientSignal (block->client);
1479	fs_abort_blockrec (conn, block);
1480	}
1481	}
1482	if (conn->fs_fd >= 0)
1483	_fs_connection_died (conn);
1484	}
1485
1486	static void
1487	_fs_do_blocked (FSFpePtr conn)
1488	{
1489	CARD32 now;
1490
1491	now = GetTimeInMillis ();
1492	if ((conn->blockState & FS_PENDING_REPLY0x08) &&
1493	TimeCmp (conn->blockedReplyTime, <=, now)((int) ((conn->blockedReplyTime) - (now)) <= 0))
1494	{
1495	_fs_giveup (conn);
1496	}
1497	else
1498	{
1499	if (conn->blockState & FS_BROKEN_CONNECTION0x04)
1500	{
1501	/* Try to reconnect broken connections */
1502	if (TimeCmp (conn->brokenConnectionTime, <=, now)((int) ((conn->brokenConnectionTime) - (now)) <= 0))
1503	_fs_start_reconnect (conn);
1504	}
1505	else if (conn->blockState & FS_BROKEN_WRITE0x02)
1506	{
1507	/* Try to flush blocked connections */
1508	if (TimeCmp (conn->brokenWriteTime, <=, now)((int) ((conn->brokenWriteTime) - (now)) <= 0))
1509	_fs_flush (conn);
1510	}
1511	}
1512	}
1513
1514	/*
1515	* sends the actual request out
1516	*/
1517	/* ARGSUSED */
1518	static int
1519	fs_send_open_font(pointer client, FontPathElementPtr fpe, Mask flags,
1520	char *name, int namelen,
1521	fsBitmapFormat format, fsBitmapFormatMask fmask,
1522	XID id, FontPtr *ppfont)
1523	{
1524	FSFpePtr conn = (FSFpePtr) fpe->private;
1525	FontPtr font;
1526	FSBlockDataPtr blockrec = NULL((void*)0);
1527	FSBlockedFontPtr bfont;
1528	FSFontDataPtr fsd;
1529	fsOpenBitmapFontReq openreq;
1530	fsQueryXInfoReq inforeq;
1531	fsQueryXExtents16Req extreq;
1532	int err;
1533	unsigned char buf[1024];
1534
1535	if (conn->blockState & FS_GIVE_UP0x10)
1536	return BadFontName83;
1537
1538	if (namelen <= 0 \|\| namelen > sizeof (buf) - 1)
1539	return BadFontName83;
1540
1541	/*
1542	* Get the font structure put together, either by reusing
1543	* the existing one or creating a new one
1544	*/
1545	if (flags & FontReopen0x0020)
1546	{
1547	Atom nameatom, fn = None0L;
1548	int i;
1549
1550	font = *ppfont;
1551	fsd = (FSFontDataPtr)font->fpePrivate;
1552	/* This is an attempt to reopen a font. Did the font have a
1553	NAME property? */
1554	if ((nameatom = MakeAtom("FONT", 4, 0)) != None0L)
1555	{
1556	for (i = 0; i < font->info.nprops; i++)
1557	if (font->info.props[i].name == nameatom &&
1558	font->info.isStringProp[i])
1559	{
1560	fn = font->info.props[i].value;
1561	break;
1562	}
1563	}
1564	if (fn == None0L \|\| !(name = NameForAtom(fn)))
1565	{
1566	name = fsd->name;
1567	namelen = fsd->namelen;
1568	}
1569	else
1570	namelen = strlen(name);
1571	}
1572	else
1573	{
1574	font = fs_create_font (fpe, name, namelen, format, fmask);
1575	if (!font)
1576	return AllocError80;
1577
1578	fsd = (FSFontDataPtr)font->fpePrivate;
1579	}
1580
1581	/* make a new block record, and add it to the end of the list */
1582	blockrec = fs_new_block_rec(font->fpe, client, FS_OPEN_FONT1);
1583	if (!blockrec)
1584	{
1585	if (!(flags & FontReopen0x0020))
1586	(*font->unload_font) (font);
1587	return AllocError80;
1588	}
1589
1590	/*
1591	* Must check this before generating any protocol, otherwise we'll
1592	* mess up a reconnect in progress
1593	*/
1594	if (conn->blockState & (FS_BROKEN_CONNECTION0x04 \| FS_RECONNECTING0x40))
1595	{
1596	_fs_pending_reply (conn);
1597	return Suspended84;
1598	}
1599
1600	fsd->generation = conn->generation;
1601
1602	bfont = (FSBlockedFontPtr) blockrec->data;
1603	bfont->fontid = fsd->fontid;
1604	bfont->pfont = font;
1605	bfont->state = FS_OPEN_REPLY0;
1606	bfont->flags = flags;
1607	bfont->format = fsd->format;
1608	bfont->clients_depending = (FSClientsDependingPtr)0;
1609	bfont->freeFont = (flags & FontReopen0x0020) == 0;
1610
1611	_fs_client_access (conn, client, (flags & FontOpenSync0x0010) != 0);
1612	_fs_client_resolution(conn);
1613
1614	/* do an FS_OpenFont, FS_QueryXInfo and FS_QueryXExtents */
1615	buf[0] = (unsigned char) namelen;
1616	memcpy(&buf[1], name, namelen);
1617	openreq.reqType = FS_OpenBitmapFont15;
1618	openreq.pad = 0;
1619	openreq.fid = fsd->fontid;
1620	openreq.format_hint = fsd->format;
1621	openreq.format_mask = fsd->fmask;
1622	openreq.length = (SIZEOF(fsOpenBitmapFontReq)16 + namelen + 4) >> 2;
1623
1624	_fs_add_req_log(conn, FS_OpenBitmapFont)((conn)->current_seq++);
1625	_fs_write(conn, (char *) &openreq, SIZEOF(fsOpenBitmapFontReq)16);
1626	_fs_write_pad(conn, (char *) buf, namelen + 1);
1627
1628	blockrec->sequenceNumber = conn->current_seq;
1629
1630	inforeq.reqType = FS_QueryXInfo16;
1631	inforeq.pad = 0;
1632	inforeq.id = fsd->fontid;
1633	inforeq.length = SIZEOF(fsQueryXInfoReq)8 >> 2;
1634
1635	bfont->queryInfoSequence = conn->current_seq + 1;
1636
1637	_fs_add_req_log(conn, FS_QueryXInfo)((conn)->current_seq++);
1638	_fs_write(conn, (char *) &inforeq, SIZEOF(fsQueryXInfoReq)8);
1639
1640	if (!(bfont->flags & FontReopen0x0020))
1641	{
1642	extreq.reqType = FS_QueryXExtents1618;
1643	extreq.range = fsTrue1;
1644	extreq.fid = fsd->fontid;
1645	extreq.num_ranges = 0;
1646	extreq.length = SIZEOF(fsQueryXExtents16Req)12 >> 2;
1647
1648	bfont->queryExtentsSequence = conn->current_seq + 1;
1649
1650	_fs_add_req_log(conn, FS_QueryXExtents16)((conn)->current_seq++);
1651	_fs_write(conn, (char *) &extreq, SIZEOF(fsQueryXExtents16Req)12);
1652	}
1653
1654	#ifdef NCD
1655	if (configData.ExtendedFontDiags)
1656	{
1657	memcpy(buf, name, MIN(256, namelen)((256)<(namelen)?(256):(namelen)));
1658	buf[MIN(256, namelen)((256)<(namelen)?(256):(namelen))] = '\0';
1659	printf("Requesting font \"%s\" from font server \"%s\"\n",
1660	buf, font->fpe->name);
1661	}
1662	#endif
1663	_fs_prepare_for_reply (conn);
1664
1665	err = blockrec->errcode;
1666	if (bfont->flags & FontOpenSync0x0010)
1667	{
1668	while (blockrec->errcode == StillWorking81)
1669	{
1670	if (fs_await_reply (conn) != FSIO_READY1)
1671	{
1672	blockrec->errcode = BadFontName83;
1673	break;
1674	}
1675	fs_read_reply (font->fpe, client);
1676	}
1677	err = blockrec->errcode;
1678	if (err == Successful85)
1679	*ppfont = bfont->pfont;
1680	else
1681	fs_cleanup_bfont (bfont);
1682	bfont->freeFont = FALSE0;
1683	_fs_remove_block_rec (conn, blockrec);
1684	}
1685	return err == StillWorking81 ? Suspended84 : err;
1686	}
1687
1688	static void
1689	fs_send_query_bitmaps(FontPathElementPtr fpe, FSBlockDataPtr blockrec)
1690	{
1691	FSFpePtr conn = (FSFpePtr) fpe->private;
1692	FSBlockedFontPtr bfont = (FSBlockedFontPtr) blockrec->data;
1693	fsQueryXBitmaps16Req bitreq;
1694
1695	/* send the request */
1696	bitreq.reqType = FS_QueryXBitmaps1620;
1697	bitreq.fid = bfont->fontid;
1698	bitreq.format = bfont->format;
1699	bitreq.range = TRUE1;
1700	bitreq.length = SIZEOF(fsQueryXBitmaps16Req)16 >> 2;
1701	bitreq.num_ranges = 0;
1702
1703	bfont->queryBitmapsSequence = conn->current_seq + 1;
1704
1705	_fs_add_req_log(conn, FS_QueryXBitmaps16)((conn)->current_seq++);
1706	_fs_write(conn, (char *) &bitreq, SIZEOF(fsQueryXBitmaps16Req)16);
1707	}
1708
1709	/* ARGSUSED */
1710	static int
1711	fs_open_font(pointer client, FontPathElementPtr fpe, Mask flags,
1712	char *name, int namelen,
1713	fsBitmapFormat format, fsBitmapFormatMask fmask,
1714	XID id, FontPtr *ppfont,
1715	char **alias, FontPtr non_cachable_font)
1716	{
1717	FSFpePtr conn = (FSFpePtr) fpe->private;
1718	FSBlockDataPtr blockrec;
1719	FSBlockedFontPtr bfont;
1720	int err;
1721
1722	/* libfont interface expects ImageRectMin glyphs */
1723	format = (format & ~BitmapFormatImageRectMask(3L << 2)) \| BitmapFormatImageRectMin(0L << 2);
1724
1725	alias = (char ) 0;
1726	for (blockrec = conn->blockedRequests; blockrec; blockrec = blockrec->next)
1727	{
1728	if (blockrec->type == FS_OPEN_FONT1 && blockrec->client == client)
1729	{
1730	err = blockrec->errcode;
1731	if (err == StillWorking81)
1732	return Suspended84;
1733
1734	bfont = (FSBlockedFontPtr) blockrec->data;
1735	if (err == Successful85)
1736	*ppfont = bfont->pfont;
1737	else
1738	fs_cleanup_bfont (bfont);
1739	_fs_remove_block_rec (conn, blockrec);
1740	return err;
1741	}
1742	}
1743	return fs_send_open_font(client, fpe, flags, name, namelen, format, fmask,
1744	id, ppfont);
1745	}
1746
1747	/* ARGSUSED */
1748	static int
1749	fs_send_close_font(FontPathElementPtr fpe, Font id)
1750	{
1751	FSFpePtr conn = (FSFpePtr) fpe->private;
1752	fsCloseReq req;
1753
1754	if (conn->blockState & FS_GIVE_UP0x10)
1755	return Successful85;
1756	/* tell the font server to close the font */
1757	req.reqType = FS_CloseFont21;
1758	req.pad = 0;
1759	req.length = SIZEOF(fsCloseReq)8 >> 2;
1760	req.id = id;
1761	_fs_add_req_log(conn, FS_CloseFont)((conn)->current_seq++);
1762	_fs_write(conn, (char *) &req, SIZEOF(fsCloseReq)8);
1763
1764	return Successful85;
1765	}
1766
1767	/* ARGSUSED */
1768	static void
1769	fs_close_font(FontPathElementPtr fpe, FontPtr pfont)
1770	{
1771	FSFontDataPtr fsd = (FSFontDataPtr) pfont->fpePrivate;
1772	FSFpePtr conn = (FSFpePtr) fpe->private;
1773
1774	if (conn->generation == fsd->generation)
1775	fs_send_close_font(fpe, fsd->fontid);
1776
1777	#ifdef DEBUG
1778	{
1779	FSBlockDataPtr blockrec;
1780	FSBlockedFontPtr bfont;
1781
1782	for (blockrec = conn->blockedRequests; blockrec; blockrec = blockrec->next)
1783	{
1784	if (blockrec->type == FS_OPEN_FONT1)
1785	{
1786	bfont = (FSBlockedFontPtr) blockrec->data;
1787	if (bfont->pfont == pfont)
1788	fprintf (stderrstderr, "closing font which hasn't been opened\n");
1789	}
1790	}
1791	}
1792	#endif
1793	(*pfont->unload_font) (pfont);
1794	}
1795
1796	static int
1797	fs_read_glyphs(FontPathElementPtr fpe, FSBlockDataPtr blockrec)
1798	{
1799	FSBlockedGlyphPtr bglyph = (FSBlockedGlyphPtr) blockrec->data;
1800	FSBlockedFontPtr bfont = (FSBlockedFontPtr) blockrec->data;
1801	FSFpePtr conn = (FSFpePtr) fpe->private;
1802	FontPtr pfont = bglyph->pfont;
1803	/* works for either blocked font
1804	or glyph rec... pfont is at
1805	the very beginning of both
1806	blockrec->data structures */
1807	FSFontDataPtr fsd = (FSFontDataPtr) (pfont->fpePrivate);
1808	FSFontPtr fsdata = (FSFontPtr) pfont->fontPrivate;
1809	FontInfoPtr pfi = &pfont->info;
1810	fsQueryXBitmaps16Reply *rep;
1811	char *buf;
1812	fsOffset32 *ppbits;
1813	fsOffset32 local_off;
1814	char *off_adr;
1815	pointer pbitmaps;
1816	char bits, allbits;
1817	#ifdef DEBUG
1818	char *origallbits;
1819	#endif
1820	int i,
1821	err;
1822	int nranges = 0;
1823	int ret;
1824	fsRange *nextrange = 0;
1825	unsigned long minchar, maxchar;
1826
1827	rep = (fsQueryXBitmaps16Reply *) fs_get_reply (conn, &ret);
1828	if (!rep \|\| rep->type == FS_Error1)
1829	{
1830	if (ret == FSIO_BLOCK0)
1831	return StillWorking81;
1832	if (rep)
1833	_fs_done_read (conn, rep->length << 2);
1834	err = AllocError80;
1835	goto bail;
1836	}
1837
1838	buf = (char *) rep;
1839	buf += SIZEOF (fsQueryXBitmaps16Reply)20;
1840
1841	ppbits = (fsOffset32 *) buf;
1842	buf += SIZEOF (fsOffset32)8 * (rep->num_chars);
1843
1844	pbitmaps = (pointer ) buf;
1845
1846	if (blockrec->type == FS_LOAD_GLYPHS2)
1847	{
1848	nranges = bglyph->num_expected_ranges;
1849	nextrange = bglyph->expected_ranges;
1850	}
1851
1852	/* place the incoming glyphs */
1853	if (nranges)
1854	{
1855	/* We're operating under the assumption that the ranges
1856	requested in the LoadGlyphs call were all legal for this
1857	font, and that individual ranges do not cover multiple
1858	rows... fs_build_range() is designed to ensure this. */
1859	minchar = (nextrange->min_char_high - pfi->firstRow) *
1860	(pfi->lastCol - pfi->firstCol + 1) +
1861	nextrange->min_char_low - pfi->firstCol;
1862	maxchar = (nextrange->max_char_high - pfi->firstRow) *
1863	(pfi->lastCol - pfi->firstCol + 1) +
1864	nextrange->max_char_low - pfi->firstCol;
1865	nextrange++;
1866	}
1867	else
1868	{
1869	minchar = 0;
1870	maxchar = rep->num_chars;
1871	}
1872
1873	off_adr = (char *)ppbits;
1874
1875	allbits = fs_alloc_glyphs (pfont, rep->nbytes);
1876
1877	if (!allbits)
1878	{
1879	err = AllocError80;
1880	goto bail;
1881	}
1882
1883	#ifdef DEBUG
1884	origallbits = allbits;
1885	fprintf (stderrstderr, "Reading %d glyphs in %d bytes for %s\n",
1886	(int) rep->num_chars, (int) rep->nbytes, fsd->name);
1887	#endif
1888
1889	for (i = 0; i < rep->num_chars; i++)
1890	{
1891	memcpy(&local_off, off_adr, SIZEOF(fsOffset32)8); /* align it */
1892	if (blockrec->type == FS_OPEN_FONT1 \|\|
1893	fsdata->encoding[minchar].bits == &_fs_glyph_requested)
1894	{
1895	/*
1896	* Broken X font server returns bits for missing characters
1897	* when font is padded
1898	*/
1899	if (NONZEROMETRICS(&fsdata->encoding[minchar].metrics)((&fsdata->encoding[minchar].metrics)->leftSideBearing \|\| (&fsdata->encoding[minchar].metrics)->rightSideBearing \|\| (&fsdata->encoding[minchar].metrics)->ascent \|\| (&fsdata->encoding[minchar].metrics)->descent \|\| ( &fsdata->encoding[minchar].metrics)->characterWidth ))
1900	{
1901	if (local_off.length)
1902	{
1903	bits = allbits;
1904	allbits += local_off.length;
1905	memcpy(bits, (char *)pbitmaps + local_off.position,
1906	local_off.length);
1907	}
1908	else
1909	bits = &_fs_glyph_zero_length;
1910	}
1911	else
1912	bits = 0;
1913	if (fsdata->encoding[minchar].bits == &_fs_glyph_requested)
1914	fsd->glyphs_to_get--;
1915	fsdata->encoding[minchar].bits = bits;
1916	}
1917	if (minchar++ == maxchar)
1918	{
1919	if (!--nranges) break;
1920	minchar = (nextrange->min_char_high - pfi->firstRow) *
1921	(pfi->lastCol - pfi->firstCol + 1) +
1922	nextrange->min_char_low - pfi->firstCol;
1923	maxchar = (nextrange->max_char_high - pfi->firstRow) *
1924	(pfi->lastCol - pfi->firstCol + 1) +
1925	nextrange->max_char_low - pfi->firstCol;
1926	nextrange++;
1927	}
1928	off_adr += SIZEOF(fsOffset32)8;
1929	}
1930	#ifdef DEBUG
1931	fprintf (stderrstderr, "Used %d bytes instead of %d\n",
1932	(int) (allbits - origallbits), (int) rep->nbytes);
1933	#endif
1934
1935	if (blockrec->type == FS_OPEN_FONT1)
1936	{
1937	fsd->glyphs_to_get = 0;
1938	bfont->state = FS_DONE_REPLY4;
1939	}
1940	err = Successful85;
1941
1942	bail:
1943	_fs_done_read (conn, rep->length << 2);
1944	return err;
1945	}
1946
1947	static int
1948	fs_send_load_glyphs(pointer client, FontPtr pfont,
1949	int nranges, fsRange *ranges)
1950	{
1951	FontPathElementPtr fpe = pfont->fpe;
1952	FSFpePtr conn = (FSFpePtr) fpe->private;
1953	FSBlockedGlyphPtr blockedglyph;
1954	fsQueryXBitmaps16Req req;
1955	FSBlockDataPtr blockrec;
1956
1957	if (conn->blockState & FS_GIVE_UP0x10)
1958	return BadCharRange87;
1959
1960	/* make a new block record, and add it to the end of the list */
1961	blockrec = fs_new_block_rec(fpe, client, FS_LOAD_GLYPHS2);
1962	if (!blockrec)
1963	return AllocError80;
1964	blockedglyph = (FSBlockedGlyphPtr) blockrec->data;
1965	blockedglyph->pfont = pfont;
1966	blockedglyph->num_expected_ranges = nranges;
1967	/* Assumption: it's our job to free ranges */
1968	blockedglyph->expected_ranges = ranges;
1969	blockedglyph->clients_depending = (FSClientsDependingPtr)0;
1970
1971	if (conn->blockState & (FS_BROKEN_CONNECTION0x04\|FS_RECONNECTING0x40))
1972	{
1973	_fs_pending_reply (conn);
1974	return Suspended84;
1975	}
1976
1977	/* send the request */
1978	req.reqType = FS_QueryXBitmaps1620;
1979	req.fid = ((FSFontDataPtr) pfont->fpePrivate)->fontid;
1980	req.format = pfont->format;
1981	if (pfont->info.terminalFont)
1982	req.format = (req.format & ~(BitmapFormatImageRectMask(3L << 2))) \|
1983	BitmapFormatImageRectMax(2L << 2);
1984	req.range = TRUE1;
1985	/* each range takes up 4 bytes */
1986	req.length = (SIZEOF(fsQueryXBitmaps16Req)16 >> 2) + nranges;
1987	req.num_ranges = nranges * 2; /* protocol wants count of fsChar2bs */
1988	_fs_add_req_log(conn, FS_QueryXBitmaps16)((conn)->current_seq++);
1989	_fs_write(conn, (char *) &req, SIZEOF(fsQueryXBitmaps16Req)16);
1990
1991	blockrec->sequenceNumber = conn->current_seq;
1992
1993	/* Send ranges to the server... pack into a char array by hand
1994	to avoid structure-packing portability problems and to
1995	handle swapping for version1 protocol */
1996	if (nranges)
1997	{
1998	#define RANGE_BUFFER_SIZE64 64
1999	#define RANGE_BUFFER_SIZE_MASK63 63
2000	int i;
2001	char range_buffer[RANGE_BUFFER_SIZE64 * 4];
2002	char *range_buffer_p;
2003
2004	range_buffer_p = range_buffer;
2005	for (i = 0; i < nranges;)
2006	{
2007	if (conn->fsMajorVersion > 1)
2008	{
2009	*range_buffer_p++ = ranges[i].min_char_high;
2010	*range_buffer_p++ = ranges[i].min_char_low;
2011	*range_buffer_p++ = ranges[i].max_char_high;
2012	*range_buffer_p++ = ranges[i].max_char_low;
2013	}
2014	else
2015	{
2016	*range_buffer_p++ = ranges[i].min_char_low;
2017	*range_buffer_p++ = ranges[i].min_char_high;
2018	*range_buffer_p++ = ranges[i].max_char_low;
2019	*range_buffer_p++ = ranges[i].max_char_high;
2020	}
2021
2022	if (!(++i & RANGE_BUFFER_SIZE_MASK63))
2023	{
2024	_fs_write(conn, range_buffer, RANGE_BUFFER_SIZE64 * 4);
2025	range_buffer_p = range_buffer;
2026	}
2027	}
2028	if (i &= RANGE_BUFFER_SIZE_MASK63)
2029	_fs_write(conn, range_buffer, i * 4);
2030	}
2031
2032	_fs_prepare_for_reply (conn);
2033	return Suspended84;
2034	}
2035
2036
2037	extern pointer serverClient; /* This could be any number that
2038	doesn't conflict with existing
2039	client values. */
2040
2041	static int
2042	_fs_load_glyphs(pointer client, FontPtr pfont, Bool range_flag,
2043	unsigned int nchars, int item_size, unsigned char *data)
2044	{
2045	FSFpePtr conn = (FSFpePtr) pfont->fpe->private;
2046	int nranges = 0;
2047	fsRange ranges = NULL((void)0);
2048	int res;
2049	FSBlockDataPtr blockrec;
2050	FSBlockedGlyphPtr blockedglyph;
2051	FSClientsDependingPtr clients_depending = NULL((void)0);
2052	int err;
2053
2054	/* see if the result is already there */
2055	for (blockrec = conn->blockedRequests; blockrec; blockrec = blockrec->next)
2056	{
2057	if (blockrec->type == FS_LOAD_GLYPHS2)
2058	{
2059	blockedglyph = (FSBlockedGlyphPtr) blockrec->data;
2060	if (blockedglyph->pfont == pfont)
2061	{
2062	/* Look for this request */
2063	if (blockrec->client == client)
2064	{
2065	err = blockrec->errcode;
2066	if (err == StillWorking81)
2067	return Suspended84;
2068	_fs_signal_clients_depending(&blockedglyph->clients_depending);
2069	_fs_remove_block_rec(conn, blockrec);
2070	return err;
2071	}
2072	/* We've found an existing LoadGlyphs blockrec for this
2073	font but for another client. Rather than build a
2074	blockrec for it now (which entails some complex
2075	maintenance), we'll add it to a queue of clients to
2076	be signalled when the existing LoadGlyphs is
2077	completed. */
2078	clients_depending = &blockedglyph->clients_depending;
2079	break;
2080	}
2081	}
2082	else if (blockrec->type == FS_OPEN_FONT1)
2083	{
2084	FSBlockedFontPtr bfont;
2085	bfont = (FSBlockedFontPtr) blockrec->data;
2086	if (bfont->pfont == pfont)
2087	{
2088	/*
2089	* An OpenFont is pending for this font, this must
2090	* be from a reopen attempt, so finish the open
2091	* attempt and retry the LoadGlyphs
2092	*/
2093	if (blockrec->client == client)
2094	{
2095	err = blockrec->errcode;
2096	if (err == StillWorking81)
2097	return Suspended84;
2098
2099	_fs_signal_clients_depending(&bfont->clients_depending);
2100	_fs_remove_block_rec(conn, blockrec);
2101	if (err != Successful85)
2102	return err;
2103	break;
2104	}
2105	/* We've found an existing OpenFont blockrec for this
2106	font but for another client. Rather than build a
2107	blockrec for it now (which entails some complex
2108	maintenance), we'll add it to a queue of clients to
2109	be signalled when the existing OpenFont is
2110	completed. */
2111	if (blockrec->errcode == StillWorking81)
2112	{
2113	clients_depending = &bfont->clients_depending;
2114	break;
2115	}
2116	}
2117	}
2118	}
2119
2120	/*
2121	* see if the desired glyphs already exist, and return Successful if they
2122	* do, otherwise build up character range/character string
2123	*/
2124	res = fs_build_range(pfont, range_flag, nchars, item_size, data,
2125	&nranges, &ranges);
2126
2127	switch (res)
2128	{
2129	case AccessDone0x400:
2130	return Successful85;
2131
2132	case Successful85:
2133	break;
2134
2135	default:
2136	return res;
2137	}
2138
2139	/*
2140	* If clients_depending is not null, this request must wait for
2141	* some prior request(s) to complete.
2142	*/
2143	if (clients_depending)
2144	{
2145	/* Since we're not ready to send the load_glyphs request yet,
2146	clean up the damage (if any) caused by the fs_build_range()
2147	call. */
2148	if (nranges)
2149	{
2150	_fs_clean_aborted_loadglyphs(pfont, nranges, ranges);
2151	free(ranges);
2152	}
2153	return _fs_add_clients_depending(clients_depending, client);
2154	}
2155
2156	/*
2157	* If fsd->generation != conn->generation, the font has been closed
2158	* due to a lost connection. We will reopen it, which will result
2159	* in one of three things happening:
2160	* 1) The open will succeed and obtain the same font. Life
2161	* is wonderful.
2162	* 2) The open will fail. There is code above to recognize this
2163	* and flunk the LoadGlyphs request. The client might not be
2164	* thrilled.
2165	* 3) Worst case: the open will succeed but the font we open will
2166	* be different. The fs_read_query_info() procedure attempts
2167	* to detect this by comparing the existing metrics and
2168	* properties against those of the reopened font... if they
2169	* don't match, we flunk the reopen, which eventually results
2170	* in flunking the LoadGlyphs request. We could go a step
2171	* further and compare the extents, but this should be
2172	* sufficient.
2173	*/
2174	if (((FSFontDataPtr)pfont->fpePrivate)->generation != conn->generation)
2175	{
2176	/* Since we're not ready to send the load_glyphs request yet,
2177	clean up the damage caused by the fs_build_range() call. */
2178	_fs_clean_aborted_loadglyphs(pfont, nranges, ranges);
2179	free(ranges);
2180
2181	/* Now try to reopen the font. */
2182	return fs_send_open_font(client, pfont->fpe,
2183	(Mask)FontReopen0x0020, (char *)0, 0,
2184	(fsBitmapFormat)0, (fsBitmapFormatMask)0,
2185	(XID)0, &pfont);
2186	}
2187
2188	return fs_send_load_glyphs(client, pfont, nranges, ranges);
2189	}
2190
2191	int
2192	fs_load_all_glyphs(FontPtr pfont)
2193	{
2194	int err;
2195	FSFpePtr conn = (FSFpePtr) pfont->fpe->private;
2196
2197	/*
2198	* The purpose of this procedure is to load all glyphs in the event
2199	* that we're dealing with someone who doesn't understand the finer
2200	* points of glyph caching... it is called from _fs_get_glyphs() if
2201	* the latter is called to get glyphs that have not yet been loaded.
2202	* We assume that the caller will not know how to handle a return
2203	* value of Suspended (usually the case for a GetGlyphs() caller),
2204	* so this procedure hangs around, freezing the server, for the
2205	* request to complete. This is an unpleasant kluge called to
2206	* perform an unpleasant job that, we hope, will never be required.
2207	*/
2208
2209	while ((err = _fs_load_glyphs(serverClient, pfont, TRUE1, 0, 0, NULL((void*)0))) ==
2210	Suspended84)
2211	{
2212	if (fs_await_reply (conn) != FSIO_READY1)
2213	{
2214	/* Get rid of blockrec */
2215	fs_client_died(serverClient, pfont->fpe);
2216	err = BadCharRange87;
2217	break;
2218	}
2219	fs_read_reply (pfont->fpe, serverClient);
2220	}
2221	return err;
2222	}
2223
2224	static int
2225	fs_read_list(FontPathElementPtr fpe, FSBlockDataPtr blockrec)
2226	{
2227	FSFpePtr conn = (FSFpePtr) fpe->private;
2228	FSBlockedListPtr blist = (FSBlockedListPtr) blockrec->data;
2229	fsListFontsReply *rep;
2230	char *data;
2231	int length,
2232	i,
2233	ret;
2234	int err;
2235
2236	rep = (fsListFontsReply *) fs_get_reply (conn, &ret);
2237	if (!rep \|\| rep->type == FS_Error1)
2238	{
2239	if (ret == FSIO_BLOCK0)
2240	return StillWorking81;
2241	if (rep)
2242	_fs_done_read (conn, rep->length << 2);
2243	return AllocError80;
2244	}
2245	data = (char *) rep + SIZEOF (fsListFontsReply)16;
2246
2247	err = Successful85;
2248	/* copy data into FontPathRecord */
2249	for (i = 0; i < rep->nFonts; i++)
2250	{
2251	length = (unsigned char )data++;
2252	err = AddFontNamesName(blist->names, data, length);
2253	if (err != Successful85)
2254	break;
2255	data += length;
2256	}
2257	_fs_done_read (conn, rep->length << 2);
2258	return err;
2259	}
2260
2261	static int
2262	fs_send_list_fonts(pointer client, FontPathElementPtr fpe, char *pattern,
2263	int patlen, int maxnames, FontNamesPtr newnames)
2264	{
2265	FSFpePtr conn = (FSFpePtr) fpe->private;
2266	FSBlockDataPtr blockrec;
2267	FSBlockedListPtr blockedlist;
2268	fsListFontsReq req;
2269
2270	if (conn->blockState & FS_GIVE_UP0x10)
2271	return BadFontName83;
2272
2273	/* make a new block record, and add it to the end of the list */
2274	blockrec = fs_new_block_rec(fpe, client, FS_LIST_FONTS3);
2275	if (!blockrec)
2276	return AllocError80;
2277	blockedlist = (FSBlockedListPtr) blockrec->data;
2278	blockedlist->names = newnames;
2279
2280	if (conn->blockState & (FS_BROKEN_CONNECTION0x04 \| FS_RECONNECTING0x40))
2281	{
2282	_fs_pending_reply (conn);
2283	return Suspended84;
2284	}
2285
2286	_fs_client_access (conn, client, FALSE0);
2287	_fs_client_resolution(conn);
2288
2289	/* send the request */
2290	req.reqType = FS_ListFonts13;
2291	req.pad = 0;
2292	req.maxNames = maxnames;
2293	req.nbytes = patlen;
2294	req.length = (SIZEOF(fsListFontsReq)12 + patlen + 3) >> 2;
2295	_fs_add_req_log(conn, FS_ListFonts)((conn)->current_seq++);
2296	_fs_write(conn, (char *) &req, SIZEOF(fsListFontsReq)12);
2297	_fs_write_pad(conn, (char *) pattern, patlen);
2298
2299	blockrec->sequenceNumber = conn->current_seq;
2300
2301	#ifdef NCD
2302	if (configData.ExtendedFontDiags) {
2303	char buf[256];
2304
2305	memcpy(buf, pattern, MIN(256, patlen)((256)<(patlen)?(256):(patlen)));
2306	buf[MIN(256, patlen)((256)<(patlen)?(256):(patlen))] = '\0';
2307	printf("Listing fonts on pattern \"%s\" from font server \"%s\"\n",
2308	buf, fpe->name);
2309	}
2310	#endif
2311
2312	_fs_prepare_for_reply (conn);
2313	return Suspended84;
2314	}
2315
2316	static int
2317	fs_list_fonts(pointer client, FontPathElementPtr fpe,
2318	char *pattern, int patlen, int maxnames, FontNamesPtr newnames)
2319	{
2320	FSFpePtr conn = (FSFpePtr) fpe->private;
2321	FSBlockDataPtr blockrec;
2322	int err;
2323
2324	/* see if the result is already there */
2325	for (blockrec = conn->blockedRequests; blockrec; blockrec = blockrec->next)
2326	{
2327	if (blockrec->type == FS_LIST_FONTS3 && blockrec->client == client)
2328	{
2329	err = blockrec->errcode;
2330	if (err == StillWorking81)
2331	return Suspended84;
2332	_fs_remove_block_rec(conn, blockrec);
2333	return err;
2334	}
2335	}
2336
2337	/* didn't find waiting record, so send a new one */
2338	return fs_send_list_fonts(client, fpe, pattern, patlen, maxnames, newnames);
2339	}
2340
2341	/*
2342	* Read a single list info reply and restart for the next reply
2343	*/
2344	static int
2345	fs_read_list_info(FontPathElementPtr fpe, FSBlockDataPtr blockrec)
2346	{
2347	FSBlockedListInfoPtr binfo = (FSBlockedListInfoPtr) blockrec->data;
2348	fsListFontsWithXInfoReply *rep;
2349	char *buf;
2350	FSFpePtr conn = (FSFpePtr) fpe->private;
2351	fsPropInfo *pi;
2352	fsPropOffset *po;
2353	pointer pd;
2354	int ret;
2355	int err;
2356
2357	/* clean up anything from the last trip */
2358	_fs_free_props (&binfo->info);
2359
2360	rep = (fsListFontsWithXInfoReply *) fs_get_reply (conn, &ret);
2361	if (!rep \|\| rep->type == FS_Error1)
2362	{
2363	if (ret == FSIO_BLOCK0)
2364	return StillWorking81;
2365	binfo->status = FS_LFWI_FINISHED2;
2366	err = AllocError80;
2367	goto done;
2368	}
2369	/*
2370	* Normal termination -- the list ends with a name of length 0
2371	*/
2372	if (rep->nameLength == 0)
2373	{
2374	#ifdef DEBUG
2375	fprintf (stderrstderr, "fs_read_list_info done\n");
2376	#endif
2377	binfo->status = FS_LFWI_FINISHED2;
2378	err = BadFontName83;
2379	goto done;
2380	}
2381
2382	buf = (char *) rep + SIZEOF (fsListFontsWithXInfoReply)(12 + 40);
2383
2384	/*
2385	* The original FS implementation didn't match
2386	* the spec, version 1 was respecified to match the FS.
2387	* Version 2 matches the original intent
2388	*/
2389	if (conn->fsMajorVersion <= 1)
2390	{
2391	memcpy (binfo->name, buf, rep->nameLength);
2392	buf += _fs_pad_length (rep->nameLength);
2393	}
2394	pi = (fsPropInfo *) buf;
2395	buf += SIZEOF (fsPropInfo)8;
2396	po = (fsPropOffset *) buf;
2397	buf += pi->num_offsets * SIZEOF (fsPropOffset)20;
2398	pd = (pointer) buf;
2399	buf += pi->data_len;
2400	if (conn->fsMajorVersion > 1)
2401	{
2402	memcpy (binfo->name, buf, rep->nameLength);
2403	buf += _fs_pad_length (rep->nameLength);
2404	}
2405
2406	#ifdef DEBUG
2407	binfo->name[rep->nameLength] = '\0';
2408	fprintf (stderrstderr, "fs_read_list_info %s\n", binfo->name);
2409	#endif
2410	err = _fs_convert_lfwi_reply(conn, &binfo->info, rep, pi, po, pd);
2411	if (err != Successful85)
2412	{
2413	binfo->status = FS_LFWI_FINISHED2;
2414	goto done;
2415	}
2416	binfo->namelen = rep->nameLength;
2417	binfo->remaining = rep->nReplies;
2418
2419	binfo->status = FS_LFWI_REPLY1;
2420
2421	/* disable this font server until we've processed this response */
2422	_fs_unmark_block (conn, FS_COMPLETE_REPLY0x20);
2423	FD_CLR(conn->fs_fd, &_fs_fd_mask)((void) (((&_fs_fd_mask)->fds_bits)[((conn->fs_fd) / (8 * (int) sizeof (__fd_mask)))] &= ~((__fd_mask) 1 << ((conn->fs_fd) % (8 * (int) sizeof (__fd_mask))))));
2424	done:
2425	_fs_done_read (conn, rep->length << 2);
2426	return err;
2427	}
2428
2429	/* ARGSUSED */
2430	static int
2431	fs_start_list_with_info(pointer client, FontPathElementPtr fpe,
2432	char pattern, int len, int maxnames, pointer pdata)
2433	{
2434	FSFpePtr conn = (FSFpePtr) fpe->private;
2435	FSBlockDataPtr blockrec;
2436	FSBlockedListInfoPtr binfo;
2437	fsListFontsWithXInfoReq req;
2438
2439	if (conn->blockState & FS_GIVE_UP0x10)
2440	return BadFontName83;
2441
2442	/* make a new block record, and add it to the end of the list */
2443	blockrec = fs_new_block_rec(fpe, client, FS_LIST_WITH_INFO4);
2444	if (!blockrec)
2445	return AllocError80;
2446
2447	binfo = (FSBlockedListInfoPtr) blockrec->data;
2448	bzero((char ) binfo, sizeof(FSBlockedListInfoRec))memset((char ) binfo,0,sizeof(FSBlockedListInfoRec));
2449	binfo->status = FS_LFWI_WAITING0;
2450
2451	if (conn->blockState & (FS_BROKEN_CONNECTION0x04 \| FS_RECONNECTING0x40))
2452	{
2453	_fs_pending_reply (conn);
2454	return Suspended84;
2455	}
2456
2457	_fs_client_access (conn, client, FALSE0);
2458	_fs_client_resolution(conn);
2459
2460	/* send the request */
2461	req.reqType = FS_ListFontsWithXInfo14;
2462	req.pad = 0;
2463	req.maxNames = maxnames;
2464	req.nbytes = len;
2465	req.length = (SIZEOF(fsListFontsWithXInfoReq)12 + len + 3) >> 2;
2466	_fs_add_req_log(conn, FS_ListFontsWithXInfo)((conn)->current_seq++);
2467	(void) _fs_write(conn, (char *) &req, SIZEOF(fsListFontsWithXInfoReq)12);
2468	(void) _fs_write_pad(conn, pattern, len);
2469
2470	blockrec->sequenceNumber = conn->current_seq;
2471
2472	#ifdef NCD
2473	if (configData.ExtendedFontDiags) {
2474	char buf[256];
2475
2476	memcpy(buf, pattern, MIN(256, len)((256)<(len)?(256):(len)));
2477	buf[MIN(256, len)((256)<(len)?(256):(len))] = '\0';
2478	printf("Listing fonts with info on pattern \"%s\" from font server \"%s\"\n",
2479	buf, fpe->name);
2480	}
2481	#endif
2482
2483	_fs_prepare_for_reply (conn);
2484	return Successful85;
2485	}
2486
2487	/* ARGSUSED */
2488	static int
2489	fs_next_list_with_info(pointer client, FontPathElementPtr fpe,
2490	char *namep, int namelenp,
2491	FontInfoPtr pFontInfo, int numFonts,
2492	pointer private)
2493	{
2494	FSFpePtr conn = (FSFpePtr) fpe->private;
2495	FSBlockDataPtr blockrec;
2496	FSBlockedListInfoPtr binfo;
2497	int err;
2498
2499	/* see if the result is already there */
2500	for (blockrec = conn->blockedRequests; blockrec; blockrec = blockrec->next)
2501	if (blockrec->type == FS_LIST_WITH_INFO4 && blockrec->client == client)
2502	break;
2503
2504	if (!blockrec)
2505	{
2506	/* The only good reason for not finding a blockrec would be if
2507	disconnect/reconnect to the font server wiped it out and the
2508	code that called us didn't do the right thing to create
2509	another one. Under those circumstances, we need to return an
2510	error to prevent that code from attempting to interpret the
2511	information we don't return. */
2512	return BadFontName83;
2513	}
2514
2515	binfo = (FSBlockedListInfoPtr) blockrec->data;
2516
2517	if (binfo->status == FS_LFWI_WAITING0)
2518	return Suspended84;
2519
2520	*namep = binfo->name;
2521	*namelenp = binfo->namelen;
2522	*pFontInfo = &binfo->info;
2523	*numFonts = binfo->remaining;
2524
2525	/* Restart reply processing from this font server */
2526	FD_SET(conn->fs_fd, &_fs_fd_mask)((void) (((&_fs_fd_mask)->fds_bits)[((conn->fs_fd) / (8 * (int) sizeof (__fd_mask)))] \|= ((__fd_mask) 1 << ( (conn->fs_fd) % (8 * (int) sizeof (__fd_mask))))));
2527	if (fs_reply_ready (conn))
2528	_fs_mark_block (conn, FS_COMPLETE_REPLY0x20);
2529
2530	err = blockrec->errcode;
2531	switch (binfo->status) {
2532	case FS_LFWI_FINISHED2:
2533	_fs_remove_block_rec(conn, blockrec);
2534	break;
2535	case FS_LFWI_REPLY1:
2536	binfo->status = FS_LFWI_WAITING0;
2537	blockrec->errcode = StillWorking81;
2538	conn->blockedReplyTime = GetTimeInMillis () + FontServerRequestTimeout;
2539	_fs_mark_block (conn, FS_PENDING_REPLY0x08);
2540	break;
2541	}
2542
2543	return err;
2544	}
2545
2546	/*
2547	* Called when client exits
2548	*/
2549
2550	static void
2551	fs_client_died(pointer client, FontPathElementPtr fpe)
2552	{
2553	FSFpePtr conn = (FSFpePtr) fpe->private;
2554	FSBlockDataPtr blockrec,
2555	depending;
2556	FSClientPtr *prev, cur;
2557	fsFreeACReq freeac;
2558
2559	for (prev = &conn->clients; (cur = *prev); prev = &cur->next)
2560	{
2561	if (cur->client == client) {
2562	freeac.reqType = FS_FreeAC9;
2563	freeac.pad = 0;
2564	freeac.id = cur->acid;
2565	freeac.length = sizeof (fsFreeACReq) >> 2;
2566	_fs_add_req_log(conn, FS_FreeAC)((conn)->current_seq++);
2567	_fs_write (conn, (char *) &freeac, sizeof (fsFreeACReq));
2568	*prev = cur->next;
2569	free (cur);
2570	break;
2571	}
2572	}
2573	/* find a pending requests */
2574	for (blockrec = conn->blockedRequests; blockrec; blockrec = blockrec->next)
2575	if (blockrec->client == client)
2576	break;
2577
2578	if (!blockrec)
2579	return;
2580
2581	/* replace the client pointers in this block rec with the chained one */
2582	if ((depending = blockrec->depending))
2583	{
2584	blockrec->client = depending->client;
2585	blockrec->depending = depending->depending;
2586	blockrec = depending;
2587	}
2588	fs_abort_blockrec(conn, blockrec);
2589	}
2590
2591	static void
2592	_fs_client_access (FSFpePtr conn, pointer client, Bool sync)
2593	{
2594	FSClientPtr *prev, cur;
2595	fsCreateACReq crac;
2596	fsSetAuthorizationReq setac;
2597	char *authorizations;
2598	int authlen;
2599	Bool new_cur = FALSE0;
2600	char padding[4] = { 0, 0, 0, 0 };
2601
2602	#ifdef DEBUG
2603	if (conn->blockState & (FS_RECONNECTING0x40\|FS_BROKEN_CONNECTION0x04))
2604	{
2605	fprintf (stderrstderr, "Sending requests without a connection\n");
2606	}
2607	#endif
2608	for (prev = &conn->clients; (cur = *prev); prev = &cur->next)
2609	{
2610	if (cur->client == client)
2611	{
2612	if (prev != &conn->clients)
2613	{
2614	*prev = cur->next;
2615	cur->next = conn->clients;
2616	conn->clients = cur;
2617	}
2618	break;
2619	}
2620	}
2621	if (!cur)
2622	{
2623	cur = malloc (sizeof (FSClientRec));
2624	if (!cur)
2625	return;
2626	cur->client = client;
2627	cur->next = conn->clients;
2628	conn->clients = cur;
2629	cur->acid = GetNewFontClientID ();
2630	new_cur = TRUE1;
2631	}
2632	if (new_cur \|\| cur->auth_generation != client_auth_generation(client))
2633	{
2634	if (!new_cur)
2635	{
2636	fsFreeACReq freeac;
2637	freeac.reqType = FS_FreeAC9;
2638	freeac.pad = 0;
2639	freeac.id = cur->acid;
2640	freeac.length = sizeof (fsFreeACReq) >> 2;
2641	_fs_add_req_log(conn, FS_FreeAC)((conn)->current_seq++);
2642	_fs_write (conn, (char *) &freeac, sizeof (fsFreeACReq));
2643	}
2644	crac.reqType = FS_CreateAC8;
2645	crac.num_auths = set_font_authorizations(&authorizations, &authlen,
2646	client);
2647	/* Work around bug in xfs versions up through modular release 1.0.8
2648	which rejects CreateAC packets with num_auths = 0 & authlen < 4 */
2649	if (crac.num_auths == 0) {
2650	authorizations = padding;
2651	authlen = 4;
2652	} else {
2653	authlen = (authlen + 3) & ~0x3;
2654	}
2655	crac.length = (sizeof (fsCreateACReq) + authlen) >> 2;
2656	crac.acid = cur->acid;
2657	_fs_add_req_log(conn, FS_CreateAC)((conn)->current_seq++);
2658	_fs_write(conn, (char *) &crac, sizeof (fsCreateACReq));
2659	_fs_write(conn, authorizations, authlen);
2660	/* ignore reply; we don't even care about it */
2661	conn->curacid = 0;
2662	cur->auth_generation = client_auth_generation(client);
2663	}
2664	if (conn->curacid != cur->acid)
2665	{
2666	setac.reqType = FS_SetAuthorization10;
2667	setac.pad = 0;
2668	setac.length = sizeof (fsSetAuthorizationReq) >> 2;
2669	setac.id = cur->acid;
2670	_fs_add_req_log(conn, FS_SetAuthorization)((conn)->current_seq++);
2671	_fs_write(conn, (char *) &setac, sizeof (fsSetAuthorizationReq));
2672	conn->curacid = cur->acid;
2673	}
2674	}
2675
2676	/*
2677	* Poll a pending connect
2678	*/
2679
2680	static int
2681	_fs_check_connect (FSFpePtr conn)
2682	{
2683	int ret;
2684
2685	ret = _fs_poll_connect (conn->trans_conn, 0);
2686	switch (ret) {
2687	case FSIO_READY1:
2688	conn->fs_fd = _FontTransGetConnectionNumber (conn->trans_conn);
2689	FD_SET (conn->fs_fd, &_fs_fd_mask)((void) (((&_fs_fd_mask)->fds_bits)[((conn->fs_fd) / (8 * (int) sizeof (__fd_mask)))] \|= ((__fd_mask) 1 << ( (conn->fs_fd) % (8 * (int) sizeof (__fd_mask))))));
2690	break;
2691	case FSIO_BLOCK0:
2692	break;
2693	}
2694	return ret;
2695	}
2696
2697	/*
2698	* Return an FSIO status while waiting for the completed connection
2699	* reply to arrive
2700	*/
2701
2702	static fsConnSetup *
2703	_fs_get_conn_setup (FSFpePtr conn, int error, int setup_len)
2704	{
2705	int ret;
2706	char *data;
2707	int headlen;
2708	int len;
2709	fsConnSetup *setup;
2710	fsConnSetupAccept *accept;
2711
2712	ret = _fs_start_read (conn, SIZEOF (fsConnSetup)12, &data);
2713	if (ret != FSIO_READY1)
2714	{
2715	*error = ret;
2716	return 0;
2717	}
2718
2719	setup = (fsConnSetup *) data;
2720	if (setup->major_version > FS_PROTOCOL2)
2721	{
2722	*error = FSIO_ERROR-1;
2723	return 0;
2724	}
2725
2726	headlen = (SIZEOF (fsConnSetup)12 +
2727	(setup->alternate_len << 2) +
2728	(setup->auth_len << 2));
2729	/* On anything but Success, no extra data is sent */
2730	if (setup->status != AuthSuccess0)
2731	{
2732	len = headlen;
2733	}
2734	else
2735	{
2736	ret = _fs_start_read (conn, headlen + SIZEOF (fsConnSetupAccept)12, &data);
2737	if (ret != FSIO_READY1)
2738	{
2739	*error = ret;
2740	return 0;
2741	}
2742	setup = (fsConnSetup *) data;
2743	accept = (fsConnSetupAccept *) (data + headlen);
2744	len = headlen + (accept->length << 2);
2745	}
2746	ret = _fs_start_read (conn, len, &data);
2747	if (ret != FSIO_READY1)
2748	{
2749	*error = ret;
2750	return 0;
2751	}
2752	*setup_len = len;
2753	return (fsConnSetup *) data;
2754	}
2755
2756	static int
2757	_fs_send_conn_client_prefix (FSFpePtr conn)
2758	{
2759	fsConnClientPrefix req;
2760	int endian;
2761	int ret;
2762
2763	/* send setup prefix */
2764	endian = 1;
2765	if ((char ) &endian)
2766	req.byteOrder = 'l';
2767	else
2768	req.byteOrder = 'B';
2769
2770	req.major_version = FS_PROTOCOL2;
2771	req.minor_version = FS_PROTOCOL_MINOR0;
2772
2773	/* XXX add some auth info here */
2774	req.num_auths = 0;
2775	req.auth_len = 0;
2776	ret = _fs_write (conn, (char *) &req, SIZEOF (fsConnClientPrefix)8);
2777	if (ret != FSIO_READY1)
2778	return FSIO_ERROR-1;
2779	conn->blockedConnectTime = GetTimeInMillis () + FontServerRequestTimeout;
2780	return ret;
2781	}
2782
2783	static int
2784	_fs_recv_conn_setup (FSFpePtr conn)
2785	{
2786	int ret = FSIO_ERROR-1;
2787	fsConnSetup *setup;
2788	FSFpeAltPtr alts;
2789	int i, alt_len;
2790	int setup_len;
2791	char alt_save, alt_names;
2792
2793	setup = _fs_get_conn_setup (conn, &ret, &setup_len);
2794	if (!setup)
2795	return ret;
2796	conn->current_seq = 0;
2797	conn->fsMajorVersion = setup->major_version;
2798	/*
2799	* Create an alternate list from the initial server, but
2800	* don't chain looking for alternates.
2801	*/
2802	if (conn->alternate == 0)
2803	{
2804	/*
2805	* free any existing alternates list, allowing the list to
2806	* be updated
2807	*/
2808	if (conn->alts)
2809	{
2810	free (conn->alts);
2811	conn->alts = 0;
2812	conn->numAlts = 0;
2813	}
2814	if (setup->num_alternates)
2815	{
2816	alts = malloc (setup->num_alternates * sizeof (FSFpeAltRec) +
2817	(setup->alternate_len << 2));
2818	if (alts)
2819	{
2820	alt_names = (char *) (setup + 1);
2821	alt_save = (char *) (alts + setup->num_alternates);
2822	for (i = 0; i < setup->num_alternates; i++)
2823	{
2824	alts[i].subset = alt_names[0];
2825	alt_len = alt_names[1];
2826	alts[i].name = alt_save;
2827	memcpy (alt_save, alt_names + 2, alt_len);
2828	alt_save[alt_len] = '\0';
2829	alt_save += alt_len + 1;
2830	alt_names += _fs_pad_length (alt_len + 2);
2831	}
2832	conn->numAlts = setup->num_alternates;
2833	conn->alts = alts;
2834	}
2835	}
2836	}
2837	_fs_done_read (conn, setup_len);
2838	if (setup->status != AuthSuccess0)
2839	return FSIO_ERROR-1;
2840	return FSIO_READY1;
2841	}
2842
2843	static int
2844	_fs_open_server (FSFpePtr conn)
2845	{
2846	int ret;
2847	char *servername;
2848
2849	if (conn->alternate == 0)
2850	servername = conn->servername;
2851	else
2852	servername = conn->alts[conn->alternate-1].name;
2853	conn->trans_conn = _fs_connect (servername, &ret);
2854	conn->blockedConnectTime = GetTimeInMillis () + FS_RECONNECT_WAIT5000;
2855	return ret;
2856	}
2857
2858	static char *
2859	_fs_catalog_name (char *servername)
2860	{
2861	char *sp;
2862
2863	sp = strchr (servername, '/');
2864	if (!sp)
2865	return 0;
2866	return strrchr (sp + 1, '/');
2867	}
2868
2869	static int
2870	_fs_send_init_packets (FSFpePtr conn)
2871	{
2872	fsSetResolutionReq srreq;
2873	fsSetCataloguesReq screq;
2874	int num_cats,
2875	clen;
2876	char *catalogues;
2877	char *cat;
2878	char len;
2879	char *end;
2880	int num_res;
2881	FontResolutionPtr res;
2882
2883	#define CATALOGUE_SEP'+' '+'
2884
2885	res = GetClientResolutions(&num_res);
2886	if (num_res)
2887	{
2888	srreq.reqType = FS_SetResolution11;
2889	srreq.num_resolutions = num_res;
2890	srreq.length = (SIZEOF(fsSetResolutionReq)4 +
2891	(num_res * SIZEOF(fsResolution)6) + 3) >> 2;
2892
2893	_fs_add_req_log(conn, FS_SetResolution)((conn)->current_seq++);
2894	if (_fs_write(conn, (char *) &srreq, SIZEOF(fsSetResolutionReq)4) != FSIO_READY1)
2895	return FSIO_ERROR-1;
2896	if (_fs_write_pad(conn, (char ) res, (num_res SIZEOF(fsResolution)6)) != FSIO_READY1)
2897	return FSIO_ERROR-1;
2898	}
2899
2900	catalogues = 0;
2901	if (conn->alternate != 0)
2902	catalogues = _fs_catalog_name (conn->alts[conn->alternate-1].name);
2903	if (!catalogues)
2904	catalogues = _fs_catalog_name (conn->servername);
2905
2906	if (!catalogues)
2907	{
2908	conn->has_catalogues = FALSE0;
2909	return FSIO_READY1;
2910	}
2911	conn->has_catalogues = TRUE1;
2912
2913	/* turn cats into counted list */
2914	catalogues++;
2915
2916	cat = catalogues;
2917	num_cats = 0;
2918	clen = 0;
2919	while (*cat)
2920	{
2921	num_cats++;
2922	end = strchr(cat, CATALOGUE_SEP'+');
2923	if (!end)
2924	end = cat + strlen (cat);
2925	clen += (end - cat) + 1; /* length byte + string */
2926	cat = end;
2927	}
2928
2929	screq.reqType = FS_SetCatalogues4;
2930	screq.num_catalogues = num_cats;
2931	screq.length = (SIZEOF(fsSetCataloguesReq)4 + clen + 3) >> 2;
2932
2933	_fs_add_req_log(conn, FS_SetCatalogues)((conn)->current_seq++);
2934	if (_fs_write(conn, (char *) &screq, SIZEOF(fsSetCataloguesReq)4) != FSIO_READY1)
2935	return FSIO_ERROR-1;
2936
2937	while (*cat)
2938	{
2939	num_cats++;
2940	end = strchr(cat, CATALOGUE_SEP'+');
2941	if (!end)
2942	end = cat + strlen (cat);
2943	len = end - cat;
2944	if (_fs_write (conn, &len, 1) != FSIO_READY1)
2945	return FSIO_ERROR-1;
2946	if (_fs_write (conn, cat, (int) len) != FSIO_READY1)
2947	return FSIO_ERROR-1;
2948	cat = end;
2949	}
2950
2951	if (_fs_write (conn, "....", _fs_pad_length (clen) - clen) != FSIO_READY1)
2952	return FSIO_ERROR-1;
2953
2954	return FSIO_READY1;
2955	}
2956
2957	static int
2958	_fs_send_cat_sync (FSFpePtr conn)
2959	{
2960	fsListCataloguesReq lcreq;
2961
2962	/*
2963	* now sync up with the font server, to see if an error was generated
2964	* by a bogus catalogue
2965	*/
2966	lcreq.reqType = FS_ListCatalogues3;
2967	lcreq.length = (SIZEOF(fsListCataloguesReq)12) >> 2;
2968	lcreq.maxNames = 0;
2969	lcreq.nbytes = 0;
2970	lcreq.pad2 = 0;
2971	_fs_add_req_log(conn, FS_SetCatalogues)((conn)->current_seq++);
2972	if (_fs_write(conn, (char *) &lcreq, SIZEOF(fsListCataloguesReq)12) != FSIO_READY1)
2973	return FSIO_ERROR-1;
2974	conn->blockedConnectTime = GetTimeInMillis () + FontServerRequestTimeout;
2975	return FSIO_READY1;
2976	}
2977
2978	static int
2979	_fs_recv_cat_sync (FSFpePtr conn)
2980	{
2981	fsGenericReply *reply;
2982	fsError *error;
2983	int err;
2984	int ret;
2985
2986	reply = fs_get_reply (conn, &err);
2987	if (!reply)
2988	return err;
2989
2990	ret = FSIO_READY1;
2991	if (reply->type == FS_Error1)
2992	{
2993	error = (fsError *) reply;
2994	if (error->major_opcode == FS_SetCatalogues4)
2995	ret = FSIO_ERROR-1;
2996	}
2997	_fs_done_read (conn, reply->length << 2);
2998	return ret;
2999	}
3000
3001	static void
3002	_fs_close_server (FSFpePtr conn)
3003	{
3004	_fs_unmark_block (conn, FS_PENDING_WRITE0x01\|FS_BROKEN_WRITE0x02\|FS_COMPLETE_REPLY0x20\|FS_BROKEN_CONNECTION0x04);
3005	if (conn->trans_conn)
3006	{
3007	_FontTransClose (conn->trans_conn);
3008	conn->trans_conn = 0;
3009	_fs_io_reinit (conn);
3010	}
3011	if (conn->fs_fd >= 0)
3012	{
3013	FD_CLR (conn->fs_fd, &_fs_fd_mask)((void) (((&_fs_fd_mask)->fds_bits)[((conn->fs_fd) / (8 * (int) sizeof (__fd_mask)))] &= ~((__fd_mask) 1 << ((conn->fs_fd) % (8 * (int) sizeof (__fd_mask))))));
3014	conn->fs_fd = -1;
3015	}
3016	conn->fs_conn_state = FS_CONN_UNCONNECTED0;
3017	}
3018
3019	static int
3020	_fs_do_setup_connection (FSFpePtr conn)
3021	{
3022	int ret;
3023
3024	do
3025	{
3026	#ifdef DEBUG
3027	fprintf (stderrstderr, "fs_do_setup_connection state %d\n", conn->fs_conn_state);
3028	#endif
3029	switch (conn->fs_conn_state) {
3030	case FS_CONN_UNCONNECTED0:
3031	ret = _fs_open_server (conn);
3032	if (ret == FSIO_BLOCK0)
3033	conn->fs_conn_state = FS_CONN_CONNECTING1;
3034	break;
3035	case FS_CONN_CONNECTING1:
3036	ret = _fs_check_connect (conn);
3037	break;
3038	case FS_CONN_CONNECTED2:
3039	ret = _fs_send_conn_client_prefix (conn);
3040	break;
3041	case FS_CONN_SENT_PREFIX3:
3042	ret = _fs_recv_conn_setup (conn);
3043	break;
3044	case FS_CONN_RECV_INIT4:
3045	ret = _fs_send_init_packets (conn);
3046	if (conn->has_catalogues)
3047	ret = _fs_send_cat_sync (conn);
3048	break;
3049	case FS_CONN_SENT_CAT5:
3050	if (conn->has_catalogues)
3051	ret = _fs_recv_cat_sync (conn);
3052	else
3053	ret = FSIO_READY1;
3054	break;
3055	default:
3056	ret = FSIO_READY1;
3057	break;
3058	}
3059	switch (ret) {
3060	case FSIO_READY1:
3061	if (conn->fs_conn_state < FS_CONN_RUNNING6)
3062	conn->fs_conn_state++;
3063	break;
3064	case FSIO_BLOCK0:
3065	if (TimeCmp (GetTimeInMillis (), <, conn->blockedConnectTime)((int) ((GetTimeInMillis ()) - (conn->blockedConnectTime)) < 0))
3066	break;
3067	ret = FSIO_ERROR-1;
3068	/* fall through... */
3069	case FSIO_ERROR-1:
3070	_fs_close_server (conn);
3071	/*
3072	* Try the next alternate
3073	*/
3074	if (conn->alternate < conn->numAlts)
3075	{
3076	conn->alternate++;
3077	ret = FSIO_READY1;
3078	}
3079	else
3080	conn->alternate = 0;
3081	break;
3082	}
3083	} while (conn->fs_conn_state != FS_CONN_RUNNING6 && ret == FSIO_READY1);
3084	if (ret == FSIO_READY1)
3085	conn->generation = ++generationCount;
3086	return ret;
3087	}
3088
3089	static int
3090	_fs_wait_connect (FSFpePtr conn)
3091	{
3092	int ret;
3093
3094	for (;;)
3095	{
3096	ret = _fs_do_setup_connection (conn);
3097	if (ret != FSIO_BLOCK0)
3098	break;
3099	if (conn->fs_conn_state <= FS_CONN_CONNECTING1)
3100	ret = _fs_poll_connect (conn->trans_conn, 1000);
3101	else
3102	ret = _fs_wait_for_readable (conn, 1000);
3103	if (ret == FSIO_ERROR-1)
3104	break;
3105	}
3106	return ret;
3107	}
3108
3109	/*
3110	* Poll a connection in the process of reconnecting
3111	*/
3112	static void
3113	_fs_check_reconnect (FSFpePtr conn)
3114	{
3115	int ret;
3116
3117	ret = _fs_do_setup_connection (conn);
3118	switch (ret) {
3119	case FSIO_READY1:
3120	_fs_unmark_block (conn, FS_RECONNECTING0x40\|FS_GIVE_UP0x10);
3121	_fs_restart_connection (conn);
3122	break;
3123	case FSIO_BLOCK0:
3124	break;
3125	case FSIO_ERROR-1:
3126	conn->brokenConnectionTime = GetTimeInMillis () + FS_RECONNECT_POLL1000;
3127	break;
3128	}
3129	}
3130
3131	/*
3132	* Start the reconnection process
3133	*/
3134	static void
3135	_fs_start_reconnect (FSFpePtr conn)
3136	{
3137	if (conn->blockState & FS_RECONNECTING0x40)
3138	return;
3139	conn->alternate = 0;
3140	_fs_mark_block (conn, FS_RECONNECTING0x40);
3141	_fs_unmark_block (conn, FS_BROKEN_CONNECTION0x04);
3142	_fs_check_reconnect (conn);
3143	}
3144
3145
3146	static FSFpePtr
3147	_fs_init_conn (char *servername)
3148	{
3149	FSFpePtr conn;
3150
3151	conn = calloc (1, sizeof (FSFpeRec) + strlen (servername) + 1);
3152	if (!conn)
3153	return 0;
3154	if (!_fs_io_init (conn))
3155	{
3156	free (conn);
3157	return 0;
3158	}
3159	conn->servername = (char *) (conn + 1);
3160	conn->fs_conn_state = FS_CONN_UNCONNECTED0;
3161	conn->fs_fd = -1;
3162	strcpy (conn->servername, servername);
3163	return conn;
3164	}
3165
3166	static void
3167	_fs_free_conn (FSFpePtr conn)
3168	{
3169	_fs_close_server (conn);
3170	_fs_io_fini (conn);
3171	if (conn->alts)
3172	free (conn->alts);
3173	free (conn);
3174	}
3175
3176	/*
3177	* called at server init time
3178	*/
3179
3180	void
3181	fs_register_fpe_functions(void)
3182	{
3183	RegisterFPEFunctions(fs_name_check,
3184	fs_init_fpe,
3185	fs_free_fpe,
3186	fs_reset_fpe,
3187	fs_open_font,
3188	fs_close_font,
3189	fs_list_fonts,
3190	fs_start_list_with_info,
3191	fs_next_list_with_info,
3192	fs_wakeup,
3193	fs_client_died,
3194	_fs_load_glyphs,
3195	NULL((void*)0),
3196	NULL((void*)0),
3197	NULL((void*)0));
3198	}