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