1499 lines
41 KiB
Plaintext
1499 lines
41 KiB
Plaintext
.\" $Xorg: design.ms,v 1.3 2000/08/17 19:42:51 cpqbld Exp $
|
|
.\" roff -ms
|
|
.de Ip
|
|
.IP \(bu 3
|
|
..
|
|
.de Qp
|
|
.nr PS -2
|
|
.nr VS -2
|
|
.QP
|
|
..
|
|
.\" These macros should select a typewriter font if you have one.
|
|
.de LS
|
|
.KS
|
|
.LD
|
|
.ft CB
|
|
.ta .6i 1.2i 1.8i 2.4i 3i 3.6i 4.2i
|
|
..
|
|
.de LE
|
|
.ft P
|
|
.DE
|
|
.KE
|
|
..
|
|
.de Ls
|
|
.nr PS -2
|
|
.nr VS -3
|
|
.sp
|
|
.LS
|
|
..
|
|
.de Le
|
|
.LE
|
|
.nr PS +2
|
|
.nr VS +3
|
|
.LP
|
|
..
|
|
.TL
|
|
Font server implementation overview
|
|
.AU
|
|
Dave Lemke
|
|
.AI
|
|
Network Computing Devices, Inc.
|
|
Copyright \(co 1991 Network Computing Devices, Inc.
|
|
.NH
|
|
Introduction
|
|
.PP
|
|
The font server uses the same client/server model as X. The basic structure
|
|
is that of the X Consortium X11R5 X server, and those
|
|
who know that code should find the
|
|
.I os
|
|
and
|
|
.I difs
|
|
(device independent font server) layers familiar.
|
|
.nf
|
|
.Ls
|
|
|
|
+-----------------+
|
|
+-----| difs |------+
|
|
| +-----------------+ |
|
|
| |
|
|
+----+ +------------+
|
|
| os | | renderers |
|
|
+----+ +------------+
|
|
.Le
|
|
.fi
|
|
\fBDefinitions\fR
|
|
.Ip
|
|
Renderer. Code that knows how to take font data in its raw format and
|
|
convert it to the font server's format.
|
|
.Ip
|
|
Font Path Element (FPE). An instance of a renderer, associated with a
|
|
specific font source, (ie a directory of PCF bitmaps).
|
|
.PP
|
|
The
|
|
.I difs
|
|
layer interprets the requests, and handles the renderer
|
|
independent work. This includes error checking of requests, and the
|
|
top level font database. It also contains various utility functionality
|
|
such as caching and byte swapping.
|
|
.PP
|
|
The
|
|
.I os
|
|
layer sets up the communications channel, reads requests and
|
|
sends the raw data of replies and events. It also handles font server
|
|
configuration issues, controlled by command line arguments and
|
|
a configuration file.
|
|
.PP
|
|
The renderer layer contains all font-specific code,
|
|
and is responsible for rendering a font (which may mean
|
|
just reading a bitmap from disk, or may include scaling of outline
|
|
data), computing a fonts properties and header information.
|
|
.NH
|
|
Startup
|
|
.PP
|
|
At startup, the font server handles any command line arguments,
|
|
initializes any OS-specific data, and then sets up the communications.
|
|
Various internal databases are then initialized (extensions, the font
|
|
catalogue, etc).
|
|
.PP
|
|
The config file, an ordered list of font sources, cache size hints,
|
|
default resolutions, and security information, is then read in. Each
|
|
of these source names could be a directory name, the name of another
|
|
font server, or some other string that a particular renderer can
|
|
recognize.
|
|
.PP
|
|
The default font catalogue is then built up by taking each of the font
|
|
source names and comparing it with the names a renderer recognizes.
|
|
The one that matches this name will become attached to this
|
|
source. A renderer will ``understand'' a name if it can parse the data
|
|
in that directory, or recognize that it is a valid font server address,
|
|
or recognizes a special string. Thus a collection of valid font path
|
|
elements is built up. Each
|
|
.B FPE
|
|
has a set of functions to support opening a font and accessing its
|
|
data.
|
|
.PP
|
|
Font information is accessed via method functions in the
|
|
.B Font.
|
|
When a font is
|
|
first loaded, the header information and properties are
|
|
loaded/computed. The font also initializes its function pointers to do
|
|
the proper work. When specific metrics or bitmaps are required, they
|
|
are access via the font's functions. A disk-based bitmap font will
|
|
probably want to load all data when first accessed. A scaled font or
|
|
FS font may want to do more selective caching. In both cases, the
|
|
renderer can use the utility functions to keep track of this data.
|
|
Changing values of bitmap formats could result in the font having
|
|
multiple copies of data in different formats, which the renderer may
|
|
use the utility functions to manage.
|
|
.NH
|
|
Per client processing
|
|
.PP
|
|
Each entity attaching to the server is a client. Each client has
|
|
its own authorization and resolution information, and its own view
|
|
of the font database. A font open to one client may not be open to
|
|
another, though the font server may have it loaded.
|
|
.PP
|
|
After initialization, new clients can attach to the font server and
|
|
have their requests processed. For each request that is searching for
|
|
a font
|
|
.B (OpenBitmapFont)
|
|
or listing font names
|
|
.B (ListFonts,
|
|
.B ListFontsWithXInfo),
|
|
the pattern is given to each
|
|
.B FPE.
|
|
.PP
|
|
.B OpenBitmapFont
|
|
will take the supplied name and pass it to each
|
|
.B FPE.
|
|
The
|
|
.B FPE
|
|
will return one of three things:
|
|
.I Success,
|
|
and the font object;
|
|
.I BadFont,
|
|
because it doesn't know the font; or
|
|
.I BadFont
|
|
and an alias
|
|
name, when it has an alias for the font. If
|
|
.I Success
|
|
is returned, the
|
|
server goes on to create an ID (or find an existing one) and return a
|
|
reply. If
|
|
.I BadFont
|
|
is returned, it goes on to the next
|
|
.B FPE.
|
|
If it
|
|
reaches the end without finding a font, an error is returned to the
|
|
client. If an alias is returned, the search resets to the first
|
|
.B FPE
|
|
and starts again, using the alias as the new font name. This allows
|
|
aliases to work across different
|
|
.B FPEs,
|
|
without any ordering
|
|
restrictions.
|
|
.PP
|
|
When each
|
|
.B FPE
|
|
receives a font name to open, it searches for the font's
|
|
existence. If it can't find, or can only find an alias, it returns
|
|
.I BadFont
|
|
and any alias. If it finds the font, it checks the
|
|
authorization and license status of the font to that of the client. If
|
|
it passes, it then creates a new font object, and reads and/or computes
|
|
at least the font's header information and properties. (It may also
|
|
want to produce the bitmaps and extents, but that choice is left to the
|
|
renderer.)
|
|
.PP
|
|
When a font's information is accessed, the interpreter routine looks up
|
|
the font ID to find the font object, and then uses the font's access
|
|
functions to get the data. These functions will return the data in
|
|
the format expected by the client.
|
|
|
|
.NH
|
|
Client shutdown
|
|
.PP
|
|
When a client disconnects, all its references to any fonts it
|
|
still has opened are removed. If no other clients reference these fonts, they
|
|
may be freed, though the server may choose to cache them.
|
|
|
|
.NH
|
|
Server reset and cleanup
|
|
.PP
|
|
A server may be reset to flush the caches, re-read the configuration file,
|
|
and a new list of
|
|
.B FPEs
|
|
to be built, via an OS-specific outside
|
|
action. In UNIX, this will be handled via signals; in VMS it could be
|
|
handled via an async trap or event flag.
|
|
|
|
.NH
|
|
Server offloading
|
|
.PP
|
|
In order to deal with numerous clients without major performance
|
|
degradation, the server must be able to clone itself, or provide the
|
|
client with a substitute server via the alternate server mechanism.
|
|
Since both strategies have their uses, both will be supported. For a
|
|
server that has plenty of host memory or CPU, but insufficient sockets,
|
|
cloning may be a good choice. For a host with limited memory,
|
|
assigning an alternate server on a different host may be a good
|
|
choice. The server will make this decision based on configuration
|
|
options.
|
|
|
|
.NH
|
|
Font server data structures
|
|
.LP
|
|
.IP
|
|
The
|
|
.B Client
|
|
handles per-client information and interpreter status.
|
|
.Ls
|
|
typedef struct _Client {
|
|
int index;
|
|
pointer osPrivate;
|
|
int noClientException;
|
|
int (**requestVector) ();
|
|
pointer requestBuffer;
|
|
int clientGone;
|
|
int sequence;
|
|
Bool swapped;
|
|
long last_request_time;
|
|
void (*pSwapReplyFunc) ();
|
|
AuthContextPtr auth;
|
|
char *catalogues;
|
|
int num_catalogues;
|
|
Mask eventmask;
|
|
fsResolution *resolutions;
|
|
int num_resolutions;
|
|
} ClientRec, *ClientPtr;
|
|
.Le
|
|
.IP
|
|
The
|
|
.B Font
|
|
contains basic font information, including header information and properties.
|
|
.Ls
|
|
typedef struct _font {
|
|
int refcount;
|
|
fsHeader header;
|
|
fsBitmapFormat format;
|
|
int (*get_glyphs)();
|
|
int (*get_metrics)();
|
|
int (*get_extents)();
|
|
int (*get_bitmaps)();
|
|
int (*unload_font)();
|
|
FontPathElementPtr fpe;
|
|
int *client_ids;
|
|
Bool restricted_font;
|
|
} FontRec *FontPtr;
|
|
.Le
|
|
.IP
|
|
The
|
|
.B ClientFont
|
|
is a wrapper on top of
|
|
.B Font,
|
|
handling client specific font information.
|
|
.Ls
|
|
typedef struct _clientfont {
|
|
FontPtr font;
|
|
int clientindex;
|
|
} ClientFontRec, *ClientFontRec;
|
|
.Le
|
|
.IP
|
|
The
|
|
.B AuthContext
|
|
contains authorization information.
|
|
.IP
|
|
.Ls
|
|
typedef struct _authcontext {
|
|
char *authname;
|
|
char *authdata;
|
|
FSID acid;
|
|
} AuthContextRec *AuthContextPtr;
|
|
.Le
|
|
|
|
.NH
|
|
Font Path Element functions
|
|
.PP
|
|
These functions are associated with each renderer, and handle
|
|
all aspects of font access. Font data access is controlled via
|
|
another set of functions described later. These functions are
|
|
intended to support the R5 X server as well as the font server.
|
|
As a result, some design decisions were made to support both
|
|
models. When the
|
|
.I difs
|
|
layer needs to access a font, it uses these functions.
|
|
.IP
|
|
.Ls
|
|
typedef unsigned long Mask;
|
|
.sp
|
|
typedef unsigned char *pointer;
|
|
.sp
|
|
typedef struct _FontPathElement {
|
|
int name_length;
|
|
char *name;
|
|
int type;
|
|
int refcount;
|
|
pointer private;
|
|
} FontPathElementRec, *FontPathElementPtr;
|
|
.Le
|
|
.PP
|
|
The FPE's reference count is incremented when it is added to the
|
|
current list of FPEs and when it opens a font. It is decremented
|
|
when it is no longer in the current list and when it closes a font.
|
|
All reference changes are handled by the
|
|
.I difs
|
|
layer. The count is required to support font catalogue changes
|
|
that may occur while the fontserver has fonts open, and keeps FPEs
|
|
from being lost.
|
|
.IP
|
|
.Ls
|
|
.sp
|
|
typedef struct FontNames {
|
|
int nnames;
|
|
int size;
|
|
int *length;
|
|
char **names;
|
|
} FontNamesRec, *FontNamesPtr;
|
|
.sp
|
|
typedef struct {
|
|
Bool (*name_check)();
|
|
int (*init_fpe)();
|
|
int (*reset_fpe)();
|
|
int (*free_fpe)();
|
|
int (*open_font)();
|
|
int (*close_font)();
|
|
int (*list_fonts)();
|
|
int (*start_list_fonts_with_info)();
|
|
int (*list_next_font_with_info)();
|
|
int (*wakeup_fpe)();
|
|
int (*client_died);
|
|
FontNamesPtr renderer_names;
|
|
} FPEFunctions;
|
|
.sp
|
|
int init_fpe_type(Bool (name_func)(),
|
|
int (init_func)(), int (free_func)(), int (reset_func),
|
|
int (open_func)(), int (close_func)(),
|
|
int (list_func)(),
|
|
int (start_lfwi_func)(), int (next_lfwi_func)(),
|
|
int (wakeup_func)(),
|
|
int (client_died_func)()
|
|
)
|
|
.Le
|
|
.sp
|
|
.LP
|
|
This is called by the renderer when it is initialized at the beginning
|
|
of time, and sets up
|
|
an FPEFunctions entry for the renderer.
|
|
.LP
|
|
The
|
|
.B FPEFunctions
|
|
have the following parameters:
|
|
.IP
|
|
.Ls
|
|
Bool name_check(char *name);
|
|
.Le
|
|
.LP
|
|
If
|
|
.I name
|
|
is something the renderer recognizes as a valid font
|
|
source name, it return True, otherwise False. ie, if
|
|
.I name
|
|
is a directory name, or is prefixed by the renderer's prefix, and the
|
|
directory contains font data the renderer can interpret, it would return
|
|
True.
|
|
.IP
|
|
.Ls
|
|
int init_fpe(FontPathElementPtr fpe);
|
|
.Le
|
|
.LP
|
|
Does any initialization work for the renderer. The name in
|
|
.I fpe
|
|
will be one whose prefix matches the list returned when the renderer
|
|
was initialized.
|
|
.IP
|
|
.Ls
|
|
int reset_fpe(FontPathElementPtr fpe);
|
|
.Le
|
|
.LP
|
|
Tells
|
|
.I fpe
|
|
to reset any internal state about what fonts it has available.
|
|
This will typically be called because the font server's
|
|
.B FPE
|
|
search list has been changed. The
|
|
.I fpe
|
|
should reset any cached state of available fonts (ie, re-read
|
|
.I fonts.dir) when this function is called.
|
|
.IP
|
|
.Ls
|
|
int free_fpe(FontPathElementPtr fpe);
|
|
.Le
|
|
.LP
|
|
Frees any renderer-specific data and closes any files or sockets.
|
|
.IP
|
|
.Ls
|
|
int open_font(pointer client, FontPathElementPtr fpe, Mask flags,
|
|
char *fontname, int namelength,
|
|
fsBitmapFormat format_hint, fsBitmapFormatMask format_mask,
|
|
XID fontid, FontPtr *ppfont, char **alias);
|
|
.Le
|
|
.LP
|
|
Opens the font.
|
|
The bits marked by
|
|
.I format_mask in the
|
|
.I format_hint
|
|
are used where applicable.
|
|
The resulting FontPtr is returned in
|
|
.I ppfont.
|
|
The
|
|
.I client
|
|
is optional state
|
|
information for use with blocking renderers. If the
|
|
.I fontname
|
|
resolves to an alias, it is returned in
|
|
.I alias
|
|
with a
|
|
.I FontNameAlias
|
|
error. This tells the
|
|
calling code to start searching again, using
|
|
.I alias
|
|
as the font name.
|
|
The renderer is expected to fill in any information
|
|
specified by the
|
|
.I flags.
|
|
.IP
|
|
Possible flags values are:
|
|
.Ls
|
|
#define FontLoadInfo 0x0001 /* font header info */
|
|
#define FontLoadProps 0x0002 /* font properties */
|
|
#define FontLoadMetrics 0x0004 /* font extents */
|
|
#define FontLoadBitmaps 0x0008 /* glyph bitmaps */
|
|
#define FontLoadAll 0x000f
|
|
#define FontOpenSync 0x0010 /* force synchronous loading */
|
|
.Le
|
|
.LP
|
|
Once a font has been opened, the server may place it and the pattern
|
|
it matched into a name cache, to avoid lengthy searching if the font
|
|
is reopened. If the renderer does not wish the font to be in this
|
|
cache (for licensing reasons), it should set the font's
|
|
.I restricted_access
|
|
flag.
|
|
.IP
|
|
.Ls
|
|
int close_font(FontPtr pfont);
|
|
.Le
|
|
.LP
|
|
Frees up all the data associated with the font.
|
|
.IP
|
|
.Ls
|
|
int list_fonts(pointer client, FontPathElementPtr fpe,
|
|
char *pattern, int pattern_length, int maxnames,
|
|
FontNamesPtr *paths);
|
|
.Le
|
|
.LP
|
|
Returns in
|
|
.I paths
|
|
up to
|
|
.I maxnames
|
|
font names the fpe recognizes as matching the given pattern.
|
|
.IP
|
|
.Ls
|
|
int start_list_fonts_with_info(pointer client,
|
|
FontPathElementPtr fpe, char *pattern, int pattern_length,
|
|
int maxnames, pointer fpe_data);
|
|
.Le
|
|
.LP
|
|
Initiates a
|
|
.B ListFontsWithXInfo.
|
|
Typically, a disk-based renderer
|
|
will do the equivalent of ListFonts to gather all the font names
|
|
matching the pattern. A font server renderer will send the request.
|
|
.I fpe_data
|
|
provides a handle for any FPE-private data that needs
|
|
to be passed in later via
|
|
.B list_next_font_with_info(),
|
|
eg, the list of font names for a disk-based renderer.
|
|
.IP
|
|
.Ls
|
|
int list_next_font_with_info(pointer client, FontPathElementPtr fpe,
|
|
char **name, int *namelen, FontInfoPtr &pinfo,
|
|
int &num_fonts, pointer fpe_data);
|
|
.Le
|
|
.LP
|
|
Returns the next font's information. The renderer should keep any state
|
|
it requires in the
|
|
.I fpe_data
|
|
field.
|
|
.I num_fonts
|
|
contains the number
|
|
of replies remaining.
|
|
.LP
|
|
These two routines are split for because of the way both disk-based
|
|
renderers and font server renderers handle this request.
|
|
The first function initiates the action, the second is used to gather
|
|
the results. For a
|
|
disk-based renderer, a list of font names matching the pattern is first
|
|
built up when
|
|
.B start_list_fonts_with_info()
|
|
is called, and the results are gathered with each call to
|
|
.B list_next_font_with_info.
|
|
In a font server renderer, the first function sends the
|
|
.B ListFontsWithXInfo
|
|
request, and
|
|
the second processes the replies.
|
|
.IP
|
|
.Ls
|
|
int wakeup_fpe(FontPathElementPtr fpe, unsigned long *mask)
|
|
.Le
|
|
.LP
|
|
Optional function which can be used for blocking renderers. Typical
|
|
usage is for a font server renderer, where it is called when a reply is
|
|
received, allowing the data to be read and the client to be signaled
|
|
and unblocked.
|
|
.IP
|
|
.Ls
|
|
int client_died(pointer client, FontPathElementPtr fpe)
|
|
.Le
|
|
.LP
|
|
This function is called when a client dies in the middle of a blocked
|
|
request, allowing the renderer to clean up.
|
|
|
|
.NH
|
|
Font specific functions
|
|
.LP
|
|
These functions are contained in each
|
|
.B Font.
|
|
For many renderers, every font will
|
|
use the same functions, but some renderers may wish to use different interfaces
|
|
for different fonts.
|
|
.IP
|
|
.Ls
|
|
typedef struct {
|
|
INT16 left B16,
|
|
right B16;
|
|
INT16 width B16;
|
|
INT16 ascent B16,
|
|
descent B16;
|
|
CARD16 attributes B16;
|
|
} fsCharInfo;
|
|
|
|
typedef struct {
|
|
CARD8 low,
|
|
high;
|
|
} fsChar2b;
|
|
|
|
typedef struct {
|
|
fsChar2b min_char,
|
|
max_char;
|
|
} fsRange;
|
|
|
|
int get_extents(pointer client,
|
|
FontPtr pfont, Mask flags, int num_ranges, fsRange *ranges,
|
|
int *num_extents, fsCharInfo **extents);
|
|
.Le
|
|
.LP
|
|
Possible flags:
|
|
.IP
|
|
.Ls
|
|
LoadAll /* ignore the ranges and get everything */
|
|
FinishRange /* magic for range completion as specified by protocol */
|
|
.Le
|
|
.LP
|
|
Builds up the requested array of extents. The extent data (which
|
|
the renderer allocates) is returned, as well as the number of extents.
|
|
.I closure
|
|
contains any blocking state information.
|
|
.IP
|
|
.Ls
|
|
int get_bitmaps(pointer client,
|
|
FontPtr pfont, fsBitmapFormat format, Mask flags,
|
|
int num_ranges, fsRange *ranges,
|
|
unsigned long *size, unsigned long *num_glyphs,
|
|
unsigned long **offsets, pointer *glyph_data);
|
|
.Le
|
|
.LP
|
|
Possible flags:
|
|
.IP
|
|
.Ls
|
|
LoadAll
|
|
FinishRange /* magic for range completion as specified by protocol */
|
|
.Le
|
|
.LP
|
|
Builds up the requested array of bitmaps. The glyph and offset data
|
|
(which the renderer allocates) is returned, as well as the number of
|
|
glyphs. The
|
|
.I closure
|
|
contains any blocking state information. This function will build up the
|
|
bitmap data in the format specified by
|
|
.I format
|
|
so that the interpreter can return it without any additional
|
|
modification. This should minimize data massaging, since outline
|
|
renderers will hopefully be able to produce the bitmaps in the proper
|
|
format.
|
|
.IP
|
|
.Ls
|
|
void unload_font(FontPtr pfont)
|
|
.Le
|
|
.LP
|
|
The render will free any allocated data. Note that the
|
|
.B FPE
|
|
function
|
|
.B close_font()
|
|
will also be called, and should handle any
|
|
.B FPE
|
|
data allocated for the font.
|
|
.IP
|
|
.Ls
|
|
int get_glyphs()
|
|
int get_metrics()
|
|
.Le
|
|
.LP
|
|
These two functions are used by the X server for loading glyphs and
|
|
metrics. They expect the results in a considerably different
|
|
form. The
|
|
.I get_bitmaps()
|
|
and
|
|
.I get_extents()
|
|
routines both allow for better cache control by the renderer.
|
|
|
|
.NH
|
|
Font directories and aliases
|
|
.PP
|
|
Existing bitmap renderers already have their own concept of font
|
|
organization. In the X sample server, the files
|
|
.B fonts.dir
|
|
and
|
|
.B fonts.alias
|
|
are used to list the known fonts.
|
|
.B fonts.dir
|
|
maps file names to font names, while
|
|
.B fonts.alias
|
|
maps font names to other font names.
|
|
.PP
|
|
These concepts will also be needed by other forms of fonts
|
|
which the sample X server does not currently use, but the font server
|
|
will, like Bitstream outlines.
|
|
|
|
.NH
|
|
Handling scalable fonts
|
|
.PP
|
|
For those renderers that support scalable fonts, several issues
|
|
must be addressed:
|
|
.br
|
|
.Ip
|
|
Name Parsing. An XLFD name must be parsed to determine the requested
|
|
resolutions and/or sizes.
|
|
.Ip
|
|
Property scaling. Many of the standard font properties have values
|
|
that depend on scaling (eg,
|
|
.I RESOLUTION_X.
|
|
.I POINT_SIZE)
|
|
.Ip
|
|
Default values. If resolution information is wildcarded, the proper
|
|
default resolution should be supplied.
|
|
.LP
|
|
Name Parsing
|
|
.PP
|
|
The font name pattern supplied to
|
|
.B OpenBitmapFont
|
|
or
|
|
.B ListFonts
|
|
may require some parsing to be recognized as a scalable font known
|
|
to the renderer. The
|
|
.B PIXEL_SIZE,
|
|
.B POINT_SIZE,
|
|
.B RESOLUTION_X,
|
|
.B RESOLUTION_Y
|
|
and
|
|
.B AVERAGE_WIDTH
|
|
all need to determined from the font name pattern. The master font
|
|
must then be found, and scaled appropriately. Any unspecified values
|
|
that cannot be determined should be replaced by the proper defaults.
|
|
For size fields, this is whatever the configuration specifies. For
|
|
resolution fields, these should be taken from the client's resolution
|
|
list, if set, or from the server's configuration.
|
|
.LP
|
|
Property scaling
|
|
.PP
|
|
Part of scaling a font is scaling its properties. Many scalable fonts
|
|
will have a very large number of scalable properties. One way
|
|
to deal with these is for the ``master'' outline to keep track of the
|
|
property names, and supply new values for each instance of the font.
|
|
If the property names are stored as Atoms, memory usage is kept to
|
|
a minimum.
|
|
.LP
|
|
Using defaults
|
|
.PP
|
|
Using default values as substitutions for missing values was covered above.
|
|
These defaults will also be useful in handling
|
|
.B ListFonts
|
|
requests. Returning a scalable font with an instance using the
|
|
default values will provide the most user-friendly environment.
|
|
|
|
.NH
|
|
Access control
|
|
.PP
|
|
The font server will also support large grain security. It will have
|
|
both a limit of the number of users, and on the hosts which it will
|
|
support.
|
|
.PP
|
|
Limiting the number of users is as much a server loading issue as
|
|
a security issue. The limitation will be typically be set via
|
|
configuration options or OS limitations. To change it, use:
|
|
.IP
|
|
.Ls
|
|
void AccessSetConnectionLimit(int limit)
|
|
.Le
|
|
.LP
|
|
A
|
|
.I limit
|
|
of 0 will set it to a compiled constant based on OS resources
|
|
(eg, number of file descriptors).
|
|
.PP
|
|
Client-host based access control can be used to supplement licensing,
|
|
and support font server load balancing by restricting access.
|
|
As with licensing, this is OS-specific code.
|
|
To manipulate these functions, use:
|
|
.IP
|
|
.Ls
|
|
typedef struct _host_address {
|
|
int type;
|
|
pointer address;
|
|
struct _host_address *next;
|
|
} HostAddress;
|
|
.sp
|
|
typedef HostAddress *HostList;
|
|
.sp
|
|
int AddHost(HostList list, HostAddress *address)
|
|
int RemoveHost(HostList list, HostAddress *address)
|
|
Bool ValidHost(HostList list, HostAddress *address)
|
|
.Le
|
|
.LP
|
|
.B AddHost()
|
|
adds a host to the
|
|
.I list.
|
|
.B RemoveHost()
|
|
removes it, and
|
|
.B ValidHost()
|
|
checks to see if its on the
|
|
.I list.
|
|
In all functions, the
|
|
.I address
|
|
has will ignore any value in the
|
|
.I next
|
|
field.
|
|
.PP
|
|
Network addresses are used here to avoid issues with host name aliases.
|
|
The caller fills in the desired type, and an address of that form is
|
|
returned. This is highly OS-specific, but values for the
|
|
.I type
|
|
and
|
|
.I address
|
|
fields could include:
|
|
.IP
|
|
.Ls
|
|
#define HOST_AF_INET 1
|
|
struct in_addr *address;
|
|
.sp
|
|
#define HOST_AF_DECnet 2
|
|
struct dn_addr *address;
|
|
.Le
|
|
.LP
|
|
The server will use a global host list, but having the list
|
|
as an argument will allow licensing schemes to have their
|
|
own host lists.
|
|
|
|
.NH
|
|
Licensing
|
|
.PP
|
|
Licensing is a tricky issue, which each renderer will support in a
|
|
different way. The sample font server will attempt to provide some
|
|
guidelines, and present a possible implementation of some simple
|
|
licensing schemes.
|
|
.LP
|
|
\fBHost Address licensing\fR
|
|
.LP
|
|
This is simplistic licensing based on the client's host. With
|
|
this form of licensing, a font may be accessible to some host but not
|
|
others. To get the current client's host, the following is used:
|
|
.IP
|
|
.Ls
|
|
void GetHostAddress(HostAddress *address);
|
|
.Le
|
|
.LP
|
|
A renderer can also use the host access functions to keep a list
|
|
of the licensed hosts, and
|
|
.B ValidHost()
|
|
to check a client.
|
|
.LP
|
|
\fBSimultaneous use license\fR
|
|
.PP
|
|
This licensing allows for a limited number of copies of the font to
|
|
be open at once. Since this should be a simple per-font counter,
|
|
no support should be required outside of the renderer.
|
|
|
|
.NH
|
|
DIFS contents
|
|
.PP
|
|
This contains the protocol dispatcher, interpreter and reply encoding
|
|
routines.
|
|
.PP
|
|
The interpreter is table driven off the request code. The dispatcher
|
|
gets a request from the os layer from
|
|
.B WaitForSomething(),
|
|
and uses
|
|
the request code to determine which function to call. eg, a
|
|
.I CloseFont
|
|
request would call
|
|
.B ProcCloseFont().
|
|
.PP
|
|
Each request's routine handles any applicable error checking, and then
|
|
does as much work as it can. For font related requests, this means
|
|
converting the request to the proper arguments for the renderers.
|
|
.PP
|
|
If any replies are generated, the reply data is gathered into the
|
|
bytestream format, and sent via
|
|
.I os
|
|
write functions to the client.
|
|
.PP
|
|
If the byte order of the client and server differ, the above is
|
|
modified by having the dispatcher call an intermediate function which
|
|
re-orders the request to the proper byte order. Replies go through
|
|
similar swapping.
|
|
.LP
|
|
\fBClient blocking\fR
|
|
.PP
|
|
To minimize delay caused by font server request, clients can
|
|
be blocked while they wait for data to be produced. This is primarily
|
|
intended for
|
|
.B FPEs
|
|
using a remote font server,
|
|
but can be used anywhere where the font server can pause to handle
|
|
other client requests while data needed to satisfy another is produced
|
|
(possibly via multiple processes).
|
|
.IP
|
|
.Ls
|
|
Bool ClientSleep(ClientPtr client, Bool (*function)(), pointer closure)
|
|
.Le
|
|
.LP
|
|
Puts a client to 'sleep'. This means the client will no longer be
|
|
considered while the server is dispatching requests.
|
|
.I function
|
|
will be called when the client is signaled, with the
|
|
.I client
|
|
and
|
|
.I closure
|
|
as its arguments.
|
|
.Ls
|
|
Bool ClientSignal(ClientPtr client)
|
|
.Le
|
|
.LP
|
|
This should be called when the client is ready to do more work.
|
|
At this point, the function given to
|
|
.B ClientSleep()
|
|
will be called.
|
|
.Ls
|
|
void ClientWakeup(ClientPtr client)
|
|
.Le
|
|
.LP
|
|
Puts the client back to its normal state processing requests.
|
|
.Ls
|
|
Bool ClientIsAsleep(ClientPtr client)
|
|
.Le
|
|
.LP
|
|
Can be used to check if a client is asleep. This is useful for handling
|
|
client termination, so that any requests the client is waiting upon can be
|
|
properply cleaned up.
|
|
.LP
|
|
\fBSample Usage\fR
|
|
.PP
|
|
For handling a font server renderer request for
|
|
.B OpenBitmapFont
|
|
the renderer will send the request to the remote font server, and
|
|
the call
|
|
.B ClientSleep().
|
|
The font server will then continue processing requests from other clients,
|
|
while the one making the request is blocked.
|
|
When the reply returns, the renderer will notice when its
|
|
.B wakeup_fpe()
|
|
function is called. At this point the font server renderer will
|
|
read and process the reply.
|
|
.B ClientSignal()
|
|
will be called, and the
|
|
.I closure
|
|
function will be called. It will request the data from the renderer,
|
|
completing the request, and call
|
|
.B ClientWakeup()
|
|
to return the client to normal status.
|
|
.sp
|
|
.PP
|
|
This layer also contains the resource database, which associates fonts
|
|
with IDs, extension interface functions and the server initialization
|
|
and reset control.
|
|
.NH
|
|
OS contents
|
|
.PP
|
|
This layer contains OS specific routines for configuration, command
|
|
line parsing, client/server communications, and various OS-dependent
|
|
utilities such as memory management and error handling.
|
|
.PP
|
|
.B ReadRequestFromClient()
|
|
returns a full request to the dispatcher.
|
|
.B WaitForSomething()
|
|
is where the server spends its idle time, waiting
|
|
for any action from a client or processing any work left from a blocked
|
|
client.
|
|
.PP
|
|
When a client attempts to connect, the server will call
|
|
.IP
|
|
.Ls
|
|
int CheckClientAuthorization(ClientPtr client, AuthPtr client_auth,
|
|
int *accept, int *index, int *size, char **authdata)
|
|
.Le
|
|
.LP
|
|
to see if the server is set to allow the client to connect. It may
|
|
use licensing or configuration information to determine if the client
|
|
can connect.
|
|
.PP
|
|
When then connection is established, the server will use the
|
|
.IP
|
|
.Ls
|
|
typedef struct _alt_server {
|
|
char subset;
|
|
char namelen;
|
|
char *name;
|
|
} AlternateServerRec, *AlternateServerPtr;
|
|
.sp
|
|
int ListAlternateServers(AlternateServerPtr *servers)
|
|
.Le
|
|
.LP
|
|
to return any alternate server information it may have.
|
|
.LP
|
|
When the client limit is reached, the font server may attempt to
|
|
copy itself, by calling
|
|
.IP
|
|
.Ls
|
|
int CloneMyself()
|
|
.Le
|
|
.LP
|
|
This function will (if the configuartion options allow) start a new
|
|
font server process. This is done in such a way that no pending
|
|
connections should be lost, and that the original server will accept
|
|
no new connections. Once the original server has no more clients, it will
|
|
exit.
|
|
|
|
Catalogue manipulation
|
|
.PP
|
|
Catalogues are configuration dependent, and hence sent by OS-dependent
|
|
methods. In order for the
|
|
.I difs
|
|
layer to get them, it uses
|
|
.IP
|
|
.Ls
|
|
int ListCatalogues(char *pattern, int pattern_length,
|
|
int maxnames, char **catalogues, int *len)
|
|
.Le
|
|
.LP
|
|
which returns the list of all catalogues it supports which match the pattern.
|
|
This function
|
|
will be used by the catalogue manipulation requests, as well as by renderers
|
|
when they give their
|
|
.B ListFonts
|
|
results.
|
|
.LP
|
|
.Ls
|
|
int ValidateCatalogues(int number, char *catalogues)
|
|
.Le
|
|
.LP
|
|
Can be used to validate a list of catalogues, returning True if the
|
|
list is acceptable.
|
|
|
|
.NH
|
|
Utility functions
|
|
.LP
|
|
Client data functions
|
|
.PP
|
|
These provide access to the current client's resolution and
|
|
authorization data. This form of interface is supplied rather than
|
|
passing it to all renderers in the
|
|
.B FPE
|
|
functions because the data may
|
|
be complex and/or uninteresting to all renderers.
|
|
.IP
|
|
.Ls
|
|
AuthContextPtr GetClientAuthorization()
|
|
.Le
|
|
.LP
|
|
Returns the authorization data for the current client.
|
|
.IP
|
|
.Ls
|
|
fsResolution *GetClientResolutions(int *num_resolutions)
|
|
.Le
|
|
.LP
|
|
Returns the list of resolutions that the current client has set.
|
|
.sp 2
|
|
.LP
|
|
\fBCaching functions\fR
|
|
.PP
|
|
These are functions that simplify caching of renderer data. These are
|
|
for use by
|
|
renderers that take significant resources to produce data. The data
|
|
must be re-creatable -- the cache is not meant for general storage.
|
|
The data may also be moved by the cache, so it should only be accessed
|
|
by CacheID.
|
|
.IP
|
|
.Ls
|
|
typedef void (*CacheFree)();
|
|
typedef unsigned long CacheID;
|
|
typedef unsigned long Cache;
|
|
.sp 2
|
|
Cache CacheInit(int renderer_id)
|
|
.Le
|
|
.LP
|
|
Initializes a cache object for the renderer. the returned ID should be
|
|
passed to
|
|
.B CacheStoreMemory()
|
|
when adding an object to the cache.
|
|
.IP
|
|
.Ls
|
|
void CacheStats(Cache cid, unsigned long *num_entries,
|
|
unsigned long *max_storage, unsigned long *current_storage,
|
|
unsigned long *num_lookups, unsigned long *hit_ratio)
|
|
.Le
|
|
.LP
|
|
Returns statistics on the cache. Useful if the renderer wants some
|
|
hints about whether to place an object in the cache. If the cache is
|
|
nearly full, and the priority low, it may want to take different
|
|
action.
|
|
.IP
|
|
.Ls
|
|
CacheID CacheStoreMemory(Cache cacheid, pointer data, unsigned long size,
|
|
CacheFree free_func)
|
|
.Le
|
|
.LP
|
|
The renderer hands the cache some chunk of contiguous memory, which the
|
|
cache timestamps and stores. When it needs to remove them, it calls
|
|
the
|
|
.I free_func,
|
|
which must take responsibility for properly freeing the data.
|
|
.I size
|
|
is primarily a hint to the cache, so that cache limits can be properly
|
|
calculated. A return value of zero means the store failed, probably
|
|
because the given size was over the cache limit. If the given data is
|
|
too large for the current cache, it will attempt to free old data to
|
|
make room. The returned ID is a unique value that refers both to the
|
|
object and the cache in which it was placed.
|
|
.IP
|
|
.Ls
|
|
pointer CacheFetchMemory(CacheID cid, Bool update)
|
|
.Le
|
|
.LP
|
|
Returns the memory attached to the id. If
|
|
.I update
|
|
is set, the timestamp is updated. (some accesses may wish to be 'silent',
|
|
which allows some control over the freeing scheduling.) If the cid is invalid,
|
|
.I NULL
|
|
is returned.
|
|
.IP
|
|
.Ls
|
|
int CacheFreeMemory(CacheID cid, Bool notify)
|
|
.Le
|
|
.LP
|
|
Allows the cache to flush the data. If
|
|
.I notify
|
|
is set, the CacheFree
|
|
function passed in when the data was cached will also be called.
|
|
.IP
|
|
.Ls
|
|
void MemoryFreed(CacheID cid, pointer data, int reason)
|
|
.Le
|
|
.LP
|
|
Callback function from the cache to the renderer notifying it that its
|
|
data has been flushed. This function then has the responsibility to
|
|
free that data.
|
|
.I reason
|
|
may be one of:
|
|
.IP
|
|
.Ls
|
|
CacheReset /* all cache freed because of server reset */
|
|
CacheEntryFreed /* explicit request via free_memory() */
|
|
CacheEntryOld /* cache hit limit, and memory being freed because its old */
|
|
.Le
|
|
.LP
|
|
and is supplied so that the renderer may choose how to deal with the
|
|
free request. (It will probably be ignored by most, but some may want to
|
|
keep the memory around by bypassing the cache, or re-inserting it.)
|
|
Note that the cache will consider the data gone, so it
|
|
.B must
|
|
be re-inserted to keep it alive.
|
|
.IP
|
|
.Ls
|
|
void CacheSimpleFree(CacheID cid, pointer data, int reason)
|
|
.Le
|
|
.LP
|
|
Just calls
|
|
.B free()
|
|
on the data. Simple CacheFree defined here to
|
|
prevent it being redefined in each renderer.
|
|
.PP
|
|
Typical usage of the cache is for the renderer to store a CacheID
|
|
rather than a pointer to the cacheable data. The renderer is
|
|
responsible for both allocating and freeing the data, as well as
|
|
keeping track of just what it is. When the renderer needs the cached
|
|
data, it will request it from the cache. If it fails, it must rebuild
|
|
it.
|
|
.PP
|
|
A possible configuration parameter is the size of the cache. when the
|
|
cache is filled (with the calculation based on the given size), it
|
|
sweeps the cache and frees old data. The amount of memory actually
|
|
freed may wish to be tunable: some systems may want to keep the cache
|
|
as full as possible, others may want to free some percentage such that
|
|
sweeps occur less frequently.
|
|
.PP
|
|
Cache statistics may want to be available for administrators. They
|
|
could be dumped to a file when a signal is received. (SNMP seems like
|
|
a perfect match, but apparently the technology isn't there yet.
|
|
.PP
|
|
Cached data could also be compressed, if the memory/CPU tradeoffs
|
|
make it worthwhile.
|
|
.PP
|
|
ISSUE: Is a time-based freeing schedule sufficient? Should priorities
|
|
or size also be taken into account? [ No. Anything that the renderer
|
|
thinks should have a higher priority should probably not be placed into
|
|
the cache. ]
|
|
.sp 2
|
|
.LP
|
|
\fBByte swapping\fR
|
|
.LP
|
|
Functions for swapping a 4-byte quantity, a 2-byte quantity and inverting
|
|
a byte.
|
|
.IP
|
|
.Ls
|
|
void BitOrderInvert(pointer buffer, unsigned long num_bytes)
|
|
void TwoByteSwap(pointer buffer, unsigned long num_shorts)
|
|
void FourByteSwap(pointer buffer, unsigned long num_longs)
|
|
.Le
|
|
.LP
|
|
\fBBitmap padding\fR
|
|
.LP
|
|
Functions taking a desired extents and a bitmap that will return the
|
|
bitmap properly padded.
|
|
.Ls
|
|
int RepadBitmap(pointer src, pointer dst, fsFormat src_format,
|
|
fsFormat dst_format, int width, int height)
|
|
.Le
|
|
.LP
|
|
Takes a bitmap in
|
|
.I src_format
|
|
and converts it to one in
|
|
.I dst_format.
|
|
.LP
|
|
\fBAtoms\fR
|
|
.PP
|
|
Existing bitmap-based renderers use atoms to store strings for property
|
|
information. Rather than duplicate this code in each renderer, it
|
|
lives in the
|
|
.I util
|
|
directory.
|
|
.PP
|
|
Atoms will be especially useful for property information, to prevent
|
|
many copies of the same strings from being saved. Using atoms for
|
|
comparison when modifying properties after scaling is also more
|
|
efficient. Since
|
|
.I atoms
|
|
will will exist until the server is reset, they may want to be used
|
|
sparingly for property values to avoid extraneous string data.
|
|
.IP
|
|
.Ls
|
|
typedef unsigned long Atom;
|
|
.sp
|
|
Atom MakeAtom(char *string, unsigned int length, Bool create)
|
|
.Le
|
|
.LP
|
|
Returns the atom associated with
|
|
.I string.
|
|
If
|
|
.I create
|
|
is true, a new atom will be created.
|
|
.IP
|
|
.Ls
|
|
char *NameForAtom(Atom atom)
|
|
.Le
|
|
.LP
|
|
Returns the string associated with
|
|
.I atom.
|
|
|
|
.NH
|
|
Server request details
|
|
.PP
|
|
This section describes in-depth the action of each protocol request.
|
|
In all cases, the request is first error checked for simple length
|
|
or value errors, with the server
|
|
immediately returning an error if one is encountered.
|
|
.NH 2
|
|
Connection
|
|
.PP
|
|
When a new client attempts to connect, the server first checks
|
|
its initial authorization information to see if the server is willing
|
|
to talk to it. This will be handled in some OS-specific form
|
|
using
|
|
.B CheckClientAuthorization().
|
|
If it passes
|
|
this test, and the server has sufficient to resources to talk to it, the
|
|
server sends accepts the connection and returns its connection block.
|
|
If the connection fails, the server returns the proper status and
|
|
a list of any alternate servers it may know of (gathered from
|
|
.B ListAlternateServers().)
|
|
.NH 2
|
|
ListExtension
|
|
.PP
|
|
Returns the list of extensions the server knows about.
|
|
Any extensions will be initialized when the server is first started.
|
|
.NH 2
|
|
QueryExtension
|
|
.PP
|
|
Returns the information about the requested extension, which was set
|
|
when the extension was initialized.
|
|
.NH 2
|
|
ListCatalogues
|
|
.PP
|
|
Returns the catalogues the server recognizes (the results of
|
|
.B ListCatalogues().)
|
|
.NH 2
|
|
SetCatalogues
|
|
.PP
|
|
Sets the requesting client's catalogues after verifying them with the
|
|
supported catalogues.
|
|
.NH 2
|
|
GetCatalogues
|
|
.PP
|
|
Returns the requesting client's catalogues.
|
|
.NH 2
|
|
CreateAC
|
|
.PP
|
|
Creates a new authorization context and fills it in. The list of
|
|
authorization protocols is then checked by the server with
|
|
.B CheckClientAuthorization().
|
|
If any are accepted,
|
|
the
|
|
.B AC
|
|
is placed in the resource database and
|
|
.I Success
|
|
is returned with the name of the accepted protocol. If more than one is
|
|
accepted,
|
|
.I Continue
|
|
is returned with each of the accepted protocols, until the last one
|
|
which has status
|
|
.I Success
|
|
Otherwise
|
|
.I Denied
|
|
is returned.
|
|
.NH 2
|
|
FreeAC
|
|
.PP
|
|
Looks up the
|
|
.B AC
|
|
in the resource database, and frees it if it finds it. Otherwise an
|
|
.I Access
|
|
error is returned.
|
|
.NH 2
|
|
SetAuthorization
|
|
.PP
|
|
Looks up the
|
|
.B AC
|
|
in the resource database, and set the client's AuthContextPtr
|
|
to its value if it is found. Otherwise it sends an
|
|
.I Access
|
|
error.
|
|
.NH 2
|
|
SetResolution
|
|
.PP
|
|
Sets the requesting client's resolution list to the supplied list.
|
|
.NH 2
|
|
GetResolution
|
|
.PP
|
|
Returns the requesting client's list of resolutions.
|
|
.NH 2
|
|
ListFonts
|
|
.PP
|
|
Iterates over each open FPE, calling the FPE's
|
|
.B list_fonts()
|
|
routine passing it the pattern.
|
|
When all FPE's have been processed, the list that has been built up
|
|
is returned. Note that the same
|
|
.B FontNamesPtr
|
|
is sent to each FPE in turn, so that one list is built up.
|
|
An FPE may restrict the fonts it returns based on the client's
|
|
catalogue.
|
|
.NH 2
|
|
ListFontsWithXInfo
|
|
.PP
|
|
Iterates over each FPE, calling its
|
|
.B start_list_fonts_with_info()
|
|
function to prime the FPE's renderer. It then calls the FPE's
|
|
.B list_next_font_with_info(),
|
|
sending each font's data to the client until no more fonts remain.
|
|
When all FPEs have been processed, the final reply with a zero-length
|
|
name is then sent to mark the end of the replies.
|
|
An FPE may restrict the fonts it returns based
|
|
on the client's catalogue.
|
|
Note: an issue
|
|
exists with font aliases which may require this to change, since an FPE
|
|
may contain an alias pointing to another FPE, and cannot therefore
|
|
return the font's info.
|
|
.NH 2
|
|
OpenBitmapFont
|
|
.PP
|
|
The pattern is first searched for in the font server's name cache.
|
|
If it doesn't find it, the server iterates over each FPE, calling its
|
|
.B open_font
|
|
function with the supplied pattern. This will return one of the following
|
|
values:
|
|
.Ip
|
|
an
|
|
.B Access
|
|
error, which means the renderer has the font but the client does not
|
|
have access to it because of some form of licensing restriction
|
|
.Ip
|
|
a
|
|
.B Font
|
|
error and a NULL
|
|
.I alias
|
|
parameter, which will cause the next FPE to be tried
|
|
.Ip
|
|
a
|
|
.B Font
|
|
error but a non-NULL
|
|
.I alias,
|
|
which will cause the search to start over with the first FPE using
|
|
.I alias
|
|
as the new font pattern
|
|
.Ip
|
|
.B Success,
|
|
in which case a valid font has been found.
|
|
.PP
|
|
If the end of the FPE list is reached without having found the font,
|
|
an error is returned to the client. If an
|
|
.B Access
|
|
error was encountered, it is returned, otherwise a
|
|
.B Font
|
|
error is returned.
|
|
If a valid font is found, its reference count will be incremented and
|
|
it will be checked to see if the client has
|
|
already opened it before. If so, the previous ID will be returned.
|
|
Otherwise the font will be placed in the resource database.
|
|
.PP
|
|
The renderer will fill in the font's header and property information,
|
|
and may also choose to load or create the font's metrics or glyphs.
|
|
If the glyphs are built, they will use any supplied \fIformat hint\fR.
|
|
.PP
|
|
Whenever a new font is successfuly opened, the font and its name pattern
|
|
will be placed in a name cache. This cache exists to minimize the amount
|
|
of work spent searching for a font. It will be flushed when the
|
|
font catalogue is modified. Client's with private font catalogues
|
|
will require private name caches.
|
|
.NH 2
|
|
QueryXInfo
|
|
.PP
|
|
The
|
|
.I fontid
|
|
is looked up in the resource database, and the font's header and
|
|
property info is returned.
|
|
.NH 2
|
|
QueryXExtents8 QueryXExtents16
|
|
.PP
|
|
The
|
|
.I fontid
|
|
is looked up in the resource database. The supplied list of
|
|
characters (interpreted according to request type) is then translated
|
|
into a list of ranges. The font's
|
|
.B get_extents()
|
|
function is then called. It builds the requested list of extents,
|
|
and returns them along with the number of extents.
|
|
The results are properly swapped and sent to the client.
|
|
.NH 2
|
|
QueryXBitmaps8 QueryXBitmaps16
|
|
.PP
|
|
The
|
|
.I fontid
|
|
is looked up in the resource database. The supplied list of
|
|
characters (interpreted according to request type) is then translated
|
|
into a list of ranges. The font's
|
|
.B get_bitmaps()
|
|
function is called, and the renderer will build up the requested
|
|
bitmaps, using the specified
|
|
.I format,
|
|
and returns the bitmaps, the number of glyphs and the offsets.
|
|
The offsets are properly swapped and the offsets and bitmaps are
|
|
sent to the clients.
|
|
.NH 2
|
|
CloseFont
|
|
.PP
|
|
The font's reference count is decremented. If this was the last reference,
|
|
the font's
|
|
.B unload_font()
|
|
function is called to free the renderer's data, and the font's
|
|
FPE
|
|
.B close_font()
|
|
function is called to free up any FPE specific data.
|
|
|
|
.NH
|
|
Configuration
|
|
.PP
|
|
The configuration mechanism is a simple keyword-value pair, separated
|
|
by an '='.
|
|
.LP
|
|
Configuration types:
|
|
.ta .6i 2.1i
|
|
.nf
|
|
.sp
|
|
cardinal non-negative number
|
|
.sp
|
|
boolean "[Yy]es", "[Yy]" "on", "1", "[Nn]o", "[Nn]", "off", "0"
|
|
.sp
|
|
resolution \fIcardinal,cardinal\fR
|
|
.sp
|
|
list of foo 1 or more of foo, separated by commas
|
|
.sp
|
|
.fi
|
|
.LP
|
|
Here is an incomplete list of the supported keywords:
|
|
.sp
|
|
.ta .6i 1.5i
|
|
.nf
|
|
# in the first column, a comment character
|
|
.\".sp
|
|
.\"cache-size (cardinal)
|
|
.\" Size in bytes of the FS cache.
|
|
.sp
|
|
catalogue (list of string)
|
|
Ordered list of font path element names.
|
|
.sp
|
|
alternate-servers (list of string)
|
|
List of alternate servers for this FS.
|
|
.sp
|
|
client-limit (cardinal)
|
|
Number of clients this FS will support before refusing
|
|
service.
|
|
.sp
|
|
clone-self (boolean)
|
|
Whether this FS should attempt to clone itself or
|
|
use delegates when it reachs the client-limit.
|
|
.sp
|
|
default-point-size (cardinal)
|
|
The default pointsize (in decipoints) for fonts that
|
|
don't specify.
|
|
.sp
|
|
default-resolutions (list of resolutions)
|
|
Resolutions the server supports by default.
|
|
This information may be used as a hint for pre-rendering.
|
|
.sp
|
|
error-file (string)
|
|
Filename of the error file. All warnings and errors
|
|
will be logged here.
|
|
.sp
|
|
port (cardinal)
|
|
The TCP port on which the server will listen for connections.
|
|
.sp
|
|
use-syslog (boolean)
|
|
Whether syslog(3) is to be used for errors.
|
|
.\".sp
|
|
.\"trusted-clients (list of string)
|
|
.\" Those clients the fontserver will talk to. Others
|
|
.\" will be refused for the initial connection. An empty
|
|
.\" list means the server will talk to any client.
|
|
.fi
|
|
.IP
|
|
Each renderer may also want private configuration options. The names
|
|
should be prefixed by the renderer name, ie
|
|
.I pcf-,
|
|
.I atm-.
|
|
.LP
|
|
Examples:
|
|
.sp
|
|
# allow a ~a megabyte of memory to be reserved for cache data
|
|
.br
|
|
cache-size = 1000000
|
|
.sp
|
|
catalogue = pcf:/usr/lib/X11/fonts/misc,speedo:/usr/lib/fonts/speedo
|